Introduit dans : v25.6.0
Décode une chaîne d’adresse Bech32 générée par l’algorithme bech32 ou bech32m.
Contrairement à la fonction d’encodage, bech32Decode gère automatiquement les FixedStrings avec remplissage.
bech32Decode(address[, 'raw'])
address — Une chaîne Bech32 à décoder. String ou FixedStringmode — Facultatif. Utilisez 'raw' pour décoder sans retirer le premier octet servant de witness version. À utiliser pour les adresses non SegWit (par ex. Cosmos SDK). String
Valeur renvoyée
Renvoie un tuple (hrp, data) ayant servi à encoder la chaîne. Les données sont au format binaire. Tuple(String, String)
Exemples
Décoder l’adresse
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
Lors de l’utilisation du type de données FixedString, si une valeur ne remplit pas entièrement la ligne, elle est complétée par des caractères nuls.
Bien que la fonction bech32Encode gère cela automatiquement pour l’argument hrp, les valeurs de l’argument data ne doivent pas être complétées.
Pour cette raison, il n’est pas recommandé d’utiliser le type de données FixedString pour vos données, sauf si vous êtes
certain qu’elles ont toutes la même longueur et que votre colonne FixedString est également définie sur cette longueur. bech32Encode(hrp, data[, witver | 'bech32' | 'bech32m'])
hrp — Une chaîne de 1 - 83 caractères minuscules spécifiant la « partie lisible par l’humain » du code. Généralement 'bc' ou 'tb'. String ou FixedStringdata — Une chaîne de données binaires à encoder. String ou FixedStringwitver_or_variant — Facultatif. Soit une version witness UInt* (par défaut = 1, 0 pour Bech32, 1+ pour Bech32m), soit une variante d’encodage de type String : 'bech32' (BIP173) ou 'bech32m' (BIP350). Lorsqu’une variante de chaîne est utilisée, aucun octet de version witness n’est ajouté en préfixe — cela est nécessaire pour les adresses non-SegWit comme celles de Cosmos SDK. UInt* ou String
Valeur renvoyée
Renvoie une chaîne d’adresse Bech32, composée de la partie lisible par l’humain, d’un caractère séparateur qui est toujours '1', et d’une partie de données. La longueur de la chaîne ne dépassera jamais 90 caractères. Si l’algorithme ne peut pas générer d’adresse valide à partir de l’entrée, il renvoie une chaîne vide. String
Exemples
Bech32m par défaut
-- When no witness version is supplied, the default is 1, the updated Bech32m algorithm.
SELECT bech32Encode('bc', unhex('751e76e8199196d454941c45d1b3a323f1433bd6'))
bc1w508d6qejxtdg4y5r3zarvary0c5xw7k8zcwmq
-- A witness version of 0 will result in a different address string.
SELECT bech32Encode('bc', unhex('751e76e8199196d454941c45d1b3a323f1433bd6'), 0)
bc1w508d6qejxtdg4y5r3zarvary0c5xw7kj7gz7z
-- 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)
abcdefg1w508d6qejxtdg4y5r3zarvary0c5xw7k9rp8r4
-- 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')
inj1w508d6qejxtdg4y5r3zarvary0c5xw7kgj5aqs
| Type | Description |
|---|
(U)Int* | Affiche les bits du plus significatif au moins significatif (ordre big-endian ou ordre “human-readable”). Commence par l’octet non nul le plus significatif (les octets nuls de tête sont omis), mais affiche toujours les huit bits de chaque octet, même si le bit de tête est zéro. |
Date et DateTime | Formatés comme les entiers correspondants (le nombre de jours depuis l’epoch pour Date et la valeur du timestamp Unix pour DateTime). |
String et FixedString | Tous les octets sont simplement encodés sous forme de nombres binaires sur huit bits. Les octets nuls ne sont pas omis. |
Float* et Decimal | Encodés selon leur représentation en mémoire. Comme seule l’architecture little-endian est prise en charge, ils sont encodés en little-endian. Les octets nuls de tête ou de fin ne sont pas omis. |
UUID | Encodé sous forme de chaîne en ordre big-endian. |
String
Exemples
Entier simple
┌─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)
Exemples
Un seul bit défini
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)
Exemples
Exemple de base
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
Exemples
Exemple simple
SELECT bitmaskToList(50) AS powers_list
┌─powers_list───┐
│ 2, 16, 32 │
└───────────────┘
UInt8, elle est convertie
en UInt8, avec un arrondi et un dépassement de capacité possibles.
Syntaxe
char(num1[, num2[, ...]])
String
Exemples
Exemple de base
SELECT char(104.1, 101, 108.9, 108.9, 111) AS hello;
┌─hello─┐
│ hello │
└───────┘
-- You can construct a string of arbitrary encoding by passing the corresponding bytes.
-- for example UTF8
SELECT char(0xD0, 0xBF, 0xD1, 0x80, 0xD0, 0xB8, 0xD0, 0xB2, 0xD0, 0xB5, 0xD1, 0x82) AS hello;
┌─hello──┐
│ привет │
└────────┘
| Type | Description |
|---|
(U)Int* | Affiche les chiffres hexadécimaux (“nibbles”) du plus significatif au moins significatif (ordre big-endian, ou ordre “lisible par l’humain”). Commence par l’octet non nul le plus significatif (les octets nuls en tête sont omis), mais affiche toujours les deux chiffres de chaque octet, même si le premier est zéro. |
Date et DateTime | Formatés comme les entiers correspondants (le nombre de jours depuis l’epoch pour Date et la valeur du timestamp Unix pour DateTime). |
String et FixedString | Tous les octets sont simplement encodés sous forme de deux chiffres hexadécimaux. Les octets nuls ne sont pas omis. |
Float* et Decimal | Encodés selon leur représentation en mémoire. ClickHouse représente toujours les valeurs en interne en little-endian ; elles sont donc encodées de cette façon. Les octets nuls de début et de fin ne sont pas omis. |
UUID | Encodé sous forme de chaîne en ordre big-endian. |
A-F et n’utilise ni préfixe (comme 0x) ni suffixe (comme h).
Syntaxe
Arguments
Valeur renvoyée
Renvoie une chaîne contenant la représentation hexadécimale de l’argument. String
Exemples
Entier simple
Nombres à virgule flottante 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, cette fonction possède deux modes de fonctionnement :
Mode simple
Accepte jusqu’à 2 entiers non signés comme arguments et génère un code UInt64.
Mode étendu
Accepte un masque de plage (tuple) comme premier argument et jusqu’à 2 entiers non signés comme
autres arguments. Chaque nombre du masque configure le nombre de bits de décalage vers la gauche de
l’argument correspondant, ce qui met effectivement cet argument à l’échelle
dans sa plage.
L’extension de plage peut être utile lorsque vous avez besoin d’une distribution similaire pour
des arguments dont les plages (ou la cardinalité) sont très différentes. Par exemple : ‘Adresse IP’ (0...FFFFFFFF)
et ‘Code pays’ (0...FF). Comme pour la fonction d’encodage, ce mode est limité à 8
nombres au maximum.
Syntaxe
hilbertDecode(tuple_size, code)
Tuple(UInt64)
Exemples
Mode simple
SELECT hilbertDecode(2, 31)
-- Hilbert code for one argument is always the argument itself (as a tuple).
SELECT hilbertDecode(1, 1)
-- A single argument with a tuple specifying bit shifts will be right-shifted accordingly.
SELECT hilbertDecode(tuple(2), 32768)
-- 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;
-- Simplified mode
hilbertEncode(args)
-- Expanded mode
hilbertEncode(range_mask, args)
args — Jusqu’à deux valeurs UInt ou deux colonnes de type UInt. UInt8/16/32/64range_mask — En mode étendu, jusqu’à deux valeurs UInt ou deux colonnes de type UInt. UInt8/16/32/64
Valeur renvoyée
Renvoie un code UInt64. UInt64
Exemples
Mode simple
SELECT hilbertEncode(3, 4)
-- Range expansion can be beneficial when you need a similar distribution for
-- arguments with wildly different ranges (or cardinality).
-- For example: 'IP Address' (0...FFFFFFFF) and 'Country code' (0...FF).
-- Note: tuple size must be equal to the number of the other arguments.
SELECT hilbertEncode((10, 6), 1024, 16)
-- For a single argument without a tuple, the function returns the argument
-- itself as the Hilbert index, since no dimensional mapping is needed.
SELECT hilbertEncode(1)
-- If a single argument is provided with a tuple specifying bit shifts, the function
-- shifts the argument left by the specified number of bits.
SELECT hilbertEncode(tuple(2), 128)
-- First create the table and insert some data
CREATE TABLE hilbert_numbers(
n1 UInt32,
n2 UInt32
)
ENGINE=MergeTree()
ORDER BY n1;
insert into hilbert_numbers (*) values(1, 2);
-- Use column names instead of constants as function arguments
SELECT hilbertEncode(n1, n2) FROM hilbert_numbers;
mortonEncode, cette fonction dispose de deux modes de fonctionnement :
Mode simple
Accepte comme premier argument la taille du tuple résultant, et comme second argument le code.
Mode étendu
Accepte comme premier argument un masque de plages (tuple), et comme second argument le code.
Chaque nombre du masque configure le facteur de réduction de plage :
1 - aucune réduction2 - réduction par 23 - réduction par 3
⋮- Jusqu’à une réduction par 8.
L’expansion de plage peut être utile lorsque vous avez besoin d’une distribution similaire pour
des arguments dont les plages (ou la cardinalité) sont très différentes. Par exemple : « Adresse IP » (0...FFFFFFFF)
et « Code pays » (0...FF). Comme pour la fonction d’encodage, cette fonctionnalité est limitée à
8 nombres au maximum.
Syntaxe
-- Simple mode
mortonDecode(tuple_size, code)
-- Expanded mode
mortonDecode(range_mask, code)
tuple_size — Valeur entière inférieure ou égale à 8. UInt8/16/32/64range_mask — En mode étendu, le masque de chaque argument. Le masque est un tuple d’entiers non signés. Chaque nombre du masque définit le niveau de réduction de la plage. Tuple(UInt8/16/32/64)code — Code UInt64. UInt64
Valeur renvoyée
Renvoie un tuple de la taille spécifiée. Tuple(UInt64)
Exemples
Mode simple
SELECT mortonDecode(3, 53)
SELECT mortonDecode(1, 1)
SELECT mortonDecode(tuple(2), 32768)
-- 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;
UInt64.
Mode étendu
Accepte un masque de plage (Tuple) comme premier argument et
jusqu’à 8 entiers non signés comme arguments supplémentaires.
Chaque nombre du masque détermine le niveau d’extension de la plage :
- 1 - aucune extension
- 2 - extension 2x
- 3 - extension 3x
⋮
- Jusqu’à 8x d’extension.
Syntaxe
-- Simplified mode
mortonEncode(args)
-- Expanded mode
mortonEncode(range_mask, args)
args — Jusqu’à 8 entiers non signés ou colonnes du type mentionné ci-dessus. UInt8/16/32/64range_mask — En mode étendu, le masque pour chaque argument. Le masque est un tuple d’entiers non signés de 1 à 8. Chaque nombre du masque configure le degré de réduction de la plage. Tuple(UInt8/16/32/64)
Valeur renvoyée
Renvoie un code UInt64. UInt64
Exemples
Mode simple
SELECT mortonEncode(1, 2, 3)
-- Range expansion can be beneficial when you need a similar distribution for
-- arguments with wildly different ranges (or cardinality)
-- For example: 'IP Address' (0...FFFFFFFF) and 'Country code' (0...FF).
-- Note: the Tuple size must be equal to the number of the other arguments.
SELECT mortonEncode((1,2), 1024, 16)
-- Morton encoding for one argument is always the argument itself
SELECT mortonEncode(1)
SELECT mortonEncode(tuple(2), 128)
-- 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 mortonEncode(n1, n2, n3, n4, n5, n6, n7, n8) FROM morton_numbers;
sqid — Le sqid à décoder. String
Valeur renvoyée
Renvoie un tableau de nombres issu de sqid. Array(UInt64)
Exemples
Exemple d’utilisation
SELECT sqidDecode('gXHfJ1C6dN');
┌─sqidDecode('gXHfJ1C6dN')─────┐
│ [1, 2, 3, 4, 5] │
└──────────────────────────────┘
sqidEncode(n1[, n2, ...])
sqid
Arguments
n1[, n2, ...] — Un nombre quelconque de valeurs numériques. UInt8/16/32/64
Valeur renvoyée
Renvoie un identifiant de hachage String
Exemples
Exemple d’utilisation
SELECT sqidEncode(1, 2, 3, 4, 5);
┌─sqidEncode(1, 2, 3, 4, 5)─┐
│ gXHfJ1C6dN │
└───────────────────────────┘
bin.
Pour un argument numérique, unbin() ne renvoie pas l’inverse de bin(). Si vous souhaitez convertir le résultat en nombre, vous pouvez utiliser les fonctions reverse et reinterpretAs<Type>.
Si unbin est appelée depuis le clickhouse-client, les chaînes binaires sont affichées en UTF-8.
0 et 1. Le nombre de chiffres binaires n’a pas besoin d’être un multiple de huit. Si la chaîne d’argument contient autre chose que des chiffres binaires,
le résultat est indéfini (aucune exception n’est levée).
Syntaxe
Arguments
arg — Une chaîne contenant une suite quelconque de chiffres binaires. String
Valeur renvoyée
Renvoie une chaîne binaire (BLOB). String
Exemples
Utilisation de base
SELECT UNBIN('001100000011000100110010'), UNBIN('0100110101111001010100110101000101001100')
┌─unbin('001100000011000100110010')─┬─unbin('0100110101111001010100110101000101001100')─┐
│ 012 │ MySQL │
└───────────────────────────────────┴───────────────────────────────────────────────────┘
SELECT reinterpretAsUInt64(reverse(unbin('1110'))) AS num
hex. Interprète chaque paire de chiffres hexadécimaux (dans l’argument) comme un nombre, puis la convertit
en l’octet représenté par ce nombre. La valeur renvoyée est une chaîne binaire (BLOB).
Si vous souhaitez convertir le résultat en nombre, vous pouvez utiliser les fonctions reverse et reinterpretAs<Type>.
clickhouse-client interprète les chaînes comme de l’UTF-8.
Cela peut entraîner un affichage inattendu des valeurs renvoyées par hex.
A-F, en majuscules comme en minuscules.
Le nombre de chiffres hexadécimaux n’a pas besoin d’être pair.
S’il est impair, le dernier chiffre est interprété comme la moitié de poids faible de l’octet 00-0F.
Si la chaîne d’argument contient autre chose que des chiffres hexadécimaux, un résultat défini par l’implémentation est renvoyé (aucune exception n’est levée).
Pour un argument numérique, unhex() n’effectue pas l’inverse de hex(N).
Syntaxe
Arguments
arg — Une chaîne contenant un nombre quelconque de caractères hexadécimaux. String ou FixedString
Valeur renvoyée
Renvoie une chaîne binaire (BLOB). String
Exemples
Utilisation de base
SELECT unhex('303132'), UNHEX('4D7953514C')
┌─unhex('303132')─┬─unhex('4D7953514C')─┐
│ 012 │ MySQL │
└─────────────────┴─────────────────────┘
SELECT reinterpretAsUInt64(reverse(unhex('FFF'))) AS num
┌──num─┐
│ 4095 │
└──────┘
