> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-fbfa8bee.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Documentation sur les fonctions de hachage

# Fonctions de hachage

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.

<Note>
  Le hachage de NULL est NULL. Pour obtenir un hachage non-NULL d’une colonne Nullable, enveloppez-la dans un tuple :

  ```sql theme={null}
  SELECT cityHash64(tuple(NULL))
  ```
</Note>

<Note>
  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.
</Note>

{/*AUTOGENERATED_START*/}

<div id="BLAKE3">
  ## BLAKE3
</div>

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**

```sql theme={null}
BLAKE3(message)
```

**Arguments**

* `message` — La chaîne d'entrée à hacher. [`String`](/fr/reference/data-types/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)`](/fr/reference/data-types/fixedstring)

**Exemples**

**hash**

```sql title=Query theme={null}
SELECT hex(BLAKE3('ABC'))
```

```response title=Response theme={null}
┌─hex(BLAKE3('ABC'))───────────────────────────────────────────────┐
│ D1717274597CF0289694F75D96D444B992A096F1AFD8E7BBFA6EBB1D360FEDFC │
└──────────────────────────────────────────────────────────────────┘
```

<div id="MD4">
  ## MD4
</div>

Introduit dans : v21.11.0

Calcule le hachage MD4 de la chaîne spécifiée.

**Syntaxe**

```sql theme={null}
MD4(s)
```

**Arguments**

* `s` — La chaîne d'entrée à hacher. [`String`](/fr/reference/data-types/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)`](/fr/reference/data-types/fixedstring)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT HEX(MD4('abc'));
```

```response title=Response theme={null}
┌─hex(MD4('abc'))──────────────────┐
│ A448017AAF21D8525FC10AE87AA6729D │
└──────────────────────────────────┘
```

<div id="MD5">
  ## MD5
</div>

Disponible depuis : v1.1.0

Calcule le hachage MD5 de la chaîne fournie.

**Syntaxe**

```sql theme={null}
MD5(s)
```

**Arguments**

* `s` — La chaîne d'entrée à hacher. [`String`](/fr/reference/data-types/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)`](/fr/reference/data-types/fixedstring)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT HEX(MD5('abc'));
```

```response title=Response theme={null}
┌─hex(MD5('abc'))──────────────────┐
│ 900150983CD24FB0D6963F7D28E17F72 │
└──────────────────────────────────┘
```

<div id="RIPEMD160">
  ## RIPEMD160
</div>

Introduit dans : v24.10.0

Calcule le hachage RIPEMD-160 de la chaîne fournie.

**Syntaxe**

```sql theme={null}
RIPEMD160(s)
```

**Arguments**

* `s` — La chaîne d'entrée à hacher. [`String`](/fr/reference/data-types/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)`](/fr/reference/data-types/fixedstring)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT HEX(RIPEMD160('The quick brown fox jumps over the lazy dog'));
```

```response title=Response theme={null}
┌─HEX(RIPEMD160('The quick brown fox jumps over the lazy dog'))─┐
│ 37F332F68DB77BD9D7EDD4969571AD671CF9DD3B                      │
└───────────────────────────────────────────────────────────────┘
```

<div id="SHA1">
  ## SHA1
</div>

Introduit dans : v1.1.0

Calcule le hachage SHA1 de la chaîne fournie.

**Syntaxe**

```sql theme={null}
SHA1(s)
```

**Arguments**

* `s` — La chaîne d’entrée à hacher [`String`](/fr/reference/data-types/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)`](/fr/reference/data-types/fixedstring)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT HEX(SHA1('abc'));
```

```response title=Response theme={null}
┌─hex(SHA1('abc'))─────────────────────────┐
│ A9993E364706816ABA3E25717850C26C9CD0D89D │
└──────────────────────────────────────────┘
```

<div id="SHA224">
  ## SHA224
</div>

Introduit dans : v1.1.0

Calcule le hachage SHA224 de la chaîne donnée.

**Syntaxe**

```sql theme={null}
SHA224(s)
```

**Arguments**

* `s` — La valeur d’entrée à hacher. [`String`](/fr/reference/data-types/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)`](/fr/reference/data-types/fixedstring)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT HEX(SHA224('abc'));
```

```response title=Response theme={null}
┌─hex(SHA224('abc'))───────────────────────────────────────┐
│ 23097D223405D8228642A477BDA255B32AADBCE4BDA0B3F7E36C9DA7 │
└──────────────────────────────────────────────────────────┘
```

<div id="SHA256">
  ## SHA256
</div>

Introduit dans : v1.1.0

Calcule le hachage SHA256 de la chaîne donnée.

**Syntaxe**

```sql theme={null}
SHA256(s)
```

**Arguments**

* `s` — La chaîne d’entrée à hacher. [`String`](/fr/reference/data-types/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)`](/fr/reference/data-types/fixedstring)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT HEX(SHA256('abc'));
```

```response title=Response theme={null}
┌─hex(SHA256('abc'))───────────────────────────────────────────────┐
│ BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A9CB410FF61F20015AD │
└──────────────────────────────────────────────────────────────────┘
```

<div id="SHA384">
  ## SHA384
</div>

Introduit dans : v1.1.0

Calcule le hachage SHA384 de la chaîne donnée.

**Syntaxe**

```sql theme={null}
SHA384(s)
```

**Arguments**

* `s` — La chaîne d’entrée à hacher. [`String`](/fr/reference/data-types/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)`](/fr/reference/data-types/fixedstring)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT HEX(SHA384('abc'));
```

```response title=Response theme={null}
┌─hex(SHA384('abc'))───────────────────────────────────────────────────────────────────────────────┐
│ CB00753F45A35E8BB5A03D699AC65007272C32AB0EDED1631A8B605A43FF5BED8086072BA1E7CC2358BAECA134C825A7 │
└──────────────────────────────────────────────────────────────────────────────────────────────────┘
```

<div id="SHA512">
  ## SHA512
</div>

Introduit dans : v1.1.0

Calcule le hachage SHA512 de la chaîne fournie.

**Syntaxe**

```sql theme={null}
SHA512(s)
```

**Arguments**

* `s` — La chaîne d’entrée à hacher [`String`](/fr/reference/data-types/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)`](/fr/reference/data-types/fixedstring)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT HEX(SHA512('abc'));
```

```response title=Response theme={null}
┌─hex(SHA512('abc'))───────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ DDAF35A193617ABACC417349AE20413112E6FA4E89A97EA20A9EEEE64B55D39A2192992A274FC1A836BA3C23A3FEEBBD454D4423643CE80E2A9AC94FA54CA49F │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```

<div id="SHA512_256">
  ## SHA512\_256
</div>

Introduit dans : v1.1.0

Calcule le hachage SHA512\_256 de la chaîne spécifiée.

**Syntaxe**

```sql theme={null}
SHA512_256(s)
```

**Arguments**

* `s` — La chaîne d’entrée à hacher. [`String`](/fr/reference/data-types/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)`](/fr/reference/data-types/fixedstring)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT HEX(SHA512_256('abc'));
```

```response title=Response theme={null}
┌─hex(SHA512_256('abc'))───────────────────────────────────────────┐
│ 53048E2681941EF99B2E29B76B4C7DABE4C2D0C634FC6D46E0E2F13107E7AF23 │
└──────────────────────────────────────────────────────────────────┘
```

<div id="URLHash">
  ## URLHash
</div>

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**

```sql theme={null}
URLHash(url[, N])
```

**Arguments**

* `url` — Chaîne d’URL à hacher. [`String`](/fr/reference/data-types/string)
* `N` — Facultatif. Niveau dans la hiérarchie de l’URL. [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée pour `url`. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT URLHash('https://www.clickhouse.com')
```

```response title=Response theme={null}
┌─URLHash('htt⋯house.com')─┐
│     13614512636072854701 │
└──────────────────────────┘
```

**Hachage de l’URL au niveau spécifié**

```sql title=Query theme={null}
SELECT URLHash('https://www.clickhouse.com/docs', 0);
SELECT URLHash('https://www.clickhouse.com/docs', 1);
```

```response title=Response theme={null}
-- 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 │
└──────────────────────────┘
```

<div id="cityHash64">
  ## cityHash64
</div>

Introduit dans : v1.1.0

Produit une valeur de hachage [CityHash](https://github.com/google/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.

<Info>
  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.
</Info>

<Note>
  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.
</Note>

**Syntaxe**

```sql theme={null}
cityHash64(arg1[, arg2, ...])
```

**Arguments**

* `arg1[, arg2, ...]` — Un nombre variable d’arguments d’entrée dont le hachage doit être calculé. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie le hachage calculé des arguments d’entrée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’appel**

```sql title=Query theme={null}
SELECT cityHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS CityHash, toTypeName(CityHash) AS type;
```

```response title=Response theme={null}
┌─────────────CityHash─┬─type───┐
│ 12072650598913549138 │ UInt64 │
└──────────────────────┴────────┘
```

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

```sql title=Query theme={null}
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 title=Response theme={null}
┌─groupBitXor(⋯age, city))─┐
│     11639977218258521182 │
└──────────────────────────┘
```

<div id="farmFingerprint64">
  ## farmFingerprint64
</div>

Introduit dans : v20.12.0

Produit une valeur [FarmHash](https://github.com/google/farmhash) sur 64 bits à l’aide de la méthode `Fingerprint64`.

<Tip>
  `farmFingerprint64` est à privilégier pour obtenir une valeur stable et portable plutôt que [`farmHash64`](#farmHash64).
</Tip>

<Note>
  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.
</Note>

**Syntaxe**

```sql theme={null}
farmFingerprint64(arg1[, arg2, ...])
```

**Arguments**

* `arg1[, arg2, ...]` — Un nombre variable d’arguments d’entrée dont le hachage doit être calculé. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée à partir des arguments d’entrée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT farmFingerprint64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmFingerprint, toTypeName(FarmFingerprint) AS type;
```

```response title=Response theme={null}
┌─────FarmFingerprint─┬─type───┐
│ 5752020380710916328 │ UInt64 │
└─────────────────────┴────────┘
```

<div id="farmHash64">
  ## farmHash64
</div>

Introduit dans : v1.1.0

Produit un [FarmHash](https://github.com/google/farmhash) 64 bits à l’aide de la méthode `Hash64`.

<Tip>
  [`farmFingerprint64`](#farmFingerprint64) est recommandé pour obtenir une valeur stable et portable.
</Tip>

<Note>
  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.
</Note>

**Syntaxe**

```sql theme={null}
farmHash64(arg1[, arg2, ...])
```

**Arguments**

* `arg1[, arg2, ...]` — Un nombre variable d'arguments d'entrée dont le hachage doit être calculé. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée à partir des arguments d'entrée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT farmHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmHash, toTypeName(FarmHash) AS type;
```

```response title=Response theme={null}
┌─────────────FarmHash─┬─type───┐
│ 18125596431186471178 │ UInt64 │
└──────────────────────┴────────┘
```

<div id="gccMurmurHash">
  ## gccMurmurHash
</div>

Introduit dans : v20.1.0

Calcule le hachage [MurmurHash2](https://github.com/aappleby/smhasher) sur 64 bits de la valeur d'entrée en utilisant la même graine que [GCC](https://github.com/gcc-mirror/gcc/blob/41d6b10e96a1de98e90a7c0378437c3255814b16/libstdc%2B%2B-v3/include/bits/functional_hash.h#L191).

Il est portable entre les builds de Clang et de GCC.

**Syntaxe**

```sql theme={null}
gccMurmurHash(arg1[, arg2, ...])
```

**Arguments**

* `arg1[, arg2, ...]` — Un nombre variable d’arguments dont le hachage doit être calculé. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée à partir des arguments d’entrée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT
    gccMurmurHash(1, 2, 3) AS res1,
    gccMurmurHash(('a', [1, 2, 3], 4, (4, ['foo', 'bar'], 1, (1, 2)))) AS res2
```

```response title=Response theme={null}
┌─────────────────res1─┬────────────────res2─┐
│ 12384823029245979431 │ 1188926775431157506 │
└──────────────────────┴─────────────────────┘
```

<div id="halfMD5">
  ## halfMD5
</div>

Introduit dans : v1.1.0

[Interprète](/fr/reference/functions/regular-functions/type-conversion-functions#reinterpretAsString) 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](/fr/reference/data-types/int-uint) 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`](#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**

```sql theme={null}
halfMD5(arg1[, arg2, ..., argN])
```

**Arguments**

* `arg1[, arg2, ..., argN]` — Nombre variable d’arguments pour lesquels calculer le hachage. [`Any`](/fr/reference/data-types/index)

**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`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT HEX(halfMD5('abc', 'cde', 'fgh'));
```

```response title=Response theme={null}
┌─hex(halfMD5('abc', 'cde', 'fgh'))─┐
│ 2C9506B7374CFAF4                  │
└───────────────────────────────────┘
```

<div id="hiveHash">
  ## hiveHash
</div>

Introduit dans : v20.1.0

Calcule un "HiveHash" à partir d'une chaîne de caractères.
Il s'agit simplement de [`JavaHash`](#javaHash) dont les bits de signe sont mis à zéro.
Cette fonction est utilisée dans [Apache Hive](https://en.wikipedia.org/wiki/Apache_Hive) pour les versions antérieures à 3.0.

<Warning>
  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.
</Warning>

**Syntaxe**

```sql theme={null}
hiveHash(arg)
```

**Arguments**

* `arg` — Chaîne d’entrée à hacher. [`String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie le « hive hash » calculé à partir de la chaîne d’entrée. [`Int32`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT hiveHash('Hello, world!');
```

```response title=Response theme={null}
┌─hiveHash('Hello, world!')─┐
│                 267439093 │
└───────────────────────────┘
```

<div id="icebergHash">
  ## icebergHash
</div>

Introduit dans : v25.5.0

Implémente la logique de la [transformation de hachage](https://iceberg.apache.org/spec/#appendix-b-32-bit-hash-requirements) d’Iceberg

**Syntaxe**

```sql theme={null}
icebergHash(value)
```

**Arguments**

* `value` — Valeur source à hacher, de type [`Integer`](/fr/reference/data-types/int-uint), [`Bool`](/fr/reference/data-types/boolean), [`Decimal`](/fr/reference/data-types/decimal), [`Float*`](/fr/reference/data-types/float), [`String`](/fr/reference/data-types/string), [`FixedString`](/fr/reference/data-types/fixedstring), [`UUID`](/fr/reference/data-types/uuid), [`Date`](/fr/reference/data-types/date), [`Time`](/fr/reference/data-types/time) ou [`DateTime`](/fr/reference/data-types/datetime)

**Valeur renvoyée**

Renvoie un hachage Murmur3 32 bits, variante x86, initialisé avec 0 [`Int32`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple**

```sql title=Query theme={null}
SELECT icebergHash(1.0 :: Float32)
```

```response title=Response theme={null}
-142385009
```

<div id="intHash32">
  ## intHash32
</div>

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**

```sql theme={null}
intHash32(arg)
```

**Arguments**

* `arg` — Entier à hacher. [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie le code de hachage 32 bits calculé à partir de l'entier d'entrée [`UInt32`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT intHash32(42);
```

```response title=Response theme={null}
┌─intHash32(42)─┐
│    1228623923 │
└───────────────┘
```

<div id="intHash64">
  ## intHash64
</div>

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`](#intHash32)), mais ce n’est pas une fonction de hachage cryptographique.

**Syntaxe**

```sql theme={null}
intHash64(int)
```

**Arguments**

* `int` — Entier à hacher. [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Code de hachage 64 bits. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT intHash64(42);
```

```response title=Response theme={null}
┌────────intHash64(42)─┐
│ 11490350930367293593 │
└──────────────────────┘
```

<div id="javaHash">
  ## javaHash
</div>

Introduit dans : v20.1.0

Calcule JavaHash à partir de :

* [chaîne de caractères](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/String.java#l1452),
* [Byte](https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/Byte.java#l405),
* [Short](https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/Short.java#l410),
* [Integer](https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/Integer.java#l959),
* [Long](https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/Long.java#l1060).

<Warning>
  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.
</Warning>

<Note>
  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.
</Note>

**Syntaxe**

```sql theme={null}
javaHash(arg)
```

**Arguments**

* `arg` — Valeur d'entrée à hacher. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie le hachage calculé de `arg` [`Int32`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation 1**

```sql title=Query theme={null}
SELECT javaHash(toInt32(123));
```

```response title=Response theme={null}
┌─javaHash(toInt32(123))─┐
│               123      │
└────────────────────────┘
```

**Exemple d’utilisation 2**

```sql title=Query theme={null}
SELECT javaHash('Hello, world!');
```

```response title=Response theme={null}
┌─javaHash('Hello, world!')─┐
│               -1880044555 │
└───────────────────────────┘
```

<div id="javaHashUTF16LE">
  ## javaHashUTF16LE
</div>

Introduit dans : v20.1.0

Calcule le [JavaHash](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/String.java#l1452) 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**

```sql theme={null}
javaHashUTF16LE(arg)
```

**Arguments**

* `arg` — Une chaîne encodée en UTF-16LE. [`String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie le hachage calculé de la chaîne encodée en UTF-16LE. [`Int32`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'));
```

```response title=Response theme={null}
┌─javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'))─┐
│                                                      3556498 │
└──────────────────────────────────────────────────────────────┘
```

<div id="jumpConsistentHash">
  ## jumpConsistentHash
</div>

Introduit dans : v1.1.0

Calcule le [jump consistent hash](https://arxiv.org/pdf/1406.2294.pdf) d’un entier.

**Syntaxe**

```sql theme={null}
jumpConsistentHash(key, buckets)
```

**Arguments**

* `key` — La clé d’entrée. [`UInt64`](/fr/reference/data-types/int-uint)
* `buckets` — Le nombre de buckets. [`Int32`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée. [`Int32`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT jumpConsistentHash(256, 4)
```

```response title=Response theme={null}
┌─jumpConsistentHash(256, 4)─┐
│                          3 │
└────────────────────────────┘
```

<div id="kafkaMurmurHash">
  ## kafkaMurmurHash
</div>

Introduite dans : v23.4.0

Calcule le hachage [MurmurHash2](https://github.com/aappleby/smhasher) sur 32 bits de la valeur d’entrée, en utilisant la même seed que [Kafka](https://github.com/apache/kafka/blob/461c5cfe056db0951d9b74f5adc45973670404d7/clients/src/main/java/org/apache/kafka/common/utils/Utils.java#L482) et sans le bit de poids fort, afin d’être compatible avec [Default Partitioner](https://github.com/apache/kafka/blob/139f7709bd3f5926901a21e55043388728ccca78/clients/src/main/java/org/apache/kafka/clients/producer/internals/BuiltInPartitioner.java#L328).

**Syntaxe**

```sql theme={null}
kafkaMurmurHash(arg1[, arg2, ...])
```

**Arguments**

* `arg1[, arg2, ...]` — Un nombre variable de paramètres dont il faut calculer le hachage. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée à partir des arguments d'entrée. [`UInt32`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT
    kafkaMurmurHash('foobar') AS res1,
    kafkaMurmurHash(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS res2
```

```response title=Response theme={null}
┌───────res1─┬─────res2─┐
│ 1357151166 │ 85479775 │
└────────────┴──────────┘
```

<div id="keccak256">
  ## keccak256
</div>

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**

```sql theme={null}
keccak256(message)
```

**Arguments**

* `message` — La chaîne d’entrée à hacher. [`String`](/fr/reference/data-types/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)`](/fr/reference/data-types/fixedstring)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT hex(keccak256('hello'))
```

```response title=Response theme={null}
┌─hex(keccak256('hello'))──────────────────────────────────────────┐
│ 1C8AFF950685C2ED4BC3174F3472287B56D9517B9C948127319A09A7A36DEAC8 │
└──────────────────────────────────────────────────────────────────┘
```

<div id="kostikConsistentHash">
  ## kostikConsistentHash
</div>

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**

```sql theme={null}
kostikConsistentHash(input, n)
```

**Alias** : `yandexConsistentHash`

**Arguments**

* `input` — Une clé entière. [`UInt64`](/fr/reference/data-types/int-uint)
* `n` — Le nombre de buckets. [`UInt16`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée. [`UInt16`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT kostikConsistentHash(16045690984833335023, 2);
```

```response title=Response theme={null}
┌─kostikConsistentHash(16045690984833335023, 2)─┐
│                                             1 │
└───────────────────────────────────────────────┘
```

<div id="metroHash64">
  ## metroHash64
</div>

Introduit dans : v1.1.0

Produit une valeur de hachage [MetroHash](http://www.jandrewrogers.com/2015/05/27/metrohash/) de 64 bits.

<Note>
  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.
</Note>

**Syntaxe**

```sql theme={null}
metroHash64(arg1[, arg2, ...])
```

**Arguments**

* `arg1[, arg2, ...]` — Un nombre variable d'arguments d'entrée dont le hachage doit être calculé. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoye le hachage calculé des arguments d'entrée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT metroHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MetroHash, toTypeName(MetroHash) AS type;
```

```response title=Response theme={null}
┌────────────MetroHash─┬─type───┐
│ 14235658766382344533 │ UInt64 │
└──────────────────────┴────────┘
```

<div id="murmurHash2_32">
  ## murmurHash2\_32
</div>

Introduit dans : v18.5.0

Calcule le hachage [MurmurHash2](https://github.com/aappleby/smhasher) de la valeur d’entrée.

<Note>
  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.
</Note>

**Syntaxe**

```sql theme={null}
murmurHash2_32(arg1[, arg2, ...])
```

**Arguments**

* `arg1[, arg2, ...]` — Un nombre variable d'arguments d'entrée pour lesquels calculer le hachage. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée à partir des arguments d'entrée. [`UInt32`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT murmurHash2_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type;
```

```response title=Response theme={null}
┌─MurmurHash2─┬─type───┐
│  3681770635 │ UInt32 │
└─────────────┴────────┘
```

<div id="murmurHash2_64">
  ## murmurHash2\_64
</div>

Introduit dans : v18.10.0

Calcule le hachage [MurmurHash2](https://github.com/aappleby/smhasher) de la valeur d’entrée.

<Note>
  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.
</Note>

**Syntaxe**

```sql theme={null}
murmurHash2_64(arg1[, arg2, ...])
```

**Arguments**

* `arg1[, arg2, ...]` — Un nombre variable d'arguments d'entrée à partir desquels calculer le hachage. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie le hachage calculé à partir des arguments d'entrée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT murmurHash2_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type;
```

```response title=Response theme={null}
┌──────────MurmurHash2─┬─type───┐
│ 11832096901709403633 │ UInt64 │
└──────────────────────┴────────┘
```

<div id="murmurHash3_128">
  ## murmurHash3\_128
</div>

Introduit dans : v18.10.0

Calcule le hachage [MurmurHash3](https://github.com/aappleby/smhasher) sur 128 bits de la valeur d’entrée.

**Syntaxe**

```sql theme={null}
murmurHash3_128(arg1[, arg2, ...])
```

**Arguments**

* `arg1[, arg2, ...]` — Un nombre variable d'arguments d'entrée sur lesquels calculer le hachage. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie la valeur de hachage `MurmurHash3` 128 bits calculée à partir des arguments d'entrée. [`FixedString(16)`](/fr/reference/data-types/fixedstring)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT hex(murmurHash3_128('foo', 'foo', 'foo'));
```

```response title=Response theme={null}
┌─hex(murmurHash3_128('foo', 'foo', 'foo'))─┐
│ F8F7AD9B6CD4CF117A71E277E2EC2931          │
└───────────────────────────────────────────┘
```

<div id="murmurHash3_32">
  ## murmurHash3\_32
</div>

Introduit dans : v18.10.0

Produit une valeur de hachage [MurmurHash3](https://github.com/aappleby/smhasher).

<Note>
  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.
</Note>

**Syntaxe**

```sql theme={null}
murmurHash3_32(arg1[, arg2, ...])
```

**Arguments**

* `arg1[, arg2, ...]` — Un nombre variable d'arguments d'entrée dont le hachage doit être calculé. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée à partir des arguments d'entrée. [`UInt32`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT murmurHash3_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type;
```

```response title=Response theme={null}
┌─MurmurHash3─┬─type───┐
│     2152717 │ UInt32 │
└─────────────┴────────┘
```

<div id="murmurHash3_64">
  ## murmurHash3\_64
</div>

Introduit dans : v18.10.0

Calcule le hachage [MurmurHash3](https://github.com/aappleby/smhasher) de la valeur d’entrée.

<Note>
  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.
</Note>

**Syntaxe**

```sql theme={null}
murmurHash3_64(arg1[, arg2, ...])
```

**Arguments**

* `arg1[, arg2, ...]` — Un nombre variable d'arguments d'entrée pour lesquels calculer le hachage. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée à partir des arguments d'entrée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT murmurHash3_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type;
```

```response title=Response theme={null}
┌──────────MurmurHash3─┬─type───┐
│ 11832096901709403633 │ UInt64 │
└──────────────────────┴────────┘
```

<div id="ngramMinHash">
  ## ngramMinHash
</div>

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`](/fr/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Pour deux chaînes, si les hachages renvoyés sont identiques pour les deux chaînes, alors ces chaînes sont identiques.

**Syntaxe**

```sql theme={null}
ngramMinHash(string[, ngramsize, hashnum])
```

**Arguments**

* `string` — Chaîne dont il faut calculer le hachage. [`String`](/fr/reference/data-types/string)
* `ngramsize` — Facultatif. La taille d’un n-gram, toute valeur comprise entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `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`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tuple contenant deux hachages — le minimum et le maximum. [`Tuple`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT ngramMinHash('ClickHouse') AS Tuple;
```

```response title=Response theme={null}
┌─Tuple──────────────────────────────────────┐
│ (18333312859352735453,9054248444481805918) │
└────────────────────────────────────────────┘
```

<div id="ngramMinHashArg">
  ## ngramMinHashArg
</div>

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`](#ngramMinHash) sur la même entrée.
Cette fonction est sensible à la casse.

**Syntaxe**

```sql theme={null}
ngramMinHashArg(string[, ngramsize, hashnum])
```

**Arguments**

* `string` — Chaîne pour laquelle calculer le hachage. [`String`](/fr/reference/data-types/string)
* `ngramsize` — Facultatif. La taille d’un n-gramme, comprise entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `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`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tuple contenant deux tuples de `hashnum` n-grammes chacun. [`Tuple(String)`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT ngramMinHashArg('ClickHouse') AS Tuple;
```

```response title=Response theme={null}
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ous','ick','lic','Hou','kHo','use'),('Hou','lic','ick','ous','ckH','Cli')) │
└───────────────────────────────────────────────────────────────────────────────┘
```

<div id="ngramMinHashArgCaseInsensitive">
  ## ngramMinHashArgCaseInsensitive
</div>

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`](#ngramMinHashCaseInsensitive) appliquée à la même entrée.
Ne tient pas compte de la casse.

**Syntaxe**

```sql theme={null}
ngramMinHashArgCaseInsensitive(string[, ngramsize, hashnum])
```

**Arguments**

* `string` — Chaîne dont il faut calculer le hachage. [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/int-uint)
* `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`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tuple contenant deux tuples de `hashnum` n-grammes chacun. [`Tuple(Tuple(String))`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT ngramMinHashArgCaseInsensitive('ClickHouse') AS Tuple;
```

```response title=Response theme={null}
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ous','ick','lic','kHo','use','Cli'),('kHo','lic','ick','ous','ckH','Hou')) │
└───────────────────────────────────────────────────────────────────────────────┘
```

<div id="ngramMinHashArgCaseInsensitiveUTF8">
  ## ngramMinHashArgCaseInsensitiveUTF8
</div>

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**

```sql theme={null}
ngramMinHashArgCaseInsensitiveUTF8(string[, ngramsize, hashnum])
```

**Arguments**

* `string` — Chaîne pour laquelle calculer le hachage. [`String`](/fr/reference/data-types/string)
* `ngramsize` — Facultatif. La taille d’un n-gramme, toute valeur comprise entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `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`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tuple contenant deux tuples de `hashnum` n-grammes chacun. [`Tuple(Tuple(String))`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT ngramMinHashArgCaseInsensitiveUTF8('ClickHouse') AS Tuple;
```

```response title=Response theme={null}
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ckH','ous','ick','lic','kHo','use'),('kHo','lic','ick','ous','ckH','Hou')) │
└───────────────────────────────────────────────────────────────────────────────┘
```

<div id="ngramMinHashArgUTF8">
  ## ngramMinHashArgUTF8
</div>

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**

```sql theme={null}
ngramMinHashArgUTF8(string[, ngramsize, hashnum])
```

**Arguments**

* `string` — Chaîne pour laquelle calculer le hachage. [`String`](/fr/reference/data-types/string)
* `ngramsize` — Facultatif. La taille d’un n-gramme, n’importe quel nombre de `1` à `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `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`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tuple contenant deux tuples de `hashnum` n-grammes chacun. [`Tuple(Tuple(String))`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT ngramMinHashArgUTF8('ClickHouse') AS Tuple;
```

```response title=Response theme={null}
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ous','ick','lic','Hou','kHo','use'),('kHo','Hou','lic','ick','ous','ckH')) │
└───────────────────────────────────────────────────────────────────────────────┘
```

<div id="ngramMinHashCaseInsensitive">
  ## ngramMinHashCaseInsensitive
</div>

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`](/fr/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Pour deux chaînes, si les hachages renvoyés sont identiques pour les deux chaînes, alors ces chaînes sont identiques.

**Syntaxe**

```sql theme={null}
ngramMinHashCaseInsensitive(string[, ngramsize, hashnum])
```

**Arguments**

* `string` — String. [String](/fr/reference/data-types/string). - `ngramsize` — La taille d’un n-gramme. Facultatif. Valeurs possibles : tout nombre compris entre `1` et `25`. Valeur par défaut : `3`. [UInt8](/fr/reference/data-types/int-uint). - `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](/fr/reference/data-types/int-uint).

**Valeur renvoyée**

Tuple contenant deux hachages — le minimum et le maximum. [Tuple](/fr/reference/data-types/tuple)([UInt64](/fr/reference/data-types/int-uint), [UInt64](/fr/reference/data-types/int-uint)). [`Tuple`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT ngramMinHashCaseInsensitive('ClickHouse') AS Tuple;
```

```response title=Response theme={null}
┌─Tuple──────────────────────────────────────┐
│ (2106263556442004574,13203602793651726206) │
└────────────────────────────────────────────┘
```

<div id="ngramMinHashCaseInsensitiveUTF8">
  ## ngramMinHashCaseInsensitiveUTF8
</div>

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`](/fr/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Pour deux chaînes, si les hachages renvoyés sont identiques pour les deux chaînes, alors ces chaînes sont identiques.

**Syntaxe**

```sql theme={null}
ngramMinHashCaseInsensitiveUTF8(string [, ngramsize, hashnum])
```

**Arguments**

* `string` — Chaîne pour laquelle calculer le hachage. [`String`](/fr/reference/data-types/string)
* `ngramsize` — Facultatif. Taille d’un n-gramme, toute valeur comprise entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `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`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tuple contenant deux hachages — le minimum et le maximum. [`Tuple`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT ngramMinHashCaseInsensitiveUTF8('ClickHouse') AS Tuple;
```

```response title=Response theme={null}
┌─Tuple───────────────────────────────────────┐
│ (12493625717655877135,13203602793651726206) │
└─────────────────────────────────────────────┘
```

<div id="ngramMinHashUTF8">
  ## ngramMinHashUTF8
</div>

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`](/fr/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Pour deux chaînes, si les hachages renvoyés sont identiques pour les deux chaînes, alors ces chaînes sont identiques.

**Syntaxe**

```sql theme={null}
ngramMinHashUTF8(string[, ngramsize, hashnum])
```

**Arguments**

* `string` — Chaîne pour laquelle calculer le hachage. [`String`](/fr/reference/data-types/string)
* `ngramsize` — Facultatif. La taille d’un n-gram, tout nombre de `1` à `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `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`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tuple contenant deux hachages — le minimum et le maximum. [`Tuple`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT ngramMinHashUTF8('ClickHouse') AS Tuple;
```

```response title=Response theme={null}
┌─Tuple──────────────────────────────────────┐
│ (18333312859352735453,6742163577938632877) │
└────────────────────────────────────────────┘
```

<div id="ngramSimHash">
  ## ngramSimHash
</div>

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`](/fr/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Plus la [distance de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre les `simhachages` calculés de deux chaînes est faible, plus il est probable que ces chaînes soient identiques.

**Syntaxe**

```sql theme={null}
ngramSimHash(string[, ngramsize])
```

**Arguments**

* `string` — Chaîne pour laquelle calculer le `simhachage` sensible à la casse. [`String`](/fr/reference/data-types/string)
* `ngramsize` — Facultatif. Taille d’un n-gramme, comprise entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie le hachage calculé de la chaîne d’entrée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT ngramSimHash('ClickHouse') AS Hash;
```

```response title=Response theme={null}
┌───────Hash─┐
│ 1627567969 │
└────────────┘
```

<div id="ngramSimHashCaseInsensitive">
  ## ngramSimHashCaseInsensitive
</div>

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`](/fr/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Plus la [distance de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre les `simhashes` calculés de deux chaînes est faible, plus il est probable que ces chaînes soient identiques.

**Syntaxe**

```sql theme={null}
ngramSimHashCaseInsensitive(string[, ngramsize])
```

**Arguments**

* `string` — Chaîne pour laquelle calculer le `simhash` insensible à la casse. [`String`](/fr/reference/data-types/string)
* `ngramsize` — Facultatif. Taille d’un n-gramme, comprise entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Valeur de hachage. [UInt64](/fr/reference/data-types/int-uint). [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT ngramSimHashCaseInsensitive('ClickHouse') AS Hash;
```

```response title=Response theme={null}
┌──────Hash─┐
│ 562180645 │
└───────────┘
```

<div id="ngramSimHashCaseInsensitiveUTF8">
  ## ngramSimHashCaseInsensitiveUTF8
</div>

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](/fr/reference/functions/regular-functions/bit-functions#bitHammingDistance). Plus la [distance de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre les `simhachages` calculés de deux chaînes est faible, plus il est probable que ces chaînes soient identiques.

**Syntaxe**

```sql theme={null}
ngramSimHashCaseInsensitiveUTF8(string[, ngramsize])
```

**Arguments**

* `string` — Chaîne dont il faut calculer le hachage. [`String`](/fr/reference/data-types/string)
* `ngramsize` — Facultatif. Taille d'un n-gramme, nombre compris entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT ngramSimHashCaseInsensitiveUTF8('ClickHouse') AS Hash;
```

```response title=Response theme={null}
┌───────Hash─┐
│ 1636742693 │
└────────────┘
```

<div id="ngramSimHashUTF8">
  ## ngramSimHashUTF8
</div>

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`](/fr/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Plus la [distance de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre les `simhachages` calculés de deux chaînes est faible, plus il est probable que ces chaînes soient identiques.

**Syntaxe**

```sql theme={null}
ngramSimHashUTF8(string[, ngramsize])
```

**Arguments**

* `string` — Chaîne pour laquelle calculer le hachage. [`String`](/fr/reference/data-types/string)
* `ngramsize` — Facultatif. Taille d’un n-gramme, comprise entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT ngramSimHashUTF8('ClickHouse') AS Hash;
```

```response title=Response theme={null}
┌───────Hash─┐
│ 1628157797 │
└────────────┘
```

<div id="sipHash128">
  ## sipHash128
</div>

Introduit dans : v1.1.0

Comme [`sipHash64`](#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.

<Tip>
  **utilisez sipHash128Reference pour les nouveaux projets**

  Cette 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`](#sipHash128Reference).
</Tip>

**Syntaxe**

```sql theme={null}
sipHash128(arg1[, arg2, ...])
```

**Arguments**

* `arg1[, arg2, ...]` — Un nombre variable d'arguments d'entrée dont le hachage doit être calculé. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie une valeur de hachage `SipHash` sur 128 bits. [`FixedString(16)`](/fr/reference/data-types/fixedstring)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT hex(sipHash128('foo', '\x01', 3));
```

```response title=Response theme={null}
┌─hex(sipHash128('foo', '', 3))────┐
│ 9DE516A64A414D4B1B609415E4523F24 │
└──────────────────────────────────┘
```

<div id="sipHash128Keyed">
  ## sipHash128Keyed
</div>

Introduit dans : v23.2.0

Identique à [`sipHash128`](#sipHash128), mais accepte en plus une clé explicite en argument au lieu d’utiliser une clé fixe.

<Tip>
  **utilisez sipHash128ReferenceKeyed pour les nouveaux projets**

  Cette 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`](#sipHash128ReferenceKeyed).
</Tip>

**Syntaxe**

```sql theme={null}
sipHash128Keyed((k0, k1), [arg1, arg2, ...])
```

**Arguments**

* `(k0, k1)` — Un tuple de deux valeurs UInt64 représentant la clé. [`Tuple(UInt64, UInt64)`](/fr/reference/data-types/tuple)
* `arg1[, arg2, ...]` — Un nombre variable d'arguments d'entrée dont le hachage doit être calculé. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Une valeur de hachage `SipHash` sur 128 bits, de type [FixedString(16)](/fr/reference/data-types/fixedstring). [`FixedString(16)`](/fr/reference/data-types/fixedstring)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT hex(sipHash128Keyed((506097522914230528, 1084818905618843912),'foo', '\x01', 3));
```

```response title=Response theme={null}
┌─hex(sipHash128Keyed((506097522914230528, 1084818905618843912), 'foo', '', 3))─┐
│ B8467F65C8B4CFD9A5F8BD733917D9BF                                              │
└───────────────────────────────────────────────────────────────────────────────┘
```

<div id="sipHash128Reference">
  ## sipHash128Reference
</div>

Introduit dans : v23.2.0

Semblable à [`sipHash128`](/fr/reference/functions/regular-functions/hash-functions#sipHash128), mais implémente l’algorithme 128 bits des auteurs originels de SipHash.

**Syntaxe**

```sql theme={null}
sipHash128Reference(arg1[, arg2, ...])
```

**Arguments**

* `arg1[, arg2, ...]` — Un nombre variable d'arguments d'entrée dont le hachage doit être calculé. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie la valeur de hachage `SipHash` 128 bits calculée à partir des arguments d'entrée. [`FixedString(16)`](/fr/reference/data-types/fixedstring)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT hex(sipHash128Reference('foo', '
', 3));
```

```response title=Response theme={null}
┌─hex(sipHash128Reference('foo', '', 3))─┐
│ 4D1BE1A22D7F5933C0873E1698426260       │
└────────────────────────────────────────┘
```

<div id="sipHash128ReferenceKeyed">
  ## sipHash128ReferenceKeyed
</div>

Introduite dans : v23.2.0

Identique à [`sipHash128Reference`](#sipHash128Reference), mais prend en plus un argument de clé explicite au lieu d’utiliser une clé fixe.

**Syntaxe**

```sql theme={null}
sipHash128ReferenceKeyed((k0, k1), arg1[, arg2, ...])
```

**Arguments**

* `(k0, k1)` — Tuple de deux valeurs représentant la clé [`Tuple(UInt64, UInt64)`](/fr/reference/data-types/tuple)
* `arg1[, arg2, ...]` — Nombre variable d'arguments d'entrée pour lesquels calculer le hachage. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie la valeur de hachage `SipHash` calculée de 128 bits des arguments d'entrée. [`FixedString(16)`](/fr/reference/data-types/fixedstring)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT hex(sipHash128Reference('foo', '
', 3));
```

```response title=Response theme={null}
┌─hex(sipHash128Reference('foo', '', 3))─┐
│ 4D1BE1A22D7F5933C0873E1698426260       │
└────────────────────────────────────────┘
```

<div id="sipHash64">
  ## sipHash64
</div>

Introduit dans : v1.1.0

Produit une valeur de hachage [SipHash](https://en.wikipedia.org/wiki/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`](#MD5).

La fonction [interprète](/fr/reference/functions/regular-functions/type-conversion-functions#reinterpretAsString) 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.

<Note>
  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.
</Note>

**Syntaxe**

```sql theme={null}
sipHash64(arg1[, arg2, ...])
```

**Arguments**

* `arg1[, arg2, ...]` — Un nombre variable d’arguments en entrée. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie une valeur de hachage calculée à partir des arguments en entrée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT sipHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type;
```

```response title=Response theme={null}
┌──────────────SipHash─┬─type───┐
│ 11400366955626497465 │ UInt64 │
└──────────────────────┴────────┘
```

<div id="sipHash64Keyed">
  ## sipHash64Keyed
</div>

Introduit dans : v23.2.0

Comme [`sipHash64`](#sipHash64), mais avec un argument de clé explicite au lieu d’utiliser une clé fixe.

**Syntaxe**

```sql theme={null}
sipHash64Keyed((k0, k1), arg1[,arg2, ...])
```

**Arguments**

* `(k0, k1)` — Un tuple de deux valeurs représentant la clé. [`Tuple(UInt64, UInt64)`](/fr/reference/data-types/tuple)
* `arg1[,arg2, ...]` — Un nombre variable d’arguments d’entrée. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie le hachage calculé à partir des valeurs d’entrée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT sipHash64Keyed((506097522914230528, 1084818905618843912), array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type;
```

```response title=Response theme={null}
┌─────────────SipHash─┬─type───┐
│ 8017656310194184311 │ UInt64 │
└─────────────────────┴────────┘
```

<div id="wordShingleMinHash">
  ## wordShingleMinHash
</div>

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`](/fr/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Pour deux chaînes, si les hachages renvoyés sont identiques pour les deux chaînes, alors ces chaînes sont identiques.

**Syntaxe**

```sql theme={null}
wordShingleMinHash(string[, shinglesize, hashnum])
```

**Arguments**

* `string` — Chaîne dont le hachage doit être calculé. [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/int-uint)
* `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`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tuple contenant deux hachages — le minimum et le maximum. [`Tuple(UInt64, UInt64)`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT wordShingleMinHash('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
```

```response title=Response theme={null}
┌─Tuple──────────────────────────────────────┐
│ (16452112859864147620,5844417301642981317) │
└────────────────────────────────────────────┘
```

<div id="wordShingleMinHashArg">
  ## wordShingleMinHashArg
</div>

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**

```sql theme={null}
wordShingleMinHashArg(string[, shinglesize, hashnum])
```

**Arguments**

* `string` — Chaîne dont le hachage doit être calculé. [`String`](/fr/reference/data-types/string)
* `shinglesize` — Facultatif. Taille d’un shingle de mots, comprise entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `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`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tuple composé de deux tuples contenant chacun `hashnum` shingles de mots. [`Tuple(Tuple(String))`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT wordShingleMinHashArg('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
```

```response title=Response theme={null}
┌─Tuple─────────────────────────────────────────────────────────────────┐
│ (('OLAP','database','analytical'),('online','oriented','processing')) │
└───────────────────────────────────────────────────────────────────────┘
```

<div id="wordShingleMinHashArgCaseInsensitive">
  ## wordShingleMinHashArgCaseInsensitive
</div>

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`](#wordShingleMinHashCaseInsensitive) avec la même entrée.
Est insensible à la casse.

**Syntaxe**

```sql theme={null}
wordShingleMinHashArgCaseInsensitive(string[, shinglesize, hashnum])
```

**Arguments**

* `string` — Chaîne pour laquelle calculer le hachage. [`String`](/fr/reference/data-types/string)
* `shinglesize` — Facultatif. Taille d’un shingle de mots, toute valeur comprise entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `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`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoyer un tuple composé de deux tuples contenant chacun `hashnum` shingles de mots. [`Tuple(Tuple(String))`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT wordShingleMinHashArgCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
```

```response title=Response theme={null}
┌─Tuple──────────────────────────────────────────────────────────────────┐
│ (('queries','database','analytical'),('oriented','processing','DBMS')) │
└────────────────────────────────────────────────────────────────────────┘
```

<div id="wordShingleMinHashArgCaseInsensitiveUTF8">
  ## wordShingleMinHashArgCaseInsensitiveUTF8
</div>

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`](#wordShingleMinHashCaseInsensitiveUTF8) sur la même entrée.
Elle est insensible à la casse.

**Syntaxe**

```sql theme={null}
wordShingleMinHashArgCaseInsensitiveUTF8(string[, shinglesize, hashnum])
```

**Arguments**

* `string` — Chaîne dont il faut calculer le hachage. [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/int-uint)
* `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`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tuple contenant deux tuples de `hashnum` shingles de mots chacun. [`Tuple(Tuple(String))`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT wordShingleMinHashArgCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
```

```response title=Response theme={null}
┌─Tuple──────────────────────────────────────────────────────────────────┐
│ (('queries','database','analytical'),('oriented','processing','DBMS')) │
└────────────────────────────────────────────────────────────────────────┘
```

<div id="wordShingleMinHashArgUTF8">
  ## wordShingleMinHashArgUTF8
</div>

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`](#wordShingleMinHashUTF8) pour la même entrée.
La fonction est sensible à la casse.

**Syntaxe**

```sql theme={null}
wordShingleMinHashArgUTF8(string[, shinglesize, hashnum])
```

**Arguments**

* `string` — Chaîne pour laquelle calculer le hachage. [`String`](/fr/reference/data-types/string)
* `shinglesize` — Facultatif. Taille d’un shingle de mots, comprise entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `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`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoyer un tuple contenant deux tuples de `hashnum` shingles de mots chacun. [`Tuple(Tuple(String))`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT wordShingleMinHashArgUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
```

```response title=Response theme={null}
┌─Tuple─────────────────────────────────────────────────────────────────┐
│ (('OLAP','database','analytical'),('online','oriented','processing')) │
└───────────────────────────────────────────────────────────────────────┘
```

<div id="wordShingleMinHashCaseInsensitive">
  ## wordShingleMinHashCaseInsensitive
</div>

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`](/fr/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Pour deux chaînes, si les hachages renvoyés sont identiques pour les deux chaînes, alors ces chaînes sont identiques.

**Syntaxe**

```sql theme={null}
wordShingleMinHashCaseInsensitive(string[, shinglesize, hashnum])
```

**Arguments**

* `string` — Chaîne pour laquelle calculer le hachage. [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/int-uint)
* `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`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tuple contenant deux hachages — le minimum et le maximum. [`Tuple(UInt64, UInt64)`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT wordShingleMinHashCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
```

```response title=Response theme={null}
┌─Tuple─────────────────────────────────────┐
│ (3065874883688416519,1634050779997673240) │
└───────────────────────────────────────────┘
```

<div id="wordShingleMinHashCaseInsensitiveUTF8">
  ## wordShingleMinHashCaseInsensitiveUTF8
</div>

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`](/fr/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Pour deux chaînes, si les hachages renvoyés sont identiques pour les deux chaînes, alors ces chaînes sont identiques.

**Syntaxe**

```sql theme={null}
wordShingleMinHashCaseInsensitiveUTF8(string[, shinglesize, hashnum])
```

**Arguments**

* `string` — Chaîne dont le hachage doit être calculé. [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/int-uint)
* `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`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tuple contenant deux hachages — le minimum et le maximum. [`Tuple(UInt64, UInt64)`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT wordShingleMinHashCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
```

```response title=Response theme={null}
┌─Tuple─────────────────────────────────────┐
│ (3065874883688416519,1634050779997673240) │
└───────────────────────────────────────────┘
```

<div id="wordShingleMinHashUTF8">
  ## wordShingleMinHashUTF8
</div>

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`](/fr/reference/functions/regular-functions/tuple-functions#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**

```sql theme={null}
wordShingleMinHashUTF8(string[, shinglesize, hashnum])
```

**Arguments**

* `string` — Chaîne pour laquelle calculer le hachage. [`String`](/fr/reference/data-types/string)
* `shinglesize` — Facultatif. La taille d’un `shingle de mots`, comprise entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)
* `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`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tuple contenant deux hachages — le minimum et le maximum. [`Tuple(UInt64, UInt64)`](/fr/reference/data-types/tuple)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT wordShingleMinHashUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
```

```response title=Response theme={null}
┌─Tuple──────────────────────────────────────┐
│ (16452112859864147620,5844417301642981317) │
└────────────────────────────────────────────┘
```

<div id="wordShingleSimHash">
  ## wordShingleSimHash
</div>

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`](/fr/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Plus la [distance de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre les `simhashes` calculés de deux chaînes est faible, plus il est probable que ces chaînes soient identiques.

**Syntaxe**

```sql theme={null}
wordShingleSimHash(string[, shinglesize])
```

**Arguments**

* `string` — Chaîne pour laquelle calculer le hachage. [`String`](/fr/reference/data-types/string)
* `shinglesize` — Facultatif. Taille d’un groupe contigu de mots, comprise entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT wordShingleSimHash('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
```

```response title=Response theme={null}
┌───────Hash─┐
│ 2328277067 │
└────────────┘
```

<div id="wordShingleSimHashCaseInsensitive">
  ## wordShingleSimHashCaseInsensitive
</div>

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`](/fr/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Plus la [distance de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre les `simhash` calculés de deux chaînes est faible, plus ces chaînes ont de chances d’être identiques.

**Syntaxe**

```sql theme={null}
wordShingleSimHashCaseInsensitive(string[, shinglesize])
```

**Arguments**

* `string` — Chaîne pour laquelle calculer le hachage. [`String`](/fr/reference/data-types/string)
* `shinglesize` — Facultatif. Taille d’un shingle de mots, nombre compris entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT wordShingleSimHashCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
```

```response title=Response theme={null}
┌───────Hash─┐
│ 2194812424 │
└────────────┘
```

<div id="wordShingleSimHashCaseInsensitiveUTF8">
  ## wordShingleSimHashCaseInsensitiveUTF8
</div>

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`](/fr/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Plus la [distance de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre les `simhashes` calculés pour deux chaînes est faible, plus il est probable que ces chaînes soient identiques.

**Syntaxe**

```sql theme={null}
wordShingleSimHashCaseInsensitiveUTF8(string[, shinglesize])
```

**Arguments**

* `string` — Chaîne pour laquelle calculer le hachage. [`String`](/fr/reference/data-types/string)
* `shinglesize` — Facultatif. Taille d'un shingle de mots, comprise entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT wordShingleSimHashCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
```

```response title=Response theme={null}
┌───────Hash─┐
│ 2194812424 │
└────────────┘
```

<div id="wordShingleSimHashUTF8">
  ## wordShingleSimHashUTF8
</div>

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`](/fr/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Plus la [distance de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre les `simhashes` calculés de deux chaînes est faible, plus il est probable que ces chaînes soient identiques.

**Syntaxe**

```sql theme={null}
wordShingleSimHashUTF8(string[, shinglesize])
```

**Arguments**

* `string` — Chaîne dont il faut calculer le hachage. [`String`](/fr/reference/data-types/string)
* `shinglesize` — Facultatif. Taille d’un shingle de mots, toute valeur comprise entre `1` et `25`. La valeur par défaut est `3`. [`UInt8`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT wordShingleSimHashUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
```

```response title=Response theme={null}
┌───────Hash─┐
│ 2328277067 │
└────────────┘
```

<div id="wyHash64">
  ## wyHash64
</div>

Introduit dans : v22.7.0

Calcule une valeur de hachage 64 bits [wyHash64](https://github.com/wangyi-fudan/wyhash).

**Syntaxe**

```sql theme={null}
wyHash64(arg)
```

**Arguments**

* `arg` — argument de type String dont la valeur de hachage doit être calculée. [`String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie la valeur de hachage calculée sur 64 bits [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT wyHash64('ClickHouse') AS Hash;
```

```response title=Response theme={null}
12336419557878201794
```

<div id="xxHash32">
  ## xxHash32
</div>

Introduit dans : v20.1.0

Calcule un [xxHash](http://cyan4973.github.io/xxHash/) à partir d’une chaîne de caractères.

Pour la version 64 bits, voir [`xxHash64`](#xxHash64)

**Syntaxe**

```sql theme={null}
xxHash32(arg)
```

**Arguments**

* `arg` — Chaîne à hacher. [`String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie le hachage 32 bits calculé à partir de la chaîne d’entrée. [`UInt32`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT xxHash32('Hello, world!');
```

```response title=Response theme={null}
┌─xxHash32('Hello, world!')─┐
│                 834093149 │
└───────────────────────────┘
```

<div id="xxHash64">
  ## xxHash64
</div>

Introduit dans : v20.1.0

Calcule un [xxHash](http://cyan4973.github.io/xxHash/) à partir d’une chaîne de caractères.

Pour la version 32 bits, voir [`xxHash32`](#xxHash32)

**Syntaxe**

```sql theme={null}
xxHash64(arg)
```

**Arguments**

* `arg` — Chaîne d'entrée à hacher. [`String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie le hachage 64 bits calculé à partir de la chaîne d'entrée. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT xxHash64('Hello, world!');
```

```response title=Response theme={null}
┌─xxHash64('Hello, world!')─┐
│      17691043854468224118 │
└───────────────────────────┘
```

<div id="xxh3">
  ## xxh3
</div>

Introduit dans : v22.12.0

Calcule une valeur de hachage [XXH3](https://github.com/Cyan4973/xxHash) sur 64 bits.

**Syntaxe**

```sql theme={null}
xxh3(expr)
```

**Arguments**

* `expr` — Une liste d’expressions de n’importe quel type de données. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie la valeur de hachage `xxh3` sur 64 bits calculée [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT xxh3('ClickHouse')
```

```response title=Response theme={null}
18009318874338624809
```

<div id="xxh3_128">
  ## xxh3\_128
</div>

Introduit dans : v26.2.0

Calcule une valeur de hachage [XXH3](https://github.com/Cyan4973/xxHash) sur 128 bits.

**Syntaxe**

```sql theme={null}
xxh3_128(expr)
```

**Arguments**

* `expr` — Une liste d’expressions de n’importe quel type de données. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie la valeur de hachage `xxh3` calculée sur 128 bits [`UInt128`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT hex(xxh3_128('ClickHouse'))
```

```response title=Response theme={null}
3A038784C52804B4DBA43A038784C528
```