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

> Documentación de funciones hash

# Funciones hash

Las funciones hash pueden usarse para el reordenamiento seudoaleatorio determinista de elementos.

Simhash es una función hash que devuelve valores hash próximos para argumentos próximos (similares).

La mayoría de las funciones hash aceptan cualquier número de argumentos de cualquier tipo.

<Note>
  El hash de NULL es NULL. Para obtener un hash no NULL de una columna Nullable, envuélvala en una tupla:

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

<Note>
  Para calcular el hash de todo el contenido de una tabla, use `sum(cityHash64(tuple(*)))` (u otra función hash). `tuple` garantiza que no se omitan las filas con valores NULL. `sum` garantiza que el orden de las filas no importe.
</Note>

{/*AUTOGENERATED_START*/}

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

Introducido en: v22.10.0

Calcula una cadena hash BLAKE3 y devuelve el conjunto de bytes resultante como FixedString.
Esta función hash criptográfica está integrada en ClickHouse mediante la biblioteca BLAKE3 de Rust.
La función es bastante rápida y ofrece un rendimiento aproximadamente dos veces superior al de SHA-2, mientras genera hashes de la misma longitud que SHA-256.
Devuelve un hash BLAKE3 como un array de bytes de tipo FixedString(32).

**Sintaxis**

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

**Argumentos**

* `message` — La cadena de entrada para calcular el hash. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el hash BLAKE3 de 32 bytes de la cadena de entrada como una cadena de longitud fija. [`FixedString(32)`](/es/reference/data-types/fixedstring)

**Ejemplos**

**hash**

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

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

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

Introducido en: v21.11.0

Calcula el hash MD4 de la cadena especificada.

**Sintaxis**

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

**Argumentos**

* `s` — La cadena de entrada para calcular el hash. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el hash MD4 de la cadena de entrada proporcionada como una cadena de longitud fija. [`FixedString(16)`](/es/reference/data-types/fixedstring)

**Ejemplos**

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

Introducido en: v1.1.0

Calcula el hash MD5 de la cadena dada.

**Sintaxis**

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

**Argumentos**

* `s` — La cadena de entrada para calcular el hash. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el hash MD5 de la cadena de entrada proporcionada como una cadena de longitud fija. [`FixedString(16)`](/es/reference/data-types/fixedstring)

**Ejemplos**

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

Introducido en: v24.10.0

Calcula el hash RIPEMD-160 de la cadena dada.

**Sintaxis**

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

**Argumentos**

* `s` — La cadena de entrada para calcular el hash. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el hash RIPEMD160 de la cadena de entrada proporcionada como una cadena de longitud fija. [`FixedString(20)`](/es/reference/data-types/fixedstring)

**Ejemplos**

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

Introducido en: v1.1.0

Calcula el hash SHA1 de la cadena especificada.

**Sintaxis**

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

**Argumentos**

* `s` — La cadena de entrada para calcular el `hash` [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el hash SHA1 de la cadena de entrada dada como una cadena de longitud fija. [`FixedString(20)`](/es/reference/data-types/fixedstring)

**Ejemplos**

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

Introducido en: v1.1.0

Calcula el hash SHA224 de la cadena proporcionada.

**Sintaxis**

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

**Argumentos**

* `s` — El valor de entrada para calcular el hash. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el hash SHA224 de la cadena de entrada especificada como una cadena de longitud fija. [`FixedString(28)`](/es/reference/data-types/fixedstring)

**Ejemplos**

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

Introducido en: v1.1.0

Calcula el hash SHA256 de la cadena proporcionada.

**Sintaxis**

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

**Argumentos**

* `s` — La cadena de entrada para calcular el hash. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el hash SHA256 de la cadena de entrada dada como una cadena de longitud fija. [`FixedString(32)`](/es/reference/data-types/fixedstring)

**Ejemplos**

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

Introducido en: v1.1.0

Calcula el hash SHA384 de la cadena proporcionada.

**Sintaxis**

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

**Argumentos**

* `s` — La cadena de entrada para calcular el hash. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el hash SHA384 de la cadena de entrada proporcionada como una cadena de longitud fija. [`FixedString(48)`](/es/reference/data-types/fixedstring)

**Ejemplos**

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

Introducido en: v1.1.0

Calcula el hash SHA512 de la cadena proporcionada.

**Sintaxis**

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

**Argumentos**

* `s` — La cadena de entrada para calcular el `hash` [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el hash SHA512 de la cadena de entrada proporcionada como una cadena de longitud fija. [`FixedString(64)`](/es/reference/data-types/fixedstring)

**Ejemplos**

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

Introducido en: v1.1.0

Calcula el hash SHA512\_256 de la cadena especificada.

**Sintaxis**

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

**Argumentos**

* `s` — La cadena de entrada para calcular el hash. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el hash SHA512\_256 de la cadena de entrada dada como una cadena de longitud fija. [`FixedString(32)`](/es/reference/data-types/fixedstring)

**Ejemplos**

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

Introducido en: v1.1.0

Una función hash no criptográfica rápida y de calidad razonable para una cadena obtenida de una URL mediante algún tipo de normalización.

Esta función hash tiene dos modos:

| Modo              | Descripción                                                                                                                                                                                               |
| ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `URLHash(url)`    | Calcula un hash a partir de una cadena sin alguno de los símbolos finales `/`, `?` o `#`, si está presente.                                                                                               |
| `URLHash(url, N)` | Calcula un hash a partir de una cadena hasta el nivel N en la jerarquía de la URL, sin alguno de los símbolos finales `/`, `?` o `#`, si está presente. Los niveles son los mismos que en `URLHierarchy`. |

**Sintaxis**

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

**Argumentos**

* `url` — Cadena de URL cuyo hash se calcula. [`String`](/es/reference/data-types/string)
* `N` — Opcional. Nivel en la jerarquía de la URL. [`(U)Int*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el valor hash calculado de `url`. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

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

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

**Hash de la URL con el nivel 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>

Introducido en: v1.1.0

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

Se trata de una función hash rápida no criptográfica.
Utiliza el algoritmo CityHash para los parámetros de cadena y una función hash rápida no criptográfica específica de la implementación para los parámetros con otros tipos de datos.
La función utiliza el combinador CityHash para obtener los resultados finales.

<Info>
  Google cambió el algoritmo de CityHash después de que se añadiera a ClickHouse.
  En otras palabras, cityHash64 de ClickHouse y la versión upstream de CityHash de Google ahora producen resultados diferentes.
  cityHash64 de ClickHouse corresponde a CityHash v1.0.2.
</Info>

<Note>
  Los valores hash calculados pueden coincidir para los mismos valores de entrada de distintos tipos de argumento.
  Esto afecta, por ejemplo, a tipos enteros de distinto tamaño, `Tuple` con nombre y sin nombre con los mismos datos, `Map` y el tipo `Array(Tuple(key, value))` correspondiente con los mismos datos.
</Note>

**Sintaxis**

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

**Argumentos**

* `arg1[, arg2, ...]` — Un número variable de argumentos de entrada sobre los que se calcula el hash. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el hash calculado a partir de los argumentos de entrada. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de llamada**

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

**Cálculo de la suma de comprobación de toda la tabla, teniendo en cuenta el orden de las filas**

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

Introducido en: v20.12.0

Produce un valor [FarmHash](https://github.com/google/farmhash) de 64 bits usando el método `Fingerprint64`.

<Tip>
  Se prefiere `farmFingerprint64` porque ofrece un valor estable y portable frente a [`farmHash64`](#farmHash64).
</Tip>

<Note>
  Los valores hash calculados pueden ser iguales para los mismos valores de entrada de distintos tipos de argumento.
  Esto afecta, por ejemplo, a tipos enteros de distinto tamaño, `Tuple` con nombre y sin nombre con los mismos datos, `Map` y el tipo correspondiente `Array(Tuple(key, value))` con los mismos datos.
</Note>

**Sintaxis**

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

**Argumentos**

* `arg1[, arg2, ...]` — Un número variable de argumentos de entrada para los que se debe calcular el hash. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el valor hash calculado a partir de los argumentos de entrada. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v1.1.0

Genera un [FarmHash](https://github.com/google/farmhash) de 64 bits con el método `Hash64`.

<Tip>
  Se prefiere [`farmFingerprint64`](#farmFingerprint64) para obtener un valor estable y portable.
</Tip>

<Note>
  Los valores hash calculados pueden coincidir para los mismos valores de entrada de distintos tipos de argumento.
  Esto afecta, por ejemplo, a tipos enteros de distinto tamaño, a `Tuple` con nombre y sin nombre con los mismos datos, y a `Map` y el tipo correspondiente `Array(Tuple(key, value))` con los mismos datos.
</Note>

**Sintaxis**

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

**Argumentos**

* `arg1[, arg2, ...]` — Un número variable de argumentos de entrada para los que se debe calcular el hash. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el valor hash calculado a partir de los argumentos de entrada. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v20.1.0

Calcula el hash de 64 bits [MurmurHash2](https://github.com/aappleby/smhasher) del valor de entrada usando la misma semilla que utiliza [GCC](https://github.com/gcc-mirror/gcc/blob/41d6b10e96a1de98e90a7c0378437c3255814b16/libstdc%2B%2B-v3/include/bits/functional_hash.h#L191).

Es portable entre las compilaciones de Clang y GCC.

**Sintaxis**

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

**Argumentos**

* `arg1[, arg2, ...]` — Un número variable de argumentos sobre los que calcular el hash. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el valor hash calculado a partir de los argumentos de entrada. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v1.1.0

[Interpreta](/es/reference/functions/regular-functions/type-conversion-functions#reinterpretAsString) todos los parámetros de entrada como cadenas y calcula el valor hash MD5 para cada uno de ellos. Luego combina los hashes, toma los primeros 8 bytes del hash de la cadena resultante y los interpreta como [UInt64](/es/reference/data-types/int-uint) en orden de bytes big-endian. La función es relativamente lenta (5 millones de cadenas cortas por segundo por núcleo de procesador).

Considere usar en su lugar la función [`sipHash64`](#sipHash64).

La función acepta un número variable de parámetros de entrada.
Los argumentos pueden ser de cualquiera de los tipos de datos compatibles.
Para algunos tipos de datos, el valor calculado por la función hash puede ser el mismo para los mismos valores, incluso si los tipos de los argumentos difieren (enteros de distinto tamaño, Tuple con nombre y sin nombre con los mismos datos, Map y el tipo Array(Tuple(key, value)) correspondiente con los mismos datos).

**Sintaxis**

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

**Argumentos**

* `arg1[, arg2, ..., argN]` — Número variable de argumentos para los que se calcula el hash. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve la mitad calculada del hash MD5 de los parámetros de entrada proporcionados, como un `UInt64` en orden de bytes big-endian. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v20.1.0

Calcula un "HiveHash" a partir de una cadena.
No es más que [`JavaHash`](#javaHash) con los bits de signo puestos a cero.
Esta función se utiliza en [Apache Hive](https://en.wikipedia.org/wiki/Apache_Hive) en versiones anteriores a la 3.0.

<Warning>
  Esta función hash tiene un rendimiento deficiente.
  Úsela solo cuando este algoritmo ya se utilice en otro sistema y necesite calcular el mismo resultado.
</Warning>

**Sintaxis**

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

**Argumentos**

* `arg` — Cadena de entrada para calcular el hash. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el "hive hash" calculado de la cadena de entrada. [`Int32`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v25.5.0

Implementa la lógica de la [transformación hash de Iceberg](https://iceberg.apache.org/spec/#appendix-b-32-bit-hash-requirements)

**Sintaxis**

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

**Argumentos**

* `value` — Valor de entrada del que se calculará el hash de [`Integer`](/es/reference/data-types/int-uint) o [`Bool`](/es/reference/data-types/boolean) o [`Decimal`](/es/reference/data-types/decimal) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`UUID`](/es/reference/data-types/uuid) o [`Date`](/es/reference/data-types/date) o [`Time`](/es/reference/data-types/time) o [`DateTime`](/es/reference/data-types/datetime)

**Valor devuelto**

Devuelve un hash Murmur3 de 32 bits, variante x86, con semilla 0 [`Int32`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo**

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

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

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

Introducido en: v1.1.0

Calcula un hash de 32 bits a partir de un entero.

La función hash es relativamente rápida, pero no es una función hash criptográfica.

**Sintaxis**

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

**Argumentos**

* `arg` — Entero al que se aplica la función hash. [`(U)Int*`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el código hash de 32 bits calculado a partir del entero de entrada [`UInt32`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

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

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

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

Introducido en: v1.1.0

Calcula un hash de 64 bits para un entero.

La función hash es relativamente rápida (incluso más rápida que [`intHash32`](#intHash32)), pero no es una función hash criptográfica.

**Sintaxis**

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

**Argumentos**

* `int` — Entero del que se calcula el hash. [`(U)Int*`](/es/reference/data-types/int-uint)

**Valor devuelto**

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

**Ejemplos**

**Ejemplo de uso**

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

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

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

Introducido en: 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 función hash tiene un rendimiento bajo.
  Úsela solo cuando este algoritmo ya se utilice en otro sistema y necesite calcular el mismo resultado.
</Warning>

<Note>
  Java solo admite calcular el hash de enteros con signo,
  por lo que, si quiere calcular el hash de enteros sin signo, debe convertirlos mediante CAST a los tipos con signo de ClickHouse adecuados.
</Note>

**Sintaxis**

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

**Argumentos**

* `arg` — Valor de entrada para calcular el hash. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el hash calculado de `arg` [`Int32`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso 1**

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

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

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

Introducido en: v20.1.0

Calcula [JavaHash](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/String.java#l1452) de una cadena, asumiendo que contiene bytes que representan una cadena codificada en UTF-16LE.

**Sintaxis**

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

**Argumentos**

* `arg` — Una cadena con codificación UTF-16LE. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el hash calculado de la cadena codificada en UTF-16LE. [`Int32`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v1.1.0

Calcula el [jump hash consistente](https://arxiv.org/pdf/1406.2294.pdf) de un entero.

**Sintaxis**

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

**Argumentos**

* `key` — La clave de entrada. [`UInt64`](/es/reference/data-types/int-uint)
* `buckets` — El número de buckets. [`Int32`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el valor hash calculado. [`Int32`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v23.4.0

Calcula el hash [MurmurHash2](https://github.com/aappleby/smhasher) de 32 bits del valor de entrada usando la misma semilla que [Kafka](https://github.com/apache/kafka/blob/461c5cfe056db0951d9b74f5adc45973670404d7/clients/src/main/java/org/apache/kafka/common/utils/Utils.java#L482) y sin el bit más significativo, para ser compatible con [Default Partitioner](https://github.com/apache/kafka/blob/139f7709bd3f5926901a21e55043388728ccca78/clients/src/main/java/org/apache/kafka/clients/producer/internals/BuiltInPartitioner.java#L328).

**Sintaxis**

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

**Argumentos**

* `arg1[, arg2, ...]` — Una cantidad variable de parámetros cuyo hash se calcula. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el valor hash calculado de los argumentos de entrada. [`UInt32`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v25.4.0

Calcula el hash criptográfico Keccak-256 de la cadena proporcionada.
Esta función hash se utiliza ampliamente en aplicaciones de blockchain, en particular en Ethereum.

**Sintaxis**

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

**Argumentos**

* `message` — La cadena de entrada para calcular el hash. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el hash Keccak-256 de 32 bytes de la cadena de entrada como una cadena de longitud fija. [`FixedString(32)`](/es/reference/data-types/fixedstring)

**Ejemplos**

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

Introducido en: v22.6.0

Un algoritmo de hash consistente con complejidad temporal y espacial O(1), de Konstantin 'Kostik' Oblakov.
Solo es eficiente con `n <= 32768`.

**Sintaxis**

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

**Aliases**: `yandexConsistentHash`

**Argumentos**

* `input` — Una clave de tipo entero. [`UInt64`](/es/reference/data-types/int-uint)
* `n` — El número de buckets. [`UInt16`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el valor hash calculado. [`UInt16`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v1.1.0

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

<Note>
  Los valores hash calculados pueden ser iguales para los mismos valores de entrada de distintos tipos de argumento.
  Esto afecta, por ejemplo, a tipos enteros de distinto tamaño, `Tuple` con nombre y sin nombre con los mismos datos, `Map` y el tipo correspondiente `Array(Tuple(key, value))` con los mismos datos.
</Note>

**Sintaxis**

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

**Argumentos**

* `arg1[, arg2, ...]` — Un número variable de argumentos de entrada para calcular el hash. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el hash calculado a partir de los argumentos de entrada. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v18.5.0

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

<Note>
  Los valores hash calculados pueden coincidir para los mismos valores de entrada de distintos tipos de argumento.
  Esto afecta, por ejemplo, a tipos enteros de distinto tamaño, a `Tuple` con y sin nombre con los mismos datos, y a `Map` y el tipo `Array(Tuple(key, value))` correspondiente con los mismos datos.
</Note>

**Sintaxis**

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

**Argumentos**

* `arg1[, arg2, ...]` — Una cantidad variable de argumentos de entrada para los que se calcula el hash. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el valor hash calculado a partir de los argumentos de entrada. [`UInt32`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v18.10.0

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

<Note>
  Los valores hash calculados pueden coincidir para los mismos valores de entrada de distintos tipos de argumento.
  Esto afecta, por ejemplo, a tipos enteros de distinto tamaño, `Tuple` con nombre y sin nombre con los mismos datos, `Map` y el tipo correspondiente `Array(Tuple(key, value))` con los mismos datos.
</Note>

**Sintaxis**

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

**Argumentos**

* `arg1[, arg2, ...]` — Un número variable de argumentos de entrada para los que se calcula el hash. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el hash calculado a partir de los argumentos de entrada. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v18.10.0

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

**Sintaxis**

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

**Argumentos**

* `arg1[, arg2, ...]` — Un número variable de argumentos de entrada para los que se calcula el hash. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el valor hash `MurmurHash3` de 128 bits calculado a partir de los argumentos de entrada. [`FixedString(16)`](/es/reference/data-types/fixedstring)

**Ejemplos**

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

Introducido en: v18.10.0

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

<Note>
  Los valores hash calculados pueden ser iguales para los mismos valores de entrada de distintos tipos de argumento.
  Esto afecta, por ejemplo, a tipos enteros de distinto tamaño, `Tuple` con nombre y sin nombre con los mismos datos, `Map` y el tipo correspondiente `Array(Tuple(key, value))` con los mismos datos.
</Note>

**Sintaxis**

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

**Argumentos**

* `arg1[, arg2, ...]` — Un número variable de argumentos de entrada a partir de los cuales se calcula el hash. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el valor hash calculado a partir de los argumentos de entrada. [`UInt32`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v18.10.0

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

<Note>
  Los valores hash calculados pueden coincidir para los mismos valores de entrada de distintos tipos de argumento.
  Esto afecta, por ejemplo, a tipos enteros de distinto tamaño, `Tuple` con nombre y sin nombre con los mismos datos, `Map` y el tipo `Array(Tuple(key, value))` correspondiente con los mismos datos.
</Note>

**Sintaxis**

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

**Argumentos**

* `arg1[, arg2, ...]` — Una cantidad variable de argumentos de entrada cuyo hash se calcula. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el valor hash calculado a partir de los argumentos de entrada. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena ASCII en n-gramas de `ngramsize` símbolos, calcula valores hash para cada n-grama y devuelve una tupla con esos hashes.
Usa los `hashnum` hashes mínimos para calcular el hash mínimo y los `hashnum` hashes máximos para calcular el hash máximo.
Distingue entre mayúsculas y minúsculas.

Puede usarse para detectar cadenas semiduplicadas con [`tupleHammingDistance`](/es/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para dos cadenas, si los hashes devueltos son los mismos en ambas, entonces esas cadenas son iguales.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena sobre la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `ngramsize` — Opcional. El tamaño de un n-grama, cualquier valor entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `hashnum` — Opcional. El número de hashes mínimos y máximos que se usan para calcular el resultado, cualquier valor entre `1` y `25`. El valor predeterminado es `6`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una tupla con dos hashes: el mínimo y el máximo. [`Tuple`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena ASCII en n-gramas de `ngramsize` símbolos y devuelve los n-gramas con los hashes mínimo y máximo, calculados mediante la función [`ngramMinHash`](#ngramMinHash) con la misma entrada.
Distingue entre mayúsculas y minúsculas.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `ngramsize` — Opcional. El tamaño de un n-grama; cualquier número entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `hashnum` — Opcional. La cantidad de hashes mínimos y máximos usados para calcular el resultado; cualquier número entre `1` y `25`. El valor predeterminado es `6`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una tupla que contiene dos tuplas con `hashnum` n-gramas cada una. [`Tuple(String)`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena ASCII en n-gramas de `ngramsize` símbolos y devuelve los n-gramas con el hash mínimo y máximo, calculados por la función [`ngramMinHashCaseInsensitive`](#ngramMinHashCaseInsensitive) con la misma entrada.
No distingue entre mayúsculas y minúsculas.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena sobre la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `ngramsize` — Opcional. El tamaño de un n-grama, cualquier número entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `hashnum` — Opcional. El número de hashes mínimos y máximos utilizados para calcular el resultado, cualquier número entre `1` y `25`. El valor predeterminado es `6`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una tupla formada por dos tuplas con `hashnum` n-gramas cada una. [`Tuple(Tuple(String))`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena UTF-8 en n-gramas de `ngramsize` símbolos y devuelve los n-gramas con los valores hash mínimo y máximo, calculados mediante la función ngramMinHashCaseInsensitiveUTF8 con la misma entrada.
No distingue entre mayúsculas y minúsculas.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `ngramsize` — Opcional. El tamaño de un n-grama; puede ser cualquier número de `1` a `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `hashnum` — Opcional. El número de hashes mínimos y máximos utilizados para calcular el resultado; puede ser cualquier número de `1` a `25`. El valor predeterminado es `6`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una tupla compuesta por dos tuplas con `hashnum` n-gramas cada una. [`Tuple(Tuple(String))`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducida en: v21.1.0

Divide una cadena UTF-8 en n-gramas de `ngramsize` símbolos y devuelve los n-gramas con el valor hash mínimo y máximo, calculados por la función `ngramMinHashUTF8` con la misma entrada.
Distingue entre mayúsculas y minúsculas.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `ngramsize` — Opcional. El tamaño de un n-grama; cualquier valor de `1` a `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `hashnum` — Opcional. La cantidad de hashes mínimos y máximos utilizados para calcular el resultado; cualquier valor de `1` a `25`. El valor predeterminado es `6`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una tupla con dos tuplas, cada una con `hashnum` n-gramas. [`Tuple(Tuple(String))`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena ASCII en n-gramas de `ngramsize` símbolos, calcula los valores hash de cada n-grama y devuelve una tupla con esos hashes.
Usa `hashnum` hashes mínimos para calcular el hash mínimo y `hashnum` hashes máximos para calcular el hash máximo.
No distingue entre mayúsculas y minúsculas.

Puede usarse para detectar cadenas semiduplicadas con [`tupleHammingDistance`](/es/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para dos cadenas, si los hashes devueltos son iguales en ambas, entonces esas cadenas son iguales.

**Sintaxis**

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

**Argumentos**

* `string` — String. [String](/es/reference/data-types/string). - `ngramsize` — El tamaño de un n-grama. Opcional. Valores posibles: cualquier número de `1` a `25`. Valor predeterminado: `3`. [UInt8](/es/reference/data-types/int-uint). - `hashnum` — La cantidad de hashes mínimos y máximos utilizados para calcular el resultado. Opcional. Valores posibles: cualquier número de `1` a `25`. Valor predeterminado: `6`. [UInt8](/es/reference/data-types/int-uint).

**Valor devuelto**

Tupla con dos hashes: el mínimo y el máximo. [Tuple](/es/reference/data-types/tuple)([UInt64](/es/reference/data-types/int-uint), [UInt64](/es/reference/data-types/int-uint)). [`Tuple`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena UTF-8 en n-grams de `ngramsize` símbolos, calcula valores hash para cada n-gram y devuelve una tupla con estos hash.
Usa `hashnum` hash mínimos para calcular el hash mínimo y `hashnum` hash máximos para calcular el hash máximo.
No distingue entre mayúsculas y minúsculas.

Puede usarse para detectar cadenas semiduplicadas con [`tupleHammingDistance`](/es/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para dos cadenas, si los hash devueltos son los mismos para ambas, entonces esas cadenas son iguales.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `ngramsize` — Opcional. El tamaño de un n-grama; cualquier valor entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `hashnum` — Opcional. La cantidad de hashes mínimos y máximos que se usan para calcular el resultado; cualquier valor entre `1` y `25`. El valor predeterminado es `6`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una tupla con dos hashes: el mínimo y el máximo. [`Tuple`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena UTF-8 en n-gramas de `ngramsize` símbolos, calcula valores hash para cada n-grama y devuelve una tupla con esos hashes.
Usa `hashnum` hashes mínimos para calcular el hash mínimo y `hashnum` hashes máximos para calcular el hash máximo.
Distingue entre mayúsculas y minúsculas.

Puede usarse para detectar cadenas semiduplicadas con [`tupleHammingDistance`](/es/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para dos cadenas, si los hashes devueltos son los mismos en ambas, entonces esas cadenas son iguales.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `ngramsize` — Opcional. El tamaño de un n-grama; cualquier valor entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `hashnum` — Opcional. La cantidad de hashes mínimos y máximos utilizada para calcular el resultado; cualquier valor entre `1` y `25`. El valor predeterminado es `6`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una tupla con dos hashes: el mínimo y el máximo. [`Tuple`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena ASCII en n-gramas de `ngramsize` símbolos y devuelve el `simhash` de los n-gramas.

Puede utilizarse para detectar cadenas semiduplicadas con [`bitHammingDistance`](/es/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Cuanto menor sea la [distancia de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) de los `simhashes` calculados de dos cadenas, más probable será que esas cadenas sean iguales.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el `simhash` que distingue entre mayúsculas y minúsculas. [`String`](/es/reference/data-types/string)
* `ngramsize` — Opcional. El tamaño de un ngrama, cualquier número entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el hash calculado de la cadena de entrada. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

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

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

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

Introducido en: v21.1.0

Divide una cadena ASCII en n-gramas de `ngramsize` símbolos y devuelve el `simhash` de n-gramas.
No distingue entre mayúsculas y minúsculas.

Puede usarse para detectar cadenas semiduplicadas con [`bitHammingDistance`](/es/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Cuanto menor sea la [distancia de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre los `simhashes` calculados de dos cadenas, mayor será la probabilidad de que esas cadenas sean iguales.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el `simhash` sin distinción entre mayúsculas y minúsculas. [`String`](/es/reference/data-types/string)
* `ngramsize` — Opcional. El tamaño de un n-grama, cualquier valor entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

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

**Ejemplos**

**Ejemplo de uso**

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

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

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

Introducido en: v21.1.0

Divide una cadena UTF-8 en n-gramas de `ngramsize` símbolos y devuelve el `simhash` del n-grama.
No distingue entre mayúsculas y minúsculas.

Puede utilizarse para detectar cadenas semiduplicadas con [bitHammingDistance](/es/reference/functions/regular-functions/bit-functions#bitHammingDistance). Cuanto menor sea la [distancia de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre los `simhashes` calculados de dos cadenas, mayor será la probabilidad de que esas cadenas sean iguales.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `ngramsize` — Opcional. El tamaño de un n-grama; cualquier valor entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el valor hash calculado. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

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

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

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

Introducido en: v21.1.0

Divide una cadena codificada en UTF-8 en n-gramas de `ngramsize` símbolos y devuelve el `simhash` de cada n-grama.
Distingue entre mayúsculas y minúsculas.

Puede utilizarse para detectar cadenas semiduplicadas con [`bitHammingDistance`](/es/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Cuanto menor sea la [distancia de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre los `simhashes` calculados de dos cadenas, mayor será la probabilidad de que esas cadenas sean iguales.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `ngramsize` — Opcional. El tamaño de un n-grama, cualquier valor entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el valor hash calculado. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

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

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

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

Introducido en: v1.1.0

Como [`sipHash64`](#sipHash64), pero produce un valor hash de 128 bits; es decir, el estado final de xor-folding se calcula hasta 128 bits.

<Tip>
  **utilice sipHash128Reference en proyectos nuevos**

  Esta variante de 128 bits difiere de la implementación de referencia y es más débil.
  Esta versión existe porque, cuando se escribió, no había una extensión oficial de 128 bits para SipHash.
  En los proyectos nuevos, se recomienda usar [`sipHash128Reference`](#sipHash128Reference).
</Tip>

**Sintaxis**

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

**Argumentos**

* `arg1[, arg2, ...]` — Un número variable de argumentos de entrada sobre los que calcular el hash. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve un valor hash `SipHash` de 128 bits. [`FixedString(16)`](/es/reference/data-types/fixedstring)

**Ejemplos**

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

Introducido en: v23.2.0

Igual que [`sipHash128`](#sipHash128), pero además acepta un argumento de clave explícito en lugar de usar una clave fija.

<Tip>
  **use sipHash128ReferenceKeyed para proyectos nuevos**

  Esta variante de 128 bits difiere de la implementación de referencia y es más débil.
  Esta versión existe porque, cuando se escribió, no había una extensión oficial de 128 bits para SipHash.
  Los proyectos nuevos probablemente deberían usar [`sipHash128ReferenceKeyed`](#sipHash128ReferenceKeyed).
</Tip>

**Sintaxis**

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

**Argumentos**

* `(k0, k1)` — Una tupla de dos valores UInt64 que representa la clave. [`Tuple(UInt64, UInt64)`](/es/reference/data-types/tuple)
* `arg1[, arg2, ...]` — Un número variable de argumentos de entrada para los que se debe calcular el hash. [`Any`](/es/reference/data-types)

**Valor devuelto**

Un valor hash `SipHash` de 128 bits de tipo [FixedString(16)](/es/reference/data-types/fixedstring). [`FixedString(16)`](/es/reference/data-types/fixedstring)

**Ejemplos**

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

Introducido en: v23.2.0

Igual que [`sipHash128`](/es/reference/functions/regular-functions/hash-functions#sipHash128), pero implementa el algoritmo de 128 bits de los autores originales de SipHash.

**Sintaxis**

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

**Argumentos**

* `arg1[, arg2, ...]` — Un número variable de argumentos de entrada para los que se calculará el hash. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el valor de hash `SipHash` de 128 bits calculado a partir de los argumentos de entrada. [`FixedString(16)`](/es/reference/data-types/fixedstring)

**Ejemplos**

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

Introducido en: v23.2.0

Igual que [`sipHash128Reference`](#sipHash128Reference), pero además recibe un argumento de clave explícito en lugar de usar una clave fija.

**Sintaxis**

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

**Argumentos**

* `(k0, k1)` — Tupla de dos valores que representan la clave [`Tuple(UInt64, UInt64)`](/es/reference/data-types/tuple)
* `arg1[, arg2, ...]` — Un número variable de argumentos de entrada para los que se calcula el valor hash. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el valor hash `SipHash` de 128 bits calculado a partir de los argumentos de entrada. [`FixedString(16)`](/es/reference/data-types/fixedstring)

**Ejemplos**

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

Introducido en: v1.1.0

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

Esta es una función hash criptográfica. Funciona al menos tres veces más rápido que la función hash [`MD5`](#MD5).

La función [interpreta](/es/reference/functions/regular-functions/type-conversion-functions#reinterpretAsString) todos los parámetros de entrada como cadenas y calcula el valor hash de cada uno de ellos.
A continuación, combina los hashes mediante el siguiente algoritmo:

1. El primer y el segundo valor hash se concatenan en un array, del que se calcula el hash.
2. El valor hash calculado previamente y el hash del tercer parámetro de entrada se procesan del mismo modo.
3. Este cálculo se repite para todos los valores hash restantes de la entrada original.

<Note>
  los valores hash calculados pueden ser iguales para los mismos valores de entrada de distintos tipos de argumento.
  Esto afecta, por ejemplo, a los tipos enteros de distinto tamaño, `Tuple` con nombre y sin nombre con los mismos datos, `Map` y el tipo `Array(Tuple(key, value))` correspondiente con los mismos datos.
</Note>

**Sintaxis**

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

**Argumentos**

* `arg1[, arg2, ...]` — Un número variable de argumentos de entrada. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve un valor hash calculado a partir de los argumentos de entrada. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v23.2.0

Como [`sipHash64`](#sipHash64), pero además recibe un argumento explícito `key` en lugar de usar una clave fija.

**Sintaxis**

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

**Argumentos**

* `(k0, k1)` — Una tupla de dos valores que representa la clave. [`Tuple(UInt64, UInt64)`](/es/reference/data-types/tuple)
* `arg1[,arg2, ...]` — Un número variable de argumentos de entrada. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el hash calculado a partir de los valores de entrada. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena ASCII en partes (shingles) de `shinglesize` palabras, calcula los valores hash de cada secuencia de palabras y devuelve una tupla con esos hashes.
Usa `hashnum` hashes mínimos para calcular el hash mínimo y `hashnum` hashes máximos para calcular el hash máximo.
Distingue entre mayúsculas y minúsculas.

Puede usarse para detectar cadenas semiduplicadas con [`tupleHammingDistance`](/es/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para dos cadenas, si los hashes devueltos son iguales en ambas, entonces esas cadenas son iguales.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `shinglesize` — Opcional. El tamaño de una secuencia contigua de palabras; cualquier número entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `hashnum` — Opcional. El número de hashes mínimos y máximos utilizados para calcular el resultado; cualquier número entre `1` y `25`. El valor predeterminado es `6`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una tupla con dos hashes: el mínimo y el máximo. [`Tuple(UInt64, UInt64)`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducido en: v1.1.0

Divide una cadena ASCII en partes (shingles) de `shinglesize` palabras cada una y devuelve los shingles con el hash mínimo y máximo de palabras, calculados por la función wordShingleMinHash con la misma entrada.
Distingue entre mayúsculas y minúsculas.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `shinglesize` — Opcional. El tamaño de una secuencia de palabras; cualquier valor entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `hashnum` — Opcional. El número de hashes mínimos y máximos utilizados para calcular el resultado; cualquier valor entre `1` y `25`. El valor predeterminado es `6`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una tupla compuesta por dos tuplas, cada una con `hashnum` secuencias de palabras. [`Tuple(Tuple(String))`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena ASCII en partes (shingles) de `shinglesize` palabras cada una y devuelve las secuencias de palabras con los hashes mínimo y máximo de las palabras, calculados por la función [`wordShingleMinHashCaseInsensitive`](#wordShingleMinHashCaseInsensitive) con la misma entrada.
No distingue entre mayúsculas y minúsculas.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `shinglesize` — Opcional. El tamaño de una secuencia de palabras; cualquier valor entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `hashnum` — Opcional. El número de hashes mínimos y máximos utilizados para calcular el resultado; cualquier valor entre `1` y `25`. El valor predeterminado es `6`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una tupla compuesta por dos tuplas, cada una con `hashnum` secuencias de palabras. [`Tuple(Tuple(String))`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena UTF-8 en partes (shingles) de `shinglesize` palabras cada una y devuelve los shingles con el hash mínimo y máximo de palabras, calculados mediante la función [`wordShingleMinHashCaseInsensitiveUTF8`](#wordShingleMinHashCaseInsensitiveUTF8) a partir de la misma entrada.
No distingue entre mayúsculas y minúsculas.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `shinglesize` — Opcional. El tamaño de una secuencia de palabras contiguas; cualquier número de `1` a `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `hashnum` — Opcional. La cantidad de hashes mínimos y máximos que se usan para calcular el resultado; cualquier número de `1` a `25`. El valor predeterminado es `6`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una tupla con dos tuplas, cada una con `hashnum` secuencias de palabras contiguas. [`Tuple(Tuple(String))`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena UTF-8 en partes (shingles) de `shinglesize` palabras cada una y devuelve los shingles con el hash de palabra mínimo y máximo, calculados por la función [`wordShingleMinHashUTF8`](#wordShingleMinHashUTF8) con la misma entrada.
Distingue entre mayúsculas y minúsculas.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `shinglesize` — Opcional. El tamaño de la `secuencia de palabras`; cualquier valor entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `hashnum` — Opcional. La cantidad de hashes mínimos y máximos utilizados para calcular el resultado; cualquier valor entre `1` y `25`. El valor predeterminado es `6`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una tupla que contiene dos tuplas, cada una con `hashnum` `secuencias de palabras`. [`Tuple(Tuple(String))`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena ASCII en partes (shingles) de `shinglesize` palabras, calcula los valores hash de cada secuencia de palabras y devuelve una tupla con esos hashes.
Utiliza `hashnum` hashes mínimos para calcular el hash mínimo y `hashnum` hashes máximos para calcular el hash máximo.
No distingue entre mayúsculas y minúsculas.

Puede usarse para detectar cadenas semiduplicadas con [`tupleHammingDistance`](/es/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para dos cadenas, si los hashes devueltos son los mismos en ambas, entonces esas cadenas son iguales.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `shinglesize` — Opcional. El tamaño de una secuencia de palabras, cualquier valor entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `hashnum` — Opcional. El número de hashes mínimos y máximos que se usan para calcular el resultado, cualquier valor entre `1` y `25`. El valor predeterminado es `6`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una tupla con dos hashes: el mínimo y el máximo. [`Tuple(UInt64, UInt64)`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena UTF-8 en partes (shingles) de `shinglesize` palabras, calcula valores hash para cada secuencia de palabras y devuelve una tupla con esos hashes.
Usa `hashnum` hashes mínimos para calcular el hash mínimo y `hashnum` hashes máximos para calcular el hash máximo.
No distingue entre mayúsculas y minúsculas.

Se puede usar para detectar cadenas semiduplicado con [`tupleHammingDistance`](/es/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para dos cadenas, si los hashes devueltos son los mismos en ambas, entonces esas cadenas son iguales.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena sobre la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `shinglesize` — Opcional. El tamaño de una secuencia de palabras; puede ser cualquier número entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `hashnum` — Opcional. La cantidad de hashes mínimos y máximos utilizados para calcular el resultado; puede ser cualquier número entre `1` y `25`. El valor predeterminado es `6`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una tupla con dos hashes: el mínimo y el máximo. [`Tuple(UInt64, UInt64)`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena UTF-8 en partes (shingles) de `shinglesize` palabras, calcula valores hash para cada secuencia de palabras y devuelve una tupla con esos hashes.
Usa `hashnum` hashes mínimos para calcular el hash mínimo y `hashnum` hashes máximos para calcular el hash máximo.
Distingue entre mayúsculas y minúsculas.

Puede usarse para detectar cadenas semiduplicadas con [`tupleHammingDistance`](/es/reference/functions/regular-functions/tuple-functions#tupleHammingDistance).
Para dos cadenas, si los hashes devueltos son iguales en ambas, esas cadenas son iguales.

**Sintaxis**

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

**Argumentos**

* `string` — String sobre la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `shinglesize` — Opcional. El tamaño de una secuencia contigua de palabras; cualquier valor entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)
* `hashnum` — Opcional. La cantidad de hashes mínimos y máximos utilizados para calcular el resultado; cualquier valor entre `1` y `25`. El valor predeterminado es `6`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve una tupla con dos hashes: el mínimo y el máximo. [`Tuple(UInt64, UInt64)`](/es/reference/data-types/tuple)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena ASCII en fragmentos (shingles) de `shinglesize` palabras y devuelve el `simhash` de la secuencia de palabras.
Distingue entre mayúsculas y minúsculas.

Puede usarse para detectar cadenas semiduplicadas con [`bitHammingDistance`](/es/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Cuanto menor sea la [distancia de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre los `simhashes` calculados de dos cadenas, más probable será que esas cadenas sean iguales.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `shinglesize` — Opcional. El tamaño de una secuencia de palabras, cualquier valor entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el valor hash calculado. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena ASCII en partes (shingles) de `shinglesize` palabras y devuelve el `simhash` de la secuencia de palabras.
No distingue entre mayúsculas y minúsculas.

Puede usarse para detectar cadenas semiduplicadas con [`bitHammingDistance`](/es/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Cuanto menor sea la [distancia de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre los `simhashes` calculados de dos cadenas, mayor será la probabilidad de que sean iguales.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena para la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `shinglesize` — Opcional. El tamaño de una secuencia de palabras; puede ser cualquier número entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el hash calculado. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v1.1.0

Divide una cadena codificada en UTF-8 en partes (shingles) de `shinglesize` palabras y devuelve el `simhash` de la secuencia de palabras.
No distingue entre mayúsculas y minúsculas.

Puede usarse para detectar cadenas semiduplicadas con [`bitHammingDistance`](/es/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Cuanto menor sea la [distancia de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre los `simhashes` calculados de dos cadenas, más probable será que esas cadenas sean iguales.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena sobre la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `shinglesize` — Opcional. El tamaño de una secuencia de palabras; puede ser cualquier valor entre `1` y `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el valor hash calculado. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v21.1.0

Divide una cadena UTF-8 en partes (shingles) de `shinglesize` palabras y devuelve el `simhash` de la secuencia de palabras.
Distingue entre mayúsculas y minúsculas.

Puede usarse para detectar cadenas semiduplicadas con [`bitHammingDistance`](/es/reference/functions/regular-functions/bit-functions#bitHammingDistance).
Cuanto menor sea la [distancia de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre los `simhashes` calculados de dos cadenas, mayor será la probabilidad de que esas cadenas sean iguales.

**Sintaxis**

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

**Argumentos**

* `string` — Cadena sobre la que se calcula el hash. [`String`](/es/reference/data-types/string)
* `shinglesize` — Opcional. El tamaño de una secuencia contigua de palabras; cualquier valor de `1` a `25`. El valor predeterminado es `3`. [`UInt8`](/es/reference/data-types/int-uint)

**Valor devuelto**

Devuelve el valor hash calculado. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v22.7.0

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

**Sintaxis**

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

**Argumentos**

* `arg` — Argumento de tipo String para el que se va a calcular el hash. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el valor hash calculado de 64 bits [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

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

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

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

Introducido en: v20.1.0

Calcula un [xxHash](http://cyan4973.github.io/xxHash/) de una cadena.

Para ver la versión de 64 bits, consulte [`xxHash64`](#xxHash64)

**Sintaxis**

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

**Argumentos**

* `arg` — Cadena de entrada para calcular el hash. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el hash de 32 bits calculado a partir de la cadena de entrada. [`UInt32`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v20.1.0

Calcula un [xxHash](http://cyan4973.github.io/xxHash/) de una cadena.

Para la versión de 32 bits, consulte [`xxHash32`](#xxHash32)

**Sintaxis**

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

**Argumentos**

* `arg` — Cadena de entrada para calcular el hash. [`String`](/es/reference/data-types/string)

**Valor devuelto**

Devuelve el hash de 64 bits calculado a partir de la cadena de entrada. [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

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

Introducido en: v22.12.0

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

**Sintaxis**

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

**Argumentos**

* `expr` — Una lista de expresiones de cualquier tipo de dato. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el valor hash `xxh3` calculado de 64 bits [`UInt64`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

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

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

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

Introducido en: v26.2.0

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

**Sintaxis**

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

**Argumentos**

* `expr` — Una lista de expresiones de cualquier tipo de dato. [`Any`](/es/reference/data-types)

**Valor devuelto**

Devuelve el valor hash `xxh3` calculado de 128 bits [`UInt128`](/es/reference/data-types/int-uint)

**Ejemplos**

**Ejemplo de uso**

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

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