Funciones hash - ClickHouse Documentation

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.

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

SELECT cityHash64(tuple(NULL))

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.

BLAKE3

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

BLAKE3(message)

Argumentos

message — La cadena de entrada para calcular el hash. String

Valor devuelto Devuelve el hash BLAKE3 de 32 bytes de la cadena de entrada como una cadena de longitud fija. FixedString(32) Ejemplos hash

Query

SELECT hex(BLAKE3('ABC'))

Response

┌─hex(BLAKE3('ABC'))───────────────────────────────────────────────┐
│ D1717274597CF0289694F75D96D444B992A096F1AFD8E7BBFA6EBB1D360FEDFC │
└──────────────────────────────────────────────────────────────────┘

MD4

Introducido en: v21.11.0 Calcula el hash MD4 de la cadena especificada. Sintaxis

MD4(s)

Argumentos

s — La cadena de entrada para calcular el hash. String

Valor devuelto Devuelve el hash MD4 de la cadena de entrada proporcionada como una cadena de longitud fija. FixedString(16) Ejemplos Ejemplo de uso

Query

SELECT HEX(MD4('abc'));

Response

┌─HEX(MD4('abc'))──────────────────┐
│ A448017AAF21D8525FC10AE87AA6729D │
└──────────────────────────────────┘

MD5

Introducido en: v1.1.0 Calcula el hash MD5 de la cadena dada. Sintaxis

MD5(s)

Argumentos

s — La cadena de entrada para calcular el hash. String

Valor devuelto Devuelve el hash MD5 de la cadena de entrada proporcionada como una cadena de longitud fija. FixedString(16) Ejemplos Ejemplo de uso

Query

SELECT HEX(MD5('abc'));

Response

┌─HEX(MD5('abc'))──────────────────┐
│ 900150983CD24FB0D6963F7D28E17F72 │
└──────────────────────────────────┘

RIPEMD160

Introducido en: v24.10.0 Calcula el hash RIPEMD-160 de la cadena dada. Sintaxis

RIPEMD160(s)

Argumentos

s — La cadena de entrada para calcular el hash. String

Valor devuelto Devuelve el hash RIPEMD160 de la cadena de entrada proporcionada como una cadena de longitud fija. FixedString(20) Ejemplos Ejemplo de uso

Query

SELECT HEX(RIPEMD160('The quick brown fox jumps over the lazy dog'));

Response

┌─HEX(RIPEMD160('The quick brown fox jumps over the lazy dog'))─┐
│ 37F332F68DB77BD9D7EDD4969571AD671CF9DD3B                      │
└───────────────────────────────────────────────────────────────┘

SHA1

Introducido en: v1.1.0 Calcula el hash SHA1 de la cadena especificada. Sintaxis

SHA1(s)

Argumentos

s — La cadena de entrada para calcular el hash String

Valor devuelto Devuelve el hash SHA1 de la cadena de entrada dada como una cadena de longitud fija. FixedString(20) Ejemplos Ejemplo de uso

Query

SELECT HEX(SHA1('abc'));

Response

┌─HEX(SHA1('abc'))─────────────────────────┐
│ A9993E364706816ABA3E25717850C26C9CD0D89D │
└──────────────────────────────────────────┘

SHA224

Introducido en: v1.1.0 Calcula el hash SHA224 de la cadena proporcionada. Sintaxis

SHA224(s)

Argumentos

s — El valor de entrada para calcular el hash. String

Valor devuelto Devuelve el hash SHA224 de la cadena de entrada especificada como una cadena de longitud fija. FixedString(28) Ejemplos Ejemplo de uso

Query

SELECT HEX(SHA224('abc'));

Response

┌─HEX(SHA224('abc'))───────────────────────────────────────┐
│ 23097D223405D8228642A477BDA255B32AADBCE4BDA0B3F7E36C9DA7 │
└──────────────────────────────────────────────────────────┘

SHA256

Introducido en: v1.1.0 Calcula el hash SHA256 de la cadena proporcionada. Sintaxis

SHA256(s)

Argumentos

s — La cadena de entrada para calcular el hash. String

Valor devuelto Devuelve el hash SHA256 de la cadena de entrada dada como una cadena de longitud fija. FixedString(32) Ejemplos Ejemplo de uso

Query

SELECT HEX(SHA256('abc'));

Response

┌─HEX(SHA256('abc'))───────────────────────────────────────────────┐
│ BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A9CB410FF61F20015AD │
└──────────────────────────────────────────────────────────────────┘

SHA384

Introducido en: v1.1.0 Calcula el hash SHA384 de la cadena proporcionada. Sintaxis

SHA384(s)

Argumentos

s — La cadena de entrada para calcular el hash. String

Valor devuelto Devuelve el hash SHA384 de la cadena de entrada proporcionada como una cadena de longitud fija. FixedString(48) Ejemplos Ejemplo de uso

Query

SELECT HEX(SHA384('abc'));

Response

┌─HEX(SHA384('abc'))───────────────────────────────────────────────────────────────────────────────┐
│ CB00753F45A35E8BB5A03D699AC65007272C32AB0EDED1631A8B605A43FF5BED8086072BA1E7CC2358BAECA134C825A7 │
└──────────────────────────────────────────────────────────────────────────────────────────────────┘

SHA512

Introducido en: v1.1.0 Calcula el hash SHA512 de la cadena proporcionada. Sintaxis

SHA512(s)

Argumentos

s — La cadena de entrada para calcular el hash String

Valor devuelto Devuelve el hash SHA512 de la cadena de entrada proporcionada como una cadena de longitud fija. FixedString(64) Ejemplos Ejemplo de uso

Query

SELECT HEX(SHA512('abc'));

Response

┌─HEX(SHA512('abc'))───────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ DDAF35A193617ABACC417349AE20413112E6FA4E89A97EA20A9EEEE64B55D39A2192992A274FC1A836BA3C23A3FEEBBD454D4423643CE80E2A9AC94FA54CA49F │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

SHA512_256

Introducido en: v1.1.0 Calcula el hash SHA512_256 de la cadena especificada. Sintaxis

SHA512_256(s)

Argumentos

s — La cadena de entrada para calcular el hash. String

Valor devuelto Devuelve el hash SHA512_256 de la cadena de entrada dada como una cadena de longitud fija. FixedString(32) Ejemplos Ejemplo de uso

Query

SELECT HEX(SHA512_256('abc'));

Response

┌─HEX(SHA512_256('abc'))───────────────────────────────────────────┐
│ 53048E2681941EF99B2E29B76B4C7DABE4C2D0C634FC6D46E0E2F13107E7AF23 │
└──────────────────────────────────────────────────────────────────┘

URLHash

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

URLHash(url[, N])

Argumentos

url — Cadena de URL cuyo hash se calcula. String
N — Opcional. Nivel en la jerarquía de la URL. (U)Int*

Valor devuelto Devuelve el valor hash calculado de url. UInt64 Ejemplos Ejemplo de uso

Query

SELECT URLHash('https://www.clickhouse.com')

Response

┌─URLHash('https://www.clickhouse.com')─┐
│                  13614512636072854701 │
└───────────────────────────────────────┘

Hash de la URL con el nivel especificado

Query

SELECT URLHash('https://www.clickhouse.com/docs', 0);
SELECT URLHash('https://www.clickhouse.com/docs', 1);

Response

13614512636072854701
13167253331440520598

cityHash64

Introducido en: v1.1.0 Produce un valor hash de 64 bits de 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.

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.

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.

Sintaxis

cityHash64(arg1[, arg2, ...])

Argumentos

arg1[, arg2, ...] — Un número variable de argumentos de entrada sobre los que se calcula el hash. Any

Valor devuelto Devuelve el hash calculado a partir de los argumentos de entrada. UInt64 Ejemplos Ejemplo de llamada

Query

SELECT cityHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS CityHash, toTypeName(CityHash) AS type;

Response

┌─────────────CityHash─┬─type───┐
│ 17177535963988450974 │ UInt64 │
└──────────────────────┴────────┘

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

Query

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

┌─groupBitXor(cityHash64(id, name, age, city))─┐
│                         11639977218258521182 │
└──────────────────────────────────────────────┘

farmFingerprint64

Introducido en: v20.12.0 Produce un valor FarmHash de 64 bits usando el método Fingerprint64.

Se prefiere farmFingerprint64 porque ofrece un valor estable y portable frente a farmHash64.

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.

Sintaxis

farmFingerprint64(arg1[, arg2, ...])

Argumentos

arg1[, arg2, ...] — Un número variable de argumentos de entrada para los que se debe calcular el hash. Any

Valor devuelto Devuelve el valor hash calculado a partir de los argumentos de entrada. UInt64 Ejemplos Ejemplo de uso

Query

SELECT farmFingerprint64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmFingerprint, toTypeName(FarmFingerprint) AS type;

Response

┌──────FarmFingerprint─┬─type───┐
│ 16673609057812504858 │ UInt64 │
└──────────────────────┴────────┘

farmHash64

Introducido en: v1.1.0 Genera un FarmHash de 64 bits con el método Hash64.

Se prefiere farmFingerprint64 para obtener un valor estable y portable.

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.

Sintaxis

farmHash64(arg1[, arg2, ...])

Argumentos

arg1[, arg2, ...] — Un número variable de argumentos de entrada para los que se debe calcular el hash. Any

Valor devuelto Devuelve el valor hash calculado a partir de los argumentos de entrada. UInt64 Ejemplos Ejemplo de uso

Query

SELECT farmHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmHash, toTypeName(FarmHash) AS type;

Response

┌────────────FarmHash─┬─type───┐
│ 2663412879246289891 │ UInt64 │
└─────────────────────┴────────┘

gccMurmurHash

Introducido en: v20.1.0 Calcula el hash de 64 bits MurmurHash2 del valor de entrada usando la misma semilla que utiliza GCC. Es portable entre las compilaciones de Clang y GCC. Sintaxis

gccMurmurHash(arg1[, arg2, ...])

Argumentos

arg1[, arg2, ...] — Un número variable de argumentos sobre los que calcular el hash. Any

Valor devuelto Devuelve el valor hash calculado a partir de los argumentos de entrada. UInt64 Ejemplos Ejemplo de uso

Query

SELECT
    gccMurmurHash(1, 2, 3) AS res1,
    gccMurmurHash(('a', [1, 2, 3], 4, (4, ['foo', 'bar'], 1, (1, 2)))) AS res2

Response

┌─────────────────res1─┬────────────────res2─┐
│ 12384823029245979431 │ 1188926775431157506 │
└──────────────────────┴─────────────────────┘

halfMD5

Introducido en: v1.1.0 Interpreta 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 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. 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

halfMD5(arg1[, arg2, ..., argN])

Argumentos

arg1[, arg2, ..., argN] — Número variable de argumentos para los que se calcula el hash. Any

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 Ejemplos Ejemplo de uso

Query

SELECT HEX(halfMD5('abc', 'cde', 'fgh'));

Response

┌─HEX(halfMD5('abc', 'cde', 'fgh'))─┐
│ 2C9506B7374CFAF4                  │
└───────────────────────────────────┘

hiveHash

Introducido en: v20.1.0 Calcula un “HiveHash” a partir de una cadena. No es más que JavaHash con los bits de signo puestos a cero. Esta función se utiliza en Apache Hive en versiones anteriores a la 3.0.

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.

Sintaxis

hiveHash(arg)

Argumentos

arg — Cadena de entrada para calcular el hash. String

Valor devuelto Devuelve el “hive hash” calculado de la cadena de entrada. Int32 Ejemplos Ejemplo de uso

Query

SELECT hiveHash('Hello, world!');

Response

┌─hiveHash('Hello, world!')─┐
│                 267439093 │
└───────────────────────────┘

icebergHash

Introducido en: v25.5.0 Implementa la lógica de la transformación hash de Iceberg Sintaxis

icebergHash(value)

Argumentos

value — Valor de entrada del que se calculará el hash de Integer o Bool o Decimal o Float* o String o FixedString o UUID o Date o Time o DateTime

Valor devuelto Devuelve un hash Murmur3 de 32 bits, variante x86, con semilla 0 Int32 Ejemplos Ejemplo

Query

SELECT icebergHash(1.0 :: Float32)

Response

-142385009

intHash32

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

intHash32(arg)

Argumentos

arg — Entero al que se aplica la función hash. (U)Int*

Valor devuelto Devuelve el código hash de 32 bits calculado a partir del entero de entrada UInt32 Ejemplos Ejemplo de uso

Query

SELECT intHash32(42);

Response

┌─intHash32(42)─┐
│    1228623923 │
└───────────────┘

intHash64

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), pero no es una función hash criptográfica. Sintaxis

intHash64(int)

Argumentos

int — Entero del que se calcula el hash. (U)Int*

Valor devuelto Código hash de 64 bits. UInt64 Ejemplos Ejemplo de uso

Query

SELECT intHash64(42);

Response

┌────────intHash64(42)─┐
│ 11490350930367293593 │
└──────────────────────┘

javaHash

Introducido en: v20.1.0 Calcula JavaHash a partir de:

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.

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.

Sintaxis

javaHash(arg)

Argumentos

arg — Valor de entrada para calcular el hash. Any

Valor devuelto Devuelve el hash calculado de arg Int32 Ejemplos Ejemplo de uso 1

Query

SELECT javaHash(toInt32(123));

Response

┌─javaHash(toInt32(123))─┐
│                    123 │
└────────────────────────┘

Ejemplo de uso 2

Query

SELECT javaHash('Hello, world!');

Response

┌─javaHash('Hello, world!')─┐
│               -1880044555 │
└───────────────────────────┘

javaHashUTF16LE

Introducido en: v20.1.0 Calcula JavaHash de una cadena, asumiendo que contiene bytes que representan una cadena codificada en UTF-16LE. Sintaxis

javaHashUTF16LE(arg)

Argumentos

arg — Una cadena con codificación UTF-16LE. String

Valor devuelto Devuelve el hash calculado de la cadena codificada en UTF-16LE. Int32 Ejemplos Ejemplo de uso

Query

SELECT javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'));

Response

┌─javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'))─┐
│                                                      3556498 │
└──────────────────────────────────────────────────────────────┘

jumpConsistentHash

Introducido en: v1.1.0 Calcula el jump hash consistente de un entero. Sintaxis

jumpConsistentHash(key, buckets)

Argumentos

key — La clave de entrada. UInt64
buckets — El número de buckets. Int32

Valor devuelto Devuelve el valor hash calculado. Int32 Ejemplos Ejemplo de uso

Query

SELECT jumpConsistentHash(256, 4)

Response

┌─jumpConsistentHash(256, 4)─┐
│                          3 │
└────────────────────────────┘

kafkaMurmurHash

Introducido en: v23.4.0 Calcula el hash MurmurHash2 de 32 bits del valor de entrada usando la misma semilla que Kafka y sin el bit más significativo, para ser compatible con Default Partitioner. Sintaxis

kafkaMurmurHash(arg1[, arg2, ...])

Argumentos

arg1[, arg2, ...] — Una cantidad variable de parámetros cuyo hash se calcula. Any

Valor devuelto Devuelve el valor hash calculado de los argumentos de entrada. UInt32 Ejemplos Ejemplo de uso

Query

SELECT
    kafkaMurmurHash('foobar') AS res1,
    kafkaMurmurHash(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS res2

Response

┌───────res1─┬─────res2─┐
│ 1357151166 │ 85479775 │
└────────────┴──────────┘

keccak256

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

keccak256(message)

Argumentos

message — La cadena de entrada para calcular el hash. String

Valor devuelto Devuelve el hash Keccak-256 de 32 bytes de la cadena de entrada como una cadena de longitud fija. FixedString(32) Ejemplos Ejemplo de uso

Query

SELECT hex(keccak256('hello'))

Response

┌─hex(keccak256('hello'))──────────────────────────────────────────┐
│ 1C8AFF950685C2ED4BC3174F3472287B56D9517B9C948127319A09A7A36DEAC8 │
└──────────────────────────────────────────────────────────────────┘

kostikConsistentHash

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

kostikConsistentHash(input, n)

Aliases: yandexConsistentHash Argumentos

input — Una clave de tipo entero. UInt64
n — El número de buckets. UInt16

Valor devuelto Devuelve el valor hash calculado. UInt16 Ejemplos Ejemplo de uso

Query

SELECT kostikConsistentHash(16045690984833335023, 2);

Response

┌─kostikConsistentHash(16045690984833335023, 2)─┐
│                                             1 │
└───────────────────────────────────────────────┘

metroHash64

Introducido en: v1.1.0 Genera un valor hash de 64 bits de MetroHash.

Sintaxis

metroHash64(arg1[, arg2, ...])

Argumentos

arg1[, arg2, ...] — Un número variable de argumentos de entrada para calcular el hash. Any

Valor devuelto Devuelve el hash calculado a partir de los argumentos de entrada. UInt64 Ejemplos Ejemplo de uso

Query

SELECT metroHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MetroHash, toTypeName(MetroHash) AS type;

Response

┌────────────MetroHash─┬─type───┐
│ 16292826582821303855 │ UInt64 │
└──────────────────────┴────────┘

murmurHash2_32

Introducido en: v18.5.0 Calcula el hash MurmurHash2 del valor de entrada.

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.

Sintaxis

murmurHash2_32(arg1[, arg2, ...])

Argumentos

arg1[, arg2, ...] — Una cantidad variable de argumentos de entrada para los que se calcula el hash. Any

Valor devuelto Devuelve el valor hash calculado a partir de los argumentos de entrada. UInt32 Ejemplos Ejemplo de uso

Query

SELECT murmurHash2_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type;

Response

┌─MurmurHash2─┬─type───┐
│  2947095100 │ UInt32 │
└─────────────┴────────┘

murmurHash2_64

Introducido en: v18.10.0 Calcula el hash MurmurHash2 del valor de entrada.

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.

Sintaxis

murmurHash2_64(arg1[, arg2, ...])

Argumentos

arg1[, arg2, ...] — Un número variable de argumentos de entrada para los que se calcula el hash. Any

Valor devuelto Devuelve el hash calculado a partir de los argumentos de entrada. UInt64 Ejemplos Ejemplo de uso

Query

SELECT murmurHash2_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type;

Response

┌──────────MurmurHash2─┬─type───┐
│ 16479669305841206229 │ UInt64 │
└──────────────────────┴────────┘

murmurHash3_128

Introducido en: v18.10.0 Calcula el hash de 128 bits MurmurHash3 del valor de entrada. Sintaxis

murmurHash3_128(arg1[, arg2, ...])

Argumentos

arg1[, arg2, ...] — Un número variable de argumentos de entrada para los que se calcula el hash. Any

Valor devuelto Devuelve el valor hash MurmurHash3 de 128 bits calculado a partir de los argumentos de entrada. FixedString(16) Ejemplos Ejemplo de uso

Query

SELECT hex(murmurHash3_128('foo', 'foo', 'foo'));

Response

┌─hex(murmurHash3_128('foo', 'foo', 'foo'))─┐
│ F8F7AD9B6CD4CF117A71E277E2EC2931          │
└───────────────────────────────────────────┘

murmurHash3_32

Introducido en: v18.10.0 Genera un valor hash de MurmurHash3.

Sintaxis

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

Valor devuelto Devuelve el valor hash calculado a partir de los argumentos de entrada. UInt32 Ejemplos Ejemplo de uso

Query

SELECT murmurHash3_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type;

Response

┌─MurmurHash3─┬─type───┐
│   317985299 │ UInt32 │
└─────────────┴────────┘

murmurHash3_64

Introducido en: v18.10.0 Calcula el hash MurmurHash3 del valor de entrada.

Sintaxis

murmurHash3_64(arg1[, arg2, ...])

Argumentos

arg1[, arg2, ...] — Una cantidad variable de argumentos de entrada cuyo hash se calcula. Any

Valor devuelto Devuelve el valor hash calculado a partir de los argumentos de entrada. UInt64 Ejemplos Ejemplo de uso

Query

SELECT murmurHash3_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type;

Response

┌──────────MurmurHash3─┬─type───┐
│ 11285022984631508790 │ UInt64 │
└──────────────────────┴────────┘

ngramMinHash

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. Para dos cadenas, si los hashes devueltos son los mismos en ambas, entonces esas cadenas son iguales. Sintaxis

ngramMinHash(string[, ngramsize, hashnum])

Argumentos

string — Cadena sobre la que se calcula el hash. String
ngramsize — Opcional. El tamaño de un n-grama, cualquier valor entre 1 y 25. El valor predeterminado es 3. UInt8
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

Valor devuelto Devuelve una tupla con dos hashes: el mínimo y el máximo. Tuple Ejemplos Ejemplo de uso

Query

SELECT ngramMinHash('ClickHouse') AS Tuple;

Response

┌─Tuple──────────────────────────────────────┐
│ (18333312859352735453,9054248444481805918) │
└────────────────────────────────────────────┘

ngramMinHashArg

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 con la misma entrada. Distingue entre mayúsculas y minúsculas. Sintaxis

ngramMinHashArg(string[, ngramsize, hashnum])

Argumentos

string — Cadena para la que se calcula el hash. String
ngramsize — Opcional. El tamaño de un n-grama; cualquier número entre 1 y 25. El valor predeterminado es 3. UInt8
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

Valor devuelto Devuelve una tupla que contiene dos tuplas con hashnum n-gramas cada una. Tuple(String) Ejemplos Ejemplo de uso

Query

SELECT ngramMinHashArg('ClickHouse') AS Tuple;

Response

┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ous','ick','lic','Hou','kHo','use'),('Hou','lic','ick','ous','ckH','Cli')) │
└───────────────────────────────────────────────────────────────────────────────┘

ngramMinHashArgCaseInsensitive

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 con la misma entrada. No distingue entre mayúsculas y minúsculas. Sintaxis

ngramMinHashArgCaseInsensitive(string[, ngramsize, hashnum])

Argumentos

string — Cadena sobre la que se calcula el hash. String
ngramsize — Opcional. El tamaño de un n-grama, cualquier número entre 1 y 25. El valor predeterminado es 3. UInt8
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

Valor devuelto Devuelve una tupla formada por dos tuplas con hashnum n-gramas cada una. Tuple(Tuple(String)) Ejemplos Ejemplo de uso

Query

SELECT ngramMinHashArgCaseInsensitive('ClickHouse') AS Tuple;

Response

┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ous','ick','lic','kHo','use','Cli'),('kHo','lic','ick','ous','ckH','Hou')) │
└───────────────────────────────────────────────────────────────────────────────┘

ngramMinHashArgCaseInsensitiveUTF8

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

ngramMinHashArgCaseInsensitiveUTF8(string[, ngramsize, hashnum])

Argumentos

string — Cadena para la que se calcula el hash. 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
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

Valor devuelto Devuelve una tupla compuesta por dos tuplas con hashnum n-gramas cada una. Tuple(Tuple(String)) Ejemplos Ejemplo de uso

Query

SELECT ngramMinHashArgCaseInsensitiveUTF8('ClickHouse') AS Tuple;

Response

┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ckH','ous','ick','lic','kHo','use'),('kHo','lic','ick','ous','ckH','Hou')) │
└───────────────────────────────────────────────────────────────────────────────┘

ngramMinHashArgUTF8

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

ngramMinHashArgUTF8(string[, ngramsize, hashnum])

Argumentos

string — Cadena para la que se calcula el hash. String
ngramsize — Opcional. El tamaño de un n-grama; cualquier valor de 1 a 25. El valor predeterminado es 3. UInt8
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

Valor devuelto Devuelve una tupla con dos tuplas, cada una con hashnum n-gramas. Tuple(Tuple(String)) Ejemplos Ejemplo de uso

Query

SELECT ngramMinHashArgUTF8('ClickHouse') AS Tuple;

Response

┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ous','ick','lic','Hou','kHo','use'),('kHo','Hou','lic','ick','ous','ckH')) │
└───────────────────────────────────────────────────────────────────────────────┘

ngramMinHashCaseInsensitive

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. Para dos cadenas, si los hashes devueltos son iguales en ambas, entonces esas cadenas son iguales. Sintaxis

ngramMinHashCaseInsensitive(string[, ngramsize, hashnum])

Argumentos

string — String. String. - ngramsize — El tamaño de un n-grama. Opcional. Valores posibles: cualquier número de 1 a 25. Valor predeterminado: 3. UInt8. - 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.

Valor devuelto Tupla con dos hashes: el mínimo y el máximo. Tuple(UInt64, UInt64). Tuple Ejemplos Ejemplo de uso

Query

SELECT ngramMinHashCaseInsensitive('ClickHouse') AS Tuple;

Response

┌─Tuple──────────────────────────────────────┐
│ (2106263556442004574,13203602793651726206) │
└────────────────────────────────────────────┘

ngramMinHashCaseInsensitiveUTF8

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. Para dos cadenas, si los hash devueltos son los mismos para ambas, entonces esas cadenas son iguales. Sintaxis

ngramMinHashCaseInsensitiveUTF8(string [, ngramsize, hashnum])

Argumentos

string — Cadena para la que se calcula el hash. String
ngramsize — Opcional. El tamaño de un n-grama; cualquier valor entre 1 y 25. El valor predeterminado es 3. UInt8
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

Valor devuelto Devuelve una tupla con dos hashes: el mínimo y el máximo. Tuple Ejemplos Ejemplo de uso

Query

SELECT ngramMinHashCaseInsensitiveUTF8('ClickHouse') AS Tuple;

Response

┌─Tuple───────────────────────────────────────┐
│ (12493625717655877135,13203602793651726206) │
└─────────────────────────────────────────────┘

ngramMinHashUTF8

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. Para dos cadenas, si los hashes devueltos son los mismos en ambas, entonces esas cadenas son iguales. Sintaxis

ngramMinHashUTF8(string[, ngramsize, hashnum])

Argumentos

string — Cadena para la que se calcula el hash. String
ngramsize — Opcional. El tamaño de un n-grama; cualquier valor entre 1 y 25. El valor predeterminado es 3. UInt8
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

Valor devuelto Devuelve una tupla con dos hashes: el mínimo y el máximo. Tuple Ejemplos Ejemplo de uso

Query

SELECT ngramMinHashUTF8('ClickHouse') AS Tuple;

Response

┌─Tuple──────────────────────────────────────┐
│ (18333312859352735453,6742163577938632877) │
└────────────────────────────────────────────┘

ngramSimHash

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. Cuanto menor sea la distancia de Hamming de los simhashes calculados de dos cadenas, más probable será que esas cadenas sean iguales. Sintaxis

ngramSimHash(string[, ngramsize])

Argumentos

string — Cadena para la que se calcula el simhash que distingue entre mayúsculas y minúsculas. String
ngramsize — Opcional. El tamaño de un ngrama, cualquier número entre 1 y 25. El valor predeterminado es 3. UInt8

Valor devuelto Devuelve el hash calculado de la cadena de entrada. UInt64 Ejemplos Ejemplo de uso

Query

SELECT ngramSimHash('ClickHouse') AS Hash;

Response

┌───────Hash─┐
│ 1627567969 │
└────────────┘

ngramSimHashCaseInsensitive

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. Cuanto menor sea la distancia de Hamming entre los simhashes calculados de dos cadenas, mayor será la probabilidad de que esas cadenas sean iguales. Sintaxis

ngramSimHashCaseInsensitive(string[, ngramsize])

Argumentos

string — Cadena para la que se calcula el simhash sin distinción entre mayúsculas y minúsculas. String
ngramsize — Opcional. El tamaño de un n-grama, cualquier valor entre 1 y 25. El valor predeterminado es 3. UInt8

Valor devuelto Valor hash. UInt64. UInt64 Ejemplos Ejemplo de uso

Query

SELECT ngramSimHashCaseInsensitive('ClickHouse') AS Hash;

Response

┌──────Hash─┐
│ 562180645 │
└───────────┘

ngramSimHashCaseInsensitiveUTF8

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. Cuanto menor sea la distancia de Hamming entre los simhashes calculados de dos cadenas, mayor será la probabilidad de que esas cadenas sean iguales. Sintaxis

ngramSimHashCaseInsensitiveUTF8(string[, ngramsize])

Argumentos

string — Cadena para la que se calcula el hash. String
ngramsize — Opcional. El tamaño de un n-grama; cualquier valor entre 1 y 25. El valor predeterminado es 3. UInt8

Valor devuelto Devuelve el valor hash calculado. UInt64 Ejemplos Ejemplo de uso

Query

SELECT ngramSimHashCaseInsensitiveUTF8('ClickHouse') AS Hash;

Response

┌───────Hash─┐
│ 1636742693 │
└────────────┘

ngramSimHashUTF8

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. Cuanto menor sea la distancia de Hamming entre los simhashes calculados de dos cadenas, mayor será la probabilidad de que esas cadenas sean iguales. Sintaxis

ngramSimHashUTF8(string[, ngramsize])

Argumentos

string — Cadena para la que se calcula el hash. String
ngramsize — Opcional. El tamaño de un n-grama, cualquier valor entre 1 y 25. El valor predeterminado es 3. UInt8

Valor devuelto Devuelve el valor hash calculado. UInt64 Ejemplos Ejemplo de uso

Query

SELECT ngramSimHashUTF8('ClickHouse') AS Hash;

Response

┌───────Hash─┐
│ 1628157797 │
└────────────┘

sipHash128

Introducido en: v1.1.0 Como sipHash64, pero produce un valor hash de 128 bits; es decir, el estado final de xor-folding se calcula hasta 128 bits.

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.

Sintaxis

sipHash128(arg1[, arg2, ...])

Argumentos

arg1[, arg2, ...] — Un número variable de argumentos de entrada sobre los que calcular el hash. Any

Valor devuelto Devuelve un valor hash SipHash de 128 bits. FixedString(16) Ejemplos Ejemplo de uso

Query

SELECT hex(sipHash128('foo', '\x01', 3)) AS res;

Response

┌─res──────────────────────────────┐
│ 9DE516A64A414D4B1B609415E4523F24 │
└──────────────────────────────────┘

sipHash128Keyed

Introducido en: v23.2.0 Igual que sipHash128, pero además acepta un argumento de clave explícito en lugar de usar una clave fija.

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.

Sintaxis

sipHash128Keyed((k0, k1), [arg1, arg2, ...])

Argumentos

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

Valor devuelto Un valor hash SipHash de 128 bits de tipo FixedString(16). FixedString(16) Ejemplos Ejemplo de uso

Query

SELECT hex(sipHash128Keyed((506097522914230528, 1084818905618843912), 'foo', '\x01', 3)) AS res;

Response

┌─res──────────────────────────────┐
│ B8467F65C8B4CFD9A5F8BD733917D9BF │
└──────────────────────────────────┘

sipHash128Reference

Introducido en: v23.2.0 Igual que sipHash128, pero implementa el algoritmo de 128 bits de los autores originales de SipHash. Sintaxis

sipHash128Reference(arg1[, arg2, ...])

Argumentos

arg1[, arg2, ...] — Un número variable de argumentos de entrada para los que se calculará el hash. Any

Valor devuelto Devuelve el valor hash SipHash de 128 bits calculado a partir de los argumentos de entrada. FixedString(16) Ejemplos Ejemplo de uso

Query

SELECT hex(sipHash128Reference('foo', '\x01', 3)) AS res;

Response

┌─res──────────────────────────────┐
│ C3AA2F3C06A14DBE3742E9107AA9765D │
└──────────────────────────────────┘

sipHash128ReferenceKeyed

Introducido en: v23.2.0 Igual que sipHash128Reference, pero además recibe un argumento de clave explícito en lugar de usar una clave fija. Sintaxis

sipHash128ReferenceKeyed((k0, k1), arg1[, arg2, ...])

Argumentos

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

Valor devuelto Devuelve el valor hash SipHash de 128 bits calculado a partir de los argumentos de entrada. FixedString(16) Ejemplos Ejemplo de uso

Query

SELECT hex(sipHash128ReferenceKeyed((506097522914230528, 1084818905618843912), 'foo', '\x01', 3)) AS res;

Response

┌─res──────────────────────────────┐
│ 1D010CC83FB5460C25B556CE40992E61 │
└──────────────────────────────────┘

sipHash64

Introducido en: v1.1.0 Produce un valor hash 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. La función interpreta 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:

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

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.

Sintaxis

sipHash64(arg1[, arg2, ...])

Argumentos

arg1[, arg2, ...] — Un número variable de argumentos de entrada. Any

Valor devuelto Devuelve un valor hash calculado a partir de los argumentos de entrada. UInt64 Ejemplos Ejemplo de uso

Query

SELECT sipHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type;

Response

┌──────────────SipHash─┬─type───┐
│ 11348918044846389429 │ UInt64 │
└──────────────────────┴────────┘

sipHash64Keyed

Introducido en: v23.2.0 Como sipHash64, pero además recibe un argumento explícito clave en lugar de usar una clave fija. Sintaxis

sipHash64Keyed((k0, k1), arg1[,arg2, ...])

Argumentos

(k0, k1) — Una tupla de dos valores que representa la clave. Tuple(UInt64, UInt64)
arg1[,arg2, ...] — Un número variable de argumentos de entrada. Any

Valor devuelto Devuelve el hash calculado a partir de los valores de entrada. UInt64 Ejemplos Ejemplo de uso

Query

SELECT sipHash64Keyed((506097522914230528, 1084818905618843912), array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type;

Response

┌─────────────SipHash─┬─type───┐
│ 8194087499447867747 │ UInt64 │
└─────────────────────┴────────┘

wordShingleMinHash

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. Para dos cadenas, si los hashes devueltos son iguales en ambas, entonces esas cadenas son iguales. Sintaxis

wordShingleMinHash(string[, shinglesize, hashnum])

Argumentos

string — Cadena para la que se calcula el hash. 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
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

Valor devuelto Devuelve una tupla con dos hashes: el mínimo y el máximo. Tuple(UInt64, UInt64) Ejemplos Ejemplo de uso

Query

SELECT wordShingleMinHash('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;

Response

┌─Tuple──────────────────────────────────────┐
│ (16452112859864147620,5844417301642981317) │
└────────────────────────────────────────────┘

wordShingleMinHashArg

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

wordShingleMinHashArg(string[, shinglesize, hashnum])

Argumentos

string — Cadena para la que se calcula el hash. String
shinglesize — Opcional. El tamaño de una secuencia de palabras; cualquier valor entre 1 y 25. El valor predeterminado es 3. UInt8
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

Valor devuelto Devuelve una tupla compuesta por dos tuplas, cada una con hashnum secuencias de palabras. Tuple(Tuple(String)) Ejemplos Ejemplo de uso

Query

SELECT wordShingleMinHashArg('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;

Response

┌─Tuple─────────────────────────────────────────────────────────────────┐
│ (('OLAP','database','analytical'),('online','oriented','processing')) │
└───────────────────────────────────────────────────────────────────────┘

wordShingleMinHashArgCaseInsensitive

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 con la misma entrada. No distingue entre mayúsculas y minúsculas. Sintaxis

wordShingleMinHashArgCaseInsensitive(string[, shinglesize, hashnum])

Argumentos

string — Cadena para la que se calcula el hash. String
shinglesize — Opcional. El tamaño de una secuencia de palabras; cualquier valor entre 1 y 25. El valor predeterminado es 3. UInt8
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

Valor devuelto Devuelve una tupla compuesta por dos tuplas, cada una con hashnum secuencias de palabras. Tuple(Tuple(String)) Ejemplos Ejemplo de uso

Query

SELECT wordShingleMinHashArgCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;

Response

┌─Tuple──────────────────────────────────────────────────────────────────┐
│ (('queries','database','analytical'),('oriented','processing','DBMS')) │
└────────────────────────────────────────────────────────────────────────┘

wordShingleMinHashArgCaseInsensitiveUTF8

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 a partir de la misma entrada. No distingue entre mayúsculas y minúsculas. Sintaxis

wordShingleMinHashArgCaseInsensitiveUTF8(string[, shinglesize, hashnum])

Argumentos

string — Cadena para la que se calcula el hash. 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
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

Valor devuelto Devuelve una tupla con dos tuplas, cada una con hashnum secuencias de palabras contiguas. Tuple(Tuple(String)) Ejemplos Ejemplo de uso

Query

SELECT wordShingleMinHashArgCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;

Response

┌─Tuple──────────────────────────────────────────────────────────────────┐
│ (('queries','database','analytical'),('oriented','processing','DBMS')) │
└────────────────────────────────────────────────────────────────────────┘

wordShingleMinHashArgUTF8

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 con la misma entrada. Distingue entre mayúsculas y minúsculas. Sintaxis

wordShingleMinHashArgUTF8(string[, shinglesize, hashnum])

Argumentos

string — Cadena para la que se calcula el hash. String
shinglesize — Opcional. El tamaño de la secuencia de palabras; cualquier valor entre 1 y 25. El valor predeterminado es 3. UInt8
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

Valor devuelto Devuelve una tupla que contiene dos tuplas, cada una con hashnum secuencias de palabras. Tuple(Tuple(String)) Ejemplos Ejemplo de uso

Query

SELECT wordShingleMinHashArgUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;

Response

┌─Tuple─────────────────────────────────────────────────────────────────┐
│ (('OLAP','database','analytical'),('online','oriented','processing')) │
└───────────────────────────────────────────────────────────────────────┘

wordShingleMinHashCaseInsensitive

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. Para dos cadenas, si los hashes devueltos son los mismos en ambas, entonces esas cadenas son iguales. Sintaxis

wordShingleMinHashCaseInsensitive(string[, shinglesize, hashnum])

Argumentos

string — Cadena para la que se calcula el hash. String
shinglesize — Opcional. El tamaño de una secuencia de palabras, cualquier valor entre 1 y 25. El valor predeterminado es 3. UInt8
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

Valor devuelto Devuelve una tupla con dos hashes: el mínimo y el máximo. Tuple(UInt64, UInt64) Ejemplos Ejemplo de uso

Query

SELECT wordShingleMinHashCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;

Response

┌─Tuple─────────────────────────────────────┐
│ (3065874883688416519,1634050779997673240) │
└───────────────────────────────────────────┘

wordShingleMinHashCaseInsensitiveUTF8

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. Para dos cadenas, si los hashes devueltos son los mismos en ambas, entonces esas cadenas son iguales. Sintaxis

wordShingleMinHashCaseInsensitiveUTF8(string[, shinglesize, hashnum])

Argumentos

string — Cadena sobre la que se calcula el hash. 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
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

Valor devuelto Devuelve una tupla con dos hashes: el mínimo y el máximo. Tuple(UInt64, UInt64) Ejemplos Ejemplo de uso

Query

SELECT wordShingleMinHashCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;

Response

┌─Tuple─────────────────────────────────────┐
│ (3065874883688416519,1634050779997673240) │
└───────────────────────────────────────────┘

wordShingleMinHashUTF8

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. Para dos cadenas, si los hashes devueltos son iguales en ambas, esas cadenas son iguales. Sintaxis

wordShingleMinHashUTF8(string[, shinglesize, hashnum])

Argumentos

string — String sobre la que se calcula el hash. String
shinglesize — Opcional. El tamaño de una secuencia contigua de palabras; cualquier valor entre 1 y 25. El valor predeterminado es 3. UInt8
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

Valor devuelto Devuelve una tupla con dos hashes: el mínimo y el máximo. Tuple(UInt64, UInt64) Ejemplos Ejemplo de uso

Query

SELECT wordShingleMinHashUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;

Response

┌─Tuple──────────────────────────────────────┐
│ (16452112859864147620,5844417301642981317) │
└────────────────────────────────────────────┘

wordShingleSimHash

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. Cuanto menor sea la distancia de Hamming entre los simhashes calculados de dos cadenas, más probable será que esas cadenas sean iguales. Sintaxis

wordShingleSimHash(string[, shinglesize])

Argumentos

string — Cadena para la que se calcula el hash. String
shinglesize — Opcional. El tamaño de una secuencia de palabras, cualquier valor entre 1 y 25. El valor predeterminado es 3. UInt8

Valor devuelto Devuelve el valor hash calculado. UInt64 Ejemplos Ejemplo de uso

Query

SELECT wordShingleSimHash('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;

Response

┌───────Hash─┐
│ 2328277067 │
└────────────┘

wordShingleSimHashCaseInsensitive

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. Cuanto menor sea la distancia de Hamming entre los simhashes calculados de dos cadenas, mayor será la probabilidad de que sean iguales. Sintaxis

wordShingleSimHashCaseInsensitive(string[, shinglesize])

Argumentos

string — Cadena para la que se calcula el hash. 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

Valor devuelto Devuelve el hash calculado. UInt64 Ejemplos Ejemplo de uso

Query

SELECT wordShingleSimHashCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;

Response

┌───────Hash─┐
│ 2194812424 │
└────────────┘

wordShingleSimHashCaseInsensitiveUTF8

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. Cuanto menor sea la distancia de Hamming entre los simhashes calculados de dos cadenas, más probable será que esas cadenas sean iguales. Sintaxis

wordShingleSimHashCaseInsensitiveUTF8(string[, shinglesize])

Argumentos

string — Cadena sobre la que se calcula el hash. 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

Valor devuelto Devuelve el valor hash calculado. UInt64 Ejemplos Ejemplo de uso

Query

SELECT wordShingleSimHashCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;

Response

┌───────Hash─┐
│ 2194812424 │
└────────────┘

wordShingleSimHashUTF8

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. Cuanto menor sea la distancia de Hamming entre los simhashes calculados de dos cadenas, mayor será la probabilidad de que esas cadenas sean iguales. Sintaxis

wordShingleSimHashUTF8(string[, shinglesize])

Argumentos

string — Cadena sobre la que se calcula el hash. String
shinglesize — Opcional. El tamaño de una secuencia contigua de palabras; cualquier valor de 1 a 25. El valor predeterminado es 3. UInt8

Valor devuelto Devuelve el valor hash calculado. UInt64 Ejemplos Ejemplo de uso

Query

SELECT wordShingleSimHashUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;

Response

┌───────Hash─┐
│ 2328277067 │
└────────────┘

wyHash64

Introducido en: v22.7.0 Calcula un valor hash de 64 bits wyHash64. Sintaxis

wyHash64(arg)

Argumentos

arg — Argumento de tipo String para el que se va a calcular el hash. String

Valor devuelto Devuelve el valor hash calculado de 64 bits UInt64 Ejemplos Ejemplo de uso

Query

SELECT wyHash64('ClickHouse') AS Hash;

Response

12336419557878201794

xxHash32

Introducido en: v20.1.0 Calcula un xxHash de una cadena. Para ver la versión de 64 bits, consulte xxHash64 Sintaxis

xxHash32(arg)

Argumentos

arg — Cadena de entrada para calcular el hash. String

Valor devuelto Devuelve el hash de 32 bits calculado a partir de la cadena de entrada. UInt32 Ejemplos Ejemplo de uso

Query

SELECT xxHash32('Hello, world!');

Response

┌─xxHash32('Hello, world!')─┐
│                 834093149 │
└───────────────────────────┘

xxHash64

Introducido en: v20.1.0 Calcula un xxHash de una cadena. Para la versión de 32 bits, consulte xxHash32 Sintaxis

xxHash64(arg)

Argumentos

arg — Cadena de entrada para calcular el hash. String

Valor devuelto Devuelve el hash de 64 bits calculado a partir de la cadena de entrada. UInt64 Ejemplos Ejemplo de uso

Query

SELECT xxHash64('Hello, world!');

Response

┌─xxHash64('Hello, world!')─┐
│      17691043854468224118 │
└───────────────────────────┘

xxHash64Spark

Introducida en: v26.7.0 Calcula un xxHash a partir de una cadena con la misma seed que Spark. Esta función es igual que xxHash64, pero usa la seed 42 y devuelve el resultado como Int64. Solo admite entradas String y NULL. Para NULL, la función devuelve 42, en consonancia con el comportamiento de la seed en Spark. Sintaxis

xxHash64Spark(arg)

Argumentos

arg — Cadena de entrada para calcular el hash. String

Valor devuelto Devuelve el hash de 64 bits calculado a partir de la cadena de entrada. Int64 Ejemplos Ejemplo de uso

Query

SELECT xxHash64Spark('ABC');

Response

┌─xxHash64Spark('ABC')─┐
│  4105715581806190027 │
└──────────────────────┘

xxh3

Introducido en: v22.12.0 Calcula un valor de hash de 64 bits XXH3. Sintaxis

xxh3(expr)

Argumentos

expr — Una lista de expresiones de cualquier tipo de dato. Any

Valor devuelto Devuelve el valor hash xxh3 calculado de 64 bits UInt64 Ejemplos Ejemplo de uso

Query

SELECT xxh3('ClickHouse')

Response

18009318874338624809

xxh3_128

Introducido en: v26.2.0 Calcula un valor hash XXH3 de 128 bits. Sintaxis

xxh3_128(expr)

Argumentos

expr — Una lista de expresiones de cualquier tipo de dato. Any

Valor devuelto Devuelve el valor hash xxh3 calculado de 128 bits UInt128 Ejemplos Ejemplo de uso

Query

SELECT hex(xxh3_128('ClickHouse'))

Response

14C27B7BEF95D36FECF5520CA2DAF030

​BLAKE3

​MD4

​MD5

​RIPEMD160

​SHA1

​SHA224

​SHA256

​SHA384

​SHA512

​SHA512_256

​URLHash

​cityHash64

​farmFingerprint64

​farmHash64

​gccMurmurHash

​halfMD5

​hiveHash

​icebergHash

​intHash32

​intHash64

​javaHash

​javaHashUTF16LE

​jumpConsistentHash

​kafkaMurmurHash

​keccak256

​kostikConsistentHash

​metroHash64

​murmurHash2_32

​murmurHash2_64

​murmurHash3_128

​murmurHash3_32

​murmurHash3_64

​ngramMinHash

​ngramMinHashArg

​ngramMinHashArgCaseInsensitive

​ngramMinHashArgCaseInsensitiveUTF8

​ngramMinHashArgUTF8

​ngramMinHashCaseInsensitive

​ngramMinHashCaseInsensitiveUTF8

​ngramMinHashUTF8

​ngramSimHash

​ngramSimHashCaseInsensitive

​ngramSimHashCaseInsensitiveUTF8

​ngramSimHashUTF8

​sipHash128

​sipHash128Keyed

​sipHash128Reference

​sipHash128ReferenceKeyed

​sipHash64

​sipHash64Keyed

​wordShingleMinHash

​wordShingleMinHashArg

​wordShingleMinHashArgCaseInsensitive

​wordShingleMinHashArgCaseInsensitiveUTF8

​wordShingleMinHashArgUTF8

​wordShingleMinHashCaseInsensitive

​wordShingleMinHashCaseInsensitiveUTF8

​wordShingleMinHashUTF8

​wordShingleSimHash

​wordShingleSimHashCaseInsensitive

​wordShingleSimHashCaseInsensitiveUTF8

​wordShingleSimHashUTF8

​wyHash64

​xxHash32

​xxHash64

​xxHash64Spark

​xxh3

​xxh3_128

BLAKE3

MD4

MD5

RIPEMD160

SHA1

SHA224

SHA256

SHA384

SHA512

SHA512_256

URLHash

cityHash64

farmFingerprint64

farmHash64

gccMurmurHash

halfMD5

hiveHash

icebergHash

intHash32

intHash64

javaHash

javaHashUTF16LE

jumpConsistentHash

kafkaMurmurHash

keccak256

kostikConsistentHash

metroHash64

murmurHash2_32

murmurHash2_64

murmurHash3_128

murmurHash3_32

murmurHash3_64

ngramMinHash

ngramMinHashArg

ngramMinHashArgCaseInsensitive

ngramMinHashArgCaseInsensitiveUTF8

ngramMinHashArgUTF8

ngramMinHashCaseInsensitive

ngramMinHashCaseInsensitiveUTF8

ngramMinHashUTF8

ngramSimHash

ngramSimHashCaseInsensitive

ngramSimHashCaseInsensitiveUTF8

ngramSimHashUTF8

sipHash128

sipHash128Keyed

sipHash128Reference

sipHash128ReferenceKeyed

sipHash64

sipHash64Keyed

wordShingleMinHash

wordShingleMinHashArg

wordShingleMinHashArgCaseInsensitive

wordShingleMinHashArgCaseInsensitiveUTF8

wordShingleMinHashArgUTF8

wordShingleMinHashCaseInsensitive

wordShingleMinHashCaseInsensitiveUTF8

wordShingleMinHashUTF8

wordShingleSimHash

wordShingleSimHashCaseInsensitive

wordShingleSimHashCaseInsensitiveUTF8

wordShingleSimHashUTF8

wyHash64

xxHash32

xxHash64

xxHash64Spark

xxh3

xxh3_128