> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-3a82795f.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. > Documentación sobre las funciones de codificación # Funciones de codificación {/*AUTOGENERATED_START*/}
## bech32Decode
Introducido en: v25.6.0 Decodifica una cadena de dirección Bech32 generada por los algoritmos bech32 o bech32m. A diferencia de la función de codificación, `bech32Decode` manejará automáticamente las FixedStrings con relleno. **Sintaxis** ```sql theme={null} bech32Decode(address[, 'raw']) ``` **Argumentos** * `address` — Una cadena Bech32 que se va a decodificar. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) * `mode` — Opcional. Pase `'raw'` para decodificar sin eliminar el primer byte como versión witness. Use esta opción para direcciones que no sean SegWit (p. ej., Cosmos SDK). [`String`](/es/reference/data-types/string) **Valor devuelto** Devuelve una tupla compuesta por `(hrp, data)` que se usó para codificar la cadena. Los datos están en formato binario. [`Tuple(String, String)`](/es/reference/data-types/tuple) **Ejemplos** **Decodificar una dirección** ```sql title=Query theme={null} SELECT tup.1 AS hrp, hex(tup.2) AS data FROM (SELECT bech32Decode('bc1w508d6qejxtdg4y5r3zarvary0c5xw7kj7gz7z') AS tup) ``` ```response title=Response theme={null} bc 751E76E8199196D454941C45D1B3A323F1433BD6 ``` **Dirección de la red de pruebas** ```sql title=Query theme={null} SELECT tup.1 AS hrp, hex(tup.2) AS data FROM (SELECT bech32Decode('tb1w508d6qejxtdg4y5r3zarvary0c5xw7kzp034v') AS tup) ``` ```response title=Response theme={null} tb 751E76E8199196D454941C45D1B3A323F1433BD6 ```
## bech32Encode
Introducido en: v25.6.0 Codifica una cadena de datos binarios, junto con una parte legible para humanos (HRP), mediante los algoritmos [Bech32 o Bech32m](https://en.bitcoin.it/wiki/Bech32). Al usar el tipo de dato [`FixedString`](/es/reference/data-types/fixedstring), si un valor no llena por completo la fila, se rellena con caracteres nulos. Aunque la función `bech32Encode` gestiona esto automáticamente para el argumento hrp, en el caso del argumento data los valores no deben estar rellenados. Por este motivo, no se recomienda usar el tipo de dato [`FixedString`](/es/reference/data-types/fixedstring) para los valores de datos, a menos que tenga la certeza de que todos tienen la misma longitud y se asegure de que la columna `FixedString` también esté configurada con esa longitud. **Sintaxis** ```sql theme={null} bech32Encode(hrp, data[, witver | 'bech32' | 'bech32m']) ``` **Argumentos** * `hrp` — Una cadena `String` de `1 - 83` caracteres en minúsculas que especifica la "parte legible para humanos" del código. Normalmente, 'bc' o 'tb'. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) * `data` — Una cadena `String` de datos binarios para codificar. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) * `witver_or_variant` — Opcional. Puede ser una versión witness de tipo UInt\* (predeterminado = 1, `0` para Bech32, `1`+ para Bech32m) o una variante de codificación de tipo String: `'bech32'` (BIP173) o `'bech32m'` (BIP350). Cuando se usa una variante en forma de cadena, no se antepone ningún byte de versión witness; esto es necesario para direcciones no SegWit, como las de Cosmos SDK. [`UInt*`](/es/reference/data-types/int-uint) o [`String`](/es/reference/data-types/string) **Valor devuelto** Devuelve una cadena de dirección Bech32, compuesta por la parte legible para humanos, un carácter separador que siempre es '1' y una parte de datos. La longitud de la cadena nunca superará los 90 caracteres. Si el algoritmo no puede generar una dirección válida a partir de la entrada, devolverá una cadena vacía. [`String`](/es/reference/data-types/string) **Ejemplos** **Bech32m predeterminado** ```sql title=Query theme={null} -- Cuando no se proporciona una versión witness, el valor predeterminado es 1, el algoritmo Bech32m actualizado. SELECT bech32Encode('bc', unhex('751e76e8199196d454941c45d1b3a323f1433bd6')) ``` ```response title=Response theme={null} bc1w508d6qejxtdg4y5r3zarvary0c5xw7k8zcwmq ``` **Algoritmo Bech32** ```sql title=Query theme={null} -- Una versión witness igual a 0 producirá una cadena de dirección diferente. SELECT bech32Encode('bc', unhex('751e76e8199196d454941c45d1b3a323f1433bd6'), 0) ``` ```response title=Response theme={null} bc1w508d6qejxtdg4y5r3zarvary0c5xw7kj7gz7z ``` **HRP personalizado** ```sql title=Query theme={null} -- Aunque 'bc' (Mainnet) y 'tb' (Testnet) son los únicos valores hrp permitidos para el -- formato de dirección SegWit, Bech32 permite cualquier hrp que cumpla los requisitos anteriores. SELECT bech32Encode('abcdefg', unhex('751e76e8199196d454941c45d1b3a323f1433bd6'), 10) ``` ```response title=Response theme={null} abcdefg1w508d6qejxtdg4y5r3zarvary0c5xw7k9rp8r4 ``` **Dirección de Cosmos SDK (BIP173, sin versión witness)** ```sql title=Query theme={null} -- El uso de la variante 'bech32' codifica datos sin procesar sin un byte de versión witness, -- compatible con Cosmos SDK, Injective, Osmosis y otras cadenas no SegWit. SELECT bech32Encode('inj', unhex('751e76e8199196d454941c45d1b3a323f1433bd6'), 'bech32') ``` ```response title=Response theme={null} inj1w508d6qejxtdg4y5r3zarvary0c5xw7kgj5aqs ```
## bin
Introducido en: v21.8.0 Devuelve una cadena que contiene la representación binaria del argumento según la siguiente lógica para distintos tipos: | Tipo | Descripción | | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `(U)Int*` | Imprime los dígitos binarios del más significativo al menos significativo (orden big-endian o "legible para humanos"). Comienza con el byte distinto de cero más significativo (se omiten los bytes cero iniciales), pero siempre imprime ocho dígitos de cada byte si el dígito inicial es cero. | | `Date` y `DateTime` | Se formatean como los enteros correspondientes (el número de días desde epoch para `Date` y el valor de la marca temporal Unix para `DateTime`). | | `String` y `FixedString` | Todos los bytes se codifican simplemente como ocho números binarios. Los bytes cero no se omiten. | | `Float*` y `Decimal` | Se codifican según su representación en memoria. Como admitimos arquitectura little-endian, se codifican en little-endian. Los bytes cero iniciales/finales no se omiten. | | `UUID` | Se codifica como una cadena en orden big-endian. | **Sintaxis** ```sql theme={null} bin(arg) ``` **Argumentos** * `arg` — Un valor para convertir a binario. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) **Valor devuelto** Devuelve una cadena con la representación binaria del argumento. [`String`](/es/reference/data-types/string) **Ejemplos** **Entero simple** ```sql title=Query theme={null} SELECT bin(14) ``` ```response title=Response theme={null} ┌─bin(14)──┐ │ 00001110 │ └──────────┘ ``` **Números Float32** ```sql title=Query theme={null} SELECT bin(toFloat32(number)) AS bin_presentation FROM numbers(15, 2) ``` ```response title=Response theme={null} ┌─bin_presentation─────────────────┐ │ 00000000000000000111000001000001 │ │ 00000000000000001000000001000001 │ └──────────────────────────────────┘ ``` **Números de tipo Float64** ```sql title=Query theme={null} SELECT bin(toFloat64(number)) AS bin_presentation FROM numbers(15, 2) ``` ```response title=Response theme={null} ┌─bin_presentation─────────────────────────────────────────────────┐ │ 0000000000000000000000000000000000000000000000000010111001000000 │ │ 0000000000000000000000000000000000000000000000000011000001000000 │ └──────────────────────────────────────────────────────────────────┘ ``` **Conversión de UUID** ```sql title=Query theme={null} SELECT bin(toUUID('61f0c404-5cb3-11e7-907b-a6006ad3dba0')) AS bin_uuid ``` ```response title=Response theme={null} ┌─bin_uuid─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ │ 01100001111100001100010000000100010111001011001100010001111001111001000001111011101001100000000001101010110100111101101110100000 │ └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ ```
## bitPositionsToArray
Introducido en: v21.7.0 Esta función devuelve las posiciones (en orden ascendente) de los bits con valor 1 en la representación binaria de un entero sin signo. Los enteros de entrada con signo se convierten primero en un entero sin signo. **Sintaxis** ```sql theme={null} bitPositionsToArray(arg) ``` **Argumentos** * `arg` — Un valor entero. [`(U)Int*`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve un array con las posiciones, ordenadas de forma ascendente, de los bits con valor 1 en la representación binaria de la entrada. [`Array(UInt64)`](/es/reference/data-types/array) **Ejemplos** **Un solo bit activado** ```sql title=Query theme={null} SELECT bitPositionsToArray(toInt8(1)) AS bit_positions ``` ```response title=Response theme={null} ┌─bit_positions─┐ │ [0] │ └───────────────┘ ``` **Todos los bits a 1** ```sql title=Query theme={null} SELECT bitPositionsToArray(toInt8(-1)) AS bit_positions ``` ```response title=Response theme={null} ┌─bit_positions─────────────┐ │ [0, 1, 2, 3, 4, 5, 6, 7] │ └───────────────────────────┘ ```
## bitmaskToArray
Introducida en: v1.1.0 Esta función descompone un entero en una suma de potencias de dos. Las potencias de dos se devuelven en un array ordenado de forma ascendente. **Sintaxis** ```sql theme={null} bitmaskToArray(num) ``` **Argumentos** * `num` — Un valor entero. [`(U)Int*`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve un array con las potencias de dos en orden ascendente cuya suma es igual al número de entrada. [`Array(UInt64)`](/es/reference/data-types/array) **Ejemplos** **Ejemplo básico** ```sql title=Query theme={null} SELECT bitmaskToArray(50) AS powers_of_two ``` ```response title=Response theme={null} ┌─powers_of_two───┐ │ [2, 16, 32] │ └─────────────────┘ ``` **Una sola potencia de dos** ```sql title=Query theme={null} SELECT bitmaskToArray(8) AS powers_of_two ``` ```response title=Response theme={null} ┌─powers_of_two─┐ │ [8] │ └───────────────┘ ```
## bitmaskToList
Introducido en: v1.1.0 Como bitmaskToArray, pero devuelve las potencias de dos en una cadena separada por comas. **Sintaxis** ```sql theme={null} bitmaskToList(num) ``` **Argumentos** * `num` — Un valor entero. [`(U)Int*`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve una cadena con potencias de dos separadas por comas. [`String`](/es/reference/data-types/string) **Ejemplos** **Ejemplo básico** ```sql title=Query theme={null} SELECT bitmaskToList(50) AS powers_list ``` ```response title=Response theme={null} ┌─powers_list───┐ │ 2, 16, 32 │ └───────────────┘ ```
## char
Introducido en: v20.1.0 Devuelve una cadena cuya longitud es igual al número de argumentos proporcionados, donde cada byte tiene el valor del argumento correspondiente. Acepta varios argumentos de tipos numéricos. Si el valor del argumento está fuera del rango del tipo de datos `UInt8`, se convierte a `UInt8` con posible redondeo y desbordamiento. **Sintaxis** ```sql theme={null} char(num1[, num2[, ...]]) ``` **Argumentos** * `num1[, num2[, num3 ...]]` — Argumentos numéricos interpretados como enteros. [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) **Valor devuelto** Devuelve una cadena a partir de los bytes dados. [`String`](/es/reference/data-types/string) **Ejemplos** **Ejemplo básico** ```sql title=Query theme={null} SELECT char(104.1, 101, 108.9, 108.9, 111) AS hello; ``` ```response title=Response theme={null} ┌─hello─┐ │ hello │ └───────┘ ``` **Creación de codificaciones arbitrarias** ```sql title=Query theme={null} -- Puedes construir una cadena con codificación arbitraria pasando los bytes correspondientes. -- por ejemplo UTF8 SELECT char(0xD0, 0xBF, 0xD1, 0x80, 0xD0, 0xB8, 0xD0, 0xB2, 0xD0, 0xB5, 0xD1, 0x82) AS hello; ``` ```response title=Response theme={null} ┌─hello──┐ │ привет │ └────────┘ ```
## hex
Introducido en: v1.1.0 Devuelve una cadena que contiene la representación hexadecimal del argumento según la siguiente lógica para distintos tipos: | Tipo | Descripción | | -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `(U)Int*` | Imprime dígitos hexadecimales ("nibbles") del más significativo al menos significativo (orden big-endian o de "legible para humanos"). Comienza con el byte distinto de cero más significativo (se omiten los bytes cero iniciales), pero siempre imprime ambos dígitos de cada byte, incluso si el dígito inicial es cero. | | `Date` and `DateTime` | Se formatea como los enteros correspondientes (el número de días desde la época para Date y el valor de la marca de tiempo Unix para DateTime). | | `String` and `FixedString` | Todos los bytes se codifican simplemente como dos dígitos hexadecimales. Los bytes cero no se omiten. | | `Float*` and `Decimal` | Se codifican según su representación en memoria. ClickHouse representa internamente los valores siempre en little endian, por lo tanto se codifican de esa manera. Los bytes cero iniciales y finales no se omiten. | | `UUID` | Se codifica como una cadena en orden big-endian. | La función usa letras mayúsculas `A-F` y no utiliza ningún prefijo (como `0x`) ni sufijo (como `h`). **Sintaxis** ```sql theme={null} hex(arg) ``` **Argumentos** * `arg` — Un valor para convertir a hexadecimal. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) **Valor devuelto** Devuelve una cadena con la representación hexadecimal del argumento. [`String`](/es/reference/data-types/string) **Ejemplos** **Entero simple** ```sql title=Query theme={null} SELECT hex(1) ``` ```response title=Response theme={null} 01 ``` **Números de tipo Float32** ```sql title=Query theme={null} SELECT hex(toFloat32(number)) AS hex_presentation FROM numbers(15, 2) ``` ```response title=Response theme={null} ┌─hex_presentation─┐ │ 00007041 │ │ 00008041 │ └──────────────────┘ ``` **Números Float64** ```sql title=Query theme={null} SELECT hex(toFloat64(number)) AS hex_presentation FROM numbers(15, 2) ``` ```response title=Response theme={null} ┌─hex_presentation─┐ │ 0000000000002E40 │ │ 0000000000003040 │ └──────────────────┘ ``` **Conversión de UUID** ```sql title=Query theme={null} SELECT lower(hex(toUUID('61f0c404-5cb3-11e7-907b-a6006ad3dba0'))) AS uuid_hex ``` ```response title=Response theme={null} ┌─uuid_hex─────────────────────────┐ │ 61f0c4045cb311e7907ba6006ad3dba0 │ └──────────────────────────────────┘ ```
## hilbertDecode
Introducido en: v24.6.0 Decodifica un índice de curva de Hilbert de nuevo en una tupla de enteros sin signo, que representa coordenadas en un espacio multidimensional. Al igual que la función `hilbertEncode`, esta función tiene dos modos de funcionamiento: * **Simple** * **Expandido** **Modo simple** Acepta hasta 2 enteros sin signo como argumentos y produce un código `UInt64`. **Modo expandido** Acepta una máscara de rango (tupla) como primer argumento y hasta 2 enteros sin signo como argumentos adicionales. Cada número de la máscara configura la cantidad de bits en que el argumento correspondiente se desplazará a la izquierda, escalando así el argumento dentro de su rango. La expansión de rango puede resultar útil cuando se necesita una distribución similar para argumentos con rangos (o cardinalidad) muy diferentes. Por ejemplo: 'Dirección IP' `(0...FFFFFFFF)` y 'Código de país' `(0...FF)`. Al igual que con la función de codificación, esto se limita a 8 números como máximo. **Sintaxis** ```sql theme={null} hilbertDecode(tuple_size, code) ``` **Argumentos** * `tuple_size` — Valor entero no superior a `2`. [`UInt8/16/32/64`](/es/reference/data-types/int-uint) o [`Tuple(UInt8/16/32/64)`](/es/reference/data-types/tuple) * `code` — Código `UInt64`. [`UInt64`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve una tupla del tamaño especificado. [`Tuple(UInt64)`](/es/reference/data-types/tuple) **Ejemplos** **Modo simple** ```sql title=Query theme={null} SELECT hilbertDecode(2, 31) ``` ```response title=Response theme={null} ["3", "4"] ``` **Un único argumento** ```sql title=Query theme={null} -- El código de Hilbert para un argumento siempre es el argumento en sí (como una tupla). SELECT hilbertDecode(1, 1) ``` ```response title=Response theme={null} ["1"] ``` **Modo ampliado** ```sql title=Query theme={null} -- Un único argumento con una tupla que especifica desplazamientos de bits se desplazará a la derecha en consecuencia. SELECT hilbertDecode(tuple(2), 32768) ``` ```response title=Response theme={null} ["128"] ``` **Uso con columnas** ```sql title=Query theme={null} -- Primero, crear la tabla e insertar algunos datos CREATE TABLE hilbert_numbers( n1 UInt32, n2 UInt32 ) ENGINE=MergeTree() ORDER BY n1 SETTINGS index_granularity_bytes = '10Mi'; insert into hilbert_numbers (*) values(1,2); -- Usar nombres de columna en lugar de constantes como argumentos de la función SELECT untuple(hilbertDecode(2, hilbertEncode(n1, n2))) FROM hilbert_numbers; ``` ```response title=Response theme={null} 1 2 ```
## hilbertEncode
Introducido en: v24.6.0 Calcula el código de la curva de Hilbert para una lista de enteros sin signo. La función tiene dos modos de operación: * **Simple** * **expandido** **Modo simple** Acepta hasta 2 enteros sin signo como argumentos y genera un código UInt64. **Modo expandido** Acepta una máscara de rango ([Tuple](/es/reference/data-types/tuple)) como primer argumento y hasta 2 [enteros sin signo](/es/reference/data-types/int-uint) como argumentos adicionales. Cada número de la máscara indica cuántos bits se desplazará a la izquierda el argumento correspondiente, lo que escala efectivamente el argumento dentro de su rango. **Sintaxis** ```sql theme={null} -- Modo simplificado hilbertEncode(args) -- Modo expandido hilbertEncode(range_mask, args) ``` **Argumentos** * `args` — Como máximo, dos valores `UInt` o columnas de tipo `UInt`. [`UInt8/16/32/64`](/es/reference/data-types/int-uint) * `range_mask` — Para el modo expandido, como máximo, dos valores `UInt` o columnas de tipo `UInt`. [`UInt8/16/32/64`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve un código `UInt64`. [`UInt64`](/es/reference/data-types/int-uint) **Ejemplos** **Modo simple** ```sql title=Query theme={null} SELECT hilbertEncode(3, 4) ``` ```response title=Response theme={null} 31 ``` **Modo expandido** ```sql title=Query theme={null} -- La expansión de rango puede ser útil cuando se necesita una distribución similar para -- argumentos con rangos (o cardinalidad) muy diferentes. -- Por ejemplo: 'IP Address' (0...FFFFFFFF) y 'Country code' (0...FF). -- Nota: el tamaño del tuple debe ser igual al número de los demás argumentos. SELECT hilbertEncode((10, 6), 1024, 16) ``` ```response title=Response theme={null} 4031541586602 ``` **Un solo argumento** ```sql title=Query theme={null} -- Para un único argumento sin tupla, la función devuelve el argumento -- en sí mismo como el índice de Hilbert, ya que no se necesita asignación dimensional. SELECT hilbertEncode(1) ``` ```response title=Response theme={null} 1 ``` **Un solo argumento expandido** ```sql title=Query theme={null} -- Si se proporciona un único argumento con una tupla que especifica los desplazamientos de bits, la función -- desplaza el argumento hacia la izquierda el número de bits especificado. SELECT hilbertEncode(tuple(2), 128) ``` ```response title=Response theme={null} 512 ``` **Uso de columnas** ```sql title=Query theme={null} -- Primero, crear la tabla e insertar algunos datos CREATE TABLE hilbert_numbers( n1 UInt32, n2 UInt32 ) ENGINE=MergeTree() ORDER BY n1; insert into hilbert_numbers (*) values(1, 2); -- Usar nombres de columna en lugar de constantes como argumentos de la función SELECT hilbertEncode(n1, n2) FROM hilbert_numbers; ``` ```response title=Response theme={null} 13 ```
## mortonDecode
Introducido en: v24.6.0 Decodifica una codificación de Morton (ZCurve) en la tupla correspondiente de enteros sin signo. Al igual que la función `mortonEncode`, esta función tiene dos modos de funcionamiento: * **Simple** * **expandido** **Modo simple** Acepta el tamaño de la tupla resultante como primer argumento y el código como segundo argumento. **Modo expandido** Acepta una máscara de rango (tupla) como primer argumento y el código como segundo argumento. Cada número de la máscara configura el grado de reducción del rango: * `1` - sin reducción * `2` - reducción de 2x * `3` - reducción de 3x ⋮ * Hasta 8x de reducción. La expansión del rango puede resultar útil cuando se necesita una distribución similar para argumentos con rangos muy diferentes (o cardinalidad). Por ejemplo: 'Dirección IP' `(0...FFFFFFFF)` y 'código de país' `(0...FF)`. Al igual que con la función de codificación, esto está limitado a un máximo de 8 números. **Sintaxis** ```sql theme={null} -- Modo simple mortonDecode(tuple_size, code) -- Modo expandido mortonDecode(range_mask, code) ``` **Argumentos** * `tuple_size` — Valor entero no superior a 8. [`UInt8/16/32/64`](/es/reference/data-types/int-uint) * `range_mask` — En el modo expandido, la máscara de cada argumento. La máscara es una tupla de enteros sin signo. Cada número de la máscara configura el grado de reducción del rango. [`Tuple(UInt8/16/32/64)`](/es/reference/data-types/tuple) * `code` — Código `UInt64`. [`UInt64`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve una tupla del tamaño especificado. [`Tuple(UInt64)`](/es/reference/data-types/tuple) **Ejemplos** **Modo simple** ```sql title=Query theme={null} SELECT mortonDecode(3, 53) ``` ```response title=Response theme={null} ["1", "2", "3"] ``` **Un solo argumento** ```sql title=Query theme={null} SELECT mortonDecode(1, 1) ``` ```response title=Response theme={null} ["1"] ``` **Modo expandido, reducción de un argumento** ```sql title=Query theme={null} SELECT mortonDecode(tuple(2), 32768) ``` ```response title=Response theme={null} ["128"] ``` **Uso de columnas** ```sql title=Query theme={null} -- Primero crear la tabla e insertar algunos datos CREATE TABLE morton_numbers( n1 UInt32, n2 UInt32, n3 UInt16, n4 UInt16, n5 UInt8, n6 UInt8, n7 UInt8, n8 UInt8 ) ENGINE=MergeTree() ORDER BY n1; INSERT INTO morton_numbers (*) values(1, 2, 3, 4, 5, 6, 7, 8); -- Usar nombres de columna en lugar de constantes como argumentos de la función SELECT untuple(mortonDecode(8, mortonEncode(n1, n2, n3, n4, n5, n6, n7, n8))) FROM morton_numbers; ``` ```response title=Response theme={null} 1 2 3 4 5 6 7 8 ```
## mortonEncode
Introducido en: v24.6.0 Calcula la codificación de Morton (ZCurve) para una lista de enteros sin signo. La función tiene dos modos de operación: * **Simple** * *expandido*\* **Modo simple** Acepta hasta 8 enteros sin signo como argumentos y genera un código `UInt64`. **Modo expandido** Acepta una máscara de rango ([Tuple](/es/reference/data-types/tuple)) como primer argumento y hasta 8 [enteros sin signo](/es/reference/data-types/int-uint) como argumentos adicionales. Cada número de la máscara configura el grado de expansión del rango: * 1 - sin expansión * 2 - expansión de 2x * 3 - expansión de 3x ⋮ * Hasta 8x de expansión. **Sintaxis** ```sql theme={null} -- Modo simplificado mortonEncode(args) -- Modo expandido mortonEncode(range_mask, args) ``` **Argumentos** * `args` — Hasta 8 enteros sin signo o columnas del tipo indicado anteriormente. [`UInt8/16/32/64`](/es/reference/data-types/int-uint) * `range_mask` — En el modo expandido, la máscara de cada argumento. La máscara es una tupla de enteros sin signo del `1` al `8`. Cada número de la máscara configura el grado de reducción del rango. [`Tuple(UInt8/16/32/64)`](/es/reference/data-types/tuple) **Valor devuelto** Devuelve un código `UInt64`. [`UInt64`](/es/reference/data-types/int-uint) **Ejemplos** **Modo simple** ```sql title=Query theme={null} SELECT mortonEncode(1, 2, 3) ``` ```response title=Response theme={null} 53 ``` **Modo expandido** ```sql title=Query theme={null} -- La expansión de rango puede ser beneficiosa cuando se necesita una distribución similar para -- argumentos con rangos (o cardinalidad) muy distintos -- Por ejemplo: 'IP Address' (0...FFFFFFFF) y 'Country code' (0...FF). -- Nota: el tamaño del Tuple debe ser igual al número de los demás argumentos. SELECT mortonEncode((1,2), 1024, 16) ``` ```response title=Response theme={null} 1572864 ``` **Un solo argumento** ```sql title=Query theme={null} -- La codificación Morton para un argumento siempre es el argumento mismo SELECT mortonEncode(1) ``` ```response title=Response theme={null} 1 ``` **Un único argumento expandido** ```sql title=Query theme={null} SELECT mortonEncode(tuple(2), 128) ``` ```response title=Response theme={null} 32768 ``` **Uso de columnas** ```sql title=Query theme={null} -- Primero crear la tabla e insertar algunos datos CREATE TABLE morton_numbers( n1 UInt32, n2 UInt32, n3 UInt16, n4 UInt16, n5 UInt8, n6 UInt8, n7 UInt8, n8 UInt8 ) ENGINE=MergeTree() ORDER BY n1; INSERT INTO morton_numbers (*) values(1, 2, 3, 4, 5, 6, 7, 8); -- Usar nombres de columna en lugar de constantes como argumentos de la función SELECT mortonEncode(n1, n2, n3, n4, n5, n6, n7, n8) FROM morton_numbers; ``` ```response title=Response theme={null} 2155374165 ```
## sqidDecode
Introducido en: v24.1.0 Convierte un [sqid](https://sqids.org/) nuevamente en un arreglo de números. **Sintaxis** ```sql theme={null} sqidDecode(sqid) ``` **Argumentos** * `sqid` — El sqid que se debe decodificar. [`String`](/es/reference/data-types/string) **Valor devuelto** Devuelve un array de números a partir de `sqid`. [`Array(UInt64)`](/es/reference/data-types/array) **Ejemplos** **Ejemplo de uso** ```sql title=Query theme={null} SELECT sqidDecode('gXHfJ1C6dN'); ``` ```response title=Response theme={null} ┌─sqidDecode('gXHfJ1C6dN')─────┐ │ [1, 2, 3, 4, 5] │ └──────────────────────────────┘ ```
## sqidEncode
Introducido en: v24.1.0 Transforma números en un [sqid](https://sqids.org/), una cadena de ID similar a las de YouTube. **Sintaxis** ```sql theme={null} sqidEncode(n1[, n2, ...]) ``` **Alias**: `sqid` **Argumentos** * `n1[, n2, ...]` — Cualquier cantidad de números. [`UInt8/16/32/64`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve un ID hash de tipo [`String`](/es/reference/data-types/string) **Ejemplos** **Ejemplo de uso** ```sql title=Query theme={null} SELECT sqidEncode(1, 2, 3, 4, 5); ``` ```response title=Response theme={null} ┌─sqidEncode(1, 2, 3, 4, 5)─┐ │ gXHfJ1C6dN │ └───────────────────────────┘ ```
## unbin
Introducido en: v21.8.0 Interpreta cada par de dígitos binarios (del argumento) como un número y lo convierte en el byte representado por ese número. La función realiza la operación inversa de `bin`. Para un argumento numérico, `unbin()` no devuelve el inverso de `bin()`. Si quiere convertir el resultado en un número, puede usar las funciones `reverse` y `reinterpretAs`. Si `unbin` se invoca desde `clickhouse-client`, las cadenas binarias se muestran con UTF-8. Admite los dígitos binarios `0` y `1`. La cantidad de dígitos binarios no tiene que ser múltiplo de ocho. Si la cadena del argumento contiene cualquier cosa distinta de dígitos binarios, el resultado no está definido (no se genera ninguna excepción). **Sintaxis** ```sql theme={null} unbin(arg) ``` **Argumentos** * `arg` — Una cadena que contiene cualquier número de dígitos binarios. [`String`](/es/reference/data-types/string) **Valor devuelto** Devuelve una cadena binaria (BLOB). [`String`](/es/reference/data-types/string) **Ejemplos** **Uso básico** ```sql title=Query theme={null} SELECT UNBIN('001100000011000100110010'), UNBIN('0100110101111001010100110101000101001100') ``` ```response title=Response theme={null} ┌─unbin('001100000011000100110010')─┬─unbin('0100110101111001010100110101000101001100')─┐ │ 012 │ MySQL │ └───────────────────────────────────┴───────────────────────────────────────────────────┘ ``` **Convertir en número** ```sql title=Query theme={null} SELECT reinterpretAsUInt64(reverse(unbin('1110'))) AS num ``` ```response title=Response theme={null} ┌─num─┐ │ 14 │ └─────┘ ```
## unhex
Introducido en: v1.1.0 Realiza la operación inversa de [`hex`](#hex). Interpreta cada par de dígitos hexadecimales (en el argumento) como un número y lo convierte en el byte representado por ese número. El valor devuelto es una cadena binaria (BLOB). Si desea convertir el resultado en un número, puede usar las funciones `reverse` y `reinterpretAs`. `clickhouse-client` interpreta las cadenas como UTF-8. Esto puede hacer que los valores devueltos por `hex` se muestren de forma inesperada. Admite tanto letras mayúsculas como minúsculas `A-F`. No es necesario que el número de dígitos hexadecimales sea par. Si es impar, el último dígito se interpreta como la mitad menos significativa del byte `00-0F`. Si la cadena de argumento contiene cualquier carácter distinto de un dígito hexadecimal, se devuelve un resultado definido por la implementación (no se lanza ninguna excepción). En el caso de un argumento numérico, `unhex()` no realiza la operación inversa de hex(N). **Sintaxis** ```sql theme={null} unhex(arg) ``` **Argumentos** * `arg` — Una cadena que contiene una cantidad cualquiera de dígitos hexadecimales. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) **Valor devuelto** Devuelve una cadena binaria (BLOB). [`String`](/es/reference/data-types/string) **Ejemplos** **Uso básico** ```sql title=Query theme={null} SELECT unhex('303132'), UNHEX('4D7953514C') ``` ```response title=Response theme={null} ┌─unhex('303132')─┬─unhex('4D7953514C')─┐ │ 012 │ MySQL │ └─────────────────┴─────────────────────┘ ``` **Convertir en número** ```sql title=Query theme={null} SELECT reinterpretAsUInt64(reverse(unhex('FFF'))) AS num ``` ```response title=Response theme={null} ┌──num─┐ │ 4095 │ └──────┘ ```