Passer au contenu principal
Les fonctions de hachage peuvent être utilisées pour réorganiser des éléments de manière pseudo-aléatoire mais déterministe. Simhash est une fonction de hachage qui renvoie des valeurs de hachage proches pour des arguments proches (similaires). La plupart des fonctions de hachage acceptent un nombre quelconque d’arguments, de n’importe quel type.
Le hachage de NULL est NULL. Pour obtenir un hachage non-NULL d’une colonne Nullable, enveloppez-la dans un tuple :
SELECT cityHash64(tuple(NULL))
Pour calculer le hachage de l’ensemble du contenu d’une table, utilisez sum(cityHash64(tuple(*))) (ou une autre fonction de hachage). tuple garantit que les lignes contenant des valeurs NULL ne sont pas ignorées. sum garantit que l’ordre des lignes n’a pas d’importance.

​
BLAKE3

Introduit dans : v22.10.0 Calcule le hachage BLAKE3 d’une chaîne et renvoie les octets obtenus sous forme de FixedString. Cette fonction de hachage cryptographique est intégrée à ClickHouse via la bibliothèque Rust BLAKE3. La fonction est relativement rapide et offre des performances environ deux fois supérieures à celles de SHA-2, tout en générant des hachages de la même longueur que SHA-256. Elle renvoie un hachage BLAKE3 sous forme de tableau d’octets de type FixedString(32). Syntaxe 
BLAKE3(message)
Arguments
  • message — La chaîne d’entrée à hacher. String
Valeur renvoyée Renvoie le hachage BLAKE3 de 32 octets de la chaîne d’entrée sous la forme d’une chaîne de longueur fixe. FixedString(32) Exemples hash
Query
SELECT hex(BLAKE3('ABC'))
Response
┌─hex(BLAKE3('ABC'))───────────────────────────────────────────────┐
│ D1717274597CF0289694F75D96D444B992A096F1AFD8E7BBFA6EBB1D360FEDFC │
└──────────────────────────────────────────────────────────────────┘

​
MD4

Introduit dans : v21.11.0 Calcule le hachage MD4 de la chaîne spécifiée. Syntaxe 
MD4(s)
Arguments
  • s — La chaîne d’entrée à hacher. String
Valeur renvoyée Renvoie le hachage MD4 de la chaîne d’entrée fournie sous la forme d’une chaîne de longueur fixe. FixedString(16) Exemples Exemple d’utilisation
Query
SELECT HEX(MD4('abc'));
Response
┌─hex(MD4('abc'))──────────────────┐
│ A448017AAF21D8525FC10AE87AA6729D │
└──────────────────────────────────┘

​
MD5

Disponible depuis : v1.1.0 Calcule le hachage MD5 de la chaîne fournie. Syntaxe 
MD5(s)
Arguments
  • s — La chaîne d’entrée à hacher. String
Valeur renvoyée Renvoie le hachage MD5 de la chaîne d’entrée donnée sous forme de chaîne de longueur fixe. FixedString(16) Exemples Exemple d’utilisation
Query
SELECT HEX(MD5('abc'));
Response
┌─hex(MD5('abc'))──────────────────┐
│ 900150983CD24FB0D6963F7D28E17F72 │
└──────────────────────────────────┘

​
RIPEMD160

Introduit dans : v24.10.0 Calcule le hachage RIPEMD-160 de la chaîne fournie. Syntaxe 
RIPEMD160(s)
Arguments
  • s — La chaîne d’entrée à hacher. String
Valeur renvoyée Renvoie le hachage RIPEMD160 de la chaîne d’entrée donnée sous la forme d’une chaîne de longueur fixe. FixedString(20) Exemples Exemple d’utilisation
Query
SELECT HEX(RIPEMD160('The quick brown fox jumps over the lazy dog'));
Response
┌─HEX(RIPEMD160('The quick brown fox jumps over the lazy dog'))─┐
│ 37F332F68DB77BD9D7EDD4969571AD671CF9DD3B                      │
└───────────────────────────────────────────────────────────────┘

​
SHA1

Introduit dans : v1.1.0 Calcule le hachage SHA1 de la chaîne fournie. Syntaxe 
SHA1(s)
Arguments
  • s — La chaîne d’entrée à hacher String
Valeur renvoyée Renvoie le hachage SHA1 de la chaîne d’entrée fournie sous la forme d’une chaîne de longueur fixe. FixedString(20) Exemples Exemple d’utilisation
Query
SELECT HEX(SHA1('abc'));
Response
┌─hex(SHA1('abc'))─────────────────────────┐
│ A9993E364706816ABA3E25717850C26C9CD0D89D │
└──────────────────────────────────────────┘

​
SHA224

Introduit dans : v1.1.0 Calcule le hachage SHA224 de la chaîne donnée. Syntaxe 
SHA224(s)
Arguments
  • s — La valeur d’entrée à hacher. String
Valeur renvoyée Renvoie le hachage SHA224 de la chaîne d’entrée fournie sous la forme d’une chaîne de longueur fixe. FixedString(28) Exemples Exemple d’utilisation
Query
SELECT HEX(SHA224('abc'));
Response
┌─hex(SHA224('abc'))───────────────────────────────────────┐
│ 23097D223405D8228642A477BDA255B32AADBCE4BDA0B3F7E36C9DA7 │
└──────────────────────────────────────────────────────────┘

​
SHA256

Introduit dans : v1.1.0 Calcule le hachage SHA256 de la chaîne donnée. Syntaxe 
SHA256(s)
Arguments
  • s — La chaîne d’entrée à hacher. String
Valeur renvoyée Renvoie le hachage SHA256 de la chaîne d’entrée sous la forme d’une chaîne de longueur fixe. FixedString(32) Exemples Exemple d’utilisation
Query
SELECT HEX(SHA256('abc'));
Response
┌─hex(SHA256('abc'))───────────────────────────────────────────────┐
│ BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A9CB410FF61F20015AD │
└──────────────────────────────────────────────────────────────────┘

​
SHA384

Introduit dans : v1.1.0 Calcule le hachage SHA384 de la chaîne donnée. Syntaxe 
SHA384(s)
Arguments
  • s — La chaîne d’entrée à hacher. String
Valeur renvoyée Renvoie le hachage SHA384 de la chaîne d’entrée fournie sous la forme d’une chaîne de longueur fixe. FixedString(48) Exemples Exemple d’utilisation
Query
SELECT HEX(SHA384('abc'));
Response
┌─hex(SHA384('abc'))───────────────────────────────────────────────────────────────────────────────┐
│ CB00753F45A35E8BB5A03D699AC65007272C32AB0EDED1631A8B605A43FF5BED8086072BA1E7CC2358BAECA134C825A7 │
└──────────────────────────────────────────────────────────────────────────────────────────────────┘

​
SHA512

Introduit dans : v1.1.0 Calcule le hachage SHA512 de la chaîne fournie. Syntaxe 
SHA512(s)
Arguments
  • s — La chaîne d’entrée à hacher String
Valeur renvoyée Renvoie le hachage SHA512 de la chaîne d’entrée fournie sous la forme d’une chaîne de longueur fixe. FixedString(64) Exemples Exemple d’utilisation
Query
SELECT HEX(SHA512('abc'));
Response
┌─hex(SHA512('abc'))───────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ DDAF35A193617ABACC417349AE20413112E6FA4E89A97EA20A9EEEE64B55D39A2192992A274FC1A836BA3C23A3FEEBBD454D4423643CE80E2A9AC94FA54CA49F │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

​
SHA512_256

Introduit dans : v1.1.0 Calcule le hachage SHA512_256 de la chaîne spécifiée. Syntaxe 
SHA512_256(s)
Arguments
  • s — La chaîne d’entrée à hacher. String
Valeur renvoyée Renvoie le hachage SHA512_256 de la chaîne d’entrée fournie sous la forme d’une chaîne de longueur fixe. FixedString(32) Exemples Exemple d’utilisation
Query
SELECT HEX(SHA512_256('abc'));
Response
┌─hex(SHA512_256('abc'))───────────────────────────────────────────┐
│ 53048E2681941EF99B2E29B76B4C7DABE4C2D0C634FC6D46E0E2F13107E7AF23 │
└──────────────────────────────────────────────────────────────────┘

​
URLHash

Introduit dans : v1.1.0 Une fonction de hachage non cryptographique rapide et de bonne qualité pour une chaîne dérivée d’une URL au moyen d’un certain type de normalisation. Cette fonction de hachage comporte deux modes :
ModeDescription
URLHash(url)Calcule un hachage à partir d’une chaîne sans le symbole final /, ? ou #, s’il est présent.
URLHash(url, N)Calcule un hachage à partir d’une chaîne jusqu’au niveau N dans la hiérarchie de l’URL, sans le symbole final /, ? ou #, s’il est présent. Les niveaux sont les mêmes que dans URLHierarchy.
Syntaxe 
URLHash(url[, N])
Arguments
  • url — Chaîne d’URL à hacher. String
  • N — Facultatif. Niveau dans la hiérarchie de l’URL. (U)Int*
Valeur renvoyée Renvoie la valeur de hachage calculée pour url. UInt64 Exemples Exemple d’utilisation
Query
SELECT URLHash('https://www.clickhouse.com')
Response
┌─URLHash('htt⋯house.com')─┐
│     13614512636072854701 │
└──────────────────────────┘
Hachage de l’URL au niveau spécifié
Query
SELECT URLHash('https://www.clickhouse.com/docs', 0);
SELECT URLHash('https://www.clickhouse.com/docs', 1);
Response
-- hash of https://www.clickhouse.com
┌─URLHash('htt⋯m/docs', 0)─┐
│     13614512636072854701 │
└──────────────────────────┘
-- hash of https://www.clickhouse.com/docs
┌─URLHash('htt⋯m/docs', 1)─┐
│     13167253331440520598 │
└──────────────────────────┘

​
cityHash64

Introduit dans : v1.1.0 Produit une valeur de hachage CityHash sur 64 bits. Il s’agit d’une fonction de hachage rapide non cryptographique. Elle utilise l’algorithme CityHash pour les paramètres de type chaîne, et une fonction de hachage rapide non cryptographique propre à l’implémentation pour les paramètres d’autres types de données. La fonction utilise le combinator CityHash pour obtenir les résultats finaux.
Google a modifié l’algorithme de CityHash après son ajout à ClickHouse. Autrement dit, cityHash64 de ClickHouse et le CityHash upstream de Google produisent désormais des résultats différents. Le cityHash64 de ClickHouse correspond à CityHash v1.0.2.
Les valeurs de hachage calculées peuvent être identiques pour les mêmes valeurs d’entrée avec des types d’argument différents. Cela concerne par exemple des types entiers de tailles différentes, des Tuple nommés et non nommés contenant les mêmes données, Map et le type Array(Tuple(key, value)) correspondant contenant les mêmes données.
Syntaxe 
cityHash64(arg1[, arg2, ...])
Arguments
  • arg1[, arg2, ...] — Un nombre variable d’arguments d’entrée dont le hachage doit être calculé. Any
Valeur renvoyée Renvoie le hachage calculé des arguments d’entrée. UInt64 Exemples Exemple d’appel
Query
SELECT cityHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS CityHash, toTypeName(CityHash) AS type;
Response
┌─────────────CityHash─┬─type───┐
│ 12072650598913549138 │ UInt64 │
└──────────────────────┴────────┘
Calcul de la somme de contrôle de l’ensemble de la table, à l’ordre des lignes près
Query
CREATE TABLE users (
    id UInt32,
    name String,
    age UInt8,
    city String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO users VALUES
(1, 'Alice', 25, 'New York'),
(2, 'Bob', 30, 'London'),
(3, 'Charlie', 35, 'Tokyo');

SELECT groupBitXor(cityHash64(*)) FROM users;
Response
┌─groupBitXor(⋯age, city))─┐
│     11639977218258521182 │
└──────────────────────────┘

​
farmFingerprint64

Introduit dans : v20.12.0 Produit une valeur FarmHash sur 64 bits à l’aide de la méthode Fingerprint64.
farmFingerprint64 est à privilégier pour obtenir une valeur stable et portable plutôt que farmHash64.
Les valeurs de hachage calculées peuvent être identiques pour les mêmes valeurs d’entrée avec des types d’arguments différents. Cela concerne par exemple des types entiers de tailles différentes, des Tuple nommés et non nommés contenant les mêmes données, ainsi que Map et le type correspondant Array(Tuple(key, value)) contenant les mêmes données.
Syntaxe 
farmFingerprint64(arg1[, arg2, ...])
Arguments
  • arg1[, arg2, ...] — Un nombre variable d’arguments d’entrée dont le hachage doit être calculé. Any
Valeur renvoyée Renvoie la valeur de hachage calculée à partir des arguments d’entrée. UInt64 Exemples Exemple d’utilisation
Query
SELECT farmFingerprint64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmFingerprint, toTypeName(FarmFingerprint) AS type;
Response
┌─────FarmFingerprint─┬─type───┐
│ 5752020380710916328 │ UInt64 │
└─────────────────────┴────────┘

​
farmHash64

Introduit dans : v1.1.0 Produit un FarmHash 64 bits à l’aide de la méthode Hash64.
farmFingerprint64 est recommandé pour obtenir une valeur stable et portable.
Les valeurs de hachage calculées peuvent être identiques pour les mêmes valeurs d’entrée avec des types d’argument différents. Cela concerne par exemple les types entiers de tailles différentes, les Tuple nommés et non nommés contenant les mêmes données, ainsi que Map et le type Array(Tuple(key, value)) correspondant contenant les mêmes données.
Syntaxe 
farmHash64(arg1[, arg2, ...])
Arguments
  • arg1[, arg2, ...] — Un nombre variable d’arguments d’entrée dont le hachage doit être calculé. Any
Valeur renvoyée Renvoie la valeur de hachage calculée à partir des arguments d’entrée. UInt64 Exemples Exemple d’utilisation
Query
SELECT farmHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmHash, toTypeName(FarmHash) AS type;
Response
┌─────────────FarmHash─┬─type───┐
│ 18125596431186471178 │ UInt64 │
└──────────────────────┴────────┘

​
gccMurmurHash

Introduit dans : v20.1.0 Calcule le hachage MurmurHash2 sur 64 bits de la valeur d’entrée en utilisant la même graine que GCC. Il est portable entre les builds de Clang et de GCC. Syntaxe 
gccMurmurHash(arg1[, arg2, ...])
Arguments
  • arg1[, arg2, ...] — Un nombre variable d’arguments dont le hachage doit être calculé. Any
Valeur renvoyée Renvoie la valeur de hachage calculée à partir des arguments d’entrée. UInt64 Exemples Exemple d’utilisation
Query
SELECT
    gccMurmurHash(1, 2, 3) AS res1,
    gccMurmurHash(('a', [1, 2, 3], 4, (4, ['foo', 'bar'], 1, (1, 2)))) AS res2
Response
┌─────────────────res1─┬────────────────res2─┐
│ 12384823029245979431 │ 1188926775431157506 │
└──────────────────────┴─────────────────────┘

​
halfMD5

Introduit dans : v1.1.0 Interprète tous les paramètres d’entrée comme des chaînes de caractères et calcule la valeur de hachage MD5 pour chacun d’eux. Combine ensuite les hachages, prend les 8 premiers octets du hachage de la chaîne résultante et les interprète comme un UInt64 en ordre des octets big-endian. La fonction est relativement lente (5 millions de chaînes courtes par seconde et par cœur de processeur). Envisagez plutôt d’utiliser la fonction sipHash64. La fonction accepte un nombre variable de paramètres d’entrée. Les arguments peuvent être de n’importe quel type de données pris en charge. Pour certains types de données, la valeur calculée de la fonction de hachage peut être identique pour des valeurs identiques même si les types des arguments diffèrent (entiers de tailles différentes, Tuple nommé et non nommé avec les mêmes données, Map et le type Array(Tuple(key, value)) correspondant avec les mêmes données). Syntaxe 
halfMD5(arg1[, arg2, ..., argN])
Arguments
  • arg1[, arg2, ..., argN] — Nombre variable d’arguments pour lesquels calculer le hachage. Any
Valeur renvoyée Renvoie le semi-hachage MD5 calculé à partir des paramètres d’entrée donnés, sous la forme d’un UInt64 en ordre d’octets big-endian. UInt64 Exemples Exemple d’utilisation
Query
SELECT HEX(halfMD5('abc', 'cde', 'fgh'));
Response
┌─hex(halfMD5('abc', 'cde', 'fgh'))─┐
│ 2C9506B7374CFAF4                  │
└───────────────────────────────────┘

​
hiveHash

Introduit dans : v20.1.0 Calcule un “HiveHash” à partir d’une chaîne de caractères. Il s’agit simplement de JavaHash dont les bits de signe sont mis à zéro. Cette fonction est utilisée dans Apache Hive pour les versions antérieures à 3.0.
Cette fonction de hachage est peu performante. Utilisez-la uniquement si cet algorithme est déjà utilisé dans un autre système et que vous devez obtenir le même résultat.
Syntaxe 
hiveHash(arg)
Arguments
  • arg — Chaîne d’entrée à hacher. String
Valeur renvoyée Renvoie le « hive hash » calculé à partir de la chaîne d’entrée. Int32 Exemples Exemple d’utilisation
Query
SELECT hiveHash('Hello, world!');
Response
┌─hiveHash('Hello, world!')─┐
│                 267439093 │
└───────────────────────────┘

​
icebergHash

Introduit dans : v25.5.0 Implémente la logique de la transformation de hachage d’Iceberg Syntaxe 
icebergHash(value)
Arguments Valeur renvoyée Renvoie un hachage Murmur3 32 bits, variante x86, initialisé avec 0 Int32 Exemples Exemple
Query
SELECT icebergHash(1.0 :: Float32)
Response
-142385009

​
intHash32

Introduit dans : v1.1.0 Calcule le hachage 32 bits d’un entier. La fonction de hachage est relativement rapide, mais n’est pas une fonction de hachage cryptographique. Syntaxe 
intHash32(arg)
Arguments
  • arg — Entier à hacher. (U)Int*
Valeur renvoyée Renvoie le code de hachage 32 bits calculé à partir de l’entier d’entrée UInt32 Exemples Exemple d’utilisation
Query
SELECT intHash32(42);
Response
┌─intHash32(42)─┐
│    1228623923 │
└───────────────┘

​
intHash64

Introduit dans : v1.1.0 Calcule un hachage 64 bits d’un entier. La fonction de hachage est relativement rapide (même plus rapide que intHash32), mais ce n’est pas une fonction de hachage cryptographique. Syntaxe 
intHash64(int)
Arguments
  • int — Entier à hacher. (U)Int*
Valeur renvoyée Code de hachage 64 bits. UInt64 Exemples Exemple d’utilisation
Query
SELECT intHash64(42);
Response
┌────────intHash64(42)─┐
│ 11490350930367293593 │
└──────────────────────┘

​
javaHash

Introduit dans : v20.1.0 Calcule JavaHash à partir de :
Cette fonction de hachage est peu performante. Utilisez-la uniquement si cet algorithme est déjà utilisé dans un autre système et que vous devez obtenir le même résultat.
Java ne prend en charge que le calcul du hachage d’entiers signés. Donc, si vous souhaitez calculer le hachage d’entiers non signés, vous devez les convertir vers les types signés ClickHouse appropriés.
Syntaxe 
javaHash(arg)
Arguments
  • arg — Valeur d’entrée à hacher. Any
Valeur renvoyée Renvoie le hachage calculé de arg Int32 Exemples Exemple d’utilisation 1
Query
SELECT javaHash(toInt32(123));
Response
┌─javaHash(toInt32(123))─┐
│               123      │
└────────────────────────┘
Exemple d’utilisation 2
Query
SELECT javaHash('Hello, world!');
Response
┌─javaHash('Hello, world!')─┐
│               -1880044555 │
└───────────────────────────┘

​
javaHashUTF16LE

Introduit dans : v20.1.0 Calcule le JavaHash d’une chaîne, en supposant qu’elle contient des octets représentant une chaîne de caractères encodée en UTF-16LE. Syntaxe 
javaHashUTF16LE(arg)
Arguments
  • arg — Une chaîne encodée en UTF-16LE. String
Valeur renvoyée Renvoie le hachage calculé de la chaîne encodée en UTF-16LE. Int32 Exemples Exemple d’utilisation
Query
SELECT javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'));
Response
┌─javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'))─┐
│                                                      3556498 │
└──────────────────────────────────────────────────────────────┘

​
jumpConsistentHash

Introduit dans : v1.1.0 Calcule le jump consistent hash d’un entier. Syntaxe 
jumpConsistentHash(key, buckets)
Arguments
  • key — La clé d’entrée. UInt64
  • buckets — Le nombre de buckets. Int32
Valeur renvoyée Renvoie la valeur de hachage calculée. Int32 Exemples Exemple d’utilisation
Query
SELECT jumpConsistentHash(256, 4)
Response
┌─jumpConsistentHash(256, 4)─┐
│                          3 │
└────────────────────────────┘

​
kafkaMurmurHash

Introduite dans : v23.4.0 Calcule le hachage MurmurHash2 sur 32 bits de la valeur d’entrée, en utilisant la même seed que Kafka et sans le bit de poids fort, afin d’être compatible avec Default Partitioner. Syntaxe 
kafkaMurmurHash(arg1[, arg2, ...])
Arguments
  • arg1[, arg2, ...] — Un nombre variable de paramètres dont il faut calculer le hachage. Any
Valeur renvoyée Renvoie la valeur de hachage calculée à partir des arguments d’entrée. UInt32 Exemples Exemple d’utilisation
Query
SELECT
    kafkaMurmurHash('foobar') AS res1,
    kafkaMurmurHash(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS res2
Response
┌───────res1─┬─────res2─┐
│ 1357151166 │ 85479775 │
└────────────┴──────────┘

​
keccak256

Introduit dans : v25.4.0 Calcule le hachage cryptographique Keccak-256 de la chaîne donnée. Cette fonction de hachage est largement utilisée dans les applications de blockchain, en particulier sur Ethereum. Syntaxe 
keccak256(message)
Arguments
  • message — La chaîne d’entrée à hacher. String
Valeur renvoyée Renvoie le hachage Keccak-256 de 32 octets de la chaîne d’entrée sous la forme d’une chaîne de longueur fixe. FixedString(32) Exemples Exemple d’utilisation
Query
SELECT hex(keccak256('hello'))
Response
┌─hex(keccak256('hello'))──────────────────────────────────────────┐
│ 1C8AFF950685C2ED4BC3174F3472287B56D9517B9C948127319A09A7A36DEAC8 │
└──────────────────────────────────────────────────────────────────┘

​
kostikConsistentHash

Introduit dans : v22.6.0 Un algorithme de hachage cohérent de Konstantin ‘Kostik’ Oblakov, en temps et espace O(1). Efficace uniquement pour n <= 32768. Syntaxe 
kostikConsistentHash(input, n)
Alias : yandexConsistentHash Arguments
  • input — Une clé entière. UInt64
  • n — Le nombre de buckets. UInt16
Valeur renvoyée Renvoie la valeur de hachage calculée. UInt16 Exemples Exemple d’utilisation
Query
SELECT kostikConsistentHash(16045690984833335023, 2);
Response
┌─kostikConsistentHash(16045690984833335023, 2)─┐
│                                             1 │
└───────────────────────────────────────────────┘

​
metroHash64

Introduit dans : v1.1.0 Produit une valeur de hachage MetroHash de 64 bits.
Les valeurs de hachage calculées peuvent être identiques pour les mêmes valeurs d’entrée de types d’arguments différents. Cela concerne, par exemple, des types entiers de tailles différentes, des Tuple nommés et non nommés contenant les mêmes données, ainsi que Map et le type Array(Tuple(key, value)) correspondant contenant les mêmes données.
Syntaxe 
metroHash64(arg1[, arg2, ...])
Arguments
  • arg1[, arg2, ...] — Un nombre variable d’arguments d’entrée dont le hachage doit être calculé. Any
Valeur renvoyée Renvoye le hachage calculé des arguments d’entrée. UInt64 Exemples Exemple d’utilisation
Query
SELECT metroHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MetroHash, toTypeName(MetroHash) AS type;
Response
┌────────────MetroHash─┬─type───┐
│ 14235658766382344533 │ UInt64 │
└──────────────────────┴────────┘

​
murmurHash2_32

Introduit dans : v18.5.0 Calcule le hachage MurmurHash2 de la valeur d’entrée.
Les valeurs de hachage calculées peuvent être identiques pour des valeurs d’entrée identiques mais de types d’argument différents. Cela concerne par exemple les types entiers de tailles différentes, les Tuple nommés et non nommés contenant les mêmes données, ainsi que Map et le type Array(Tuple(key, value)) correspondant contenant les mêmes données.
Syntaxe 
murmurHash2_32(arg1[, arg2, ...])
Arguments
  • arg1[, arg2, ...] — Un nombre variable d’arguments d’entrée pour lesquels calculer le hachage. Any
Valeur renvoyée Renvoie la valeur de hachage calculée à partir des arguments d’entrée. UInt32 Exemples Exemple d’utilisation
Query
SELECT murmurHash2_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type;
Response
┌─MurmurHash2─┬─type───┐
│  3681770635 │ UInt32 │
└─────────────┴────────┘

​
murmurHash2_64

Introduit dans : v18.10.0 Calcule le hachage MurmurHash2 de la valeur d’entrée.
Les valeurs de hachage calculées peuvent être identiques pour les mêmes valeurs d’entrée, même si les types d’arguments diffèrent. Cela concerne par exemple les types entiers de tailles différentes, les Tuple nommés et non nommés contenant les mêmes données, ainsi que Map et le type Array(Tuple(key, value)) correspondant contenant les mêmes données.
Syntaxe 
murmurHash2_64(arg1[, arg2, ...])
Arguments
  • arg1[, arg2, ...] — Un nombre variable d’arguments d’entrée à partir desquels calculer le hachage. Any
Valeur renvoyée Renvoie le hachage calculé à partir des arguments d’entrée. UInt64 Exemples Exemple d’utilisation
Query
SELECT murmurHash2_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type;
Response
┌──────────MurmurHash2─┬─type───┐
│ 11832096901709403633 │ UInt64 │
└──────────────────────┴────────┘

​
murmurHash3_128

Introduit dans : v18.10.0 Calcule le hachage MurmurHash3 sur 128 bits de la valeur d’entrée. Syntaxe 
murmurHash3_128(arg1[, arg2, ...])
Arguments
  • arg1[, arg2, ...] — Un nombre variable d’arguments d’entrée sur lesquels calculer le hachage. Any
Valeur renvoyée Renvoie la valeur de hachage MurmurHash3 128 bits calculée à partir des arguments d’entrée. FixedString(16) Exemples Exemple d’utilisation
Query
SELECT hex(murmurHash3_128('foo', 'foo', 'foo'));
Response
┌─hex(murmurHash3_128('foo', 'foo', 'foo'))─┐
│ F8F7AD9B6CD4CF117A71E277E2EC2931          │
└───────────────────────────────────────────┘

​
murmurHash3_32

Introduit dans : v18.10.0 Produit une valeur de hachage MurmurHash3.
Les valeurs de hachage calculées peuvent être identiques pour les mêmes valeurs d’entrée avec des types d’argument différents. Cela concerne par exemple des types entiers de tailles différentes, des Tuple nommés et non nommés avec les mêmes données, ainsi que Map et le type Array(Tuple(key, value)) correspondant avec les mêmes données.
Syntaxe 
murmurHash3_32(arg1[, arg2, ...])
Arguments
  • arg1[, arg2, ...] — Un nombre variable d’arguments d’entrée dont le hachage doit être calculé. Any
Valeur renvoyée Renvoie la valeur de hachage calculée à partir des arguments d’entrée. UInt32 Exemples Exemple d’utilisation
Query
SELECT murmurHash3_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type;
Response
┌─MurmurHash3─┬─type───┐
│     2152717 │ UInt32 │
└─────────────┴────────┘

​
murmurHash3_64

Introduit dans : v18.10.0 Calcule le hachage MurmurHash3 de la valeur d’entrée.
Les valeurs de hachage calculées peuvent être identiques pour les mêmes valeurs d’entrée de types d’argument différents. Cela concerne, par exemple, des types entiers de tailles différentes, des Tuple nommés et non nommés contenant les mêmes données, ainsi que Map et le type Array(Tuple(key, value)) correspondant contenant les mêmes données.
Syntaxe 
murmurHash3_64(arg1[, arg2, ...])
Arguments
  • arg1[, arg2, ...] — Un nombre variable d’arguments d’entrée pour lesquels calculer le hachage. Any
Valeur renvoyée Renvoie la valeur de hachage calculée à partir des arguments d’entrée. UInt64 Exemples Exemple d’utilisation
Query
SELECT murmurHash3_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type;
Response
┌──────────MurmurHash3─┬─type───┐
│ 11832096901709403633 │ UInt64 │
└──────────────────────┴────────┘

​
ngramMinHash

Introduit dans : v21.1.0 Divise une chaîne ASCII en n-grammes de ngramsize symboles, calcule des valeurs de hachage pour chaque n-gramme et renvoie un tuple contenant ces hachages. Utilise les hashnum hachages minimum pour calculer le hachage minimum et les hashnum hachages maximum pour calculer le hachage maximum. Cette fonction est sensible à la casse. Peut être utilisé pour détecter des chaînes quasi dupliquées avec tupleHammingDistance. Pour deux chaînes, si les hachages renvoyés sont identiques pour les deux chaînes, alors ces chaînes sont identiques. Syntaxe 
ngramMinHash(string[, ngramsize, hashnum])
Arguments
  • string — Chaîne dont il faut calculer le hachage. String
  • ngramsize — Facultatif. La taille d’un n-gram, toute valeur comprise entre 1 et 25. La valeur par défaut est 3. UInt8
  • hashnum — Facultatif. Le nombre de hachages minimum et maximum utilisés pour calculer le résultat, toute valeur comprise entre 1 et 25. La valeur par défaut est 6. UInt8
Valeur renvoyée Renvoie un tuple contenant deux hachages — le minimum et le maximum. Tuple Exemples Exemple d’utilisation
Query
SELECT ngramMinHash('ClickHouse') AS Tuple;
Response
┌─Tuple──────────────────────────────────────┐
│ (18333312859352735453,9054248444481805918) │
└────────────────────────────────────────────┘

​
ngramMinHashArg

Introduit dans : v21.1.0 Découpe une chaîne ASCII en n-grammes de ngramsize symboles et renvoie les n-grammes ayant les hachages minimum et maximum, calculés par la fonction ngramMinHash sur la même entrée. Cette fonction est sensible à la casse. Syntaxe 
ngramMinHashArg(string[, ngramsize, hashnum])
Arguments
  • string — Chaîne pour laquelle calculer le hachage. String
  • ngramsize — Facultatif. La taille d’un n-gramme, comprise entre 1 et 25. La valeur par défaut est 3. UInt8
  • hashnum — Facultatif. Le nombre de hachages minimum et maximum utilisés pour calculer le résultat, compris entre 1 et 25. La valeur par défaut est 6. UInt8
Valeur renvoyée Renvoie un tuple contenant deux tuples de hashnum n-grammes chacun. Tuple(String) Exemples Exemple d’utilisation
Query
SELECT ngramMinHashArg('ClickHouse') AS Tuple;
Response
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ous','ick','lic','Hou','kHo','use'),('Hou','lic','ick','ous','ckH','Cli')) │
└───────────────────────────────────────────────────────────────────────────────┘

​
ngramMinHashArgCaseInsensitive

Introduit dans : v21.1.0 Divise une chaîne ASCII en n-grammes de ngramsize symboles et renvoie les n-grammes ayant les valeurs de hachage minimale et maximale, calculées par la fonction ngramMinHashCaseInsensitive appliquée à la même entrée. Ne tient pas compte de la casse. Syntaxe 
ngramMinHashArgCaseInsensitive(string[, ngramsize, hashnum])
Arguments
  • string — Chaîne dont il faut calculer le hachage. String
  • ngramsize — Facultatif. La taille d’un n-gramme, sous la forme d’une valeur comprise entre 1 et 25. La valeur par défaut est 3. UInt8
  • hashnum — Facultatif. Le nombre de hachages minimum et maximum utilisés pour calculer le résultat, sous la forme d’une valeur comprise entre 1 et 25. La valeur par défaut est 6. UInt8
Valeur renvoyée Renvoie un tuple contenant deux tuples de hashnum n-grammes chacun. Tuple(Tuple(String)) Exemples Exemple d’utilisation
Query
SELECT ngramMinHashArgCaseInsensitive('ClickHouse') AS Tuple;
Response
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ous','ick','lic','kHo','use','Cli'),('kHo','lic','ick','ous','ckH','Hou')) │
└───────────────────────────────────────────────────────────────────────────────┘

​
ngramMinHashArgCaseInsensitiveUTF8

Introduit dans : v21.1.0 Découpe une chaîne UTF-8 en n-grammes de ngramsize symboles et renvoie les n-grammes dont les valeurs de hachage sont minimale et maximale, calculées par la fonction ngramMinHashCaseInsensitiveUTF8 avec la même entrée. Cette fonction est insensible à la casse. Syntaxe 
ngramMinHashArgCaseInsensitiveUTF8(string[, ngramsize, hashnum])
Arguments
  • string — Chaîne pour laquelle calculer le hachage. String
  • ngramsize — Facultatif. La taille d’un n-gramme, toute valeur comprise entre 1 et 25. La valeur par défaut est 3. UInt8
  • hashnum — Facultatif. Le nombre de hachages minimum et maximum utilisés pour calculer le résultat, toute valeur comprise entre 1 et 25. La valeur par défaut est 6. UInt8
Valeur renvoyée Renvoie un tuple contenant deux tuples de hashnum n-grammes chacun. Tuple(Tuple(String)) Exemples Exemple d’utilisation
Query
SELECT ngramMinHashArgCaseInsensitiveUTF8('ClickHouse') AS Tuple;
Response
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ckH','ous','ick','lic','kHo','use'),('kHo','lic','ick','ous','ckH','Hou')) │
└───────────────────────────────────────────────────────────────────────────────┘

​
ngramMinHashArgUTF8

Introduit dans : v21.1.0 Découpe une chaîne UTF-8 en n-grammes de ngramsize symboles et renvoie les n-grammes dont les hachages sont minimum et maximum, tels que calculés par la fonction ngramMinHashUTF8 avec la même entrée. Cette fonction est sensible à la casse. Syntaxe 
ngramMinHashArgUTF8(string[, ngramsize, hashnum])
Arguments
  • string — Chaîne pour laquelle calculer le hachage. String
  • ngramsize — Facultatif. La taille d’un n-gramme, n’importe quel nombre de 1 à 25. La valeur par défaut est 3. UInt8
  • hashnum — Facultatif. Le nombre de hachages minimum et maximum utilisés pour calculer le résultat, n’importe quel nombre de 1 à 25. La valeur par défaut est 6. UInt8
Valeur renvoyée Renvoie un tuple contenant deux tuples de hashnum n-grammes chacun. Tuple(Tuple(String)) Exemples Exemple d’utilisation
Query
SELECT ngramMinHashArgUTF8('ClickHouse') AS Tuple;
Response
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ous','ick','lic','Hou','kHo','use'),('kHo','Hou','lic','ick','ous','ckH')) │
└───────────────────────────────────────────────────────────────────────────────┘

​
ngramMinHashCaseInsensitive

Introduit dans : v21.1.0 Découpe une chaîne ASCII en n-grammes de ngramsize symboles, calcule une valeur de hachage pour chaque n-gramme et renvoie un tuple contenant ces hachages. Utilise hashnum hachages minimaux pour calculer le hachage minimal et hashnum hachages maximaux pour calculer le hachage maximal. Est insensible à la casse. Peut être utilisé pour détecter des chaînes semi-dupliquées avec tupleHammingDistance. Pour deux chaînes, si les hachages renvoyés sont identiques pour les deux chaînes, alors ces chaînes sont identiques. Syntaxe 
ngramMinHashCaseInsensitive(string[, ngramsize, hashnum])
Arguments
  • string — String. String. - ngramsize — La taille d’un n-gramme. Facultatif. Valeurs possibles : tout nombre compris entre 1 et 25. Valeur par défaut : 3. UInt8. - hashnum — Le nombre de hachages minimum et maximum utilisés pour calculer le résultat. Facultatif. Valeurs possibles : tout nombre compris entre 1 et 25. Valeur par défaut : 6. UInt8.
Valeur renvoyée Tuple contenant deux hachages — le minimum et le maximum. Tuple(UInt64, UInt64). Tuple Exemples Exemple d’utilisation
Query
SELECT ngramMinHashCaseInsensitive('ClickHouse') AS Tuple;
Response
┌─Tuple──────────────────────────────────────┐
│ (2106263556442004574,13203602793651726206) │
└────────────────────────────────────────────┘

​
ngramMinHashCaseInsensitiveUTF8

Introduit dans : v21.1.0 Découpe une chaîne UTF-8 en n-grammes de ngramsize symboles, calcule une valeur de hachage pour chaque n-gramme et renvoie un tuple contenant ces hachages. Utilise hashnum hachages minimaux pour calculer le hachage minimal et hashnum hachages maximaux pour calculer le hachage maximal. Cette fonction est insensible à la casse. Peut être utilisée pour détecter des chaînes semi-dupliquées avec tupleHammingDistance. Pour deux chaînes, si les hachages renvoyés sont identiques pour les deux chaînes, alors ces chaînes sont identiques. Syntaxe 
ngramMinHashCaseInsensitiveUTF8(string [, ngramsize, hashnum])
Arguments
  • string — Chaîne pour laquelle calculer le hachage. String
  • ngramsize — Facultatif. Taille d’un n-gramme, toute valeur comprise entre 1 et 25. La valeur par défaut est 3. UInt8
  • hashnum — Facultatif. Nombre de hachages minimaux et maximaux utilisés pour calculer le résultat, toute valeur comprise entre 1 et 25. La valeur par défaut est 6. UInt8
Valeur renvoyée Renvoie un tuple contenant deux hachages — le minimum et le maximum. Tuple Exemples Exemple d’utilisation
Query
SELECT ngramMinHashCaseInsensitiveUTF8('ClickHouse') AS Tuple;
Response
┌─Tuple───────────────────────────────────────┐
│ (12493625717655877135,13203602793651726206) │
└─────────────────────────────────────────────┘

​
ngramMinHashUTF8

Introduite dans : v21.1.0 Divise une chaîne UTF-8 en n-grammes de ngramsize symboles, calcule des valeurs de hachage pour chaque n-gramme et renvoie un tuple contenant ces hachages. Utilise hashnum hachages minimaux pour calculer le hachage minimal et hashnum hachages maximaux pour calculer le hachage maximal. La fonction est sensible à la casse. Peut être utilisée pour détecter des chaînes semi-dupliquées avec tupleHammingDistance. Pour deux chaînes, si les hachages renvoyés sont identiques pour les deux chaînes, alors ces chaînes sont identiques. Syntaxe 
ngramMinHashUTF8(string[, ngramsize, hashnum])
Arguments
  • string — Chaîne pour laquelle calculer le hachage. String
  • ngramsize — Facultatif. La taille d’un n-gram, tout nombre de 1 à 25. La valeur par défaut est 3. UInt8
  • hashnum — Facultatif. Le nombre de hachages minimum et maximum utilisés pour calculer le résultat, tout nombre de 1 à 25. La valeur par défaut est 6. UInt8
Valeur renvoyée Renvoie un tuple contenant deux hachages — le minimum et le maximum. Tuple Exemples Exemple d’utilisation
Query
SELECT ngramMinHashUTF8('ClickHouse') AS Tuple;
Response
┌─Tuple──────────────────────────────────────┐
│ (18333312859352735453,6742163577938632877) │
└────────────────────────────────────────────┘

​
ngramSimHash

Introduit dans : v21.1.0 Découpe une chaîne ASCII en n-grammes de ngramsize symboles et renvoie le simhachage des n-grammes. Peut être utilisée pour détecter des chaînes semi-dupliquées avec bitHammingDistance. Plus la distance de Hamming entre les simhachages calculés de deux chaînes est faible, plus il est probable que ces chaînes soient identiques. Syntaxe 
ngramSimHash(string[, ngramsize])
Arguments
  • string — Chaîne pour laquelle calculer le simhachage sensible à la casse. String
  • ngramsize — Facultatif. Taille d’un n-gramme, comprise entre 1 et 25. La valeur par défaut est 3. UInt8
Valeur renvoyée Renvoie le hachage calculé de la chaîne d’entrée. UInt64 Exemples Exemple d’utilisation
Query
SELECT ngramSimHash('ClickHouse') AS Hash;
Response
┌───────Hash─┐
│ 1627567969 │
└────────────┘

​
ngramSimHashCaseInsensitive

Introduit dans : v21.1.0 Divise une chaîne ASCII en n-grammes de ngramsize symboles et renvoie le simhash des n-grammes. Ne tient pas compte de la casse. Peut être utilisé pour détecter des chaînes semi-dupliquées avec bitHammingDistance. Plus la distance de Hamming entre les simhashes calculés de deux chaînes est faible, plus il est probable que ces chaînes soient identiques. Syntaxe 
ngramSimHashCaseInsensitive(string[, ngramsize])
Arguments
  • string — Chaîne pour laquelle calculer le simhash insensible à la casse. String
  • ngramsize — Facultatif. Taille d’un n-gramme, comprise entre 1 et 25. La valeur par défaut est 3. UInt8
Valeur renvoyée Valeur de hachage. UInt64. UInt64 Exemples Exemple d’utilisation
Query
SELECT ngramSimHashCaseInsensitive('ClickHouse') AS Hash;
Response
┌──────Hash─┐
│ 562180645 │
└───────────┘

​
ngramSimHashCaseInsensitiveUTF8

Introduit dans : v21.1.0 Découpe une chaîne UTF-8 en n-grams de ngramsize symboles et renvoie le simhachage des n-grams. Il est insensible à la casse. Peut être utilisé pour détecter des chaînes semi-dupliquées avec bitHammingDistance. Plus la distance de Hamming entre les simhachages calculés de deux chaînes est faible, plus il est probable que ces chaînes soient identiques. Syntaxe 
ngramSimHashCaseInsensitiveUTF8(string[, ngramsize])
Arguments
  • string — Chaîne dont il faut calculer le hachage. String
  • ngramsize — Facultatif. Taille d’un n-gramme, nombre compris entre 1 et 25. La valeur par défaut est 3. UInt8
Valeur renvoyée Renvoie la valeur de hachage calculée. UInt64 Exemples Exemple d’utilisation
Query
SELECT ngramSimHashCaseInsensitiveUTF8('ClickHouse') AS Hash;
Response
┌───────Hash─┐
│ 1636742693 │
└────────────┘

​
ngramSimHashUTF8

Introduit dans : v21.1.0 Découpe une chaîne encodée en UTF-8 en n-grammes de ngramsize symboles et renvoie le simhachage du n-gramme. Cette fonction est sensible à la casse. Peut être utilisée pour détecter des chaînes semi-dupliquées avec bitHammingDistance. Plus la distance de Hamming entre les simhachages calculés de deux chaînes est faible, plus il est probable que ces chaînes soient identiques. Syntaxe 
ngramSimHashUTF8(string[, ngramsize])
Arguments
  • string — Chaîne pour laquelle calculer le hachage. String
  • ngramsize — Facultatif. Taille d’un n-gramme, comprise entre 1 et 25. La valeur par défaut est 3. UInt8
Valeur renvoyée Renvoie la valeur de hachage calculée. UInt64 Exemples Exemple d’utilisation
Query
SELECT ngramSimHashUTF8('ClickHouse') AS Hash;
Response
┌───────Hash─┐
│ 1628157797 │
└────────────┘

​
sipHash128

Introduit dans : v1.1.0 Comme sipHash64, mais produit une valeur de hachage sur 128 bits, c.-à-d. que l’état final de réduction par xor est calculé jusqu’à 128 bits.
utilisez sipHash128Reference pour les nouveaux projetsCette variante 128 bits diffère de l’implémentation de référence et est moins robuste. Cette version existe car, au moment de son écriture, il n’existait pas encore d’extension officielle 128 bits pour SipHash. Pour les nouveaux projets, il est recommandé d’utiliser sipHash128Reference.
Syntaxe 
sipHash128(arg1[, arg2, ...])
Arguments
  • arg1[, arg2, ...] — Un nombre variable d’arguments d’entrée dont le hachage doit être calculé. Any
Valeur renvoyée Renvoie une valeur de hachage SipHash sur 128 bits. FixedString(16) Exemples Exemple d’utilisation
Query
SELECT hex(sipHash128('foo', '\x01', 3));
Response
┌─hex(sipHash128('foo', '', 3))────┐
│ 9DE516A64A414D4B1B609415E4523F24 │
└──────────────────────────────────┘

​
sipHash128Keyed

Introduit dans : v23.2.0 Identique à sipHash128, mais accepte en plus une clé explicite en argument au lieu d’utiliser une clé fixe.
utilisez sipHash128ReferenceKeyed pour les nouveaux projetsCette variante 128 bits diffère de l’implémentation de référence et est moins robuste. Cette version existe parce que, au moment de sa création, il n’existait pas d’extension officielle 128 bits pour SipHash. Les nouveaux projets devraient probablement utiliser sipHash128ReferenceKeyed.
Syntaxe 
sipHash128Keyed((k0, k1), [arg1, arg2, ...])
Arguments
  • (k0, k1) — Un tuple de deux valeurs UInt64 représentant la clé. Tuple(UInt64, UInt64)
  • arg1[, arg2, ...] — Un nombre variable d’arguments d’entrée dont le hachage doit être calculé. Any
Valeur renvoyée Une valeur de hachage SipHash sur 128 bits, de type FixedString(16). FixedString(16) Exemples Exemple d’utilisation
Query
SELECT hex(sipHash128Keyed((506097522914230528, 1084818905618843912),'foo', '\x01', 3));
Response
┌─hex(sipHash128Keyed((506097522914230528, 1084818905618843912), 'foo', '', 3))─┐
│ B8467F65C8B4CFD9A5F8BD733917D9BF                                              │
└───────────────────────────────────────────────────────────────────────────────┘

​
sipHash128Reference

Introduit dans : v23.2.0 Semblable à sipHash128, mais implémente l’algorithme 128 bits des auteurs originels de SipHash. Syntaxe 
sipHash128Reference(arg1[, arg2, ...])
Arguments
  • arg1[, arg2, ...] — Un nombre variable d’arguments d’entrée dont le hachage doit être calculé. Any
Valeur renvoyée Renvoie la valeur de hachage SipHash 128 bits calculée à partir des arguments d’entrée. FixedString(16) Exemples Exemple d’utilisation
Query
SELECT hex(sipHash128Reference('foo', '', 3));
Response
┌─hex(sipHash128Reference('foo', '', 3))─┐
│ 4D1BE1A22D7F5933C0873E1698426260       │
└────────────────────────────────────────┘

​
sipHash128ReferenceKeyed

Introduite dans : v23.2.0 Identique à sipHash128Reference, mais prend en plus un argument de clé explicite au lieu d’utiliser une clé fixe. Syntaxe 
sipHash128ReferenceKeyed((k0, k1), arg1[, arg2, ...])
Arguments
  • (k0, k1) — Tuple de deux valeurs représentant la clé Tuple(UInt64, UInt64)
  • arg1[, arg2, ...] — Nombre variable d’arguments d’entrée pour lesquels calculer le hachage. Any
Valeur renvoyée Renvoie la valeur de hachage SipHash calculée de 128 bits des arguments d’entrée. FixedString(16) Exemples Exemple d’utilisation
Query
SELECT hex(sipHash128Reference('foo', '', 3));
Response
┌─hex(sipHash128Reference('foo', '', 3))─┐
│ 4D1BE1A22D7F5933C0873E1698426260       │
└────────────────────────────────────────┘

​
sipHash64

Introduit dans : v1.1.0 Produit une valeur de hachage SipHash de 64 bits. Il s’agit d’une fonction de hachage cryptographique. Elle est au moins trois fois plus rapide que la fonction de hachage MD5. La fonction interprète tous les paramètres d’entrée comme des chaînes de caractères et calcule la valeur de hachage de chacun d’eux. Elle combine ensuite ces hachages selon l’algorithme suivant :
  1. La première et la deuxième valeur de hachage sont concaténées dans un tableau, qui est ensuite haché.
  2. La valeur de hachage calculée précédemment et le hachage du troisième paramètre d’entrée sont hachés de la même manière.
  3. Ce calcul est répété pour toutes les autres valeurs de hachage de l’entrée d’origine.
les valeurs de hachage calculées peuvent être identiques pour les mêmes valeurs d’entrée avec des types d’argument différents. Cela concerne par exemple les types entiers de tailles différentes, les Tuple nommés et non nommés contenant les mêmes données, Map et le type Array(Tuple(key, value)) correspondant contenant les mêmes données.
Syntaxe 
sipHash64(arg1[, arg2, ...])
Arguments
  • arg1[, arg2, ...] — Un nombre variable d’arguments en entrée. Any
Valeur renvoyée Renvoie une valeur de hachage calculée à partir des arguments en entrée. UInt64 Exemples Exemple d’utilisation
Query
SELECT sipHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type;
Response
┌──────────────SipHash─┬─type───┐
│ 11400366955626497465 │ UInt64 │
└──────────────────────┴────────┘

​
sipHash64Keyed

Introduit dans : v23.2.0 Comme sipHash64, mais avec un argument de clé explicite au lieu d’utiliser une clé fixe. Syntaxe 
sipHash64Keyed((k0, k1), arg1[,arg2, ...])
Arguments
  • (k0, k1) — Un tuple de deux valeurs représentant la clé. Tuple(UInt64, UInt64)
  • arg1[,arg2, ...] — Un nombre variable d’arguments d’entrée. Any
Valeur renvoyée Renvoie le hachage calculé à partir des valeurs d’entrée. UInt64 Exemples Exemple d’utilisation
Query
SELECT sipHash64Keyed((506097522914230528, 1084818905618843912), array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type;
Response
┌─────────────SipHash─┬─type───┐
│ 8017656310194184311 │ UInt64 │
└─────────────────────┴────────┘

​
wordShingleMinHash

Introduit dans : v21.1.0 Découpe une chaîne ASCII en segments (shingles) de shinglesize mots, calcule les valeurs de hachage pour chaque shingle de mots et renvoie un tuple contenant ces hachages. Utilise les hashnum hachages minimum pour calculer le hachage minimum et les hashnum hachages maximum pour calculer le hachage maximum. La fonction est sensible à la casse. Peut être utilisé pour détecter des chaînes semi-dupliquées avec tupleHammingDistance. Pour deux chaînes, si les hachages renvoyés sont identiques pour les deux chaînes, alors ces chaînes sont identiques. Syntaxe 
wordShingleMinHash(string[, shinglesize, hashnum])
Arguments
  • string — Chaîne dont le hachage doit être calculé. String
  • shinglesize — Facultatif. La taille d’un shingle de mots, toute valeur comprise entre 1 et 25. La valeur par défaut est 3. UInt8
  • hashnum — Facultatif. Le nombre de hachages minimaux et maximaux utilisés pour calculer le résultat, toute valeur comprise entre 1 et 25. La valeur par défaut est 6. UInt8
Valeur renvoyée Renvoie un tuple contenant deux hachages — le minimum et le maximum. Tuple(UInt64, UInt64) Exemples Exemple d’utilisation
Query
SELECT wordShingleMinHash('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
Response
┌─Tuple──────────────────────────────────────┐
│ (16452112859864147620,5844417301642981317) │
└────────────────────────────────────────────┘

​
wordShingleMinHashArg

Introduit dans : v1.1.0 Divise une chaîne ASCII en segments (shingles) de shinglesize mots chacun et renvoie les shingles dont les hachages de mots sont minimaux et maximaux, tels qu’ils sont calculés par la fonction wordShingleMinHash avec la même entrée. Elle est sensible à la casse. Syntaxe 
wordShingleMinHashArg(string[, shinglesize, hashnum])
Arguments
  • string — Chaîne dont le hachage doit être calculé. String
  • shinglesize — Facultatif. Taille d’un shingle de mots, comprise entre 1 et 25. La valeur par défaut est 3. UInt8
  • hashnum — Facultatif. Nombre de hachages minimum et maximum utilisés pour calculer le résultat, compris entre 1 et 25. La valeur par défaut est 6. UInt8
Valeur renvoyée Renvoie un tuple composé de deux tuples contenant chacun hashnum shingles de mots. Tuple(Tuple(String)) Exemples Exemple d’utilisation
Query
SELECT wordShingleMinHashArg('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
Response
┌─Tuple─────────────────────────────────────────────────────────────────┐
│ (('OLAP','database','analytical'),('online','oriented','processing')) │
└───────────────────────────────────────────────────────────────────────┘

​
wordShingleMinHashArgCaseInsensitive

Introduit dans : v21.1.0 Découpe une chaîne ASCII en groupes (shingles) de shinglesize mots chacun et renvoie les shingles dont les hachages de mots sont minimaux et maximaux, tels que calculés par la fonction wordShingleMinHashCaseInsensitive avec la même entrée. Est insensible à la casse. Syntaxe 
wordShingleMinHashArgCaseInsensitive(string[, shinglesize, hashnum])
Arguments
  • string — Chaîne pour laquelle calculer le hachage. String
  • shinglesize — Facultatif. Taille d’un shingle de mots, toute valeur comprise entre 1 et 25. La valeur par défaut est 3. UInt8
  • hashnum — Facultatif. Nombre de hachages minimum et maximum utilisés pour calculer le résultat, toute valeur comprise entre 1 et 25. La valeur par défaut est 6. UInt8
Valeur renvoyée Renvoyer un tuple composé de deux tuples contenant chacun hashnum shingles de mots. Tuple(Tuple(String)) Exemples Exemple d’utilisation
Query
SELECT wordShingleMinHashArgCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
Response
┌─Tuple──────────────────────────────────────────────────────────────────┐
│ (('queries','database','analytical'),('oriented','processing','DBMS')) │
└────────────────────────────────────────────────────────────────────────┘

​
wordShingleMinHashArgCaseInsensitiveUTF8

Introduit dans : v21.1.0 Découpe une chaîne UTF-8 en shingles de shinglesize mots chacun et renvoie les shingles dont les hachages de mots sont minimum et maximum, calculés par la fonction wordShingleMinHashCaseInsensitiveUTF8 sur la même entrée. Elle est insensible à la casse. Syntaxe 
wordShingleMinHashArgCaseInsensitiveUTF8(string[, shinglesize, hashnum])
Arguments
  • string — Chaîne dont il faut calculer le hachage. String
  • shinglesize — Facultatif. La taille d’un shingle de mots, toute valeur comprise entre 1 et 25. La valeur par défaut est 3. UInt8
  • hashnum — Facultatif. Le nombre de hachages minimum et maximum utilisés pour calculer le résultat, toute valeur comprise entre 1 et 25. La valeur par défaut est 6. UInt8
Valeur renvoyée Renvoie un tuple contenant deux tuples de hashnum shingles de mots chacun. Tuple(Tuple(String)) Exemples Exemple d’utilisation
Query
SELECT wordShingleMinHashArgCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
Response
┌─Tuple──────────────────────────────────────────────────────────────────┐
│ (('queries','database','analytical'),('oriented','processing','DBMS')) │
└────────────────────────────────────────────────────────────────────────┘

​
wordShingleMinHashArgUTF8

Introduite dans : v21.1.0 Divise une chaîne UTF-8 en shingles de shinglesize mots chacun et renvoie les shingles dont les hachages de mots sont minimum et maximum, tels que calculés par la fonction wordShingleMinHashUTF8 pour la même entrée. La fonction est sensible à la casse. Syntaxe 
wordShingleMinHashArgUTF8(string[, shinglesize, hashnum])
Arguments
  • string — Chaîne pour laquelle calculer le hachage. String
  • shinglesize — Facultatif. Taille d’un shingle de mots, comprise entre 1 et 25. La valeur par défaut est 3. UInt8
  • hashnum — Facultatif. Nombre de hachages minimum et maximum utilisés pour calculer le résultat, compris entre 1 et 25. La valeur par défaut est 6. UInt8
Valeur renvoyée Renvoyer un tuple contenant deux tuples de hashnum shingles de mots chacun. Tuple(Tuple(String)) Exemples Exemple d’utilisation
Query
SELECT wordShingleMinHashArgUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
Response
┌─Tuple─────────────────────────────────────────────────────────────────┐
│ (('OLAP','database','analytical'),('online','oriented','processing')) │
└───────────────────────────────────────────────────────────────────────┘

​
wordShingleMinHashCaseInsensitive

Introduit dans : v21.1.0 Scinde une chaîne ASCII en parties (shingles) de shinglesize mots, calcule les valeurs de hachage de chaque shingle de mots et renvoie un tuple contenant ces hachages. Utilise les hashnum hachages minimum pour calculer le hachage minimum et les hashnum hachages maximum pour calculer le hachage maximum. Il est insensible à la casse. Peut être utilisé pour détecter des chaînes semi-dupliquées avec tupleHammingDistance. Pour deux chaînes, si les hachages renvoyés sont identiques pour les deux chaînes, alors ces chaînes sont identiques. Syntaxe 
wordShingleMinHashCaseInsensitive(string[, shinglesize, hashnum])
Arguments
  • string — Chaîne pour laquelle calculer le hachage. String
  • shinglesize — Facultatif. La taille d’un groupe de mots contigus, avec une valeur comprise entre 1 et 25. La valeur par défaut est 3. UInt8
  • hashnum — Facultatif. Le nombre de hachages minimaux et maximaux utilisés pour calculer le résultat, avec une valeur comprise entre 1 et 25. La valeur par défaut est 6. UInt8
Valeur renvoyée Renvoie un tuple contenant deux hachages — le minimum et le maximum. Tuple(UInt64, UInt64) Exemples Exemple d’utilisation
Query
SELECT wordShingleMinHashCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
Response
┌─Tuple─────────────────────────────────────┐
│ (3065874883688416519,1634050779997673240) │
└───────────────────────────────────────────┘

​
wordShingleMinHashCaseInsensitiveUTF8

Introduit dans : v21.1.0 Découpe une chaîne UTF-8 en segments (shingles) de shinglesize mots, calcule les valeurs de hachage pour chaque word shingle et renvoie un tuple contenant ces hachages. Utilise les hashnum hachages minimum pour calculer le hachage minimum et les hashnum hachages maximum pour calculer le hachage maximum. Est insensible à la casse. Peut être utilisé pour détecter des chaînes semi-dupliquées avec tupleHammingDistance. Pour deux chaînes, si les hachages renvoyés sont identiques pour les deux chaînes, alors ces chaînes sont identiques. Syntaxe 
wordShingleMinHashCaseInsensitiveUTF8(string[, shinglesize, hashnum])
Arguments
  • string — Chaîne dont le hachage doit être calculé. String
  • shinglesize — Facultatif. La taille d’un shingle de mots, tout nombre compris entre 1 et 25. La valeur par défaut est 3. UInt8
  • hashnum — Facultatif. Le nombre de hachages minimaux et maximaux utilisés pour calculer le résultat, tout nombre compris entre 1 et 25. La valeur par défaut est 6. UInt8
Valeur renvoyée Renvoie un tuple contenant deux hachages — le minimum et le maximum. Tuple(UInt64, UInt64) Exemples Exemple d’utilisation
Query
SELECT wordShingleMinHashCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
Response
┌─Tuple─────────────────────────────────────┐
│ (3065874883688416519,1634050779997673240) │
└───────────────────────────────────────────┘

​
wordShingleMinHashUTF8

Introduit dans : v21.1.0 Découpe une chaîne UTF-8 en groupes (shingles) de shinglesize mots, calcule les valeurs de hachage pour chaque groupe de mots et renvoie un tuple contenant ces hachages. Utilise hashnum hachages minimaux pour calculer le hachage minimal et hashnum hachages maximaux pour calculer le hachage maximal. La fonction est sensible à la casse. Peut être utilisée pour détecter des chaînes semi-dupliquées avec tupleHammingDistance. Pour deux chaînes, si les hachages renvoyés sont les mêmes pour les deux chaînes, alors ces chaînes sont identiques. Syntaxe 
wordShingleMinHashUTF8(string[, shinglesize, hashnum])
Arguments
  • string — Chaîne pour laquelle calculer le hachage. String
  • shinglesize — Facultatif. La taille d’un shingle de mots, comprise entre 1 et 25. La valeur par défaut est 3. UInt8
  • hashnum — Facultatif. Le nombre de hachages minimum et maximum utilisés pour calculer le résultat, compris entre 1 et 25. La valeur par défaut est 6. UInt8
Valeur renvoyée Renvoie un tuple contenant deux hachages — le minimum et le maximum. Tuple(UInt64, UInt64) Exemples Exemple d’utilisation
Query
SELECT wordShingleMinHashUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
Response
┌─Tuple──────────────────────────────────────┐
│ (16452112859864147620,5844417301642981317) │
└────────────────────────────────────────────┘

​
wordShingleSimHash

Introduit dans : v21.1.0 Découpe une chaîne ASCII en groupes de shinglesize mots (shingles) et renvoie le simhash du shingle de mots. Cette fonction est sensible à la casse. Peut être utilisé pour détecter des chaînes semi-dupliquées avec bitHammingDistance. Plus la distance de Hamming entre les simhashes calculés de deux chaînes est faible, plus il est probable que ces chaînes soient identiques. Syntaxe 
wordShingleSimHash(string[, shinglesize])
Arguments
  • string — Chaîne pour laquelle calculer le hachage. String
  • shinglesize — Facultatif. Taille d’un groupe contigu de mots, comprise entre 1 et 25. La valeur par défaut est 3. UInt8
Valeur renvoyée Renvoie la valeur de hachage calculée. UInt64 Exemples Exemple d’utilisation
Query
SELECT wordShingleSimHash('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
Response
┌───────Hash─┐
│ 2328277067 │
└────────────┘

​
wordShingleSimHashCaseInsensitive

Introduit dans : v21.1.0 Divise une chaîne ASCII en segments (shingles) de shinglesize mots et renvoie le simhash du shingle de mots. Est insensible à la casse. Peut être utilisé pour détecter des chaînes quasi dupliquées avec bitHammingDistance. Plus la distance de Hamming entre les simhash calculés de deux chaînes est faible, plus ces chaînes ont de chances d’être identiques. Syntaxe 
wordShingleSimHashCaseInsensitive(string[, shinglesize])
Arguments
  • string — Chaîne pour laquelle calculer le hachage. String
  • shinglesize — Facultatif. Taille d’un shingle de mots, nombre compris entre 1 et 25. La valeur par défaut est 3. UInt8
Valeur renvoyée Renvoie la valeur de hachage calculée. UInt64 Exemples Exemple d’utilisation
Query
SELECT wordShingleSimHashCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
Response
┌───────Hash─┐
│ 2194812424 │
└────────────┘

​
wordShingleSimHashCaseInsensitiveUTF8

Introduit dans : v1.1.0 Découpe une chaîne codée en UTF-8 en groupes (shingles) de shinglesize mots et renvoie le simhash du shingle de mots. Est insensible à la casse. Peut être utilisée pour détecter des chaînes quasi dupliquées avec bitHammingDistance. Plus la distance de Hamming entre les simhashes calculés pour deux chaînes est faible, plus il est probable que ces chaînes soient identiques. Syntaxe 
wordShingleSimHashCaseInsensitiveUTF8(string[, shinglesize])
Arguments
  • string — Chaîne pour laquelle calculer le hachage. String
  • shinglesize — Facultatif. Taille d’un shingle de mots, comprise entre 1 et 25. La valeur par défaut est 3. UInt8
Valeur renvoyée Renvoie la valeur de hachage calculée. UInt64 Exemples Exemple d’utilisation
Query
SELECT wordShingleSimHashCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
Response
┌───────Hash─┐
│ 2194812424 │
└────────────┘

​
wordShingleSimHashUTF8

Introduit dans : v21.1.0 Divise une chaîne UTF-8 en groupes (shingles) de shinglesize mots et renvoie le simhash des shingles de mots. Il est sensible à la casse. Peut être utilisé pour détecter des chaînes quasi dupliquées avec bitHammingDistance. Plus la distance de Hamming entre les simhashes calculés de deux chaînes est faible, plus il est probable que ces chaînes soient identiques. Syntaxe 
wordShingleSimHashUTF8(string[, shinglesize])
Arguments
  • string — Chaîne dont il faut calculer le hachage. String
  • shinglesize — Facultatif. Taille d’un shingle de mots, toute valeur comprise entre 1 et 25. La valeur par défaut est 3. UInt8
Valeur renvoyée Renvoie la valeur de hachage calculée. UInt64 Exemples Exemple d’utilisation
Query
SELECT wordShingleSimHashUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
Response
┌───────Hash─┐
│ 2328277067 │
└────────────┘

​
wyHash64

Introduit dans : v22.7.0 Calcule une valeur de hachage 64 bits wyHash64. Syntaxe 
wyHash64(arg)
Arguments
  • arg — argument de type String dont la valeur de hachage doit être calculée. String
Valeur renvoyée Renvoie la valeur de hachage calculée sur 64 bits UInt64 Exemples Exemple d’utilisation
Query
SELECT wyHash64('ClickHouse') AS Hash;
Response
12336419557878201794

​
xxHash32

Introduit dans : v20.1.0 Calcule un xxHash à partir d’une chaîne de caractères. Pour la version 64 bits, voir xxHash64 Syntaxe 
xxHash32(arg)
Arguments
  • arg — Chaîne à hacher. String
Valeur renvoyée Renvoie le hachage 32 bits calculé à partir de la chaîne d’entrée. UInt32 Exemples Exemple d’utilisation
Query
SELECT xxHash32('Hello, world!');
Response
┌─xxHash32('Hello, world!')─┐
│                 834093149 │
└───────────────────────────┘

​
xxHash64

Introduit dans : v20.1.0 Calcule un xxHash à partir d’une chaîne de caractères. Pour la version 32 bits, voir xxHash32 Syntaxe 
xxHash64(arg)
Arguments
  • arg — Chaîne d’entrée à hacher. String
Valeur renvoyée Renvoie le hachage 64 bits calculé à partir de la chaîne d’entrée. UInt64 Exemples Exemple d’utilisation
Query
SELECT xxHash64('Hello, world!');
Response
┌─xxHash64('Hello, world!')─┐
│      17691043854468224118 │
└───────────────────────────┘

​
xxh3

Introduit dans : v22.12.0 Calcule une valeur de hachage XXH3 sur 64 bits. Syntaxe 
xxh3(expr)
Arguments
  • expr — Une liste d’expressions de n’importe quel type de données. Any
Valeur renvoyée Renvoie la valeur de hachage xxh3 sur 64 bits calculée UInt64 Exemples Exemple d’utilisation
Query
SELECT xxh3('ClickHouse')
Response
18009318874338624809

​
xxh3_128

Introduit dans : v26.2.0 Calcule une valeur de hachage XXH3 sur 128 bits. Syntaxe 
xxh3_128(expr)
Arguments
  • expr — Une liste d’expressions de n’importe quel type de données. Any
Valeur renvoyée Renvoie la valeur de hachage xxh3 calculée sur 128 bits UInt128 Exemples Exemple d’utilisation
Query
SELECT hex(xxh3_128('ClickHouse'))
Response
3A038784C52804B4DBA43A038784C528
Dernière modification le 25 juin 2026