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

> Документация по хеш-функциям

# Хеш-функции

Хеш-функции можно использовать для детерминированного псевдослучайного перемешивания элементов.

Simhash — это хеш-функция, которая возвращает схожие хеш-значения для близких (похожих) аргументов.

Большинство хеш-функций принимают любое количество аргументов любых типов.

<Note>
  Хеш от NULL равен NULL. Чтобы получить хеш, отличный от NULL, для столбца типа Nullable, оберните его в tuple:

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

<Note>
  Чтобы вычислить хеш всего содержимого таблицы, используйте `sum(cityHash64(tuple(*)))` (или другую хеш-функцию). `tuple` гарантирует, что строки со значениями NULL не будут пропущены. `sum` гарантирует, что порядок строк не имеет значения.
</Note>

{/*AUTOGENERATED_START*/}

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

Добавленный в: v22.10.0

Вычисляет хеш-строку BLAKE3 и возвращает результирующий набор байтов в виде FixedString.
Эта криптографическая хеш-функция интегрирована в ClickHouse с помощью библиотеки BLAKE3 для Rust.
Функция достаточно быстрая и работает примерно в два раза быстрее по сравнению с SHA-2, при этом генерируя хеши той же длины, что и SHA-256.
Возвращает хеш BLAKE3 как массив байтов типа FixedString(32).

**Синтаксис**

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

**Аргументы**

* `message` — Входная строка для хеширования. [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Возвращает 32-байтный хеш BLAKE3 входной строки в виде строки фиксированной длины. [`FixedString(32)`](/ru/reference/data-types/fixedstring)

**Примеры**

**hash**

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

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

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

Добавленный в: v21.11.0

Вычисляет хеш MD4 от заданной строки.

**Синтаксис**

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

**Аргументы**

* `s` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Возвращает MD4-хеш указанной строки в виде строки фиксированной длины. [`FixedString(16)`](/ru/reference/data-types/fixedstring)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v1.1.0

Вычисляет хеш MD5 заданной строки.

**Синтаксис**

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

**Аргументы**

* `s` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Возвращает MD5-хеш заданной строки в виде строки фиксированной длины. [`FixedString(16)`](/ru/reference/data-types/fixedstring)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v24.10.0

Вычисляет хеш RIPEMD-160 от заданной строки.

**Синтаксис**

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

**Аргументы**

* `s` — Входная строка для вычисления хеша. [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Возвращает хеш RIPEMD160 от заданной входной строки в виде строки фиксированной длины. [`FixedString(20)`](/ru/reference/data-types/fixedstring)

**Примеры**

**Пример использования**

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

Добавленный в: v1.1.0

Вычисляет SHA1-хеш заданной строки.

**Синтаксис**

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

**Аргументы**

* `s` — Входная строка, для которой вычисляется хеш [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Возвращает SHA1-хеш заданной строки в виде строки фиксированной длины. [`FixedString(20)`](/ru/reference/data-types/fixedstring)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v1.1.0

Вычисляет хеш SHA224 для заданной строки.

**Синтаксис**

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

**Аргументы**

* `s` — Входное значение, для которого вычисляется хеш. [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Возвращает SHA224-хеш указанной входной строки в виде строки фиксированной длины. [`FixedString(28)`](/ru/reference/data-types/fixedstring)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v1.1.0

Вычисляет хеш SHA256 заданной строки.

**Синтаксис**

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

**Аргументы**

* `s` — входная строка для хеширования. [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Возвращает SHA256-хеш заданной строки в виде строки фиксированной длины. [`FixedString(32)`](/ru/reference/data-types/fixedstring)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v1.1.0

Вычисляет хеш SHA384 для заданной строки.

**Синтаксис**

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

**Аргументы**

* `s` — Входная строка для вычисления хеша. [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Возвращает SHA384-хеш заданной строки ввода в виде строки фиксированной длины. [`FixedString(48)`](/ru/reference/data-types/fixedstring)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v1.1.0

Вычисляет хеш SHA512 для заданной строки.

**Синтаксис**

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

**Аргументы**

* `s` — Строка, которую нужно хешировать [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Возвращает хеш SHA512 указанной строки в виде строки фиксированной длины. [`FixedString(64)`](/ru/reference/data-types/fixedstring)

**Примеры**

**Пример использования**

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

Добавленный в: v1.1.0

Вычисляет хеш SHA512\_256 заданной строки.

**Синтаксис**

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

**Аргументы**

* `s` — Входная строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Возвращает хеш SHA512\_256 заданной строки ввода в виде строки фиксированной длины. [`FixedString(32)`](/ru/reference/data-types/fixedstring)

**Примеры**

**Пример использования**

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

Добавленный в: v1.1.0

Быстрая некриптографическая хеш-функция приемлемого качества для строки, полученной из URL с применением нормализации.

У этой хеш-функции есть два режима:

| Режим             | Описание                                                                                                                                                                                  |
| ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `URLHash(url)`    | Вычисляет хеш для строки без одного из завершающих символов `/`, `?` или `#` в конце, если такой символ присутствует.                                                                     |
| `URLHash(url, N)` | Вычисляет хеш для строки до N-го уровня в иерархии URL без одного из завершающих символов `/`, `?` или `#` в конце, если такой символ присутствует. Уровни те же, что и в `URLHierarchy`. |

**Синтаксис**

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

**Аргументы**

* `url` — URL-строка для хеширования. [`String`](/ru/reference/data-types/string)
* `N` — Необязательный. Уровень в иерархии URL. [`(U)Int*`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение `url`. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

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

**Хеш URL на указанном уровне**

```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}
-- хеш https://www.clickhouse.com
┌─URLHash('htt⋯m/docs', 0)─┐
│     13614512636072854701 │
└──────────────────────────┘
-- хеш https://www.clickhouse.com/docs
┌─URLHash('htt⋯m/docs', 1)─┐
│     13167253331440520598 │
└──────────────────────────┘
```

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

Добавленный в: v1.1.0

Возвращает 64-битное хеш-значение [CityHash](https://github.com/google/cityhash).

Это быстрая некриптографическая хеш-функция.
Для строковых параметров она использует алгоритм CityHash, а для параметров с другими типами данных — быструю некриптографическую хеш-функцию, зависящую от реализации.
Функция использует комбинатор CityHash для получения итогового результата.

<Info>
  Google изменила алгоритм CityHash после того, как он был добавлен в ClickHouse.
  Иными словами, cityHash64 в ClickHouse и исходный CityHash от Google теперь выдают разные результаты.
  cityHash64 в ClickHouse соответствует CityHash v1.0.2.
</Info>

<Note>
  Вычисленные хеш-значения могут совпадать для одних и тех же входных значений аргументов разных типов.
  Это касается, например, целочисленных типов разного размера, именованных и неименованных `Tuple` с одинаковыми данными, а также `Map` и соответствующего типа `Array(Tuple(key, value))` с одинаковыми данными.
</Note>

**Синтаксис**

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

**Аргументы**

* `arg1[, arg2, ...]` — переменное количество входных аргументов, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает вычисленный хеш входных аргументов. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример вызова**

```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 │
└──────────────────────┴────────┘
```

**Вычисление контрольной суммы всей таблицы с точностью до порядка строк**

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

Добавленный в: v20.12.0

Вычисляет 64-битное [FarmHash](https://github.com/google/farmhash) хеш-значение с использованием метода `Fingerprint64`.

<Tip>
  Для получения стабильного и переносимого значения рекомендуется использовать `farmFingerprint64` вместо [`farmHash64`](#farmHash64).
</Tip>

<Note>
  Вычисленные хеш-значения могут совпадать для одинаковых входных значений аргументов разных типов.
  Это относится, например, к целочисленным типам разного размера, именованным и неименованным `Tuple` с одинаковыми данными, `Map` и соответствующему типу `Array(Tuple(key, value))` с одинаковыми данными.
</Note>

**Синтаксис**

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

**Аргументы**

* `arg1[, arg2, ...]` — Переменное число входных аргументов, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение входных аргументов. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v1.1.0

Вычисляет 64-битное хеш-значение [FarmHash](https://github.com/google/farmhash) с помощью метода `Hash64`.

<Tip>
  Для получения стабильного и переносимого значения предпочтительнее использовать [`farmFingerprint64`](#farmFingerprint64).
</Tip>

<Note>
  Вычисленные хеш-значения могут совпадать для одинаковых входных значений аргументов разных типов.
  Это касается, например, целочисленных типов разного размера, именованных и неименованных `Tuple` с одинаковыми данными, а также `Map` и соответствующего типа `Array(Tuple(key, value))` с одинаковыми данными.
</Note>

**Синтаксис**

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

**Аргументы**

* `arg1[, arg2, ...]` — Переменное число входных аргументов, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение входных аргументов. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v20.1.0

Вычисляет 64-битный хеш [MurmurHash2](https://github.com/aappleby/smhasher) входного значения, используя тот же seed, что и в [GCC](https://github.com/gcc-mirror/gcc/blob/41d6b10e96a1de98e90a7c0378437c3255814b16/libstdc%2B%2B-v3/include/bits/functional_hash.h#L191).

Переносим между сборками Clang и GCC.

**Синтаксис**

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

**Аргументы**

* `arg1[, arg2, ...]` — Переменное количество аргументов, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение входных аргументов. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v1.1.0

[Интерпретирует](/ru/reference/functions/regular-functions/type-conversion-functions#reinterpretAsString) все входные
параметры как строки и вычисляет MD5-хеш-значение для каждого из них. Затем объединяет хеши, берёт первые 8 байт хеша
получившейся строки и интерпретирует их как [UInt64](/ru/reference/data-types/int-uint) в порядке байтов с прямым порядком байтов (big-endian). Функция
относительно медленная (5 миллионов коротких строк в секунду на одно ядро процессора).

Рекомендуется использовать вместо неё функцию [`sipHash64`](#sipHash64).

Функция принимает переменное число входных параметров.
Аргументами могут быть любые поддерживаемые типы данных.
Для некоторых типов данных вычисленное хеш-значение может совпадать для одинаковых значений, даже если типы аргументов различаются (целые числа разного размера, именованный и неименованный Tuple с одинаковыми данными, Map и соответствующий тип Array(Tuple(key, value)) с одинаковыми данными).

**Синтаксис**

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

**Аргументы**

* `arg1[, arg2, ..., argN]` — переменное количество аргументов, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает вычисленную половину MD5-хеша для указанных входных параметров в виде `UInt64` с порядком байтов big-endian. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v20.1.0

Вычисляет "HiveHash" для строки.
Это просто [`JavaHash`](#javaHash) с обнулёнными знаковыми битами.
Эта функция используется в [Apache Hive](https://en.wikipedia.org/wiki/Apache_Hive) в версиях до 3.0.

<Warning>
  Эта хеш-функция работает медленно.
  Используйте её только в том случае, если этот алгоритм уже используется в другой системе и вам нужно получить тот же результат.
</Warning>

**Синтаксис**

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

**Аргументы**

* `arg` — Входная строка для вычисления хеша. [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Возвращает вычисленное значение "hive hash" для входной строки. [`Int32`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v25.5.0

Реализует логику [хеш-преобразования](https://iceberg.apache.org/spec/#appendix-b-32-bit-hash-requirements) Iceberg

**Синтаксис**

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

**Аргументы**

* `value` — исходное значение, для которого вычисляется хеш: [`Integer`](/ru/reference/data-types/int-uint) или [`Bool`](/ru/reference/data-types/boolean) или [`Decimal`](/ru/reference/data-types/decimal) или [`Float*`](/ru/reference/data-types/float) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring) или [`UUID`](/ru/reference/data-types/uuid) или [`Date`](/ru/reference/data-types/date) или [`Time`](/ru/reference/data-types/time) или [`DateTime`](/ru/reference/data-types/datetime)

**Возвращаемое значение**

Возвращает 32-битный хеш Murmur3 (вариант x86) с seed, равным 0 [`Int32`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример**

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

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

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

Добавленный в: v1.1.0

Вычисляет 32-битный хеш целого числа.

Эта хеш-функция работает относительно быстро, но не является криптографической.

**Синтаксис**

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

**Аргументы**

* `arg` — Целое число для хеширования. [`(U)Int*`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает вычисленное 32-битное хеш-значение для входного целого числа [`UInt32`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v1.1.0

Вычисляет 64-битный хеш от целого числа.

Эта хеш-функция работает относительно быстро (даже быстрее, чем [`intHash32`](#intHash32)), но не является криптографической хеш-функцией.

**Синтаксис**

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

**Аргументы**

* `int` — Целое число, для которого вычисляется хеш. [`(U)Int*`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

64-битное значение хеша. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v20.1.0

Вычисляет JavaHash для:

* [строки](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>
  Эта хеш-функция работает медленно.
  Используйте её только если этот алгоритм уже используется в другой системе и вам нужно получить тот же результат.
</Warning>

<Note>
  В Java хеш можно вычислять только для знаковых целых чисел,
  поэтому, если вы хотите вычислить хеш для беззнаковых целых чисел, их нужно привести к соответствующим знаковым типам ClickHouse.
</Note>

**Синтаксис**

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

**Аргументы**

* `arg` — Входное значение, для которого вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает хеш, вычисленный для `arg` [`Int32`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования 1**

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

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

**Пример использования 2**

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

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

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

Добавленный в: v20.1.0

Вычисляет [JavaHash](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/String.java#l1452) для строки, предполагая, что она содержит байты строки в кодировке UTF-16LE.

**Синтаксис**

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

**Аргументы**

* `arg` — Строка в кодировке UTF-16LE. [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение строки в кодировке UTF-16LE. [`Int32`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v1.1.0

Вычисляет [jump consistent hash](https://arxiv.org/pdf/1406.2294.pdf) от целого числа.

**Синтаксис**

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

**Аргументы**

* `key` — Входной ключ. [`UInt64`](/ru/reference/data-types/int-uint)
* `buckets` — Количество бакетов. [`Int32`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение. [`Int32`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v23.4.0

Вычисляет 32-битный хеш [MurmurHash2](https://github.com/aappleby/smhasher) от входного значения, используя тот же seed, что и [Kafka](https://github.com/apache/kafka/blob/461c5cfe056db0951d9b74f5adc45973670404d7/clients/src/main/java/org/apache/kafka/common/utils/Utils.java#L482), и отбрасывая старший бит для совместимости с [Default Partitioner](https://github.com/apache/kafka/blob/139f7709bd3f5926901a21e55043388728ccca78/clients/src/main/java/org/apache/kafka/clients/producer/internals/BuiltInPartitioner.java#L328).

**Синтаксис**

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

**Аргументы**

* `arg1[, arg2, ...]` — Переменное число параметров, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение переданных аргументов. [`UInt32`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v25.4.0

Вычисляет криптографический хеш Keccak-256 для указанной строки.
Эта хеш-функция широко используется в блокчейн-приложениях, особенно в Ethereum.

**Синтаксис**

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

**Аргументы**

* `message` — Входная строка, которую нужно хешировать. [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Возвращает 32-байтный хеш Keccak-256 от входной строки в виде строки фиксированной длины. [`FixedString(32)`](/ru/reference/data-types/fixedstring)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v22.6.0

Алгоритм согласованного хеширования Константина 'Kostik' Облакова со сложностью O(1) по времени и памяти.
Эффективен только при `n <= 32768`.

**Синтаксис**

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

**Псевдонимы**: `yandexConsistentHash`

**Аргументы**

* `input` — Целое число, используемое в качестве ключа. [`UInt64`](/ru/reference/data-types/int-uint)
* `n` — Количество бакетов. [`UInt16`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение. [`UInt16`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v1.1.0

Возвращает 64-битное хеш-значение [MetroHash](http://www.jandrewrogers.com/2015/05/27/metrohash/).

<Note>
  Вычисленные хеш-значения могут совпадать для одинаковых входных значений аргументов разных типов.
  Это относится, например, к целочисленным типам разного размера, именованным и неименованным `Tuple` с одинаковыми данными, а также к `Map` и соответствующему типу `Array(Tuple(key, value))` с одинаковыми данными.
</Note>

**Синтаксис**

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

**Аргументы**

* `arg1[, arg2, ...]` — Переменное число входных аргументов, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает хеш, вычисленный по входным аргументам. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v18.5.0

Вычисляет хеш [MurmurHash2](https://github.com/aappleby/smhasher) от входного значения.

<Note>
  Вычисленные хеш-значения могут совпадать для одинаковых входных значений аргументов разных типов.
  Это относится, например, к целочисленным типам разного размера, именованному и неименованному `Tuple` с одними и теми же данными, а также `Map` и соответствующему типу `Array(Tuple(key, value))` с одними и теми же данными.
</Note>

**Синтаксис**

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

**Аргументы**

* `arg1[, arg2, ...]` — Переменное количество входных аргументов, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение входных аргументов. [`UInt32`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v18.10.0

Вычисляет хеш [MurmurHash2](https://github.com/aappleby/smhasher) от входного значения.

<Note>
  Вычисленные хеш-значения могут совпадать для одинаковых входных значений аргументов разных типов.
  Это относится, например, к целочисленным типам разного размера, именованным и неименованным `Tuple` с одинаковыми данными, а также к `Map` и соответствующему типу `Array(Tuple(key, value))` с одинаковыми данными.
</Note>

**Синтаксис**

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

**Аргументы**

* `arg1[, arg2, ...]` — Переменное число входных аргументов, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает хеш, вычисленный по входным аргументам. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v18.10.0

Вычисляет 128-битный хеш [MurmurHash3](https://github.com/aappleby/smhasher) для входного значения.

**Синтаксис**

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

**Аргументы**

* `arg1[, arg2, ...]` — Переменное число входных аргументов, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает вычисленное 128-битное хеш-значение `MurmurHash3` для входных аргументов. [`FixedString(16)`](/ru/reference/data-types/fixedstring)

**Примеры**

**Пример использования**

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

Добавленный в: v18.10.0

Возвращает хеш-значение [MurmurHash3](https://github.com/aappleby/smhasher).

<Note>
  Вычисленные хеш-значения могут совпадать для одних и тех же входных значений при разных типах аргументов.
  Это относится, например, к целочисленным типам разного размера, именованным и неименованным `Tuple` с одинаковыми данными, а также к `Map` и соответствующему типу `Array(Tuple(key, value))` с одинаковыми данными.
</Note>

**Синтаксис**

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

**Аргументы**

* `arg1[, arg2, ...]` — переменное количество входных аргументов, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение входных аргументов. [`UInt32`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v18.10.0

Вычисляет хеш [MurmurHash3](https://github.com/aappleby/smhasher) от входного значения.

<Note>
  Вычисленные хеш-значения могут совпадать для одинаковых входных значений аргументов разных типов.
  Это касается, например, целочисленных типов разного размера, именованных и неименованных `Tuple` с одинаковыми данными, `Map` и соответствующего типа `Array(Tuple(key, value))` с одинаковыми данными.
</Note>

**Синтаксис**

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

**Аргументы**

* `arg1[, arg2, ...]` — Переменное число входных аргументов, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает хеш-значение, вычисленное для входных аргументов. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v21.1.0

Разбивает ASCII-строку на n-граммы длиной `ngramsize` символов, вычисляет хеш-значение для каждой n-граммы и возвращает кортеж с этими хешами.
Использует `hashnum` минимальных хешей для вычисления минимального хеш-значения и `hashnum` максимальных хешей для вычисления максимального хеш-значения.
Учитывает регистр.

Можно использовать для обнаружения похожих строк с помощью [`tupleHammingDistance`](/ru/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Если для двух строк возвращаемые хеши совпадают, значит, эти строки одинаковы.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `ngramsize` — Необязательный параметр. Размер n-граммы, любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `hashnum` — Необязательный параметр. Количество минимальных и максимальных хешей, используемых для вычисления результата, любое число от `1` до `25`. Значение по умолчанию — `6`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает кортеж из двух хешей — минимального и максимального. [`Tuple`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v21.1.0

Разбивает ASCII-строку на n-граммы длиной `ngramsize` символов и возвращает n-граммы с минимальным и максимальным хешами, вычисленными функцией [`ngramMinHash`](#ngramMinHash) для тех же входных данных.
Функция чувствительна к регистру.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `ngramsize` — Необязательно. Размер n-граммы, любое значение от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `hashnum` — Необязательно. Число минимальных и максимальных хешей, используемых для вычисления результата, любое значение от `1` до `25`. Значение по умолчанию — `6`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает кортеж из двух кортежей по `hashnum` n-грамм в каждом. [`Tuple(String)`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

Добавленный в: v21.1.0

Разбивает ASCII-строку на n-граммы длиной `ngramsize` символов и возвращает n-граммы с минимальными и максимальными хешами, вычисленными функцией [`ngramMinHashCaseInsensitive`](#ngramMinHashCaseInsensitive) для тех же входных данных.
Поддерживает регистронезависимый поиск.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `ngramsize` — Необязательно. Размер n-граммы, любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `hashnum` — Необязательно. Количество минимальных и максимальных хешей, используемых для вычисления результата, любое число от `1` до `25`. Значение по умолчанию — `6`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает кортеж из двух кортежей, каждый из которых содержит по `hashnum` n-грамм. [`Tuple(Tuple(String))`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

Добавленный в: v21.1.0

Разбивает UTF-8-строку на n-граммы длиной `ngramsize` символов и возвращает n-граммы с минимальным и максимальным хешами, вычисленными функцией ngramMinHashCaseInsensitiveUTF8 для тех же входных данных.
Поддерживает регистронезависимый поиск.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `ngramsize` — Необязательно. Размер n-граммы, любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `hashnum` — Необязательно. Количество минимальных и максимальных хешей, используемых для вычисления результата, любое число от `1` до `25`. Значение по умолчанию — `6`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает кортеж из двух кортежей по `hashnum` n-грамм в каждом. [`Tuple(Tuple(String))`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

Добавленный в: v21.1.0

Разбивает UTF-8-строку на n-граммы длиной `ngramsize` символов и возвращает n-граммы с минимальным и максимальным хешами, вычисленными функцией `ngramMinHashUTF8` для тех же входных данных.
Функция чувствительна к регистру.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `ngramsize` — Необязательно. Размер n-граммы, любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `hashnum` — Необязательно. Количество минимальных и максимальных хешей, используемых для вычисления результата, любое число от `1` до `25`. Значение по умолчанию — `6`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает кортеж из двух кортежей, в каждом из которых содержится по `hashnum` n-грамм. [`Tuple(Tuple(String))`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

Добавленный в: v21.1.0

Разбивает ASCII-строку на n-граммы длиной `ngramsize` символов, вычисляет хеш-значение для каждой n-граммы и возвращает кортеж с этими хешами.
Использует `hashnum` минимальных хешей для вычисления минимального хеша и `hashnum` максимальных хешей для вычисления максимального хеша.
Поддерживает регистронезависимый поиск.

Может использоваться для обнаружения почти повторяющихся строк с помощью [`tupleHammingDistance`](/ru/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Если для двух строк возвращаемые хеши совпадают, значит, эти строки одинаковы.

**Синтаксис**

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

**Аргументы**

* `string` — String. [String](/ru/reference/data-types/string). - `ngramsize` — Размер n-граммы. Необязательный. Возможные значения: любое число от `1` до `25`. Значение по умолчанию: `3`. [UInt8](/ru/reference/data-types/int-uint). - `hashnum` — Число минимальных и максимальных хешей, используемых для вычисления результата. Необязательный. Возможные значения: любое число от `1` до `25`. Значение по умолчанию: `6`. [UInt8](/ru/reference/data-types/int-uint).

**Возвращаемое значение**

кортеж с двумя хешами — минимальным и максимальным. [Tuple](/ru/reference/data-types/tuple)([UInt64](/ru/reference/data-types/int-uint), [UInt64](/ru/reference/data-types/int-uint)). [`Tuple`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v21.1.0

Разбивает UTF-8-строку на n-граммы длиной `ngramsize` символов, вычисляет хеш-значения для каждой n-граммы и возвращает кортеж с этими хешами.
Использует `hashnum` минимальных хешей для вычисления минимального хеша и `hashnum` максимальных хешей для вычисления максимального хеша.
Функция поддерживает регистронезависимый поиск.

Может использоваться для обнаружения почти одинаковых строк с помощью [`tupleHammingDistance`](/ru/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Для двух строк: если возвращаемые хеши совпадают для обеих строк, значит, эти строки одинаковы.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `ngramsize` — Необязательный. Размер n-граммы, любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `hashnum` — Необязательный. Количество минимальных и максимальных хешей, используемых для вычисления результата, любое число от `1` до `25`. Значение по умолчанию — `6`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает кортеж из двух хешей — минимального и максимального. [`Tuple`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v21.1.0

Разбивает UTF-8-строку на n-граммы длиной `ngramsize` символов, вычисляет хеш-значения для каждой n-граммы и возвращает кортеж с этими хешами.
Использует `hashnum` минимальных хешей для вычисления минимального хеша и `hashnum` максимальных хешей для вычисления максимального хеша.
Функция чувствительна к регистру.

Можно использовать для обнаружения почти дублирующихся строк с помощью [`tupleHammingDistance`](/ru/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Если для двух строк возвращаемые хеши совпадают, то эти строки одинаковы.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `ngramsize` — Необязательный параметр. Размер n-граммы, любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `hashnum` — Необязательный параметр. Количество минимальных и максимальных хешей, используемых для вычисления результата; любое число от `1` до `25`. Значение по умолчанию — `6`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает кортеж из двух хешей — минимального и максимального. [`Tuple`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v21.1.0

Разбивает ASCII-строку на n-граммы длиной `ngramsize` символов и возвращает `simhash` n-граммы.

Может использоваться для обнаружения почти дублирующихся строк с помощью [`bitHammingDistance`](/ru/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Чем меньше [расстояние Хэмминга](https://en.wikipedia.org/wiki/Hamming_distance) между вычисленными `simhash` двух строк, тем выше вероятность, что эти строки совпадают.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется `simhash` с учетом регистра. [`String`](/ru/reference/data-types/string)
* `ngramsize` — Необязательный параметр. Размер n-граммы — любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает вычисленный хеш входной строки. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v21.1.0

Разбивает ASCII-строку на n-граммы длиной `ngramsize` символов и возвращает их `simhash`.
Поддерживает регистронезависимый поиск.

Может использоваться для поиска почти дублирующихся строк с помощью [`bitHammingDistance`](/ru/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Чем меньше [расстояние Хэмминга](https://en.wikipedia.org/wiki/Hamming_distance) между вычисленными `simhashes` двух строк, тем выше вероятность, что эти строки совпадают.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется `simhash` для регистронезависимого поиска. [`String`](/ru/reference/data-types/string)
* `ngramsize` — Необязательный параметр. Размер n-граммы, любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Хеш-значение. [UInt64](/ru/reference/data-types/int-uint). [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v21.1.0

Разбивает UTF-8-строку на n-граммы размером `ngramsize` символов и возвращает `simhash` n-грамм.
Выполняет регистронезависимый поиск.

Может использоваться для обнаружения частично дублирующихся строк с помощью [bitHammingDistance](/ru/reference/functions/regular-functions/bit-functions#bitHammingDistance). Чем меньше [расстояние Хэмминга](https://en.wikipedia.org/wiki/Hamming_distance) между вычисленными `simhashes` двух строк, тем выше вероятность, что эти строки совпадают.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `ngramsize` — Необязательно. Размер n-граммы — любое число от `1` до `25`. Значение по умолчанию: `3`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v21.1.0

Разбивает строку в кодировке UTF-8 на n-граммы длиной `ngramsize` символов и возвращает `simhash` n-граммы.
Функция чувствительна к регистру.

Может использоваться для выявления частично дублирующихся строк с помощью [`bitHammingDistance`](/ru/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Чем меньше [расстояние Хэмминга](https://en.wikipedia.org/wiki/Hamming_distance) между вычисленными `simhashes` двух строк, тем выше вероятность, что эти строки совпадают.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `ngramsize` — Необязательный параметр. Размер n-граммы — любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v1.1.0

Как [`sipHash64`](#sipHash64), но возвращает 128-битное хеш-значение, то есть итоговое состояние xor-folding вычисляется до 128 бит.

<Tip>
  **используйте sipHash128Reference в новых проектах**

  Этот 128-битный вариант отличается от эталонной реализации и менее надёжен.
  Эта версия существует потому, что на момент её создания не было официального 128-битного расширения для SipHash.
  В новых проектах рекомендуется использовать [`sipHash128Reference`](#sipHash128Reference).
</Tip>

**Синтаксис**

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

**Аргументы**

* `arg1[, arg2, ...]` — Переменное число входных аргументов, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает 128-битное хеш-значение `SipHash`. [`FixedString(16)`](/ru/reference/data-types/fixedstring)

**Примеры**

**Пример использования**

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

Добавленный в: v23.2.0

То же, что и [`sipHash128`](#sipHash128), но дополнительно принимает явный аргумент key вместо использования фиксированного ключа.

<Tip>
  **используйте sipHash128ReferenceKeyed в новых проектах**

  Этот 128-битный вариант отличается от эталонной реализации и является менее стойким.
  Эта версия существует потому, что на момент её создания не было официального 128-битного расширения SipHash.
  В новых проектах, вероятно, следует использовать [`sipHash128ReferenceKeyed`](#sipHash128ReferenceKeyed).
</Tip>

**Синтаксис**

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

**Аргументы**

* `(k0, k1)` — кортеж из двух значений UInt64, представляющий ключ. [`Tuple(UInt64, UInt64)`](/ru/reference/data-types/tuple)
* `arg1[, arg2, ...]` — переменное число входных аргументов, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

128-битное хеш-значение `SipHash` типа [FixedString(16)](/ru/reference/data-types/fixedstring). [`FixedString(16)`](/ru/reference/data-types/fixedstring)

**Примеры**

**Пример использования**

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

Добавленный в: v23.2.0

Как [`sipHash128`](/ru/reference/functions/regular-functions/hash-functions#sipHash128), но использует 128-битный алгоритм от исходных авторов SipHash.

**Синтаксис**

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

**Аргументы**

* `arg1[, arg2, ...]` — переменное число входных аргументов, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает вычисленное 128-битное хеш-значение `SipHash` от входных аргументов. [`FixedString(16)`](/ru/reference/data-types/fixedstring)

**Примеры**

**Пример использования**

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

Добавленный в: v23.2.0

То же, что и [`sipHash128Reference`](#sipHash128Reference), но дополнительно принимает явный аргумент key вместо использования фиксированного ключа.

**Синтаксис**

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

**Аргументы**

* `(k0, k1)` — кортеж из двух значений, представляющий ключ [`Tuple(UInt64, UInt64)`](/ru/reference/data-types/tuple)
* `arg1[, arg2, ...]` — Переменное число входных аргументов, для которых вычисляется хеш. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает вычисленное 128-битное хеш-значение `SipHash` для входных аргументов. [`FixedString(16)`](/ru/reference/data-types/fixedstring)

**Примеры**

**Пример использования**

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

Добавленный в: v1.1.0

Создает 64-битное хеш-значение [SipHash](https://en.wikipedia.org/wiki/SipHash).

Это криптографическая хеш-функция. Она работает как минимум в три раза быстрее, чем хеш-функция [`MD5`](#MD5).

Функция [интерпретирует](/ru/reference/functions/regular-functions/type-conversion-functions#reinterpretAsString) все входные параметры как строки и вычисляет хеш-значение для каждого из них.
Затем она объединяет хеш-значения, используя следующий алгоритм:

1. Первое и второе хеш-значения объединяются в массив, для которого вычисляется хеш.
2. Ранее вычисленное хеш-значение и хеш-значение третьего входного параметра хешируются аналогичным образом.
3. Это вычисление повторяется для всех оставшихся хеш-значений исходных входных параметров.

<Note>
  вычисленные хеш-значения могут совпадать для одинаковых входных значений аргументов разных типов.
  Это относится, например, к целочисленным типам разного размера, именованным и неименованным `Tuple` с одинаковыми данными, `Map` и соответствующему типу `Array(Tuple(key, value))` с одинаковыми данными.
</Note>

**Синтаксис**

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

**Аргументы**

* `arg1[, arg2, ...]` — Переменное число входных аргументов. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает хеш-значение, вычисленное по входным аргументам. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v23.2.0

Как [`sipHash64`](#sipHash64), но дополнительно принимает явный ключ в качестве аргумента вместо использования фиксированного ключа.

**Синтаксис**

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

**Аргументы**

* `(k0, k1)` — Кортеж из двух значений, образующих ключ. [`Tuple(UInt64, UInt64)`](/ru/reference/data-types/tuple)
* `arg1[,arg2, ...]` — Переменное число входных аргументов. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает хеш, вычисленный по входным значениям. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v21.1.0

Разбивает ASCII-строку на части (шинглы) размером `shinglesize` слов, вычисляет хеш-значения для каждого словесного шингла и возвращает кортеж с этими хешами.
Использует `hashnum` минимальных хешей для вычисления минимального хеша и `hashnum` максимальных хешей для вычисления максимального хеша.
Чувствительна к регистру.

Может использоваться для обнаружения почти дублирующихся строк с помощью [`tupleHammingDistance`](/ru/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Если для двух строк возвращённые хеши совпадают, то строки одинаковы.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `shinglesize` — Необязательно. Размер словесного шингла: любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `hashnum` — Необязательно. Количество минимальных и максимальных хешей, используемых для вычисления результата: любое число от `1` до `25`. Значение по умолчанию — `6`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает кортеж из двух хешей — минимального и максимального. [`Tuple(UInt64, UInt64)`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

Добавленный в: v1.1.0

Разбивает ASCII-строку на части (шинглы) по `shinglesize` слов в каждой и возвращает шинглы с минимальным и максимальным хешами слов, вычисленные функцией wordShingleMinHash для тех же входных данных.
Функция чувствительна к регистру.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `shinglesize` — Необязательный параметр. Размер словесного шингла; любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `hashnum` — Необязательный параметр. Количество минимальных и максимальных хешей, используемых для вычисления результата; любое число от `1` до `25`. Значение по умолчанию — `6`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает кортеж из двух кортежей, каждый из которых содержит по `hashnum` словесных шинглов. [`Tuple(Tuple(String))`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

Добавленный в: v21.1.0

Разбивает строку ASCII на части (шинглы) по `shinglesize` слов в каждой и возвращает шинглы с минимальным и максимальным хешами слов, вычисленными функцией [`wordShingleMinHashCaseInsensitive`](#wordShingleMinHashCaseInsensitive) при тех же входных данных.
Функция использует регистронезависимый поиск.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `shinglesize` — Необязательно. Размер словесного шингла; любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `hashnum` — Необязательно. Количество минимальных и максимальных хешей, используемых для вычисления результата; любое число от `1` до `25`. Значение по умолчанию — `6`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает кортеж из двух кортежей, каждый из которых содержит по `hashnum` словесных шинглов. [`Tuple(Tuple(String))`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

Добавленный в: v21.1.0

Разбивает UTF-8-строку на части (шинглы) по `shinglesize` слов в каждой и возвращает шинглы с минимальным и максимальным хешами слов, вычисленными функцией [`wordShingleMinHashCaseInsensitiveUTF8`](#wordShingleMinHashCaseInsensitiveUTF8) для тех же входных данных.
Поддерживает регистронезависимый поиск.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `shinglesize` — Необязательно. Размер словесного шингла, любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `hashnum` — Необязательно. Количество минимальных и максимальных хешей, используемых для вычисления результата, любое число от `1` до `25`. Значение по умолчанию — `6`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает кортеж из двух кортежей, каждый из которых содержит по `hashnum` словесных шинглов. [`Tuple(Tuple(String))`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

Добавленный в: v21.1.0

Разбивает UTF-8-строку на части (шинглы) по `shinglesize` слов в каждой и возвращает шинглы с минимальным и максимальным хешами слов, вычисленными функцией [`wordShingleMinHashUTF8`](#wordShingleMinHashUTF8) для той же входной строки.
Чувствительна к регистру.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `shinglesize` — Необязательный параметр. Размер словесного шингла: любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `hashnum` — Необязательный параметр. Количество минимальных и максимальных хешей, используемых для вычисления результата: любое число от `1` до `25`. Значение по умолчанию — `6`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает кортеж из двух кортежей, каждый из которых содержит по `hashnum` словесных шинглов. [`Tuple(Tuple(String))`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

Добавленный в: v21.1.0

Разбивает ASCII-строку на части (шинглы) по `shinglesize` слов, вычисляет хеш-значения для каждого словесного шингла и возвращает кортеж с этими хешами.
Использует `hashnum` минимальных хешей для вычисления минимального хеша и `hashnum` максимальных хешей для вычисления максимального хеша.
Функция использует регистронезависимый поиск.

Может использоваться для обнаружения почти дублирующихся строк с помощью [`tupleHammingDistance`](/ru/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Для двух строк: если возвращаемые хеши совпадают для обеих строк, значит, эти строки одинаковы.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `shinglesize` — Необязательно. Размер словесного шингла, любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `hashnum` — Необязательно. Количество минимальных и максимальных хешей, используемых для вычисления результата; любое число от `1` до `25`. Значение по умолчанию — `6`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает кортеж из двух хешей — минимального и максимального. [`Tuple(UInt64, UInt64)`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

Добавленный в: v21.1.0

Разбивает UTF-8-строку на части (шинглы) по `shinglesize` слов, вычисляет хеш-значения для каждого словесного шингла и возвращает кортеж с этими хешами.
Использует `hashnum` минимальных хешей для вычисления минимального хеша и `hashnum` максимальных хешей для вычисления максимального хеша.
Используется регистронезависимый поиск.

Может использоваться для обнаружения почти дублирующихся строк с помощью [`tupleHammingDistance`](/ru/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Если для двух строк возвращаются одинаковые хеши, значит, эти строки совпадают.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `shinglesize` — Необязательный аргумент. Размер словесного шингла, любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `hashnum` — Необязательный аргумент. Количество минимальных и максимальных хешей, используемых для вычисления результата, любое число от `1` до `25`. Значение по умолчанию — `6`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает кортеж из двух хешей — минимального и максимального. [`Tuple(UInt64, UInt64)`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

Добавленный в: v21.1.0

Разбивает UTF-8-строку на части (шинглы) по `shinglesize` слов, вычисляет хеш-значения для каждого словесного шингла и возвращает кортеж с этими хешами.
Для вычисления минимального хеша использует `hashnum` минимальных хешей, а для вычисления максимального хеша — `hashnum` максимальных хешей.
Функция чувствительна к регистру.

Может использоваться для обнаружения почти дублирующихся строк с помощью [`tupleHammingDistance`](/ru/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Если для двух строк возвращённые хеши совпадают, значит, эти строки одинаковы.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `shinglesize` — Необязательный аргумент. Размер словесного шингла; любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)
* `hashnum` — Необязательный аргумент. Количество минимальных и максимальных хешей, используемых для вычисления результата; любое число от `1` до `25`. Значение по умолчанию — `6`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает кортеж из двух хешей — минимального и максимального. [`Tuple(UInt64, UInt64)`](/ru/reference/data-types/tuple)

**Примеры**

**Пример использования**

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

Добавленный в: v21.1.0

Разбивает ASCII-строку на части (шинглы) по `shinglesize` слов и возвращает `simhash` словесного шингла.
Чувствительна к регистру.

Может использоваться для выявления почти дублирующихся строк с помощью [`bitHammingDistance`](/ru/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Чем меньше [расстояние Хэмминга](https://en.wikipedia.org/wiki/Hamming_distance) между вычисленными `simhash` двух строк, тем выше вероятность, что эти строки совпадают.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `shinglesize` — Необязательный параметр. Размер словесного шингла; любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v21.1.0

Разбивает ASCII-строку на части (шинглы) по `shinglesize` слов и возвращает `simhash` словесного шингла.
Используется регистронезависимый поиск.

Может использоваться для выявления почти дублирующихся строк с помощью [`bitHammingDistance`](/ru/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Чем меньше [расстояние Хэмминга](https://en.wikipedia.org/wiki/Hamming_distance) между вычисленными `simhash` двух строк, тем выше вероятность, что эти строки одинаковы.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `shinglesize` — Необязательный параметр. Размер словесного шингла, любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v1.1.0

Разбивает строку в кодировке UTF-8 на части (шинглы) по `shinglesize` слов и возвращает `simhash` словесного шингла.
Использует регистронезависимый поиск.

Может использоваться для обнаружения почти дублирующихся строк с помощью [`bitHammingDistance`](/ru/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Чем меньше [расстояние Хэмминга](https://en.wikipedia.org/wiki/Hamming_distance) между вычисленными `simhash` двух строк, тем выше вероятность, что эти строки одинаковы.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `shinglesize` — Необязательный. Размер словесного шингла: любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v21.1.0

Разбивает UTF-8-строку на части (шинглы) размером `shinglesize` слов и возвращает `simhash` словесного шингла.
Чувствительна к регистру.

Может использоваться для обнаружения почти дублирующихся строк с помощью [`bitHammingDistance`](/ru/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Чем меньше [расстояние Хэмминга](https://en.wikipedia.org/wiki/Hamming_distance) между вычисленными `simhashes` двух строк, тем выше вероятность того, что эти строки совпадают.

**Синтаксис**

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

**Аргументы**

* `string` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)
* `shinglesize` — Необязательный параметр. Размер словесного шингла; любое число от `1` до `25`. Значение по умолчанию — `3`. [`UInt8`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает вычисленное хеш-значение. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

Добавленный в: v22.7.0

Вычисляет 64-битное [wyHash64](https://github.com/wangyi-fudan/wyhash) хеш-значение.

**Синтаксис**

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

**Аргументы**

* `arg` — аргумент типа String, для которого вычисляется хеш. [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Вычисленное 64-битное хеш-значение [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v20.1.0

Вычисляет [xxHash](http://cyan4973.github.io/xxHash/) от строки.

Версию для 64 бит см. в [`xxHash64`](#xxHash64)

**Синтаксис**

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

**Аргументы**

* `arg` — Входная строка для вычисления хеша. [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Возвращает 32-битный хеш, вычисленный для входной строки. [`UInt32`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v20.1.0

Вычисляет [xxHash](http://cyan4973.github.io/xxHash/) для строки.

Описание 32-битной версии см. в [`xxHash32`](#xxHash32)

**Синтаксис**

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

**Аргументы**

* `arg` — Строка, для которой вычисляется хеш. [`String`](/ru/reference/data-types/string)

**Возвращаемое значение**

Возвращает вычисленное 64-битное хеш-значение входной строки. [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v22.12.0

Вычисляет 64-битное хеш-значение [XXH3](https://github.com/Cyan4973/xxHash).

**Синтаксис**

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

**Аргументы**

* `expr` — Список выражений любого типа данных. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает вычисленное 64-битное хеш-значение `xxh3` [`UInt64`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

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

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

Добавленный в: v26.2.0

Вычисляет 128-битное хеш-значение [XXH3](https://github.com/Cyan4973/xxHash).

**Синтаксис**

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

**Аргументы**

* `expr` — Список выражений любого типа данных. [`Any`](/ru/reference/data-types)

**Возвращаемое значение**

Возвращает вычисленное 128-битное хеш-значение `xxh3` [`UInt128`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

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

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