mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-11-19 22:22:00 +00:00
cd14f9ebcb
* split up select.md * array-join.md basic refactoring * distinct.md basic refactoring * format.md basic refactoring * from.md basic refactoring * group-by.md basic refactoring * having.md basic refactoring * additional index.md refactoring * into-outfile.md basic refactoring * join.md basic refactoring * limit.md basic refactoring * limit-by.md basic refactoring * order-by.md basic refactoring * prewhere.md basic refactoring * adjust operators/index.md links * adjust sample.md links * adjust more links * adjust operatots links * fix some links * adjust aggregate function article titles * basic refactor of remaining select clauses * absolute paths in make_links.sh * run make_links.sh * remove old select.md locations * translate docs/es * translate docs/fr * translate docs/fa * remove old operators.md location * change operators.md links * adjust links in docs/es * adjust links in docs/es * minor texts adjustments * wip * update machine translations to use new links * fix changelog * es build fixes * get rid of some select.md links * temporary adjust ru links * temporary adjust more ru links * improve curly brace handling * adjust ru as well * fa build fix * ru link fixes * zh link fixes * temporary disable part of anchor checks
485 lines
16 KiB
Markdown
485 lines
16 KiB
Markdown
---
|
||
machine_translated: true
|
||
machine_translated_rev: 72537a2d527c63c07aa5d2361a8829f3895cf2bd
|
||
toc_priority: 50
|
||
toc_title: Hash
|
||
---
|
||
|
||
# Funciones de Hash {#hash-functions}
|
||
|
||
Las funciones Hash se pueden usar para la barajada pseudoaleatoria determinista de elementos.
|
||
|
||
## HalfMD5 {#hash-functions-halfmd5}
|
||
|
||
[Interpretar](../../sql-reference/functions/type-conversion-functions.md#type_conversion_functions-reinterpretAsString) todos los parámetros de entrada como cadenas y calcula el [MD5](https://en.wikipedia.org/wiki/MD5) valor hash para cada uno de ellos. Luego combina hashes, toma los primeros 8 bytes del hash de la cadena resultante y los interpreta como `UInt64` en orden de bytes de big-endian.
|
||
|
||
``` sql
|
||
halfMD5(par1, ...)
|
||
```
|
||
|
||
La función es relativamente lenta (5 millones de cadenas cortas por segundo por núcleo del procesador).
|
||
Considere usar el [sipHash64](#hash_functions-siphash64) función en su lugar.
|
||
|
||
**Parámetros**
|
||
|
||
La función toma un número variable de parámetros de entrada. Los parámetros pueden ser cualquiera de los [tipos de datos compatibles](../../sql-reference/data-types/index.md).
|
||
|
||
**Valor devuelto**
|
||
|
||
A [UInt64](../../sql-reference/data-types/int-uint.md) tipo de datos valor hash.
|
||
|
||
**Ejemplo**
|
||
|
||
``` sql
|
||
SELECT halfMD5(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS halfMD5hash, toTypeName(halfMD5hash) AS type
|
||
```
|
||
|
||
``` text
|
||
┌────────halfMD5hash─┬─type───┐
|
||
│ 186182704141653334 │ UInt64 │
|
||
└────────────────────┴────────┘
|
||
```
|
||
|
||
## MD5 {#hash_functions-md5}
|
||
|
||
Calcula el MD5 de una cadena y devuelve el conjunto de bytes resultante como FixedString(16).
|
||
Si no necesita MD5 en particular, pero necesita un hash criptográfico decente de 128 bits, use el ‘sipHash128’ función en su lugar.
|
||
Si desea obtener el mismo resultado que la salida de la utilidad md5sum, use lower(hex(MD5(s)) .
|
||
|
||
## sipHash64 {#hash_functions-siphash64}
|
||
|
||
Produce un [SipHash](https://131002.net/siphash/) valor hash.
|
||
|
||
``` sql
|
||
sipHash64(par1,...)
|
||
```
|
||
|
||
Esta es una función hash criptográfica. Funciona al menos tres veces más rápido que el [MD5](#hash_functions-md5) función.
|
||
|
||
Función [interpretar](../../sql-reference/functions/type-conversion-functions.md#type_conversion_functions-reinterpretAsString) todos los parámetros de entrada como cadenas y calcula el valor hash para cada uno de ellos. Luego combina hashes por el siguiente algoritmo:
|
||
|
||
1. Después de hash todos los parámetros de entrada, la función obtiene la matriz de hashes.
|
||
2. La función toma el primero y el segundo elementos y calcula un hash para la matriz de ellos.
|
||
3. Luego, la función toma el valor hash, calculado en el paso anterior, y el tercer elemento de la matriz hash inicial, y calcula un hash para la matriz de ellos.
|
||
4. El paso anterior se repite para todos los elementos restantes de la matriz hash inicial.
|
||
|
||
**Parámetros**
|
||
|
||
La función toma un número variable de parámetros de entrada. Los parámetros pueden ser cualquiera de los [tipos de datos compatibles](../../sql-reference/data-types/index.md).
|
||
|
||
**Valor devuelto**
|
||
|
||
A [UInt64](../../sql-reference/data-types/int-uint.md) tipo de datos valor hash.
|
||
|
||
**Ejemplo**
|
||
|
||
``` sql
|
||
SELECT sipHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type
|
||
```
|
||
|
||
``` text
|
||
┌──────────────SipHash─┬─type───┐
|
||
│ 13726873534472839665 │ UInt64 │
|
||
└──────────────────────┴────────┘
|
||
```
|
||
|
||
## sipHash128 {#hash_functions-siphash128}
|
||
|
||
Calcula SipHash a partir de una cadena.
|
||
Acepta un argumento de tipo String. Devuelve FixedString(16).
|
||
Difiere de sipHash64 en que el estado final de plegado xor solo se realiza hasta 128 bits.
|
||
|
||
## cityHash64 {#cityhash64}
|
||
|
||
Produce un [Método de codificación de datos:](https://github.com/google/cityhash) valor hash.
|
||
|
||
``` sql
|
||
cityHash64(par1,...)
|
||
```
|
||
|
||
Esta es una función hash rápida no criptográfica. Utiliza el algoritmo CityHash para parámetros de cadena y la función hash no criptográfica rápida específica de la implementación para parámetros con otros tipos de datos. La función utiliza el combinador CityHash para obtener los resultados finales.
|
||
|
||
**Parámetros**
|
||
|
||
La función toma un número variable de parámetros de entrada. Los parámetros pueden ser cualquiera de los [tipos de datos compatibles](../../sql-reference/data-types/index.md).
|
||
|
||
**Valor devuelto**
|
||
|
||
A [UInt64](../../sql-reference/data-types/int-uint.md) tipo de datos valor hash.
|
||
|
||
**Ejemplos**
|
||
|
||
Ejemplo de llamada:
|
||
|
||
``` sql
|
||
SELECT cityHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS CityHash, toTypeName(CityHash) AS type
|
||
```
|
||
|
||
``` text
|
||
┌─────────────CityHash─┬─type───┐
|
||
│ 12072650598913549138 │ UInt64 │
|
||
└──────────────────────┴────────┘
|
||
```
|
||
|
||
En el ejemplo siguiente se muestra cómo calcular la suma de comprobación de toda la tabla con precisión hasta el orden de fila:
|
||
|
||
``` sql
|
||
SELECT groupBitXor(cityHash64(*)) FROM table
|
||
```
|
||
|
||
## intHash32 {#inthash32}
|
||
|
||
Calcula un código hash de 32 bits a partir de cualquier tipo de entero.
|
||
Esta es una función hash no criptográfica relativamente rápida de calidad media para los números.
|
||
|
||
## intHash64 {#inthash64}
|
||
|
||
Calcula un código hash de 64 bits a partir de cualquier tipo de entero.
|
||
Funciona más rápido que intHash32. Calidad media.
|
||
|
||
## SHA1 {#sha1}
|
||
|
||
## SHA224 {#sha224}
|
||
|
||
## SHA256 {#sha256}
|
||
|
||
Calcula SHA-1, SHA-224 o SHA-256 de una cadena y devuelve el conjunto de bytes resultante como FixedString(20), FixedString(28) o FixedString(32).
|
||
La función funciona bastante lentamente (SHA-1 procesa alrededor de 5 millones de cadenas cortas por segundo por núcleo del procesador, mientras que SHA-224 y SHA-256 procesan alrededor de 2.2 millones).
|
||
Recomendamos usar esta función solo en los casos en que necesite una función hash específica y no pueda seleccionarla.
|
||
Incluso en estos casos, recomendamos aplicar la función offline y precalcular valores al insertarlos en la tabla, en lugar de aplicarlo en SELECTS.
|
||
|
||
## Nombre de la red inalámbrica (SSID):\]) {#urlhashurl-n}
|
||
|
||
Una función hash no criptográfica rápida y de calidad decente para una cadena obtenida de una URL utilizando algún tipo de normalización.
|
||
`URLHash(s)` – Calculates a hash from a string without one of the trailing symbols `/`,`?` o `#` al final, si está presente.
|
||
`URLHash(s, N)` – Calculates a hash from a string up to the N level in the URL hierarchy, without one of the trailing symbols `/`,`?` o `#` al final, si está presente.
|
||
Los niveles son los mismos que en URLHierarchy. Esta función es específica de Yandex.Métrica.
|
||
|
||
## Método de codificación de datos: {#farmhash64}
|
||
|
||
Produce un [Método de codificación de datos:](https://github.com/google/farmhash) valor hash.
|
||
|
||
``` sql
|
||
farmHash64(par1, ...)
|
||
```
|
||
|
||
La función utiliza el `Hash64` de todos [métodos disponibles](https://github.com/google/farmhash/blob/master/src/farmhash.h).
|
||
|
||
**Parámetros**
|
||
|
||
La función toma un número variable de parámetros de entrada. Los parámetros pueden ser cualquiera de los [tipos de datos compatibles](../../sql-reference/data-types/index.md).
|
||
|
||
**Valor devuelto**
|
||
|
||
A [UInt64](../../sql-reference/data-types/int-uint.md) tipo de datos valor hash.
|
||
|
||
**Ejemplo**
|
||
|
||
``` sql
|
||
SELECT farmHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmHash, toTypeName(FarmHash) AS type
|
||
```
|
||
|
||
``` text
|
||
┌─────────────FarmHash─┬─type───┐
|
||
│ 17790458267262532859 │ UInt64 │
|
||
└──────────────────────┴────────┘
|
||
```
|
||
|
||
## Nombre de la red inalámbrica (SSID): {#hash_functions-javahash}
|
||
|
||
Calcular [Nivel de Cifrado WEP](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/String.java#l1452) de una cuerda. Esta función hash no es rápida ni tiene una buena calidad. La única razón para usarlo es cuando este algoritmo ya se usa en otro sistema y debe calcular exactamente el mismo resultado.
|
||
|
||
**Sintaxis**
|
||
|
||
``` sql
|
||
SELECT javaHash('');
|
||
```
|
||
|
||
**Valor devuelto**
|
||
|
||
A `Int32` tipo de datos valor hash.
|
||
|
||
**Ejemplo**
|
||
|
||
Consulta:
|
||
|
||
``` sql
|
||
SELECT javaHash('Hello, world!');
|
||
```
|
||
|
||
Resultado:
|
||
|
||
``` text
|
||
┌─javaHash('Hello, world!')─┐
|
||
│ -1880044555 │
|
||
└───────────────────────────┘
|
||
```
|
||
|
||
## javaHashUTF16LE {#javahashutf16le}
|
||
|
||
Calcular [Nivel de Cifrado WEP](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/String.java#l1452) de una cadena, suponiendo que contiene bytes que representan una cadena en codificación UTF-16LE.
|
||
|
||
**Sintaxis**
|
||
|
||
``` sql
|
||
javaHashUTF16LE(stringUtf16le)
|
||
```
|
||
|
||
**Parámetros**
|
||
|
||
- `stringUtf16le` — a string in UTF-16LE encoding.
|
||
|
||
**Valor devuelto**
|
||
|
||
A `Int32` tipo de datos valor hash.
|
||
|
||
**Ejemplo**
|
||
|
||
Consulta correcta con cadena codificada UTF-16LE.
|
||
|
||
Consulta:
|
||
|
||
``` sql
|
||
SELECT javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'))
|
||
```
|
||
|
||
Resultado:
|
||
|
||
``` text
|
||
┌─javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'))─┐
|
||
│ 3556498 │
|
||
└──────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
## HiveHash {#hash-functions-hivehash}
|
||
|
||
Calcular `HiveHash` de una cuerda.
|
||
|
||
``` sql
|
||
SELECT hiveHash('');
|
||
```
|
||
|
||
Esto es sólo [Nivel de Cifrado WEP](#hash_functions-javahash) con poco de signo puesto a cero. Esta función se utiliza en [Colmena de Apache](https://en.wikipedia.org/wiki/Apache_Hive) para versiones anteriores a la 3.0. Esta función hash no es rápida ni tiene una buena calidad. La única razón para usarlo es cuando este algoritmo ya se usa en otro sistema y debe calcular exactamente el mismo resultado.
|
||
|
||
**Valor devuelto**
|
||
|
||
A `Int32` tipo de datos valor hash.
|
||
|
||
Tipo: `hiveHash`.
|
||
|
||
**Ejemplo**
|
||
|
||
Consulta:
|
||
|
||
``` sql
|
||
SELECT hiveHash('Hello, world!');
|
||
```
|
||
|
||
Resultado:
|
||
|
||
``` text
|
||
┌─hiveHash('Hello, world!')─┐
|
||
│ 267439093 │
|
||
└───────────────────────────┘
|
||
```
|
||
|
||
## Método de codificación de datos: {#metrohash64}
|
||
|
||
Produce un [Método de codificación de datos:](http://www.jandrewrogers.com/2015/05/27/metrohash/) valor hash.
|
||
|
||
``` sql
|
||
metroHash64(par1, ...)
|
||
```
|
||
|
||
**Parámetros**
|
||
|
||
La función toma un número variable de parámetros de entrada. Los parámetros pueden ser cualquiera de los [tipos de datos compatibles](../../sql-reference/data-types/index.md).
|
||
|
||
**Valor devuelto**
|
||
|
||
A [UInt64](../../sql-reference/data-types/int-uint.md) tipo de datos valor hash.
|
||
|
||
**Ejemplo**
|
||
|
||
``` sql
|
||
SELECT metroHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MetroHash, toTypeName(MetroHash) AS type
|
||
```
|
||
|
||
``` text
|
||
┌────────────MetroHash─┬─type───┐
|
||
│ 14235658766382344533 │ UInt64 │
|
||
└──────────────────────┴────────┘
|
||
```
|
||
|
||
## SaltarConsistentHash {#jumpconsistenthash}
|
||
|
||
Calcula JumpConsistentHash forma un UInt64.
|
||
Acepta dos argumentos: una clave de tipo UInt64 y el número de cubos. Devuelve Int32.
|
||
Para obtener más información, consulte el enlace: [SaltarConsistentHash](https://arxiv.org/pdf/1406.2294.pdf)
|
||
|
||
## murmurHash2\_32, murmurHash2\_64 {#murmurhash2-32-murmurhash2-64}
|
||
|
||
Produce un [Método de codificación de datos:](https://github.com/aappleby/smhasher) valor hash.
|
||
|
||
``` sql
|
||
murmurHash2_32(par1, ...)
|
||
murmurHash2_64(par1, ...)
|
||
```
|
||
|
||
**Parámetros**
|
||
|
||
Ambas funciones toman un número variable de parámetros de entrada. Los parámetros pueden ser cualquiera de los [tipos de datos compatibles](../../sql-reference/data-types/index.md).
|
||
|
||
**Valor devuelto**
|
||
|
||
- El `murmurHash2_32` función devuelve el valor hash que tiene el [UInt32](../../sql-reference/data-types/int-uint.md) tipo de datos.
|
||
- El `murmurHash2_64` función devuelve el valor hash que tiene el [UInt64](../../sql-reference/data-types/int-uint.md) tipo de datos.
|
||
|
||
**Ejemplo**
|
||
|
||
``` sql
|
||
SELECT murmurHash2_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type
|
||
```
|
||
|
||
``` text
|
||
┌──────────MurmurHash2─┬─type───┐
|
||
│ 11832096901709403633 │ UInt64 │
|
||
└──────────────────────┴────────┘
|
||
```
|
||
|
||
## GccMurmurHash {#gccmurmurhash}
|
||
|
||
Calcula un valor de 64 bits [Método de codificación de datos:](https://github.com/aappleby/smhasher) valor hash usando la misma semilla de hash que [Gcc](https://github.com/gcc-mirror/gcc/blob/41d6b10e96a1de98e90a7c0378437c3255814b16/libstdc%2B%2B-v3/include/bits/functional_hash.h#L191). Es portátil entre las compilaciones CLang y GCC.
|
||
|
||
**Sintaxis**
|
||
|
||
``` sql
|
||
gccMurmurHash(par1, ...);
|
||
```
|
||
|
||
**Parámetros**
|
||
|
||
- `par1, ...` — A variable number of parameters that can be any of the [tipos de datos compatibles](../../sql-reference/data-types/index.md#data_types).
|
||
|
||
**Valor devuelto**
|
||
|
||
- Valor hash calculado.
|
||
|
||
Tipo: [UInt64](../../sql-reference/data-types/int-uint.md).
|
||
|
||
**Ejemplo**
|
||
|
||
Consulta:
|
||
|
||
``` sql
|
||
SELECT
|
||
gccMurmurHash(1, 2, 3) AS res1,
|
||
gccMurmurHash(('a', [1, 2, 3], 4, (4, ['foo', 'bar'], 1, (1, 2)))) AS res2
|
||
```
|
||
|
||
Resultado:
|
||
|
||
``` text
|
||
┌─────────────────res1─┬────────────────res2─┐
|
||
│ 12384823029245979431 │ 1188926775431157506 │
|
||
└──────────────────────┴─────────────────────┘
|
||
```
|
||
|
||
## murmurHash3\_32, murmurHash3\_64 {#murmurhash3-32-murmurhash3-64}
|
||
|
||
Produce un [Método de codificación de datos:](https://github.com/aappleby/smhasher) valor hash.
|
||
|
||
``` sql
|
||
murmurHash3_32(par1, ...)
|
||
murmurHash3_64(par1, ...)
|
||
```
|
||
|
||
**Parámetros**
|
||
|
||
Ambas funciones toman un número variable de parámetros de entrada. Los parámetros pueden ser cualquiera de los [tipos de datos compatibles](../../sql-reference/data-types/index.md).
|
||
|
||
**Valor devuelto**
|
||
|
||
- El `murmurHash3_32` función devuelve un [UInt32](../../sql-reference/data-types/int-uint.md) tipo de datos valor hash.
|
||
- El `murmurHash3_64` función devuelve un [UInt64](../../sql-reference/data-types/int-uint.md) tipo de datos valor hash.
|
||
|
||
**Ejemplo**
|
||
|
||
``` sql
|
||
SELECT murmurHash3_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type
|
||
```
|
||
|
||
``` text
|
||
┌─MurmurHash3─┬─type───┐
|
||
│ 2152717 │ UInt32 │
|
||
└─────────────┴────────┘
|
||
```
|
||
|
||
## murmurHash3\_128 {#murmurhash3-128}
|
||
|
||
Produce un [Método de codificación de datos:](https://github.com/aappleby/smhasher) valor hash.
|
||
|
||
``` sql
|
||
murmurHash3_128( expr )
|
||
```
|
||
|
||
**Parámetros**
|
||
|
||
- `expr` — [Expresiones](../syntax.md#syntax-expressions) devolviendo un [Cadena](../../sql-reference/data-types/string.md)-tipo de valor.
|
||
|
||
**Valor devuelto**
|
||
|
||
A [Cadena fija (16)](../../sql-reference/data-types/fixedstring.md) tipo de datos valor hash.
|
||
|
||
**Ejemplo**
|
||
|
||
``` sql
|
||
SELECT murmurHash3_128('example_string') AS MurmurHash3, toTypeName(MurmurHash3) AS type
|
||
```
|
||
|
||
``` text
|
||
┌─MurmurHash3──────┬─type────────────┐
|
||
│ 6<>1 <1C>4"S5KT<4B>~~q │ FixedString(16) │
|
||
└──────────────────┴─────────────────┘
|
||
```
|
||
|
||
## xxHash32, xxHash64 {#hash-functions-xxhash32}
|
||
|
||
Calcular `xxHash` de una cuerda. Se propone en dos sabores, 32 y 64 bits.
|
||
|
||
``` sql
|
||
SELECT xxHash32('');
|
||
|
||
OR
|
||
|
||
SELECT xxHash64('');
|
||
```
|
||
|
||
**Valor devuelto**
|
||
|
||
A `Uint32` o `Uint64` tipo de datos valor hash.
|
||
|
||
Tipo: `xxHash`.
|
||
|
||
**Ejemplo**
|
||
|
||
Consulta:
|
||
|
||
``` sql
|
||
SELECT xxHash32('Hello, world!');
|
||
```
|
||
|
||
Resultado:
|
||
|
||
``` text
|
||
┌─xxHash32('Hello, world!')─┐
|
||
│ 834093149 │
|
||
└───────────────────────────┘
|
||
```
|
||
|
||
**Ver también**
|
||
|
||
- [xxHash](http://cyan4973.github.io/xxHash/).
|
||
|
||
[Artículo Original](https://clickhouse.tech/docs/en/query_language/functions/hash_functions/) <!--hide-->
|