Skip to content
ClickHouse Docs
ClickHouse DocsClickHouse Docs
49.6kGet Started

Funciones hash

View as MarkdownEdit this pageReport an issueSet up docs MCP

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.

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

SELECT hex(BLAKE3('ABC'))
┌─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

SELECT HEX(MD4('abc'));
┌─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

SELECT HEX(MD5('abc'));
┌─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

SELECT HEX(RIPEMD160('The quick brown fox jumps over the lazy dog'));
┌─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

SELECT HEX(SHA1('abc'));
┌─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

SELECT HEX(SHA224('abc'));
┌─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

SELECT HEX(SHA256('abc'));
┌─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

SELECT HEX(SHA384('abc'));
┌─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

SELECT HEX(SHA512('abc'));
┌─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

SELECT HEX(SHA512_256('abc'));
┌─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

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

Hash de la URL con el nivel especificado

SELECT URLHash('https://www.clickhouse.com/docs', 0);
SELECT URLHash('https://www.clickhouse.com/docs', 1);
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.

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

SELECT cityHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS CityHash, toTypeName(CityHash) AS type;
┌─────────────CityHash─┬─type───┐
│ 17177535963988450974 │ UInt64 │
└──────────────────────┴────────┘

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

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;
┌─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.

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

SELECT farmFingerprint64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmFingerprint, toTypeName(FarmFingerprint) AS type;
┌──────FarmFingerprint─┬─type───┐
│ 16673609057812504858 │ UInt64 │
└──────────────────────┴────────┘

farmHash64

Introducido en: v1.1.0

Genera un FarmHash de 64 bits con el método Hash64.

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

SELECT farmHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmHash, toTypeName(FarmHash) AS type;
┌────────────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

SELECT
    gccMurmurHash(1, 2, 3) AS res1,
    gccMurmurHash(('a', [1, 2, 3], 4, (4, ['foo', 'bar'], 1, (1, 2)))) AS res2
┌─────────────────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

SELECT HEX(halfMD5('abc', 'cde', 'fgh'));
┌─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.

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

SELECT hiveHash('Hello, world!');
┌─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

Valor devuelto

Devuelve un hash Murmur3 de 32 bits, variante x86, con semilla 0 Int32

Ejemplos

Ejemplo

SELECT icebergHash(1.0 :: Float32)
-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

SELECT intHash32(42);
┌─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

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

javaHash

Introducido en: v20.1.0

Calcula JavaHash a partir de:

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

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

Ejemplo de uso 2

SELECT javaHash('Hello, world!');
┌─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

SELECT javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'));
┌─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

SELECT jumpConsistentHash(256, 4)
┌─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

SELECT
    kafkaMurmurHash('foobar') AS res1,
    kafkaMurmurHash(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS res2
┌───────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

SELECT hex(keccak256('hello'))
┌─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

SELECT kostikConsistentHash(16045690984833335023, 2);
┌─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

SELECT metroHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MetroHash, toTypeName(MetroHash) AS type;
┌────────────MetroHash─┬─type───┐
│ 16292826582821303855 │ UInt64 │
└──────────────────────┴────────┘

murmurHash2_32

Introducido en: v18.5.0

Calcula el hash MurmurHash2 del valor de entrada.

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

SELECT murmurHash2_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type;
┌─MurmurHash2─┬─type───┐
│  2947095100 │ UInt32 │
└─────────────┴────────┘

murmurHash2_64

Introducido en: v18.10.0

Calcula el hash MurmurHash2 del valor de entrada.

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

SELECT murmurHash2_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type;
┌──────────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

SELECT hex(murmurHash3_128('foo', 'foo', 'foo'));
┌─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

SELECT murmurHash3_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type;
┌─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

SELECT murmurHash3_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type;
┌──────────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

SELECT ngramMinHash('ClickHouse') AS Tuple;
┌─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

SELECT ngramMinHashArg('ClickHouse') AS Tuple;
┌─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

SELECT ngramMinHashArgCaseInsensitive('ClickHouse') AS Tuple;
┌─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

SELECT ngramMinHashArgCaseInsensitiveUTF8('ClickHouse') AS Tuple;
┌─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

SELECT ngramMinHashArgUTF8('ClickHouse') AS Tuple;
┌─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

SELECT ngramMinHashCaseInsensitive('ClickHouse') AS Tuple;
┌─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

SELECT ngramMinHashCaseInsensitiveUTF8('ClickHouse') AS Tuple;
┌─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

SELECT ngramMinHashUTF8('ClickHouse') AS Tuple;
┌─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

SELECT ngramSimHash('ClickHouse') AS Hash;
┌───────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

SELECT ngramSimHashCaseInsensitive('ClickHouse') AS Hash;
┌──────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

SELECT ngramSimHashCaseInsensitiveUTF8('ClickHouse') AS Hash;
┌───────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

SELECT ngramSimHashUTF8('ClickHouse') AS Hash;
┌───────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.

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

SELECT hex(sipHash128('foo', '\x01', 3)) AS res;
┌─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.

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

SELECT hex(sipHash128Keyed((506097522914230528, 1084818905618843912), 'foo', '\x01', 3)) AS res;
┌─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

SELECT hex(sipHash128Reference('foo', '\x01', 3)) AS res;
┌─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

SELECT hex(sipHash128ReferenceKeyed((506097522914230528, 1084818905618843912), 'foo', '\x01', 3)) AS res;
┌─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:

  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.

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

SELECT sipHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type;
┌──────────────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

SELECT sipHash64Keyed((506097522914230528, 1084818905618843912), array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type;
┌─────────────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

SELECT wordShingleMinHash('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
┌─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

SELECT wordShingleMinHashArg('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
┌─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

SELECT wordShingleMinHashArgCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
┌─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

SELECT wordShingleMinHashArgCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
┌─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

SELECT wordShingleMinHashArgUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
┌─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

SELECT wordShingleMinHashCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
┌─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

SELECT wordShingleMinHashCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
┌─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

SELECT wordShingleMinHashUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
┌─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

SELECT wordShingleSimHash('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
┌───────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

SELECT wordShingleSimHashCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
┌───────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

SELECT wordShingleSimHashCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
┌───────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

SELECT wordShingleSimHashUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
┌───────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

SELECT wyHash64('ClickHouse') AS Hash;
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

SELECT xxHash32('Hello, world!');
┌─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

SELECT xxHash64('Hello, world!');
┌─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

SELECT xxHash64Spark('ABC');
┌─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

SELECT xxh3('ClickHouse')
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

SELECT hex(xxh3_128('ClickHouse'))
14C27B7BEF95D36FECF5520CA2DAF030
Navigation