Funções de codificação

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

bc   751E76E8199196D454941C45D1B3A323F1433BD6

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

tb   751E76E8199196D454941C45D1B3A323F1433BD6

-- Quando nenhuma versão de witness é fornecida, o padrão é 1, o algoritmo Bech32m atualizado.
SELECT bech32Encode('bc', unhex('751e76e8199196d454941c45d1b3a323f1433bd6'))

bc1w508d6qejxtdg4y5r3zarvary0c5xw7k8zcwmq

-- Uma versão de witness igual a 0 resultará em uma string de endereço diferente.
SELECT bech32Encode('bc', unhex('751e76e8199196d454941c45d1b3a323f1433bd6'), 0)

bc1w508d6qejxtdg4y5r3zarvary0c5xw7kj7gz7z

-- Embora 'bc' (Mainnet) e 'tb' (Testnet) sejam os únicos valores hrp permitidos para o
-- formato de endereço SegWit, o Bech32 permite qualquer hrp que satisfaça os requisitos acima.
SELECT bech32Encode('abcdefg', unhex('751e76e8199196d454941c45d1b3a323f1433bd6'), 10)

abcdefg1w508d6qejxtdg4y5r3zarvary0c5xw7k9rp8r4

-- Usar a variante 'bech32' codifica dados brutos sem um byte de versão de witness,
-- compatível com Cosmos SDK, Injective, Osmosis e outras cadeias não-SegWit.
SELECT bech32Encode('inj', unhex('751e76e8199196d454941c45d1b3a323f1433bd6'), 'bech32')

inj1w508d6qejxtdg4y5r3zarvary0c5xw7kgj5aqs

SELECT bin(14)

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

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

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

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

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

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

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

SELECT bitPositionsToArray(toInt8(1)) AS bit_positions

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

SELECT bitPositionsToArray(toInt8(-1)) AS bit_positions

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

SELECT bitmaskToArray(50) AS powers_of_two

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

SELECT bitmaskToArray(8) AS powers_of_two

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

SELECT bitmaskToList(50) AS powers_list

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

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

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

-- Você pode construir uma string de codificação arbitrária passando os bytes correspondentes.
-- por exemplo UTF8
SELECT char(0xD0, 0xBF, 0xD1, 0x80, 0xD0, 0xB8, 0xD0, 0xB2, 0xD0, 0xB5, 0xD1, 0x82) AS hello;

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

SELECT hex(1)

01

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

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

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

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

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

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

SELECT hilbertDecode(2, 31)

["3", "4"]

-- O código de Hilbert para um argumento é sempre o próprio argumento (como uma tupla).
SELECT hilbertDecode(1, 1)

["1"]

-- Um único argumento com uma tupla especificando deslocamentos de bits será deslocado para a direita correspondentemente.
SELECT hilbertDecode(tuple(2), 32768)

["128"]

-- Primeiro crie a tabela e insira alguns dados
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 nomes de colunas em vez de constantes como argumentos da função
SELECT untuple(hilbertDecode(2, hilbertEncode(n1, n2))) FROM hilbert_numbers;

1    2

SELECT hilbertEncode(3, 4)

31

-- A expansão de intervalo pode ser útil quando você precisa de uma distribuição semelhante para
-- argumentos com intervalos (ou cardinalidade) muito diferentes.
-- Por exemplo: 'Endereço IP' (0...FFFFFFFF) e 'Código de país' (0...FF).
-- Nota: o tamanho da tupla deve ser igual ao número dos demais argumentos.
SELECT hilbertEncode((10, 6), 1024, 16)

4031541586602

-- Para um único argumento sem uma tupla, a função retorna o próprio argumento
-- como o índice de Hilbert, já que nenhum mapeamento dimensional é necessário.
SELECT hilbertEncode(1)

1

-- Se um único argumento for fornecido com uma tupla especificando deslocamentos de bits, a função
-- desloca o argumento para a esquerda pelo número de bits especificado.
SELECT hilbertEncode(tuple(2), 128)

512

-- Primeiro crie a tabela e insira alguns dados
CREATE TABLE hilbert_numbers(
    n1 UInt32,
    n2 UInt32
)
ENGINE=MergeTree()
ORDER BY n1;
insert into hilbert_numbers (*) values(1, 2);

-- Use nomes de colunas em vez de constantes como argumentos da função
SELECT hilbertEncode(n1, n2) FROM hilbert_numbers;

13

SELECT mortonDecode(3, 53)

["1", "2", "3"]

SELECT mortonDecode(1, 1)

["1"]

SELECT mortonDecode(tuple(2), 32768)

["128"]

-- Primeiro crie a tabela e insira alguns dados
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 nomes de colunas em vez de constantes como argumentos da função
SELECT untuple(mortonDecode(8, mortonEncode(n1, n2, n3, n4, n5, n6, n7, n8))) FROM morton_numbers;

1 2 3 4 5 6 7 8

SELECT mortonEncode(1, 2, 3)

53

-- A expansão de intervalo pode ser útil quando você precisa de uma distribuição semelhante para
-- argumentos com intervalos (ou cardinalidade) muito diferentes
-- Por exemplo: 'Endereço IP' (0...FFFFFFFF) e 'Código de país' (0...FF).
-- Nota: o tamanho da tupla deve ser igual ao número dos demais argumentos.
SELECT mortonEncode((1,2), 1024, 16)

1572864

-- A codificação Morton para um argumento é sempre o próprio argumento
SELECT mortonEncode(1)

1

SELECT mortonEncode(tuple(2), 128)

32768

-- Primeiro, crie a tabela e insira alguns dados
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 nomes de colunas em vez de constantes como argumentos da função
SELECT mortonEncode(n1, n2, n3, n4, n5, n6, n7, n8) FROM morton_numbers;

2155374165

SELECT sqidDecode('gXHfJ1C6dN');

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

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

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

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

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

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

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

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

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

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

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