Fonctions de hachage | ClickHouse Docs

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.

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

SELECT hex(BLAKE3('ABC'))

┌─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

SELECT HEX(MD4('abc'));

┌─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

SELECT HEX(MD5('abc'));

┌─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

SELECT HEX(RIPEMD160('The quick brown fox jumps over the lazy dog'));

┌─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

SELECT HEX(SHA1('abc'));

┌─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

SELECT HEX(SHA224('abc'));

┌─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

SELECT HEX(SHA256('abc'));

┌─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

SELECT HEX(SHA384('abc'));

┌─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

SELECT HEX(SHA512('abc'));

┌─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

SELECT HEX(SHA512_256('abc'));

┌─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 :

Mode	Description
`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

SELECT URLHash('https://www.clickhouse.com')

┌─URLHash('https://www.clickhouse.com')─┐
│                  13614512636072854701 │
└───────────────────────────────────────┘

Hachage de l’URL au niveau spécifié

SELECT URLHash('https://www.clickhouse.com/docs', 0);
SELECT URLHash('https://www.clickhouse.com/docs', 1);

13614512636072854701
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.

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

SELECT cityHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS CityHash, toTypeName(CityHash) AS type;

┌─────────────CityHash─┬─type───┐
│ 17177535963988450974 │ UInt64 │
└──────────────────────┴────────┘

Calcul de la somme de contrôle de l’ensemble de la table, à l’ordre des lignes près

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;

┌─groupBitXor(cityHash64(id, name, age, city))─┐
│                         11639977218258521182 │
└──────────────────────────────────────────────┘

farmFingerprint64

Introduit dans : v20.12.0

Produit une valeur FarmHash sur 64 bits à l’aide de la méthode Fingerprint64.

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

SELECT farmFingerprint64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmFingerprint, toTypeName(FarmFingerprint) AS type;

┌──────FarmFingerprint─┬─type───┐
│ 16673609057812504858 │ UInt64 │
└──────────────────────┴────────┘

farmHash64

Introduit dans : v1.1.0

Produit un FarmHash 64 bits à l’aide de la méthode Hash64.

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

SELECT farmHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmHash, toTypeName(FarmHash) AS type;

┌────────────FarmHash─┬─type───┐
│ 2663412879246289891 │ 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

SELECT
    gccMurmurHash(1, 2, 3) AS res1,
    gccMurmurHash(('a', [1, 2, 3], 4, (4, ['foo', 'bar'], 1, (1, 2)))) AS res2

┌─────────────────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

SELECT HEX(halfMD5('abc', 'cde', 'fgh'));

┌─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.

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

SELECT hiveHash('Hello, world!');

┌─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

value — Valeur source à hacher, de type Integer, Bool, Decimal, Float*, String, FixedString, UUID, Date, Time ou DateTime

Valeur renvoyée

Renvoie un hachage Murmur3 32 bits, variante x86, initialisé avec 0 Int32

Exemples

Exemple

SELECT icebergHash(1.0 :: Float32)

-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

SELECT intHash32(42);

┌─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

SELECT intHash64(42);

┌────────intHash64(42)─┐
│ 11490350930367293593 │
└──────────────────────┘

javaHash

Introduit dans : v20.1.0

Calcule JavaHash à partir de :

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

SELECT javaHash(toInt32(123));

┌─javaHash(toInt32(123))─┐
│                    123 │
└────────────────────────┘

Exemple d’utilisation 2

SELECT javaHash('Hello, world!');

┌─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

SELECT javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'));

┌─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

SELECT jumpConsistentHash(256, 4)

┌─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

SELECT
    kafkaMurmurHash('foobar') AS res1,
    kafkaMurmurHash(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS res2

┌───────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

SELECT hex(keccak256('hello'))

┌─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

SELECT kostikConsistentHash(16045690984833335023, 2);

┌─kostikConsistentHash(16045690984833335023, 2)─┐
│                                             1 │
└───────────────────────────────────────────────┘

metroHash64

Introduit dans : v1.1.0

Produit une valeur de hachage MetroHash de 64 bits.

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

SELECT metroHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MetroHash, toTypeName(MetroHash) AS type;

┌────────────MetroHash─┬─type───┐
│ 16292826582821303855 │ UInt64 │
└──────────────────────┴────────┘

murmurHash2_32

Introduit dans : v18.5.0

Calcule le hachage MurmurHash2 de la valeur d’entrée.

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

SELECT murmurHash2_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type;

┌─MurmurHash2─┬─type───┐
│  2947095100 │ UInt32 │
└─────────────┴────────┘

murmurHash2_64

Introduit dans : v18.10.0

Calcule le hachage MurmurHash2 de la valeur d’entrée.

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

SELECT murmurHash2_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type;

┌──────────MurmurHash2─┬─type───┐
│ 16479669305841206229 │ 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

SELECT hex(murmurHash3_128('foo', 'foo', 'foo'));

┌─hex(murmurHash3_128('foo', 'foo', 'foo'))─┐
│ F8F7AD9B6CD4CF117A71E277E2EC2931          │
└───────────────────────────────────────────┘

murmurHash3_32

Introduit dans : v18.10.0

Produit une valeur de hachage MurmurHash3.

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

SELECT murmurHash3_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type;

┌─MurmurHash3─┬─type───┐
│   317985299 │ UInt32 │
└─────────────┴────────┘

murmurHash3_64

Introduit dans : v18.10.0

Calcule le hachage MurmurHash3 de la valeur d’entrée.

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

SELECT murmurHash3_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type;

┌──────────MurmurHash3─┬─type───┐
│ 11285022984631508790 │ 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

SELECT ngramMinHash('ClickHouse') AS Tuple;

┌─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

SELECT ngramMinHashArg('ClickHouse') AS Tuple;

┌─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

SELECT ngramMinHashArgCaseInsensitive('ClickHouse') AS Tuple;

┌─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

SELECT ngramMinHashArgCaseInsensitiveUTF8('ClickHouse') AS Tuple;

┌─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

SELECT ngramMinHashArgUTF8('ClickHouse') AS Tuple;

┌─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

SELECT ngramMinHashCaseInsensitive('ClickHouse') AS Tuple;

┌─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

SELECT ngramMinHashCaseInsensitiveUTF8('ClickHouse') AS Tuple;

┌─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.

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

SELECT ngramMinHashUTF8('ClickHouse') AS Tuple;

┌─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

SELECT ngramSimHash('ClickHouse') AS Hash;

┌───────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

SELECT ngramSimHashCaseInsensitive('ClickHouse') AS Hash;

┌──────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

SELECT ngramSimHashCaseInsensitiveUTF8('ClickHouse') AS Hash;

┌───────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.

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

SELECT ngramSimHashUTF8('ClickHouse') AS Hash;

┌───────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.

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

SELECT hex(sipHash128('foo', '\x01', 3)) AS res;

┌─res──────────────────────────────┐
│ 9DE516A64A414D4B1B609415E4523F24 │
└──────────────────────────────────┘

sipHash128Keyed

Introduit dans : v23.2.0

Identique à sipHash128, mais accepte en plus un argument de clé explicite au lieu d’utiliser une clé fixe.

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

SELECT hex(sipHash128Keyed((506097522914230528, 1084818905618843912), 'foo', '\x01', 3)) AS res;

┌─res──────────────────────────────┐
│ 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

SELECT hex(sipHash128Reference('foo', '\x01', 3)) AS res;

┌─res──────────────────────────────┐
│ C3AA2F3C06A14DBE3742E9107AA9765D │
└──────────────────────────────────┘

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

SELECT hex(sipHash128ReferenceKeyed((506097522914230528, 1084818905618843912), 'foo', '\x01', 3)) AS res;

┌─res──────────────────────────────┐
│ 1D010CC83FB5460C25B556CE40992E61 │
└──────────────────────────────────┘

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 :

La première et la deuxième valeur de hachage sont concaténées dans un tableau, qui est ensuite haché.
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.
Ce calcul est répété pour toutes les autres valeurs de hachage de l’entrée d’origine.

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

SELECT sipHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type;

┌──────────────SipHash─┬─type───┐
│ 11348918044846389429 │ 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

SELECT sipHash64Keyed((506097522914230528, 1084818905618843912), array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type;

┌─────────────SipHash─┬─type───┐
│ 8194087499447867747 │ 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.

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

SELECT wordShingleMinHash('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;

┌─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

SELECT wordShingleMinHashArg('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;

┌─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

SELECT wordShingleMinHashArgCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;

┌─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

SELECT wordShingleMinHashArgCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;

┌─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

SELECT wordShingleMinHashArgUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;

┌─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.

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

SELECT wordShingleMinHashCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;

┌─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.

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

SELECT wordShingleMinHashCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;

┌─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

SELECT wordShingleMinHashUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;

┌─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.

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

SELECT wordShingleSimHash('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;

┌───────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

SELECT wordShingleSimHashCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;

┌───────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

SELECT wordShingleSimHashCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;

┌───────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

SELECT wordShingleSimHashUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;

┌───────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

SELECT wyHash64('ClickHouse') AS Hash;

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

SELECT xxHash32('Hello, world!');

┌─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

SELECT xxHash64('Hello, world!');

┌─xxHash64('Hello, world!')─┐
│      17691043854468224118 │
└───────────────────────────┘

xxHash64Spark

Introduit dans : v26.7.0

Calcule un xxHash à partir d’une chaîne de caractères avec la même seed que Spark.

Cette fonction est identique à xxHash64, mais elle utilise la seed 42 et renvoie le résultat au format Int64. Seules les entrées String et NULL sont prises en charge. Pour NULL, la fonction renvoie 42, conformément au comportement de Spark pour la seed.

Syntaxe

xxHash64Spark(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. Int64

Exemples

Exemple d'utilisation

SELECT xxHash64Spark('ABC');

┌─xxHash64Spark('ABC')─┐
│  4105715581806190027 │
└──────────────────────┘

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

SELECT xxh3('ClickHouse')

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

SELECT hex(xxh3_128('ClickHouse'))

14C27B7BEF95D36FECF5520CA2DAF030