Introduzido em: v25.6.0
Decodifica uma string de endereço Bech32 gerada pelos algoritmos bech32 ou bech32m.
Ao contrário da função de codificação, bech32Decode lida automaticamente com FixedStrings preenchidas.
bech32Decode(address[, 'raw'])
address — Uma string Bech32 a ser decodificada. String ou FixedStringmode — Opcional. Passe 'raw' para decodificar sem remover o primeiro byte como versão witness. Use essa opção para endereços não SegWit (por exemplo, Cosmos SDK). String
Valor retornado
Retorna uma tupla formada por (hrp, data) usada para codificar a string. Os dados estão em formato binário. Tuple(String, String)
Exemplos
Decodificar endereç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
Ao usar o tipo de dados FixedString, se um valor não preencher completamente a linha, ele será completado com caracteres nulos.
Embora a função bech32Encode trate isso automaticamente para o argumento hrp, no caso do argumento data os valores não devem ser completados.
Por esse motivo, não é recomendável usar o tipo de dados FixedString para seus valores de dados, a menos que você tenha
certeza de que todos eles têm o mesmo comprimento e garanta que sua coluna FixedString também esteja definida com esse comprimento. bech32Encode(hrp, data[, witver | 'bech32' | 'bech32m'])
hrp — Uma String de 1 - 83 caracteres minúsculos que especifica a “parte legível por humanos” do código. Geralmente ‘bc’ ou ‘tb’. String ou FixedStringdata — Uma String de dados binários para codificação. String ou FixedStringwitver_or_variant — Opcional. Pode ser uma versão witness UInt* (padrão = 1, 0 para Bech32, 1+ para Bech32m) ou uma variante de codificação String: 'bech32' (BIP173) ou 'bech32m' (BIP350). Quando uma variante String é usada, nenhum byte de versão witness é prefixado — isso é necessário para endereços não SegWit, como os do Cosmos SDK. UInt* ou String
Valor retornado
Retorna uma string de endereço Bech32, composta pela parte legível por humanos, um caractere separador que é sempre ‘1’ e uma parte de dados. O comprimento da string nunca excederá 90 caracteres. Se o algoritmo não conseguir gerar um endereço válido a partir da entrada, retornará uma string vazia. String
Exemplos
Bech32m padrão
-- 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
| Tipo | Descrição |
|---|
(U)Int* | Exibe os dígitos binários do mais significativo para o menos significativo (ordem big-endian, ou “legível por humanos”). Começa com o byte não zero mais significativo (bytes zero à esquerda são omitidos), mas sempre exibe os oito dígitos de cada byte, mesmo que o dígito inicial seja zero. |
Date and DateTime | Formatados como os inteiros correspondentes (o número de dias desde a epoch para Date e o valor do Unix timestamp para DateTime). |
String and FixedString | Todos os bytes são simplesmente codificados como sequências de oito dígitos binários. Bytes zero não são omitidos. |
Float* and Decimal | Codificados conforme sua representação na memória. Como há suporte para arquitetura little-endian, eles são codificados em little-endian. Bytes zero à esquerda/à direita não são omitidos. |
UUID | Codificado como string em ordem big-endian. |
String
Exemplos
Inteiro simples
┌─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 │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
Array(UInt64)
Exemplos
Um único bit ativado
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] │
└───────────────────────────┘
Array(UInt64)
Exemplos
Exemplo básico
SELECT bitmaskToArray(50) AS powers_of_two
┌─powers_of_two───┐
│ [2, 16, 32] │
└─────────────────┘
SELECT bitmaskToArray(8) AS powers_of_two
┌─powers_of_two─┐
│ [8] │
└───────────────┘
String
Exemplos
Exemplo básico
SELECT bitmaskToList(50) AS powers_list
┌─powers_list───┐
│ 2, 16, 32 │
└───────────────┘
UInt8, ele será convertido
para UInt8, com possível arredondamento e estouro.
Sintaxe
char(num1[, num2[, ...]])
String
Exemplos
Exemplo básico
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──┐
│ привет │
└────────┘
| Tipo | Descrição |
|---|
(U)Int* | Imprime dígitos hexadecimais (“nibbles”) do mais significativo para o menos significativo (ordem big-endian ou “legível para humanos”). Começa com o byte não zero mais significativo (bytes zero à esquerda são omitidos), mas sempre imprime ambos os dígitos de cada byte, mesmo que o dígito à esquerda seja zero. |
Date e DateTime | Formatados como os inteiros correspondentes (o número de dias desde o epoch para Date e o valor do timestamp Unix para DateTime). |
String e FixedString | Todos os bytes são simplesmente codificados como dois números hexadecimais. Bytes zero não são omitidos. |
Float* e Decimal | Codificados conforme sua representação na memória. O ClickHouse sempre representa os valores internamente em little-endian, portanto eles são codificados dessa forma. Bytes zero à esquerda/à direita não são omitidos. |
UUID | Codificado como string em ordem big-endian. |
A-F e não usa prefixos (como 0x) nem sufixos (como h).
Sintaxe
Argumentos
Valor retornado
Retorna uma string contendo a representação hexadecimal do argumento. String
Exemplos
Inteiro simples
Números de ponto flutuante Float32
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 │
└──────────────────────────────────┘
hilbertEncode, esta função tem dois modos de operação:
Modo simples
Aceita até 2 inteiros sem sinal como argumentos e gera um código UInt64.
Modo expandido
Aceita uma máscara de intervalo (tupla) como primeiro argumento e até 2 inteiros sem sinal como
outros argumentos. Cada número na máscara configura o número de bits pelos quais
o argumento correspondente será deslocado à esquerda, escalando efetivamente o argumento
dentro do seu intervalo.
A expansão de intervalo pode ser útil quando você precisa de uma distribuição semelhante para
argumentos com intervalos (ou cardinalidade) muito diferentes entre si. Por exemplo: ‘endereço IP’ (0...FFFFFFFF)
e ‘código do país’ (0...FF). Assim como na função de codificação, isso é limitado a 8
números no máximo.
Sintaxe
hilbertDecode(tuple_size, code)
Tuple(UInt64)
Exemplos
Modo simples
SELECT hilbertDecode(2, 31)
-- O código de Hilbert para um argumento é sempre o próprio argumento (como uma tupla).
SELECT hilbertDecode(1, 1)
-- Um único argumento com uma tupla especificando deslocamentos de bits será deslocado para a direita correspondentemente.
SELECT hilbertDecode(tuple(2), 32768)
-- 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;
-- Modo simplificado
hilbertEncode(args)
-- Modo expandido
hilbertEncode(range_mask, args)
args — Até dois valores UInt ou colunas do tipo UInt. UInt8/16/32/64range_mask — No modo expandido, até dois valores UInt ou colunas do tipo UInt. UInt8/16/32/64
Valor retornado
Retorna um código UInt64. UInt64
Exemplos
Modo simples
SELECT hilbertEncode(3, 4)
-- 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)
-- 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)
-- 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)
-- 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;
mortonEncode, esta função tem dois modos de operação:
Modo simples
Aceita o tamanho da tupla resultante como primeiro argumento e o código como segundo argumento.
Modo expandido
Aceita uma máscara de intervalo (tupla) como primeiro argumento e o código como segundo argumento.
Cada número na máscara configura o grau de redução do intervalo:
1 - sem redução2 - redução de 2x3 - redução de 3x
⋮- Até 8x de redução.
A expansão do intervalo pode ser útil quando você precisa de uma distribuição semelhante para
argumentos com intervalos muito diferentes (ou cardinalidade). Por exemplo: ‘Endereço IP’ (0...FFFFFFFF)
e ‘Código do país’ (0...FF). Assim como na função de codificação, isso é limitado a
no máximo 8 números.
Sintaxe
-- Modo simples
mortonDecode(tuple_size, code)
-- Modo expandido
mortonDecode(range_mask, code)
tuple_size — Valor inteiro de no máximo 8. UInt8/16/32/64range_mask — No modo expandido, a máscara para cada argumento. A máscara é uma tupla de inteiros sem sinal. Cada número na máscara configura o grau de redução do intervalo. Tuple(UInt8/16/32/64)code — Código UInt64. UInt64
Valor retornado
Retorna uma tupla do tamanho especificado. Tuple(UInt64)
Exemplos
Modo simples
SELECT mortonDecode(3, 53)
SELECT mortonDecode(1, 1)
SELECT mortonDecode(tuple(2), 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 untuple(mortonDecode(8, mortonEncode(n1, n2, n3, n4, n5, n6, n7, n8))) FROM morton_numbers;
UInt64.
Modo expandido
Aceita uma máscara de intervalo (tupla) como primeiro argumento e
até 8 inteiros sem sinal nos demais argumentos.
Cada número na máscara configura o fator de expansão do intervalo:
- 1 - sem expansão
- 2 - expansão de 2x
- 3 - expansão de 3x
⋮
- Até 8x de expansão.
Sintaxe
-- Modo simplificado
mortonEncode(args)
-- Modo expandido
mortonEncode(range_mask, args)
args — Até 8 inteiros sem sinal ou colunas do tipo mencionado acima. UInt8/16/32/64range_mask — No modo expandido, a máscara de cada argumento. A máscara é uma tupla de inteiros sem sinal de 1 a 8. Cada número na máscara configura o grau de redução do intervalo. Tuple(UInt8/16/32/64)
Valor retornado
Retorna um código UInt64. UInt64
Exemplos
Modo simples
SELECT mortonEncode(1, 2, 3)
-- 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)
-- A codificação Morton para um argumento é sempre o próprio argumento
SELECT mortonEncode(1)
SELECT mortonEncode(tuple(2), 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 mortonEncode(n1, n2, n3, n4, n5, n6, n7, n8) FROM morton_numbers;
sqid — O sqid a ser decodificado. String
Valor retornado
Retorna um array de números a partir de sqid. Array(UInt64)
Exemplos
Exemplo de uso
SELECT sqidDecode('gXHfJ1C6dN');
┌─sqidDecode('gXHfJ1C6dN')─────┐
│ [1, 2, 3, 4, 5] │
└──────────────────────────────┘
sqidEncode(n1[, n2, ...])
sqid
Argumentos
Valor retornado
Retorna um ID de hash String
Exemplos
Exemplo de uso
SELECT sqidEncode(1, 2, 3, 4, 5);
┌─sqidEncode(1, 2, 3, 4, 5)─┐
│ gXHfJ1C6dN │
└───────────────────────────┘
unbin() não retorna o inverso de bin(). Se você quiser converter o resultado em um número, pode usar as funções reverse e reinterpretAs<Type>.
Se unbin for chamado de dentro do clickhouse-client, as strings binárias serão exibidas usando UTF-8.
0 e 1. A quantidade de dígitos binários não precisa ser múltipla de oito. Se a string do argumento contiver qualquer coisa além de dígitos binários,
o resultado será indefinido (nenhuma exceção é lançada).
Sintaxe
Argumentos
arg — Uma string que contém qualquer número de dígitos binários. String
Valor retornado
Retorna uma string binária (BLOB). String
Exemplos
Uso básico
SELECT UNBIN('001100000011000100110010'), UNBIN('0100110101111001010100110101000101001100')
┌─unbin('001100000011000100110010')─┬─unbin('0100110101111001010100110101000101001100')─┐
│ 012 │ MySQL │
└───────────────────────────────────┴───────────────────────────────────────────────────┘
SELECT reinterpretAsUInt64(reverse(unbin('1110'))) AS num
hex. Interpreta cada par de dígitos hexadecimais (no argumento) como um número e o converte
no byte representado por esse número. O valor retornado é uma string binária (BLOB).
Se você quiser converter o resultado em um número, pode usar as funções reverse e reinterpretAs<Type>.
clickhouse-client interpreta strings como UTF-8.
Isso pode fazer com que os valores retornados por hex sejam exibidos de forma inesperada.
A-F, tanto maiúsculas quanto minúsculas.
A quantidade de dígitos hexadecimais não precisa ser par.
Se for ímpar, o último dígito será interpretado como a metade menos significativa do byte 00-0F.
Se a string do argumento contiver qualquer caractere que não seja um dígito hexadecimal, será retornado algum resultado definido pela implementação (nenhuma exceção é lançada).
Para um argumento numérico, unhex() não executa o inverso de hex(N).
Sintaxe
Argumentos
arg — Uma sequência de caracteres contendo qualquer quantidade de dígitos hexadecimais. String ou FixedString
Valor retornado
Retorna uma sequência binária de caracteres (BLOB). String
Exemplos
Uso básico
SELECT unhex('303132'), UNHEX('4D7953514C')
┌─unhex('303132')─┬─unhex('4D7953514C')─┐
│ 012 │ MySQL │
└─────────────────┴─────────────────────┘
SELECT reinterpretAsUInt64(reverse(unhex('FFF'))) AS num
┌──num─┐
│ 4095 │
└──────┘
