> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-fbfa8bee.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. > Documentation sur les fonctions d'encodage # Fonctions d'encodage {/*AUTOGENERATED_START*/}
## bech32Decode
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. **Syntaxe** ```sql theme={null} bech32Decode(address[, 'raw']) ``` **Arguments** * `address` — Une chaîne Bech32 à décoder. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) * `mode` — 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`](/fr/reference/data-types/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)`](/fr/reference/data-types/tuple) **Exemples** **Décoder l'adresse** ```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 ``` **Adresse du réseau de test** ```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
Introduit dans : v25.6.0 Encode une chaîne de données binaires avec une partie lisible par l’humain (HRP), à l’aide des algorithmes [Bech32 ou Bech32m](https://en.bitcoin.it/wiki/Bech32). Lors de l’utilisation du type de données [`FixedString`](/fr/reference/data-types/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`](/fr/reference/data-types/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. **Syntaxe** ```sql theme={null} bech32Encode(hrp, data[, witver | 'bech32' | 'bech32m']) ``` **Arguments** * `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`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) * `data` — Une chaîne de données binaires à encoder. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) * `witver_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*`](/fr/reference/data-types/int-uint) ou [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/string) **Exemples** **Bech32m par défaut** ```sql title=Query theme={null} -- When no witness version is supplied, the default is 1, the updated Bech32m algorithm. SELECT bech32Encode('bc', unhex('751e76e8199196d454941c45d1b3a323f1433bd6')) ``` ```response title=Response theme={null} bc1w508d6qejxtdg4y5r3zarvary0c5xw7k8zcwmq ``` **Algorithme Bech32** ```sql title=Query theme={null} -- A witness version of 0 will result in a different address string. SELECT bech32Encode('bc', unhex('751e76e8199196d454941c45d1b3a323f1433bd6'), 0) ``` ```response title=Response theme={null} bc1w508d6qejxtdg4y5r3zarvary0c5xw7kj7gz7z ``` **HRP personnalisé** ```sql title=Query theme={null} -- 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) ``` ```response title=Response theme={null} abcdefg1w508d6qejxtdg4y5r3zarvary0c5xw7k9rp8r4 ``` **Adresse Cosmos SDK (BIP173, sans version de témoin)** ```sql title=Query theme={null} -- 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') ``` ```response title=Response theme={null} inj1w508d6qejxtdg4y5r3zarvary0c5xw7kgj5aqs ```
## bin
Introduit dans : v21.8.0 Renvoie une chaîne contenant la représentation binaire de l'argument selon la logique suivante pour les différents types : | 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. | **Syntaxe** ```sql theme={null} bin(arg) ``` **Arguments** * `arg` — Valeur à convertir en binaire. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) **Valeur renvoyée** Renvoie une chaîne correspondant à la représentation binaire de l'argument. [`String`](/fr/reference/data-types/string) **Exemples** **Entier simple** ```sql title=Query theme={null} SELECT bin(14) ``` ```response title=Response theme={null} ┌─bin(14)──┐ │ 00001110 │ └──────────┘ ``` **Nombres de type 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 │ └──────────────────────────────────┘ ``` **Nombres de type 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 │ └──────────────────────────────────────────────────────────────────┘ ``` **Conversion d’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
Introduit dans : v21.7.0 Cette fonction renvoie les positions (par ordre croissant) des bits à 1 dans la représentation binaire d’un entier non signé. Les entiers signés en entrée sont d’abord convertis en entiers non signés. **Syntaxe** ```sql theme={null} bitPositionsToArray(arg) ``` **Arguments** * `arg` — Une valeur entière. [`(U)Int*`](/fr/reference/data-types/int-uint) **Valeur renvoyée** Renvoie un tableau contenant les positions, par ordre croissant, des bits à 1 dans la représentation binaire de la valeur d’entrée. [`Array(UInt64)`](/fr/reference/data-types/array) **Exemples** **Un seul bit défini** ```sql title=Query theme={null} SELECT bitPositionsToArray(toInt8(1)) AS bit_positions ``` ```response title=Response theme={null} ┌─bit_positions─┐ │ [0] │ └───────────────┘ ``` **Tous les bits à 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
Introduit dans : v1.1.0 Cette fonction décompose un entier en somme de puissances de deux. Les puissances de deux sont renvoyées sous la forme d’un tableau classé par ordre croissant. **Syntaxe** ```sql theme={null} bitmaskToArray(num) ``` **Arguments** * `num` — Une valeur entière. [`(U)Int*`](/fr/reference/data-types/int-uint) **Valeur renvoyée** Renvoie un tableau des puissances de deux, triées par ordre croissant, dont la somme est égale au nombre d’entrée. [`Array(UInt64)`](/fr/reference/data-types/array) **Exemples** **Exemple de base** ```sql title=Query theme={null} SELECT bitmaskToArray(50) AS powers_of_two ``` ```response title=Response theme={null} ┌─powers_of_two───┐ │ [2, 16, 32] │ └─────────────────┘ ``` **Une unique puissance de deux** ```sql title=Query theme={null} SELECT bitmaskToArray(8) AS powers_of_two ``` ```response title=Response theme={null} ┌─powers_of_two─┐ │ [8] │ └───────────────┘ ```
## bitmaskToList
Introduit dans : v1.1.0 Comme bitmaskToArray, mais renvoie les puissances de deux sous la forme d’une chaîne de caractères séparée par des virgules. **Syntaxe** ```sql theme={null} bitmaskToList(num) ``` **Arguments** * `num` — Une valeur entière. [`(U)Int*`](/fr/reference/data-types/int-uint) **Valeur renvoyée** Renvoie une chaîne contenant des puissances de deux séparées par des virgules. [`String`](/fr/reference/data-types/string) **Exemples** **Exemple simple** ```sql title=Query theme={null} SELECT bitmaskToList(50) AS powers_list ``` ```response title=Response theme={null} ┌─powers_list───┐ │ 2, 16, 32 │ └───────────────┘ ```
## char
Introduit dans : v20.1.0 Renvoie une chaîne dont la longueur est égale au nombre d’arguments passés, dans laquelle chaque octet a la valeur de l’argument correspondant. Accepte plusieurs arguments de types numériques. Si la valeur de l’argument est en dehors de la plage du type de données `UInt8`, elle est convertie en `UInt8`, avec un arrondi et un dépassement de capacité possibles. **Syntaxe** ```sql theme={null} char(num1[, num2[, ...]]) ``` **Arguments** * `num1[, num2[, num3 ...]]` — Arguments numériques interprétés comme des entiers. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) **Valeur renvoyée** Renvoie une chaîne correspondant aux octets donnés. [`String`](/fr/reference/data-types/string) **Exemples** **Exemple de base** ```sql title=Query theme={null} SELECT char(104.1, 101, 108.9, 108.9, 111) AS hello; ``` ```response title=Response theme={null} ┌─hello─┐ │ hello │ └───────┘ ``` **Création d’encodages arbitraires** ```sql title=Query theme={null} -- 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; ``` ```response title=Response theme={null} ┌─hello──┐ │ привет │ └────────┘ ```
## hex
Introduit dans : v1.1.0 Renvoie une chaîne contenant la représentation hexadécimale de l'argument selon la logique suivante pour les différents types : | 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. | La fonction utilise les lettres majuscules `A-F` et n’utilise ni préfixe (comme `0x`) ni suffixe (comme `h`). **Syntaxe** ```sql theme={null} hex(arg) ``` **Arguments** * `arg` — Une valeur à convertir en hexadécimal. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) **Valeur renvoyée** Renvoie une chaîne contenant la représentation hexadécimale de l’argument. [`String`](/fr/reference/data-types/string) **Exemples** **Entier simple** ```sql title=Query theme={null} SELECT hex(1) ``` ```response title=Response theme={null} 01 ``` **Nombres à virgule flottante 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 │ └──────────────────┘ ``` **Nombres 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 │ └──────────────────┘ ``` **Conversion d’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
Introduit dans : v24.6.0 Décode un index de courbe de Hilbert en un tuple d'entiers non signés, représentant des coordonnées dans un espace multidimensionnel. Comme la fonction `hilbertEncode`, cette fonction possède deux modes de fonctionnement : * **Simple** * **Étendu** **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** ```sql theme={null} hilbertDecode(tuple_size, code) ``` **Arguments** * `tuple_size` — Valeur entière inférieure ou égale à `2`. [`UInt8/16/32/64`](/fr/reference/data-types/int-uint) ou [`Tuple(UInt8/16/32/64)`](/fr/reference/data-types/tuple) * `code` — Code `UInt64`. [`UInt64`](/fr/reference/data-types/int-uint) **Valeur renvoyée** Renvoie un tuple de la taille indiquée. [`Tuple(UInt64)`](/fr/reference/data-types/tuple) **Exemples** **Mode simple** ```sql title=Query theme={null} SELECT hilbertDecode(2, 31) ``` ```response title=Response theme={null} ["3", "4"] ``` **Un seul argument** ```sql title=Query theme={null} -- Hilbert code for one argument is always the argument itself (as a tuple). SELECT hilbertDecode(1, 1) ``` ```response title=Response theme={null} ["1"] ``` **Mode étendu** ```sql title=Query theme={null} -- A single argument with a tuple specifying bit shifts will be right-shifted accordingly. SELECT hilbertDecode(tuple(2), 32768) ``` ```response title=Response theme={null} ["128"] ``` **Utilisation avec des colonnes** ```sql title=Query theme={null} -- 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; ``` ```response title=Response theme={null} 1 2 ```
## hilbertEncode
Introduit dans : v24.6.0 Calcule le code de la courbe de Hilbert pour une liste d’entiers non signés. La fonction propose deux modes de fonctionnement : * **Simple** * **étendu** **Mode simple** Accepte jusqu’à 2 entiers non signés comme arguments et produit un code UInt64. **Mode étendu** Accepte un masque de plage ([Tuple](/fr/reference/data-types/tuple)) comme premier argument et jusqu’à 2 [entiers non signés](/fr/reference/data-types/int-uint) comme autres arguments. Chaque nombre du masque définit le nombre de bits dont l’argument correspondant sera décalé vers la gauche, ce qui revient à mettre l’argument à l’échelle dans sa plage. **Syntaxe** ```sql theme={null} -- Simplified mode hilbertEncode(args) -- Expanded mode hilbertEncode(range_mask, args) ``` **Arguments** * `args` — Jusqu’à deux valeurs `UInt` ou deux colonnes de type `UInt`. [`UInt8/16/32/64`](/fr/reference/data-types/int-uint) * `range_mask` — En mode étendu, jusqu’à deux valeurs `UInt` ou deux colonnes de type `UInt`. [`UInt8/16/32/64`](/fr/reference/data-types/int-uint) **Valeur renvoyée** Renvoie un code `UInt64`. [`UInt64`](/fr/reference/data-types/int-uint) **Exemples** **Mode simple** ```sql title=Query theme={null} SELECT hilbertEncode(3, 4) ``` ```response title=Response theme={null} 31 ``` **Mode étendu** ```sql title=Query theme={null} -- 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) ``` ```response title=Response theme={null} 4031541586602 ``` **Un seul argument** ```sql title=Query theme={null} -- 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) ``` ```response title=Response theme={null} 1 ``` **Version étendue à argument unique** ```sql title=Query theme={null} -- 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) ``` ```response title=Response theme={null} 512 ``` **Utilisation de colonnes** ```sql title=Query theme={null} -- 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; ``` ```response title=Response theme={null} 13 ```
## mortonDecode
Introduit dans : v24.6.0 Décode un encodage Morton (ZCurve) en le tuple d’entiers non signés correspondant. Comme pour la fonction `mortonEncode`, cette fonction dispose de deux modes de fonctionnement : * **Simple** * **étendu** **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éduction * `2` - réduction par 2 * `3` - 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** ```sql theme={null} -- Simple mode mortonDecode(tuple_size, code) -- Expanded mode mortonDecode(range_mask, code) ``` **Arguments** * `tuple_size` — Valeur entière inférieure ou égale à 8. [`UInt8/16/32/64`](/fr/reference/data-types/int-uint) * `range_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)`](/fr/reference/data-types/tuple) * `code` — Code UInt64. [`UInt64`](/fr/reference/data-types/int-uint) **Valeur renvoyée** Renvoie un tuple de la taille spécifiée. [`Tuple(UInt64)`](/fr/reference/data-types/tuple) **Exemples** **Mode simple** ```sql title=Query theme={null} SELECT mortonDecode(3, 53) ``` ```response title=Response theme={null} ["1", "2", "3"] ``` **Un seul argument** ```sql title=Query theme={null} SELECT mortonDecode(1, 1) ``` ```response title=Response theme={null} ["1"] ``` **Mode étendu, avec réduction d’un argument** ```sql title=Query theme={null} SELECT mortonDecode(tuple(2), 32768) ``` ```response title=Response theme={null} ["128"] ``` **Utilisation sur des colonnes** ```sql title=Query theme={null} -- 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; ``` ```response title=Response theme={null} 1 2 3 4 5 6 7 8 ```
## mortonEncode
Introduit dans : v24.6.0 Calcule l’encodage Morton (ZCurve) pour une liste d’entiers non signés. La fonction a deux modes de fonctionnement : * **Simple** * *étendu*\* **Mode simple** Accepte jusqu’à 8 entiers non signés en argument et renvoie un code `UInt64`. **Mode étendu** Accepte un masque de plage ([Tuple](/fr/reference/data-types/tuple)) comme premier argument et jusqu’à 8 [entiers non signés](/fr/reference/data-types/int-uint) 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** ```sql theme={null} -- Simplified mode mortonEncode(args) -- Expanded mode mortonEncode(range_mask, args) ``` **Arguments** * `args` — Jusqu’à 8 entiers non signés ou colonnes du type mentionné ci-dessus. [`UInt8/16/32/64`](/fr/reference/data-types/int-uint) * `range_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)`](/fr/reference/data-types/tuple) **Valeur renvoyée** Renvoie un code `UInt64`. [`UInt64`](/fr/reference/data-types/int-uint) **Exemples** **Mode simple** ```sql title=Query theme={null} SELECT mortonEncode(1, 2, 3) ``` ```response title=Response theme={null} 53 ``` **Mode étendu** ```sql title=Query theme={null} -- 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) ``` ```response title=Response theme={null} 1572864 ``` **Un seul argument** ```sql title=Query theme={null} -- Morton encoding for one argument is always the argument itself SELECT mortonEncode(1) ``` ```response title=Response theme={null} 1 ``` **Version étendue à un seul argument** ```sql title=Query theme={null} SELECT mortonEncode(tuple(2), 128) ``` ```response title=Response theme={null} 32768 ``` **Utilisation avec des colonnes** ```sql title=Query theme={null} -- 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; ``` ```response title=Response theme={null} 2155374165 ```
## sqidDecode
Introduit dans : v24.1.0 Décode un [sqid](https://sqids.org/) en tableau de nombres. **Syntaxe** ```sql theme={null} sqidDecode(sqid) ``` **Arguments** * `sqid` — Le sqid à décoder. [`String`](/fr/reference/data-types/string) **Valeur renvoyée** Renvoie un tableau de nombres issu de `sqid`. [`Array(UInt64)`](/fr/reference/data-types/array) **Exemples** **Exemple d'utilisation** ```sql title=Query theme={null} SELECT sqidDecode('gXHfJ1C6dN'); ``` ```response title=Response theme={null} ┌─sqidDecode('gXHfJ1C6dN')─────┐ │ [1, 2, 3, 4, 5] │ └──────────────────────────────┘ ```
## sqidEncode
Introduit dans : v24.1.0 Convertit des nombres en [sqid](https://sqids.org/), une chaîne d’identifiant de type YouTube. **Syntaxe** ```sql theme={null} sqidEncode(n1[, n2, ...]) ``` **Alias** : `sqid` **Arguments** * `n1[, n2, ...]` — Un nombre quelconque de valeurs numériques. [`UInt8/16/32/64`](/fr/reference/data-types/int-uint) **Valeur renvoyée** Renvoie un identifiant de hachage [`String`](/fr/reference/data-types/string) **Exemples** **Exemple d'utilisation** ```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
Introduit dans : v21.8.0 Interprète chaque paire de chiffres binaires (dans l'argument) comme un nombre et la convertit en l'octet représenté par ce nombre. La fonction effectue l'opération inverse de `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`. Si `unbin` est appelée depuis le `clickhouse-client`, les chaînes binaires sont affichées en UTF-8. Prend en charge les chiffres binaires `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** ```sql theme={null} unbin(arg) ``` **Arguments** * `arg` — Une chaîne contenant une suite quelconque de chiffres binaires. [`String`](/fr/reference/data-types/string) **Valeur renvoyée** Renvoie une chaîne binaire (BLOB). [`String`](/fr/reference/data-types/string) **Exemples** **Utilisation de base** ```sql title=Query theme={null} SELECT UNBIN('001100000011000100110010'), UNBIN('0100110101111001010100110101000101001100') ``` ```response title=Response theme={null} ┌─unbin('001100000011000100110010')─┬─unbin('0100110101111001010100110101000101001100')─┐ │ 012 │ MySQL │ └───────────────────────────────────┴───────────────────────────────────────────────────┘ ``` **Conversion en nombre** ```sql title=Query theme={null} SELECT reinterpretAsUInt64(reverse(unbin('1110'))) AS num ``` ```response title=Response theme={null} ┌─num─┐ │ 14 │ └─────┘ ```
## unhex
Introduit dans : v1.1.0 Effectue l’opération inverse de [`hex`](#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`. `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`. Prend en charge les lettres `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** ```sql theme={null} unhex(arg) ``` **Arguments** * `arg` — Une chaîne contenant un nombre quelconque de caractères hexadécimaux. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) **Valeur renvoyée** Renvoie une chaîne binaire (BLOB). [`String`](/fr/reference/data-types/string) **Exemples** **Utilisation de base** ```sql title=Query theme={null} SELECT unhex('303132'), UNHEX('4D7953514C') ``` ```response title=Response theme={null} ┌─unhex('303132')─┬─unhex('4D7953514C')─┐ │ 012 │ MySQL │ └─────────────────┴─────────────────────┘ ``` **Convertir en valeur numérique** ```sql title=Query theme={null} SELECT reinterpretAsUInt64(reverse(unhex('FFF'))) AS num ``` ```response title=Response theme={null} ┌──num─┐ │ 4095 │ └──────┘ ```