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

> Documentação das funções de hash

# Funções de hash

As funções de hash podem ser usadas para o embaralhamento pseudoaleatório determinístico de elementos.

Simhash é uma função de hash que retorna valores de hash próximos para argumentos próximos (semelhantes).

A maioria das funções de hash aceita qualquer quantidade de argumentos de quaisquer tipos.

<Note>
  O hash de NULL é NULL. Para obter um hash não NULL de uma coluna Nullable, envolva-a em uma tupla:

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

<Note>
  Para calcular o hash de todo o conteúdo de uma tabela, use `sum(cityHash64(tuple(*)))` (ou outra função de hash). `tuple` garante que linhas com valores NULL não sejam ignoradas. `sum` garante que a ordem das linhas não importe.
</Note>

{/*AUTOGENERATED_START*/}

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

Introduzido na versão: v22.10.0

Calcula a string de hash BLAKE3 e retorna o conjunto de bytes resultante como FixedString.
Essa função hash criptográfica é integrada ao ClickHouse com a biblioteca BLAKE3 em Rust.
A função é bastante rápida e apresenta desempenho aproximadamente duas vezes superior ao SHA-2, gerando hashes com o mesmo comprimento do SHA-256.
Ela retorna um hash BLAKE3 como um array de bytes do tipo FixedString(32).

**Sintaxe**

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

**Argumentos**

* `message` — A string de entrada para calcular o hash. [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o hash BLAKE3 de 32 bytes da string de entrada como uma string de tamanho fixo. [`FixedString(32)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**hash**

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

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

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

Introduzido em: v21.11.0

Calcula o hash MD4 da string fornecida.

**Sintaxe**

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

**Argumentos**

* `s` — A string de entrada para gerar o hash. [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o hash MD4 da string de entrada fornecida como uma string de tamanho fixo. [`FixedString(16)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v1.1.0

Calcula o hash MD5 da string especificada.

**Sintaxe**

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

**Argumentos**

* `s` — A string de entrada para calcular o hash. [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o hash MD5 da string de entrada fornecida como uma string de tamanho fixo. [`FixedString(16)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v24.10.0

Calcula o hash RIPEMD-160 da string fornecida.

**Sintaxe**

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

**Argumentos**

* `s` — A string de entrada para calcular o hash. [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o hash RIPEMD160 da string de entrada fornecida como uma string de tamanho fixo. [`FixedString(20)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v1.1.0

Calcula o hash SHA1 da string informada.

**Sintaxe**

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

**Argumentos**

* `s` — A string de entrada para gerar o hash [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o hash SHA1 da string de entrada fornecida como uma string de tamanho fixo. [`FixedString(20)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v1.1.0

Calcula o hash SHA224 da string informada.

**Sintaxe**

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

**Argumentos**

* `s` — O valor de entrada para o cálculo do hash. [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o hash SHA224 da string de entrada fornecida como uma string de comprimento fixo. [`FixedString(28)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v1.1.0

Calcula o hash SHA256 da cadeia de caracteres fornecida.

**Sintaxe**

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

**Argumentos**

* `s` — A string de entrada para gerar o hash. [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o hash SHA256 da string de entrada especificada como uma string de comprimento fixo. [`FixedString(32)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v1.1.0

Calcula o hash SHA384 da string fornecida.

**Sintaxe**

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

**Argumentos**

* `s` — A string de entrada para gerar o hash. [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o hash SHA384 da string de entrada informada como uma string de comprimento fixo. [`FixedString(48)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v1.1.0

Calcula o hash SHA512 da string especificada.

**Sintaxe**

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

**Argumentos**

* `s` — String de entrada para gerar o hash [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o hash SHA512 da string de entrada informada como uma string de comprimento fixo. [`FixedString(64)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v1.1.0

Calcula o hash SHA512\_256 da string especificada.

**Sintaxe**

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

**Argumentos**

* `s` — A string de entrada para gerar o hash. [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o hash SHA512\_256 da string de entrada fornecida como uma string de tamanho fixo. [`FixedString(32)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v1.1.0

Uma função de hash não criptográfica rápida e de qualidade razoável para uma string obtida de uma URL usando algum tipo de normalização.

Esta função de hash tem dois modos:

| Modo              | Descrição                                                                                                                                                             |
| ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `URLHash(url)`    | Calcula um hash de uma string sem um dos símbolos finais `/`, `?` ou `#`, se presente.                                                                                |
| `URLHash(url, N)` | Calcula um hash de uma string até o nível N na hierarquia da URL, sem um dos símbolos finais `/`, `?` ou `#`, se presente. Os níveis são os mesmos de `URLHierarchy`. |

**Sintaxe**

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

**Argumentos**

* `url` — String da URL para calcular o hash. [`String`](/pt-BR/reference/data-types/string)
* `N` — Opcional. Nível na hierarquia da URL. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna o valor de hash calculado para `url`. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

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

**Hash da URL com o nível especificado**

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

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

Introduzido em: v1.1.0

Produz um valor de hash [CityHash](https://github.com/google/cityhash) de 64 bits.

Esta é uma função de hash rápida e não criptográfica.
Ela usa o algoritmo CityHash para parâmetros do tipo string e uma função de hash rápida e não criptográfica específica da implementação para parâmetros com outros tipos de dados.
A função usa o combinador CityHash para obter os resultados finais.

<Info>
  O Google alterou o algoritmo do CityHash depois que ele foi adicionado ao ClickHouse.
  Em outras palavras, o cityHash64 do ClickHouse e o CityHash upstream do Google agora produzem resultados diferentes.
  O cityHash64 do ClickHouse corresponde ao CityHash v1.0.2.
</Info>

<Note>
  Os valores de hash calculados podem ser iguais para os mesmos valores de entrada de diferentes tipos de argumento.
  Isso afeta, por exemplo, tipos inteiros de tamanhos diferentes, `Tuple` com nome e sem nome com os mesmos dados, `Map` e o tipo `Array(Tuple(key, value))` correspondente com os mesmos dados.
</Note>

**Sintaxe**

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

**Argumentos**

* `arg1[, arg2, ...]` — Um número variável de argumentos de entrada para os quais o hash será calculado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o hash calculado dos argumentos de entrada. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de chamada**

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

**Calculando o checksum da tabela inteira, levando em conta a ordem das linhas**

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

Introduzido em: v20.12.0

Produz um valor [FarmHash](https://github.com/google/farmhash) de 64 bits usando o método `Fingerprint64`.

<Tip>
  `farmFingerprint64` é preferível quando se deseja um valor estável e portátil, em vez de [`farmHash64`](#farmHash64).
</Tip>

<Note>
  Os valores de hash calculados podem ser iguais para os mesmos valores de entrada com diferentes tipos de argumento.
  Isso afeta, por exemplo, tipos inteiros de tamanhos diferentes, `Tuple` nomeada e não nomeada com os mesmos dados, `Map` e o tipo correspondente `Array(Tuple(key, value))` com os mesmos dados.
</Note>

**Sintaxe**

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

**Argumentos**

* `arg1[, arg2, ...]` — Uma quantidade variável de argumentos de entrada para calcular o hash. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o valor de hash calculado a partir dos argumentos de entrada. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v1.1.0

Produz um [FarmHash](https://github.com/google/farmhash) de 64 bits usando o método `Hash64`.

<Tip>
  [`farmFingerprint64`](#farmFingerprint64) é a opção preferida para um valor estável e portátil.
</Tip>

<Note>
  Os valores de hash calculados podem ser iguais para os mesmos valores de entrada de tipos de argumento diferentes.
  Isso afeta, por exemplo, tipos inteiros de tamanhos diferentes, `Tuple` nomeadas e não nomeadas com os mesmos dados, `Map` e o tipo `Array(Tuple(key, value))` correspondente com os mesmos dados.
</Note>

**Sintaxe**

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

**Argumentos**

* `arg1[, arg2, ...]` — Um número variável de argumentos de entrada para os quais o hash será calculado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o valor de hash calculado a partir dos argumentos de entrada. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v20.1.0

Calcula o hash [MurmurHash2](https://github.com/aappleby/smhasher) de 64 bits do valor de entrada usando a mesma seed usada pelo [GCC](https://github.com/gcc-mirror/gcc/blob/41d6b10e96a1de98e90a7c0378437c3255814b16/libstdc%2B%2B-v3/include/bits/functional_hash.h#L191).

É portátil entre compilações do Clang e do GCC.

**Sintaxe**

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

**Argumentos**

* `arg1[, arg2, ...]` — Um número variável de argumentos para os quais o hash deve ser calculado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o valor de hash calculado a partir dos argumentos de entrada. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v1.1.0

[Interpreta](/pt-BR/reference/functions/regular-functions/type-conversion-functions#reinterpretAsString) todos os parâmetros de entrada como strings e calcula o valor de hash MD5 de cada um deles. Em seguida, combina os hashes, extrai os primeiros 8 bytes do hash da string resultante e os interpreta como [UInt64](/pt-BR/reference/data-types/int-uint) em ordem de bytes big-endian. A função é relativamente lenta (5 milhões de strings curtas por segundo por núcleo de processador).

Considere usar a função [`sipHash64`](#sipHash64) no lugar dela.

A função aceita um número variável de parâmetros de entrada.
Os argumentos podem ser de qualquer um dos tipos de dados compatíveis.
Para alguns tipos de dados, o valor calculado da função de hash pode ser o mesmo para valores iguais, mesmo que os tipos dos argumentos sejam diferentes (inteiros de tamanhos diferentes, Tuple nomeado e não nomeado com os mesmos dados, Map e o tipo Array(Tuple(key, value)) correspondente com os mesmos dados).

**Sintaxe**

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

**Argumentos**

* `arg1[, arg2, ..., argN]` — Número variável de argumentos para os quais o hash deve ser calculado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o meio hash MD5 calculado a partir dos parâmetros de entrada informados, como um `UInt64` em ordem de bytes big-endian. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v20.1.0

Calcula um "HiveHash" de uma string.
Isso é apenas [`JavaHash`](#javaHash) com os bits de sinal zerados.
Essa função é usada no [Apache Hive](https://en.wikipedia.org/wiki/Apache_Hive) em versões anteriores à 3.0.

<Warning>
  Essa função de hash tem baixo desempenho.
  Use-a apenas quando esse algoritmo já for usado em outro sistema e você precisar calcular o mesmo resultado.
</Warning>

**Sintaxe**

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

**Argumentos**

* `arg` — String de entrada para calcular o hash. [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o "hive hash" calculado para a string de entrada. [`Int32`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v25.5.0

Implementa a lógica da [transformação hash](https://iceberg.apache.org/spec/#appendix-b-32-bit-hash-requirements) do Iceberg

**Sintaxe**

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

**Argumentos**

* `value` — Valor de entrada para o qual será calculado o hash: [`Integer`](/pt-BR/reference/data-types/int-uint) ou [`Bool`](/pt-BR/reference/data-types/boolean) ou [`Decimal`](/pt-BR/reference/data-types/decimal) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`Date`](/pt-BR/reference/data-types/date) ou [`Time`](/pt-BR/reference/data-types/time) ou [`DateTime`](/pt-BR/reference/data-types/datetime)

**Valor retornado**

Retorna um hash Murmur3 de 32 bits, variante x86, inicializado com 0 [`Int32`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo**

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

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

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

Introduzido em: v1.1.0

Calcula o hash de 32 bits de um inteiro.

A função hash é relativamente rápida, mas não é uma função hash criptográfica.

**Sintaxe**

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

**Argumentos**

* `arg` — Inteiro para gerar hash. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna o código de hash de 32 bits calculado para o inteiro de entrada [`UInt32`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v1.1.0

Calcula o hash de 64 bits de um inteiro.

A função hash é relativamente rápida (ainda mais rápida que [`intHash32`](#intHash32)), mas não é uma função hash criptográfica.

**Sintaxe**

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

**Argumentos**

* `int` — Inteiro cujo hash será calculado. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Código hash de 64 bits. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v20.1.0

Calcula JavaHash a partir de:

* [string](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>
  Esta função de hash é pouco eficiente.
  Use-a somente quando esse algoritmo já estiver em uso em outro sistema e você precisar calcular o mesmo resultado.
</Warning>

<Note>
  O Java só oferece suporte ao cálculo de hash de inteiros com sinal,
  portanto, se você quiser calcular o hash de inteiros sem sinal, deverá fazer cast deles para os tipos com sinal apropriados do ClickHouse.
</Note>

**Sintaxe**

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

**Argumentos**

* `arg` — Valor de entrada para o hash. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o hash calculado de `arg` [`Int32`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso 1**

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

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

**Exemplo de uso 2**

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

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

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

Introduzido na versão: v20.1.0

Calcula [JavaHash](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/String.java#l1452) de uma string, assumindo que ela contenha bytes que representem uma string codificada em UTF-16LE.

**Sintaxe**

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

**Argumentos**

* `arg` — Uma string com codificação UTF-16LE. [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o hash calculado da string codificada em UTF-16LE. [`Int32`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v1.1.0

Calcula o [hash consistente](https://arxiv.org/pdf/1406.2294.pdf) de um inteiro.

**Sintaxe**

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

**Argumentos**

* `key` — A chave de entrada. [`UInt64`](/pt-BR/reference/data-types/int-uint)
* `buckets` — A quantidade de buckets. [`Int32`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna o valor de hash calculado. [`Int32`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v23.4.0

Calcula o hash [MurmurHash2](https://github.com/aappleby/smhasher) de 32 bits do valor de entrada usando a mesma seed do [Kafka](https://github.com/apache/kafka/blob/461c5cfe056db0951d9b74f5adc45973670404d7/clients/src/main/java/org/apache/kafka/common/utils/Utils.java#L482) e sem o bit mais significativo, para ser compatível com o [Default Partitioner](https://github.com/apache/kafka/blob/139f7709bd3f5926901a21e55043388728ccca78/clients/src/main/java/org/apache/kafka/clients/producer/internals/BuiltInPartitioner.java#L328).

**Sintaxe**

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

**Argumentos**

* `arg1[, arg2, ...]` — Um número variável de parâmetros cujo hash será calculado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o valor de hash calculado a partir dos argumentos de entrada. [`UInt32`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v25.4.0

Calcula o hash criptográfico Keccak-256 da string fornecida.
Essa função de hash é amplamente usada em aplicações de blockchain, especialmente no Ethereum.

**Sintaxe**

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

**Argumentos**

* `message` — A string de entrada para calcular o hash. [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o hash Keccak-256 de 32 bytes da string de entrada como uma string de tamanho fixo. [`FixedString(32)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v22.6.0

Um algoritmo de hash consistente com complexidade de tempo e espaço O(1), de Konstantin 'Kostik' Oblakov.
Eficiente apenas para `n <= 32768`.

**Sintaxe**

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

**Aliases**: `yandexConsistentHash`

**Argumentos**

* `input` — Uma chave do tipo inteiro. [`UInt64`](/pt-BR/reference/data-types/int-uint)
* `n` — O número de buckets. [`UInt16`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna o valor de hash calculado. [`UInt16`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v1.1.0

Produz um valor de hash [MetroHash](http://www.jandrewrogers.com/2015/05/27/metrohash/) de 64 bits.

<Note>
  Os valores de hash calculados podem ser iguais para os mesmos valores de entrada, mesmo quando os tipos de argumento são diferentes.
  Isso afeta, por exemplo, tipos inteiros de tamanhos diferentes, uma `Tuple` nomeada e outra não nomeada com os mesmos dados, `Map` e o tipo correspondente `Array(Tuple(key, value))` com os mesmos dados.
</Note>

**Sintaxe**

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

**Argumentos**

* `arg1[, arg2, ...]` — Um número variável de argumentos de entrada usados para calcular o hash. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o hash calculado a partir dos argumentos de entrada. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v18.5.0

Calcula o hash [MurmurHash2](https://github.com/aappleby/smhasher) do valor de entrada.

<Note>
  Os valores de hash calculados podem ser iguais para os mesmos valores de entrada de tipos de argumento diferentes.
  Isso afeta, por exemplo, tipos inteiros de tamanhos diferentes, `Tuple` nomeada e não nomeada com os mesmos dados, `Map` e o tipo `Array(Tuple(key, value))` correspondente com os mesmos dados.
</Note>

**Sintaxe**

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

**Argumentos**

* `arg1[, arg2, ...]` — Um número variável de argumentos de entrada cujo hash será calculado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o valor de hash calculado a partir dos argumentos de entrada. [`UInt32`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v18.10.0

Calcula o hash [MurmurHash2](https://github.com/aappleby/smhasher) do valor de entrada.

<Note>
  Os valores de hash calculados podem ser iguais para os mesmos valores de entrada com tipos de argumento diferentes.
  Isso afeta, por exemplo, tipos inteiros de tamanhos diferentes, `Tuple` nomeadas e não nomeadas com os mesmos dados, `Map` e o tipo correspondente `Array(Tuple(key, value))` com os mesmos dados.
</Note>

**Sintaxe**

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

**Argumentos**

* `arg1[, arg2, ...]` — Um número variável de argumentos de entrada cujo hash será calculado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o hash calculado a partir dos argumentos de entrada. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v18.10.0

Calcula o hash de 128 bits [MurmurHash3](https://github.com/aappleby/smhasher) do valor de entrada.

**Sintaxe**

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

**Argumentos**

* `arg1[, arg2, ...]` — Um número variável de argumentos de entrada para os quais o hash deve ser calculado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o valor de hash `MurmurHash3` de 128 bits calculado a partir dos argumentos de entrada. [`FixedString(16)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v18.10.0

Produz um valor de hash [MurmurHash3](https://github.com/aappleby/smhasher).

<Note>
  Os valores de hash calculados podem ser iguais para os mesmos valores de entrada de tipos de argumento diferentes.
  Isso afeta, por exemplo, tipos inteiros de tamanhos diferentes, `Tuple` nomeada e não nomeada com os mesmos dados, `Map` e o tipo correspondente `Array(Tuple(key, value))` com os mesmos dados.
</Note>

**Sintaxe**

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

**Argumentos**

* `arg1[, arg2, ...]` — Um número variável de argumentos de entrada para os quais o hash deve ser calculado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o valor de hash calculado para os argumentos de entrada. [`UInt32`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v18.10.0

Calcula o hash [MurmurHash3](https://github.com/aappleby/smhasher) do valor de entrada.

<Note>
  Os valores de hash calculados podem ser iguais para os mesmos valores de entrada com tipos de argumento diferentes.
  Isso afeta, por exemplo, tipos inteiros de tamanhos diferentes, tipos `Tuple` nomeados e não nomeados com os mesmos dados, `Map` e o tipo correspondente `Array(Tuple(key, value))` com os mesmos dados.
</Note>

**Sintaxe**

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

**Argumentos**

* `arg1[, arg2, ...]` — Um número variável de argumentos de entrada para os quais o hash será calculado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o valor de hash calculado para os argumentos de entrada. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v21.1.0

Divide uma string ASCII em n-grams de `ngramsize` símbolos, calcula os valores de hash de cada n-gram e retorna uma Tuple com esses hashes.
Usa `hashnum` hashes mínimos para calcular o hash mínimo e `hashnum` hashes máximos para calcular o hash máximo.
Diferencia maiúsculas de minúsculas.

Pode ser usado para detectar strings semiduplicadas com [`tupleHammingDistance`](/pt-BR/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para duas strings, se os hashes retornados forem iguais para ambas, então essas strings são iguais.

**Sintaxe**

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

**Argumentos**

* `string` — `String` cujo hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `ngramsize` — Opcional. O tamanho de um n-grama, qualquer valor de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `hashnum` — Opcional. A quantidade de hashes mínimos e máximos usada para calcular o resultado, qualquer valor de `1` a `25`. O valor padrão é `6`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna uma tupla com dois hashes — o mínimo e o máximo. [`Tuple`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v21.1.0

Divide uma string ASCII em n-grama de `ngramsize` símbolos e retorna os n-grama com o menor e o maior hash, calculados pela função [`ngramMinHash`](#ngramMinHash) com a mesma entrada.
Diferencia maiúsculas de minúsculas.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual será calculado o hash. [`String`](/pt-BR/reference/data-types/string)
* `ngramsize` — Opcional. O tamanho de um n-gram, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `hashnum` — Opcional. O número de hashes mínimos e máximos usados para calcular o resultado, qualquer número de `1` a `25`. O valor padrão é `6`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna uma tupla contendo duas tuplas, cada uma com `hashnum` n-grama. [`Tuple(String)`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v21.1.0

Divide uma string ASCII em n-grams de `ngramsize` símbolos e retorna os n-grams com os hashes mínimo e máximo, calculados com a função [`ngramMinHashCaseInsensitive`](#ngramMinHashCaseInsensitive) usando a mesma entrada.
Não diferencia maiúsculas de minúsculas.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `ngramsize` — Opcional. O tamanho de um n-grama, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `hashnum` — Opcional. O número de hashes mínimos e máximos usados para calcular o resultado, qualquer número de `1` a `25`. O valor padrão é `6`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna uma tupla contendo duas tuplas, cada uma com `hashnum` n-gramas. [`Tuple(Tuple(String))`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v21.1.0

Divide uma string UTF-8 em n-grams de `ngramsize` símbolos e retorna os n-grams com os hashes mínimo e máximo, calculados pela função ngramMinHashCaseInsensitiveUTF8 para a mesma entrada.
Não diferencia maiúsculas de minúsculas.

**Sintaxe**

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

**Argumentos**

* `string` — String cujo hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `ngramsize` — Opcional. O tamanho de um n-grama, qualquer valor de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `hashnum` — Opcional. O número de hashes mínimos e máximos usados para calcular o resultado, qualquer valor de `1` a `25`. O valor padrão é `6`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna uma tupla contendo duas tuplas, cada uma com `hashnum` n-gramas. [`Tuple(Tuple(String))`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v21.1.0

Divide uma string UTF-8 em n-grams de `ngramsize` símbolos e retorna os n-grams com os hashes mínimo e máximo, calculados pela função `ngramMinHashUTF8` com a mesma entrada.
Diferencia maiúsculas de minúsculas.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash é calculado. [`String`](/pt-BR/reference/data-types/string)
* `ngramsize` — Opcional. O tamanho de um n-grama, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `hashnum` — Opcional. O número de hashes mínimos e máximos usados para calcular o resultado, qualquer número de `1` a `25`. O valor padrão é `6`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna uma tupla com duas tuplas, cada uma com `hashnum` n-gramas. [`Tuple(Tuple(String))`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v21.1.0

Divide uma string ASCII em n-grams de `ngramsize` símbolos, calcula os valores de hash de cada n-gram e retorna uma tupla com esses hashes.
Usa `hashnum` hashes mínimos para calcular o hash mínimo e `hashnum` hashes máximos para calcular o hash máximo.
Não diferencia maiúsculas de minúsculas.

Pode ser usada para detectar strings semiduplicado com [`tupleHammingDistance`](/pt-BR/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para duas strings, se os hashes retornados forem os mesmos para ambas, então essas strings são iguais.

**Sintaxe**

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

**Argumentos**

* `string` — String. [String](/pt-BR/reference/data-types/string). - `ngramsize` — O tamanho de um n-grama. Opcional. Valores possíveis: qualquer número de `1` a `25`. Valor padrão: `3`. [UInt8](/pt-BR/reference/data-types/int-uint). - `hashnum` — O número de hashes mínimos e máximos usado para calcular o resultado. Opcional. Valores possíveis: qualquer número de `1` a `25`. Valor padrão: `6`. [UInt8](/pt-BR/reference/data-types/int-uint).

**Valor retornado**

tupla com dois hashes — o mínimo e o máximo. [Tuple](/pt-BR/reference/data-types/tuple)([UInt64](/pt-BR/reference/data-types/int-uint), [UInt64](/pt-BR/reference/data-types/int-uint)). [`Tuple`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v21.1.0

Divide uma string UTF-8 em n-grams de `ngramsize` símbolos, calcula os valores de hash de cada n-gram e retorna uma tupla com esses hashes.
Usa `hashnum` hashes mínimos para calcular o hash mínimo e `hashnum` hashes máximos para calcular o hash máximo.
Não diferencia maiúsculas de minúsculas.

Pode ser usado para detectar strings semiduplicadas com [`tupleHammingDistance`](/pt-BR/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para duas strings, se os hashes retornados forem iguais em ambas, então essas strings são iguais.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash deve ser calculado. [`String`](/pt-BR/reference/data-types/string)
* `ngramsize` — Opcional. O tamanho de um n-grama, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `hashnum` — Opcional. A quantidade de hashes mínimos e máximos usada para calcular o resultado, qualquer número de `1` a `25`. O valor padrão é `6`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna uma tupla com dois hashes — o mínimo e o máximo. [`Tuple`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v21.1.0

Divide uma string UTF-8 em n-grams de `ngramsize` símbolos, calcula os valores de hash de cada n-gram e retorna uma tupla com esses hashes.
Usa `hashnum` hashes mínimos para calcular o hash mínimo e `hashnum` hashes máximos para calcular o hash máximo.
É sensível a maiúsculas e minúsculas.

Pode ser usado para detectar strings semiduplicado com [`tupleHammingDistance`](/pt-BR/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para duas strings, se os hashes retornados forem iguais para ambas, então essas strings são iguais.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `ngramsize` — Opcional. O tamanho de um n-grama, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `hashnum` — Opcional. A quantidade de hashes mínimos e máximos usada para calcular o resultado, qualquer número de `1` a `25`. O valor padrão é `6`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna uma tupla com dois hashes — o mínimo e o máximo. [`Tuple`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v21.1.0

Divide uma string ASCII em n-grams de `ngramsize` símbolos e retorna o `simhash` dos n-grams.

Pode ser usado para detectar strings semiduplicadas com [`bitHammingDistance`](/pt-BR/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Quanto menor a [distância de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre os `simhashes` calculados de duas strings, maior a probabilidade de que essas strings sejam iguais.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual será calculado o `simhash` com diferenciação entre maiúsculas e minúsculas. [`String`](/pt-BR/reference/data-types/string)
* `ngramsize` — Opcional. O tamanho de um n-grama, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna o hash calculado da string de entrada. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v21.1.0

Divide uma string ASCII em n-grams de `ngramsize` símbolos e retorna o `simhash` do n-gram.
Não diferencia maiúsculas de minúsculas.

Pode ser usado para detectar strings semiduplicadas com [`bitHammingDistance`](/pt-BR/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Quanto menor a [distância de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre os `simhashes` calculados de duas strings, maior a probabilidade de que essas strings sejam iguais.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual calcular o `simhash` sem distinção entre maiúsculas e minúsculas. [`String`](/pt-BR/reference/data-types/string)
* `ngramsize` — Opcional. O tamanho de um n-grama, qualquer valor de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Valor de hash. [UInt64](/pt-BR/reference/data-types/int-uint). [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v21.1.0

Divide uma string UTF-8 em n-grams de `ngramsize` símbolos e retorna o `simhash` do n-gram.
Não diferencia maiúsculas de minúsculas.

Pode ser usado para detectar strings semiduplicadas com [bitHammingDistance](/pt-BR/reference/functions/regular-functions/bit-functions#bitHammingDistance). Quanto menor a [distância de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre os `simhashes` calculados de duas strings, maior a probabilidade de que essas strings sejam iguais.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash é calculado. [`String`](/pt-BR/reference/data-types/string)
* `ngramsize` — Opcional. O tamanho de um n-grama, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna o valor de hash calculado. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v21.1.0

Divide uma string codificada em UTF-8 em n-grams de `ngramsize` símbolos e retorna o `simhash` do n-gram.
Diferencia maiúsculas de minúsculas.

Pode ser usado para detectar strings semiduplicadas com [`bitHammingDistance`](/pt-BR/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Quanto menor a [distância de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre os `simhashes` calculados de duas strings, maior a probabilidade de essas strings serem iguais.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `ngramsize` — Opcional. O tamanho de um n-grama, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna o valor de hash calculado. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v1.1.0

Como [`sipHash64`](#sipHash64), mas produz um valor de hash de 128 bits, ou seja, o estado final de xor-folding é calculado em 128 bits.

<Tip>
  **use sipHash128Reference em novos projetos**

  Esta variante de 128 bits difere da implementação de referência e é mais fraca.
  Esta versão existe porque, quando foi escrita, não havia uma extensão oficial de 128 bits para SipHash.
  Recomenda-se o uso de [`sipHash128Reference`](#sipHash128Reference) em novos projetos.
</Tip>

**Sintaxe**

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

**Argumentos**

* `arg1[, arg2, ...]` — Um número variável de argumentos de entrada para os quais o hash deve ser calculado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna um valor de hash `SipHash` de 128 bits. [`FixedString(16)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v23.2.0

Igual a [`sipHash128`](#sipHash128), mas recebe também um argumento de chave explícito em vez de usar uma chave fixa.

<Tip>
  **use sipHash128ReferenceKeyed em novos projetos**

  Esta variante de 128 bits difere da implementação de referência e é mais fraca.
  Esta versão existe porque, quando foi escrita, não havia uma extensão oficial de 128 bits para o SipHash.
  Novos projetos provavelmente devem usar [`sipHash128ReferenceKeyed`](#sipHash128ReferenceKeyed).
</Tip>

**Sintaxe**

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

**Argumentos**

* `(k0, k1)` — Uma tupla de dois valores UInt64 que representam a chave. [`Tuple(UInt64, UInt64)`](/pt-BR/reference/data-types/tuple)
* `arg1[, arg2, ...]` — Um número variável de argumentos de entrada para os quais o hash deve ser calculado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Um hash `SipHash` de 128 bits do tipo [FixedString(16)](/pt-BR/reference/data-types/fixedstring). [`FixedString(16)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v23.2.0

Semelhante a [`sipHash128`](/pt-BR/reference/functions/regular-functions/hash-functions#sipHash128), mas implementa o algoritmo de 128 bits original dos autores do SipHash.

**Sintaxe**

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

**Argumentos**

* `arg1[, arg2, ...]` — Um número variável de argumentos de entrada para os quais o hash deve ser calculado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o valor de hash `SipHash` de 128 bits calculado a partir dos argumentos de entrada. [`FixedString(16)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**Exemplo de uso**

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

Introduzido na versão: v23.2.0

Igual a [`sipHash128Reference`](#sipHash128Reference), mas também recebe um argumento de chave explícito em vez de usar uma chave fixa.

**Sintaxe**

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

**Argumentos**

* `(k0, k1)` — tupla de dois valores que representam a chave [`Tuple(UInt64, UInt64)`](/pt-BR/reference/data-types/tuple)
* `arg1[, arg2, ...]` — Um número variável de argumentos de entrada para os quais o hash deve ser calculado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o hash `SipHash` de 128 bits calculado a partir dos argumentos de entrada. [`FixedString(16)`](/pt-BR/reference/data-types/fixedstring)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v1.1.0

Produz um valor de hash [SipHash](https://en.wikipedia.org/wiki/SipHash) de 64 bits.

Esta é uma função de hash criptográfica. Ela funciona pelo menos três vezes mais rápido do que a função de hash [`MD5`](#MD5).

A função [interpreta](/pt-BR/reference/functions/regular-functions/type-conversion-functions#reinterpretAsString) todos os parâmetros de entrada como strings e calcula o valor de hash de cada um deles.
Em seguida, combina os hashes usando o seguinte algoritmo:

1. O primeiro e o segundo valor de hash são concatenados em um array, que é submetido a hash.
2. O valor de hash calculado anteriormente e o hash do terceiro parâmetro de entrada são submetidos a hash de maneira semelhante.
3. Esse cálculo é repetido para todos os valores de hash restantes da entrada original.

<Note>
  os valores de hash calculados podem ser iguais para os mesmos valores de entrada de diferentes tipos de argumento.
  Isso afeta, por exemplo, tipos inteiros de tamanhos diferentes, `Tuple` nomeado e não nomeado com os mesmos dados, `Map` e o tipo `Array(Tuple(key, value))` correspondente com os mesmos dados.
</Note>

**Sintaxe**

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

**Argumentos**

* `arg1[, arg2, ...]` — Um número variável de argumentos de entrada. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna um valor de hash calculado a partir dos argumentos de entrada. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v23.2.0

Como [`sipHash64`](#sipHash64), mas recebe adicionalmente um argumento de chave explícito em vez de usar uma chave fixa.

**Sintaxe**

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

**Argumentos**

* `(k0, k1)` — Uma tupla de dois valores que representam a chave. [`Tuple(UInt64, UInt64)`](/pt-BR/reference/data-types/tuple)
* `arg1[,arg2, ...]` — Um número variável de argumentos de entrada. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o hash calculado a partir dos valores de entrada. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v21.1.0

Divide uma string ASCII em partes (shingles) de `shinglesize` palavras, calcula os valores de hash para cada shingle de palavras e retorna uma tupla com esses hashes.
Usa `hashnum` hashes mínimos para calcular o hash mínimo e `hashnum` hashes máximos para calcular o hash máximo.
Diferencia maiúsculas de minúsculas.

Pode ser usado para detectar strings semiduplicadas com [`tupleHammingDistance`](/pt-BR/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para duas strings, se os hashes retornados forem os mesmos para ambas, então essas strings são iguais.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `shinglesize` — Opcional. O tamanho de um shingle de palavras, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `hashnum` — Opcional. O número de hashes mínimos e máximos usados para calcular o resultado, qualquer número de `1` a `25`. O valor padrão é `6`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna uma tupla com dois hashes — o mínimo e o máximo. [`Tuple(UInt64, UInt64)`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

Introduzido na versão: v1.1.0

Divide uma string ASCII em partes (shingles) de `shinglesize` palavras cada e retorna os shingles com o hash mínimo e o hash máximo das palavras, calculados pela função wordShingleMinHash com a mesma entrada.
Diferencia maiúsculas de minúsculas.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `shinglesize` — Opcional. O tamanho de um shingle de palavras, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `hashnum` — Opcional. O número de hashes mínimos e máximos usados para calcular o resultado, qualquer número de `1` a `25`. O valor padrão é `6`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna uma tupla contendo duas tuplas, cada uma com `hashnum` shingles de palavras. [`Tuple(Tuple(String))`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v21.1.0

Divide uma string ASCII em partes (shingles) de `shinglesize` palavras cada e retorna os shingles com os hashes mínimo e máximo das palavras, calculados pela função [`wordShingleMinHashCaseInsensitive`](#wordShingleMinHashCaseInsensitive) para a mesma entrada.
Não diferencia letras maiúsculas de minúsculas.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `shinglesize` — Opcional. O tamanho de um shingle de palavras, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `hashnum` — Opcional. O número de hashes mínimos e máximos usados para calcular o resultado, qualquer número de `1` a `25`. O valor padrão é `6`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna uma tupla com duas tuplas, cada uma com `hashnum` shingles de palavras. [`Tuple(Tuple(String))`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v21.1.0

Divide uma string UTF-8 em partes (shingles) de `shinglesize` palavras cada e retorna os shingles com o hash mínimo e o hash máximo das palavras, calculados pela função [`wordShingleMinHashCaseInsensitiveUTF8`](#wordShingleMinHashCaseInsensitiveUTF8) com a mesma entrada.
Não diferencia maiúsculas de minúsculas.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `shinglesize` — Opcional. O tamanho de um shingle de palavras, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `hashnum` — Opcional. O número de hashes mínimos e máximos usados para calcular o resultado, qualquer número de `1` a `25`. O valor padrão é `6`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna uma tupla com duas tuplas, cada uma com `hashnum` shingles de palavras. [`Tuple(Tuple(String))`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v21.1.0

Divide uma string UTF-8 em partes (shingles) de `shinglesize` palavras cada e retorna os shingles com o hash mínimo e o máximo das palavras, calculados pela função [`wordShingleMinHashUTF8`](#wordShingleMinHashUTF8) com a mesma entrada.
Diferencia maiúsculas de minúsculas.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `shinglesize` — Opcional. O tamanho de um shingle de palavras, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `hashnum` — Opcional. O número de hashes mínimos e máximos usados para calcular o resultado, qualquer número de `1` a `25`. O valor padrão é `6`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna uma tupla contendo duas tuplas, cada uma com `hashnum` shingles de palavras. [`Tuple(Tuple(String))`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

Introduzido na versão: v21.1.0

Divide uma string ASCII em partes (shingles) de `shinglesize` palavras, calcula os valores de hash de cada shingle de palavras e retorna uma tupla com esses hashes.
Usa `hashnum` hashes mínimos para calcular o hash mínimo e `hashnum` hashes máximos para calcular o hash máximo.
Não diferencia letras maiúsculas de minúsculas.

Pode ser usado para detectar strings semiduplicadas com [`tupleHammingDistance`](/pt-BR/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para duas strings, se os hashes retornados forem iguais para ambas, então essas strings são iguais.

**Sintaxe**

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

**Argumentos**

* `string` — `String` para a qual o hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `shinglesize` — Opcional. O tamanho de um shingle de palavras; pode ser qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `hashnum` — Opcional. O número de hashes mínimos e máximos usados para calcular o resultado; pode ser qualquer número de `1` a `25`. O valor padrão é `6`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna uma tupla com dois hashes — o mínimo e o máximo. [`Tuple(UInt64, UInt64)`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v21.1.0

Divide uma string UTF-8 em partes (shingles) de `shinglesize` palavras, calcula os valores de hash para cada shingle de palavras e retorna uma tupla com esses hashes.
Usa `hashnum` hashes mínimos para calcular o hash mínimo e `hashnum` hashes máximos para calcular o hash máximo.
Não diferencia letras maiúsculas de minúsculas.

Pode ser usado para detectar strings semiduplicadas com [`tupleHammingDistance`](/pt-BR/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para duas strings, se os hashes retornados forem os mesmos para ambas, então essas strings são iguais.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `shinglesize` — Opcional. O tamanho de um shingle de palavras, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `hashnum` — Opcional. A quantidade de hashes mínimo e máximo usada para calcular o resultado, qualquer número de `1` a `25`. O valor padrão é `6`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna uma tupla com dois hashes — o mínimo e o máximo. [`Tuple(UInt64, UInt64)`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v21.1.0

Divide uma string UTF-8 em partes (shingles) de `shinglesize` palavras, calcula os valores de hash para cada word shingle e retorna uma tupla com esses hashes.
Usa `hashnum` hashes mínimos para calcular o hash mínimo e `hashnum` hashes máximos para calcular o hash máximo.
Diferencia maiúsculas de minúsculas.

Pode ser usada para detectar strings semiduplicadas com [`tupleHammingDistance`](/pt-BR/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para duas strings, se os hashes retornados forem os mesmos para ambas, então essas strings são iguais.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `shinglesize` — Opcional. O tamanho de um shingle de palavras, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
* `hashnum` — Opcional. O número de hashes mínimos e máximos usados para calcular o resultado, qualquer número de `1` a `25`. O valor padrão é `6`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna uma tupla com dois hashes — o mínimo e o máximo. [`Tuple(UInt64, UInt64)`](/pt-BR/reference/data-types/tuple)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v21.1.0

Divide uma string ASCII em partes (shingles) de `shinglesize` palavras e retorna o `simhash` dos shingles de palavras.
Diferencia maiúsculas de minúsculas.

Pode ser usado para detectar strings semiduplicadas com [`bitHammingDistance`](/pt-BR/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Quanto menor a [distância de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre os `simhashes` calculados de duas strings, maior a probabilidade de essas strings serem iguais.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `shinglesize` — Opcional. O tamanho de um shingle de palavras, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna o valor de hash calculado. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido na versão: v21.1.0

Divide uma string ASCII em partes (shingles) de `shinglesize` palavras e retorna o `simhash` do shingle de palavras.
Não diferencia maiúsculas de minúsculas.

Pode ser usado para detectar strings semiduplicadas com [`bitHammingDistance`](/pt-BR/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Quanto menor a [distância de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre os `simhashes` calculados de duas strings, maior a probabilidade de essas strings serem iguais.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `shinglesize` — Opcional. O tamanho de um shingle de palavras, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna o valor de hash calculado. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v1.1.0

Divide uma string codificada em UTF-8 em partes (shingles) de `shinglesize` palavras e retorna o `simhash` do shingle de palavras.
Não diferencia maiúsculas de minúsculas.

Pode ser usado para detectar strings semiduplicadas com [`bitHammingDistance`](/pt-BR/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Quanto menor a [Distância de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) dos `simhashes` calculados de duas strings, maior a probabilidade de essas strings serem iguais.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `shinglesize` — Opcional. O tamanho de um shingle de palavras, qualquer valor de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna o valor de hash calculado. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v21.1.0

Divide uma string UTF-8 em partes (shingles) de `shinglesize` palavras e retorna o `simhash` do shingle de palavras.
Diferencia maiúsculas de minúsculas.

Pode ser usado para detectar strings semiduplicadas com [`bitHammingDistance`](/pt-BR/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Quanto menor a [distância de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre os `simhashes` calculados de duas strings, maior a probabilidade de essas strings serem iguais.

**Sintaxe**

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

**Argumentos**

* `string` — String para a qual o hash será calculado. [`String`](/pt-BR/reference/data-types/string)
* `shinglesize` — Opcional. O tamanho de um shingle de palavras, qualquer número de `1` a `25`. O valor padrão é `3`. [`UInt8`](/pt-BR/reference/data-types/int-uint)

**Valor retornado**

Retorna o valor de hash calculado. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

Introduzido em: v22.7.0

Calcula um [valor de hash wyHash64](https://github.com/wangyi-fudan/wyhash) de 64 bits.

**Sintaxe**

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

**Argumentos**

* `arg` — Argumento `String` cujo hash será calculado. [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o valor de hash calculado de 64 bits [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v20.1.0

Calcula um [xxHash](http://cyan4973.github.io/xxHash/) de uma string.

Para a versão de 64 bits, consulte [`xxHash64`](#xxHash64)

**Sintaxe**

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

**Argumentos**

* `arg` — String de entrada para gerar o hash. [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o hash de 32 bits calculado a partir da string de entrada. [`UInt32`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v20.1.0

Calcula um [xxHash](http://cyan4973.github.io/xxHash/) de uma string.

Para a versão de 32 bits, consulte [`xxHash32`](#xxHash32)

**Sintaxe**

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

**Argumentos**

* `arg` — String de entrada para gerar o hash. [`String`](/pt-BR/reference/data-types/string)

**Valor retornado**

Retorna o hash de 64 bits da string de entrada. [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido em: v22.12.0

Calcula um valor de hash [XXH3](https://github.com/Cyan4973/xxHash) de 64 bits.

**Sintaxe**

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

**Argumentos**

* `expr` — Uma lista de expressões de qualquer tipo de dado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o valor de hash `xxh3` calculado de 64 bits [`UInt64`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

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

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

Introduzido na versão: v26.2.0

Calcula um valor de hash [XXH3](https://github.com/Cyan4973/xxHash) de 128 bits.

**Sintaxe**

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

**Argumentos**

* `expr` — Uma lista de expressões de qualquer tipo de dado. [`Any`](/pt-BR/reference/data-types)

**Valor retornado**

Retorna o valor de hash `xxh3` calculado de 128 bits [`UInt128`](/pt-BR/reference/data-types/int-uint)

**Exemplos**

**Exemplo de uso**

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

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