Funciones de codificación

Introducido en: v25.6.0

Decodifica una cadena de dirección Bech32 generada por los algoritmos bech32 o bech32m.

Sintaxis

bech32Decode(address[, 'raw'])

Argumentos

• address — Una cadena Bech32 que se va a decodificar. String o 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

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)

Ejemplos

Decodificar una dirección

SELECT tup.1 AS hrp, hex(tup.2) AS data FROM (SELECT bech32Decode('bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4') AS tup)

┌─hrp─┬─data─────────────────────────────────────┐
│ bc  │ 751E76E8199196D454941C45D1B3A323F1433BD6 │
└─────┴──────────────────────────────────────────┘

Dirección de Testnet

SELECT tup.1 AS hrp, hex(tup.2) AS data FROM (SELECT bech32Decode('tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx') AS tup)

┌─hrp─┬─data─────────────────────────────────────┐
│ tb  │ 751E76E8199196D454941C45D1B3A323F1433BD6 │
└─────┴──────────────────────────────────────────┘

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.

Sintaxis

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 o FixedString
• data — Una cadena String de datos binarios para codificar. String o 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* o 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

Ejemplos

Bech32m predeterminado

-- When no witness version is supplied, the default is 1, the updated Bech32m algorithm.
SELECT bech32Encode('bc', unhex('751e76e8199196d454941c45d1b3a323f1433bd6'))

bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kj9wkru

Algoritmo Bech32

-- A witness version of 0 will result in a different address string.
SELECT bech32Encode('bc', unhex('751e76e8199196d454941c45d1b3a323f1433bd6'), 0)

bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4

HRP personalizado

-- While 'bc' (Mainnet) and 'tb' (Testnet) are the only allowed hrp values for the
-- SegWit address format, Bech32 allows any hrp that satisfies the above requirements.
SELECT bech32Encode('abcdefg', unhex('751e76e8199196d454941c45d1b3a323f1433bd6'), 10)

abcdefg12w508d6qejxtdg4y5r3zarvary0c5xw7kh526px

Dirección de Cosmos SDK (BIP173, sin versión witness)

-- Using 'bech32' variant encodes raw data without a witness version byte,
-- compatible with Cosmos SDK, Injective, Osmosis, and other non-SegWit chains.
SELECT bech32Encode('inj', unhex('751e76e8199196d454941c45d1b3a323f1433bd6'), 'bech32')

inj1w508d6qejxtdg4y5r3zarvary0c5xw7ks5q7aq

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:

Sintaxis

bin(arg)

Argumentos

• arg — Un valor para convertir a binario. String o FixedString o (U)Int* o Float* o Decimal o Date o DateTime

Valor devuelto

Devuelve una cadena con la representación binaria del argumento. String

Ejemplos

Entero simple

SELECT bin(14)

┌─bin(14)──┐
│ 00001110 │
└──────────┘

Números Float32

SELECT bin(toFloat32(number)) AS bin_presentation FROM numbers(15, 2)

┌─bin_presentation─────────────────┐
│ 00000000000000000111000001000001 │
│ 00000000000000001000000001000001 │
└──────────────────────────────────┘

Números de tipo Float64

SELECT bin(toFloat64(number)) AS bin_presentation FROM numbers(15, 2)

┌─bin_presentation─────────────────────────────────────────────────┐
│ 0000000000000000000000000000000000000000000000000010111001000000 │
│ 0000000000000000000000000000000000000000000000000011000001000000 │
└──────────────────────────────────────────────────────────────────┘

Conversión de UUID

SELECT bin(toUUID('61f0c404-5cb3-11e7-907b-a6006ad3dba0')) AS bin_uuid

┌─bin_uuid─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ 01100001111100001100010000000100010111001011001100010001111001111001000001111011101001100000000001101010110100111101101110100000 │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

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

bitPositionsToArray(arg)

Argumentos

• arg — Un valor entero. (U)Int*

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)

Ejemplos

Un solo bit activado

SELECT bitPositionsToArray(toInt8(1)) AS bit_positions

┌─bit_positions─┐
│ [0]           │
└───────────────┘

Todos los bits a 1

SELECT bitPositionsToArray(toInt8(-1)) AS bit_positions

┌─bit_positions─────┐
│ [0,1,2,3,4,5,6,7] │
└───────────────────┘

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

bitmaskToArray(num)

Argumentos

• num — Un valor entero. (U)Int*

Valor devuelto

Devuelve un array con las potencias de dos en orden ascendente cuya suma es igual al número de entrada. Array(UInt64)

Ejemplos

Ejemplo básico

SELECT bitmaskToArray(50) AS powers_of_two

┌─powers_of_two─┐
│ [2,16,32]     │
└───────────────┘

Una sola potencia de dos

SELECT bitmaskToArray(8) AS powers_of_two

┌─powers_of_two─┐
│ [8]           │
└───────────────┘

Introducido en: v1.1.0

Como bitmaskToArray, pero devuelve las potencias de dos en una cadena separada por comas.

Sintaxis

bitmaskToList(num)

Argumentos

• num — Un valor entero. (U)Int*

Valor devuelto

Devuelve una cadena con potencias de dos separadas por comas. String

Ejemplos

Ejemplo básico

SELECT bitmaskToList(50) AS powers_list

┌─powers_list─┐
│ 2,16,32     │
└─────────────┘

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

char(num1[, num2[, ...]])

Argumentos

• num1[, num2[, num3 ...]] — Argumentos numéricos interpretados como enteros. (U)Int8/16/32/64 o Float*

Valor devuelto

Devuelve una cadena a partir de los bytes dados. String

Ejemplos

Ejemplo básico

SELECT char(104.1, 101, 108.9, 108.9, 111) AS hello;

┌─hello─┐
│ hello │
└───────┘

Creación de codificaciones arbitrarias

-- 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;

┌─hello──┐
│ привет │
└────────┘

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:

La función usa letras mayúsculas A-F y no utiliza ningún prefijo (como 0x) ni sufijo (como h).

Sintaxis

hex(arg)

Argumentos

• arg — Un valor para convertir a hexadecimal. String o (U)Int* o Float* o Decimal o Date o DateTime

Valor devuelto

Devuelve una cadena con la representación hexadecimal del argumento. String

Ejemplos

Entero simple

SELECT hex(1)

01

Números de tipo Float32

SELECT hex(toFloat32(number)) AS hex_presentation FROM numbers(15, 2)

┌─hex_presentation─┐
│ 00007041         │
│ 00008041         │
└──────────────────┘

Números Float64

SELECT hex(toFloat64(number)) AS hex_presentation FROM numbers(15, 2)

┌─hex_presentation─┐
│ 0000000000002E40 │
│ 0000000000003040 │
└──────────────────┘

Conversión de UUID

SELECT lower(hex(toUUID('61f0c404-5cb3-11e7-907b-a6006ad3dba0'))) AS uuid_hex

┌─uuid_hex─────────────────────────┐
│ 61f0c4045cb311e7907ba6006ad3dba0 │
└──────────────────────────────────┘

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

hilbertDecode(tuple_size, code)

Argumentos

• tuple_size — Valor entero no superior a 2. UInt8/16/32/64 o Tuple(UInt8/16/32/64)
• code — Código UInt64. UInt64

Valor devuelto

Devuelve una tupla del tamaño especificado. Tuple(UInt64)

Ejemplos

Modo simple

SELECT hilbertDecode(2, 31)

(3,4)

Un solo argumento

-- Hilbert code for one argument is always the argument itself (as a tuple).
SELECT hilbertDecode(1, 1)

(1)

Modo expandido

-- A single argument with a tuple specifying bit shifts will be right-shifted accordingly.
SELECT hilbertDecode(tuple(2), 32768)

(8192)

Uso de columnas

-- First create the table and insert some data
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);

-- Use column names instead of constants as function arguments
SELECT untuple(hilbertDecode(2, hilbertEncode(n1, n2))) FROM hilbert_numbers;

1	2

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) como primer argumento y hasta 2 enteros sin signo 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

-- 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
• range_mask — Para el modo expandido, como máximo, dos valores UInt o columnas de tipo UInt. UInt8/16/32/64

Valor devuelto

Devuelve un código UInt64. UInt64

Ejemplos

Modo simple

SELECT hilbertEncode(3, 4)

31

Modo expandido

-- 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)

4031541586602

Un solo argumento

-- 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)

1

Un solo argumento expandido

-- 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)

512

Uso de columnas

-- 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;

13

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

-- Simple mode
mortonDecode(tuple_size, code)

-- Expanded mode
mortonDecode(range_mask, code)

Argumentos

• tuple_size — Valor entero no superior a 8. UInt8/16/32/64
• 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)
• code — Código UInt64. UInt64

Valor devuelto

Devuelve una tupla del tamaño especificado. Tuple(UInt64)

Ejemplos

Modo simple

SELECT mortonDecode(3, 53)

(1,2,3)

Un solo argumento

SELECT mortonDecode(1, 1)

(1)

Modo expandido, reducción de un argumento

SELECT mortonDecode(tuple(2), 32768)

(128)

Uso de columnas

-- First create the table and insert some data
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);

-- Use column names instead of constants as function arguments
SELECT untuple(mortonDecode(8, mortonEncode(n1, n2, n3, n4, n5, n6, n7, n8))) FROM morton_numbers;

1	2	3	4	5	6	7	8

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) como primer argumento y hasta 8 enteros sin signo 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

-- 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
• 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)

Valor devuelto

Devuelve un código UInt64. UInt64

Ejemplos

Modo simple

SELECT mortonEncode(1, 2, 3)

53

Modo expandido

-- 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)

1572864

Un solo argumento

-- La codificación Morton para un argumento siempre es el argumento mismo
SELECT mortonEncode(1)

1

Un único argumento expandido

SELECT mortonEncode(tuple(2), 128)

32768

Uso de columnas

-- 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;

2155374165

Introducido en: v24.1.0

Convierte un sqid nuevamente en un array de números.

Sintaxis

sqidDecode(sqid)

Argumentos

• sqid — El sqid que se debe decodificar. String

Valor devuelto

Devuelve un array de números a partir de sqid. Array(UInt64)

Ejemplos

Ejemplo de uso

SELECT sqidDecode('gXHfJ1C6dN');

┌─sqidDecode('gXHfJ1C6dN')─┐
│ [1,2,3,4,5]              │
└──────────────────────────┘

Introducido en: v24.1.0

Transforma números en un sqid, una cadena de ID similar a las de YouTube.

Sintaxis

sqidEncode(n1[, n2, ...])

Alias: sqid

Argumentos

• n1[, n2, ...] — Cualquier cantidad de números. UInt8/16/32/64

Valor devuelto

Devuelve un ID hash de tipo String

Ejemplos

Ejemplo de uso

SELECT sqidEncode(1, 2, 3, 4, 5);

┌─sqidEncode(1, 2, 3, 4, 5)─┐
│ gXHfJ1C6dN                │
└───────────────────────────┘

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<Type>.

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

unbin(arg)

Argumentos

• arg — Una cadena que contiene cualquier número de dígitos binarios. String

Valor devuelto

Devuelve una cadena binaria (BLOB). String

Ejemplos

Uso básico

SELECT UNBIN('001100000011000100110010'), UNBIN('0100110101111001010100110101000101001100')

┌─UNBIN('001100000011000100110010')─┬─UNBIN('0100110101111001010100110101000101001100')─┐
│ 012                               │ MySQL                                             │
└───────────────────────────────────┴───────────────────────────────────────────────────┘

Convertir en número

SELECT reinterpretAsUInt64(reverse(unbin('1110'))) AS num

┌─num─┐
│  14 │
└─────┘

Introducido en: v1.1.0

Realiza la operación inversa de 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<Type>.

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 del 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

unhex(arg)

Argumentos

• arg — Una cadena que contiene una cantidad cualquiera de dígitos hexadecimales. String o FixedString

Valor devuelto

Devuelve una cadena binaria (BLOB). String

Ejemplos

Uso básico

SELECT unhex('303132'), UNHEX('4D7953514C')

┌─unhex('303132')─┬─UNHEX('4D7953514C')─┐
│ 012             │ MySQL               │
└─────────────────┴─────────────────────┘

Convertir en número

SELECT reinterpretAsUInt64(reverse(unhex('FFF'))) AS num

┌──num─┐
│ 4095 │
└──────┘