跳到主要内容
跳到主要内容

Hash 函数

Hash 函数可用于元素的确定性伪随机洗牌。

Simhash 是一种 hash 函数，对于相似（接近）的参数返回相近的 hash 值。

大多数 hash 函数接受任意数量和类型的参数。

备注

NULL 的 Hash 值是 NULL。要获得 Nullable 列的非 NULL hash，请将其包装在元组中：

SELECT cityHash64(tuple(NULL))
备注

要计算整个表内容的 hash，请使用 sum(cityHash64(tuple(*))) （或其他 hash 函数）。tuple 确保不会跳过包含 NULL 值的行。sum 确保行的顺序无关紧要。

BLAKE3​

Introduced in: v22.10

计算 BLAKE3 hash 字符串，并返回结果字节集作为 FixedString。 该加密 hash 函数与 BLAKE3 Rust 库集成到 ClickHouse 中。 该函数相当快，与 SHA-2 比较性能大约快两倍，同时生成的 hash 与 SHA-256 相同长度。 它返回一个字节数组类型的 BLAKE3 hash，类型为 FixedString(32)。

语法

BLAKE3(message)

参数

  • message — 要 hash 的输入字符串。 String

返回值

返回输入字符串的 32 字节 BLAKE3 hash，作为固定长度字符串。 FixedString(32)

示例

hash

SELECT hex(BLAKE3('ABC'))

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

MD4​

Introduced in: v21.11

计算给定字符串的 MD4 hash。

语法

MD4(s)

参数

  • s — 要 hash 的输入字符串。 String

返回值

返回给定输入字符串的 MD4 hash，作为固定长度字符串。 FixedString(16)

示例

使用示例

SELECT HEX(MD4('abc'));

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

MD5​

Introduced in: v1.1

计算给定字符串的 MD5 hash。

语法

MD5(s)

参数

  • s — 要 hash 的输入字符串。 String

返回值

返回给定输入字符串的 MD5 hash，作为固定长度字符串。 FixedString(16)

示例

使用示例

SELECT HEX(MD5('abc'));

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

RIPEMD160​

Introduced in: v24.10

计算给定字符串的 RIPEMD-160 hash。

语法

RIPEMD160(s)

参数

  • s — 要 hash 的输入字符串。 String

返回值

返回给定输入字符串的 RIPEMD160 hash，作为固定长度字符串。 FixedString(20)

示例

使用示例

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​

Introduced in: v1.1

计算给定字符串的 SHA1 hash。

语法

SHA1(s)

参数

  • s — 要 hash 的输入字符串 String

返回值

返回给定输入字符串的 SHA1 hash，作为固定长度字符串。 FixedString(20)

示例

使用示例

SELECT HEX(SHA1('abc'));

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

SHA224​

Introduced in: v1.1

计算给定字符串的 SHA224 hash。

语法

SHA224(s)

参数

  • s — 要 hash 的输入值。 String

返回值

返回给定输入字符串的 SHA224 hash，作为固定长度字符串。 FixedString(28)

示例

使用示例

SELECT HEX(SHA224('abc'));

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

SHA256​

Introduced in: v1.1

计算给定字符串的 SHA256 hash。

语法

SHA256(s)

参数

  • s — 要 hash 的输入字符串。 String

返回值

返回给定输入字符串的 SHA256 hash，作为固定长度字符串。 FixedString(32)

示例

使用示例

SELECT HEX(SHA256('abc'));

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

SHA384​

Introduced in: v1.1

计算给定字符串的 SHA384 hash。

语法

SHA384(s)

参数

  • s — 要 hash 的输入字符串。 String

返回值

返回给定输入字符串的 SHA384 hash，作为固定长度字符串。 FixedString(48)

示例

使用示例

SELECT HEX(SHA384('abc'));

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

SHA512​

Introduced in: v1.1

计算给定字符串的 SHA512 hash。

语法

SHA512(s)

参数

  • s — 要 hash 的输入字符串 String

返回值

返回给定输入字符串的 SHA512 hash，作为固定长度字符串。 FixedString(64)

示例

使用示例

SELECT HEX(SHA512('abc'));

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

SHA512_256​

Introduced in: v1.1

计算给定字符串的 SHA512_256 hash。

语法

SHA512_256(s)

参数

  • s — 要 hash 的输入字符串。 String

返回值

返回给定输入字符串的 SHA512_256 hash，作为固定长度字符串。 FixedString(32)

示例

使用示例

SELECT HEX(SHA512_256('abc'));

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

URLHash​

Introduced in: v1.1

一种快速、优质的非加密 hash 函数，用于从 URL 获取的字符串，并进行某种类型的规范化。

该 hash 函数有两种模式：

模式描述
URLHash(url)计算一个字符串的 hash，在字符串末尾去掉一个尾随符号 /、? 或 # （如有）。
URLHash(url, N)计算字符串以 N 级别的 URL 层次结构的 hash，末尾去掉一个尾随符号 /、? 或 # （如有）。层级与 URLHierarchy 相同。

语法

URLHash(url[, N])

参数

  • url — 要 hash 的 URL 字符串。 String
  • N — 可选。 URL 层次结构中的级别。 (U)Int*

返回值

返回计算得到的 url 的 hash 值。 UInt64

示例

使用示例

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

┌─URLHash('htt⋯house.com')─┐
│     13614512636072854701 │
└──────────────────────────┘

带有指定级别的 URL hash

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

-- hash of https://www.clickhouse.com
┌─URLHash('htt⋯m/docs', 0)─┐
│     13614512636072854701 │
└──────────────────────────┘
-- hash of https://www.clickhouse.com/docs
┌─URLHash('htt⋯m/docs', 1)─┐
│     13167253331440520598 │
└──────────────────────────┘

cityHash64​

Introduced in: v1.1

生成 64 位 CityHash hash 值。

这是一个快速的非加密 hash 函数。 对于字符串参数使用 CityHash 算法，而对于其他数据类型的参数使用实现特定的快速非加密 hash 函数。 该函数使用 CityHash 组合器来获得最终结果。

信息

Google 在将 CityHash 集成到 ClickHouse 后更改了算法。 换句话说，ClickHouse 的 cityHash64 和 Google 的上游 CityHash 现在生成不同的结果。 ClickHouse 的 cityHash64 对应于 CityHash v1.0.2。

备注

相同输入值的不同参数类型可能计算出相同的 hash 值。 这影响例如不同大小的整数类型、具有相同数据的命名和未命名 Tuple、Map 和相应的 Array(Tuple(key, value)) 类型的相同数据。

语法

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

参数

  • arg1[, arg2, ...] — 可变数量的输入参数，以计算 hash。 Any

返回值

返回输入参数计算出的 hash。 UInt64

示例

调用示例

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

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

计算整个表的校验和，精确到行的顺序

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(⋯age, city))─┐
│     11639977218258521182 │
└──────────────────────────┘

farmFingerprint64​

Introduced in: v20.12

使用 Fingerprint64 方法生成 64 位 FarmHash 值。

提示

farmFingerprint64 在生成稳定和可移植值时优于 farmHash64。

备注

相同输入值的不同参数类型可能计算出相同的 hash 值。 这影响例如不同大小的整数类型、具有相同数据的命名和未命名 Tuple、Map 和相应的 Array(Tuple(key, value)) 类型的相同数据。

语法

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

参数

  • arg1[, arg2, ...] — 可变数量的输入参数，以计算 hash。 Any

返回值

返回输入参数计算出的 hash 值。 UInt64

示例

使用示例

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

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

farmHash64​

Introduced in: v1.1

使用 Hash64 方法生成 64 位 FarmHash。

提示

farmFingerprint64 在生成稳定和可移植值时优于。

备注

相同输入值的不同参数类型可能计算出相同的 hash 值。 这影响例如不同大小的整数类型、具有相同数据的命名和未命名 Tuple、Map 和相应的 Array(Tuple(key, value)) 类型的相同数据。

语法

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

参数

  • arg1[, arg2, ...] — 可变数量的输入参数，以计算 hash。 Any

返回值

返回输入参数计算出的 hash 值。 UInt64

示例

使用示例

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

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

gccMurmurHash​

Introduced in: v20.1

使用与 GCC 相同的种子，计算输入值的 64 位 MurmurHash2 hash。

它在 Clang 和 GCC 构建之间是可移植的。

语法

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

参数

  • arg1[, arg2, ...] — 可变数量的输入参数，以计算 hash。 Any

返回值

返回输入参数计算出的 hash 值。 UInt64

示例

使用示例

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​

Introduced in: v1.1

解释 所有输入参数为字符串，并计算每个参数的 MD5 hash 值。然后组合哈希值，取结果字符串的前 8 个字节，并将其解释为 UInt64 的大端字节顺序。该函数相对较慢（每秒每个处理器核心处理 5 百万条短字符串）。

请考虑改用 sipHash64 函数。

该函数接受可变数量的输入参数。 参数可以是任何支持的数据类型。 对于某些数据类型，即使参数的类型不同，计算出的 hash 函数值可能对相同的值相同（不同大小的整数、具有相同数据的命名和未命名 Tuple、Map 和相应的 Array(Tuple(key, value)) 类型的相同数据）。

语法

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

参数

  • arg1[, arg2, ..., argN] — 可变数量的输入参数，以计算 hash。 Any

返回值

返回计算得出的给定输入参数的半 MD5 hash，作为大端字节顺序的 UInt64。 UInt64

示例

使用示例

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

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

hiveHash​

Introduced in: v20.1

从字符串计算 “HiveHash”。 这只是 JavaHash 的符号位清零版本。 该函数用于 Apache Hive 3.0 之前的版本。

该 hash 函数性能较差。 仅在另一个系统中已经使用此算法且需要计算相同结果时使用。 :::

语法

hiveHash(arg)

参数

  • arg — 输入字符串以进行 hash。 String

返回值

返回输入字符串的计算 “hive hash”。 Int32

示例

使用示例

SELECT hiveHash('Hello, world!');

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

intHash32​

Introduced in: v1.1

计算整数的 32 位 hash。

该 hash 函数相对较快，但不是加密 hash 函数。

语法

intHash32(arg)

参数

  • arg — 要 hash 的整数。 (U)Int*

返回值

返回输入整数的计算 32 位 hash 代码。 UInt32

示例

使用示例

SELECT intHash32(42);

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

intHash64​

Introduced in: v1.1

计算整数的 64 位 hash。

该 hash 函数相对较快（甚至比 intHash32 还快）但不是加密 hash 函数。

语法

intHash64(int)

参数

  • int — 要 hash 的整数。 (U)Int*

返回值

返回 64 位 hash 代码。 UInt64

示例

使用示例

SELECT intHash64(42);

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

javaHash​

Introduced in: v20.1

从以下内容计算 JavaHash：

警告

该 hash 函数性能较差。 仅在另一个系统中已经使用此算法且需要计算相同结果时使用。

备注

Java 仅支持计算有符号整数的 hash，因此如果要计算无符号整数的 hash，则必须将其转换为适当的有符号 ClickHouse 类型。

语法

javaHash(arg)

参数

  • arg — 要 hash 的输入值。 Any

返回值

返回输入 arg 的计算 hash。 Int32

示例

使用示例 1

SELECT javaHash(toInt32(123));

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

使用示例 2

SELECT javaHash('Hello, world!');

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

javaHashUTF16LE​

Introduced in: v20.1

计算来自字符串的 JavaHash，假定它包含表示字符串的 UTF-16LE 编码字节。

语法

javaHashUTF16LE(arg)

参数

  • arg — UTF-16LE 编码的字符串。 String

返回值

返回 UTF-16LE 编码字符串的计算 hash。 Int32

示例

使用示例

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

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

jumpConsistentHash​

Introduced in: v1.1

计算整数的 jump consistent hash。

语法

jumpConsistentHash(key, buckets)

参数

  • key — 输入键。 UInt64
  • buckets — 桶的数量。 Int32

返回值

返回计算得到的 hash 值。 Int32

示例

使用示例

SELECT jumpConsistentHash(256, 4)

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

kafkaMurmurHash​

Introduced in: v23.4

使用与 Kafka 相同的种子，计算输入值的 32 位 MurmurHash2 hash，并去掉高位，以兼容 Default Partitioner。

语法

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

参数

  • arg1[, arg2, ...] — 可变数量的参数，以计算 hash。 Any

返回值

返回输入参数计算出的 hash 值。 UInt32

示例

使用示例

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​

Introduced in: v25.4

计算给定字符串的 Keccak-256 加密 hash。 该 hash 函数广泛用于区块链应用，特别是以太坊。

语法

keccak256(message)

参数

  • message — 要 hash 的输入字符串。 String

返回值

返回输入字符串的 32 字节 Keccak-256 hash，作为固定长度字符串。 FixedString(32)

示例

使用示例

SELECT hex(keccak256('hello'))

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

kostikConsistentHash​

Introduced in: v22.6

Konstantin 'Kostik' Oblakov 提出的 O(1) 时间和空间一致性 hash 算法。 当 n <= 32768 时效率高。

语法

kostikConsistentHash(input, n)

参数

  • input — 整数键。 UInt64
  • n — 桶的数量。 UInt16

返回值

返回计算得到的 hash 值。 UInt16

示例

使用示例

SELECT kostikConsistentHash(16045690984833335023, 2);

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

metroHash64​

Introduced in: v1.1

生成 64 位 MetroHash hash 值。

备注

相同输入值的不同参数类型可能计算出相同的 hash 值。 这影响例如不同大小的整数类型、具有相同数据的命名和未命名 Tuple、Map 和相应的 Array(Tuple(key, value)) 类型的相同数据。

语法

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

参数

  • arg1[, arg2, ...] — 可变数量的输入参数，以计算 hash。 Any

返回值

返回输入参数计算出的 hash。 UInt64

示例

使用示例

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

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

murmurHash2_32​

Introduced in: v18.5

计算输入值的 MurmurHash2 hash。

备注

相同输入值的不同参数类型可能计算出相同的 hash 值。 这影响例如不同大小的整数类型、具有相同数据的命名和未命名 Tuple、Map 和相应的 Array(Tuple(key, value)) 类型的相同数据。

语法

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

参数

  • arg1[, arg2, ...] — 可变数量的输入参数，以计算 hash。 Any

返回值

返回输入参数计算出的 hash 值。 UInt32

示例

使用示例

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

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

murmurHash2_64​

Introduced in: v18.10

计算输入值的 MurmurHash2 hash。

备注

相同输入值的不同参数类型可能计算出相同的 hash 值。 这影响例如不同大小的整数类型、具有相同数据的命名和未命名 Tuple、Map 和相应的 Array(Tuple(key, value)) 类型的相同数据。

语法

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

参数

  • arg1[, arg2, ...] — 可变数量的输入参数，以计算 hash。 Any

返回值

返回输入参数计算出的 hash。 UInt64

示例

使用示例

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

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

murmurHash3_128​

Introduced in: v18.10

计算输入值的 128 位 MurmurHash3 hash。

语法

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

参数

  • arg1[, arg2, ...] — 可变数量的输入参数，以计算 hash。 Any

返回值

返回输入参数计算出的 128 位 MurmurHash3 hash 值。 FixedString(16)

示例

使用示例

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

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

murmurHash3_32​

Introduced in: v18.10

生成 MurmurHash3 hash 值。

备注

相同输入值的不同参数类型可能计算出相同的 hash 值。 这影响例如不同大小的整数类型、具有相同数据的命名和未命名 Tuple、Map 和相应的 Array(Tuple(key, value)) 类型的相同数据。

语法

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

参数

  • arg1[, arg2, ...] — 可变数量的输入参数，以计算 hash。 Any

返回值

返回输入参数计算出的 hash 值。 UInt32

示例

使用示例

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

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

murmurHash3_64​

Introduced in: v18.10

计算输入值的 MurmurHash3 hash。

备注

相同输入值的不同参数类型可能计算出相同的 hash 值。 这影响例如不同大小的整数类型、具有相同数据的命名和未命名 Tuple、Map 和相应的 Array(Tuple(key, value)) 类型的相同数据。

语法

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

参数

  • arg1[, arg2, ...] — 可变数量的输入参数，以计算 hash。 Any

返回值

返回输入参数计算出的 hash 值。 UInt64

示例

使用示例

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

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

ngramMinHash​

Introduced in: v21.1

将 ASCII 字符串拆分为 ngramsize 符号的 n-grams，并计算每个 n-gram 的 hash 值，返回一个包含这些 hash 的元组。 使用 hashnum 个最小 hash 来计算最小 hash，使用 hashnum 个最大 hash 来计算最大 hash。 该函数对大小写敏感。

可用于使用 tupleHammingDistance 检测半重复字符串。 对于两个字符串，如果返回的 hash 对于这两个字符串是相同的，则这两个字符串是相同的。

语法

ngramMinHash(string[, ngramsize, hashnum])

参数

  • string — 要计算 hash 的字符串。 String
  • ngramsize — 可选。 n-gram 的大小，范围为 1 到 25 的任意数字。默认值为 3。 UInt8
  • hashnum — 可选。 用于计算结果的最小和最大 hash 的数量，范围为 1 到 25 的任意数字。默认值为 6。 UInt8

返回值

返回包含两个 hash 的元组 — 最小和最大。 Tuple

示例

使用示例

SELECT ngramMinHash('ClickHouse') AS Tuple;

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

ngramMinHashArg​

Introduced in: v21.1

将 ASCII 字符串拆分为 ngramsize 符号的 n-grams，并返回 minimum hash 和 maximum hash，计算方法为与相同输入的 ngramMinHash 函数。 该函数对大小写敏感。

语法

ngramMinHashArg(string[, ngramsize, hashnum])

参数

  • string — 要计算 hash 的字符串。 String
  • ngramsize — 可选。 n-gram 的大小，范围为 1 到 25 的任意数字。默认值为 3。 UInt8
  • hashnum — 可选。 用于计算结果的最小和最大 hash 的数量，范围为 1 到 25 的任意数字。默认值为 6。 UInt8

返回值

返回包含两个元组的元组，每个元组都有 hashnum 个 n-grams。 Tuple(String)

示例

使用示例

SELECT ngramMinHashArg('ClickHouse') AS Tuple;

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

ngramMinHashArgCaseInsensitive​

Introduced in: v21.1

将 ASCII 字符串拆分为 ngramsize 符号的 n-grams，并返回 minimum hash 和 maximum hash，计算方法为与相同输入的 ngramMinHashCaseInsensitive 函数。 该函数对大小写不敏感。

语法

ngramMinHashArgCaseInsensitive(string[, ngramsize, hashnum])

参数

  • string — 要计算 hash 的字符串。 String
  • ngramsize — 可选。 n-gram 的大小，范围为 1 到 25 的任意数字。默认值为 3。 UInt8
  • hashnum — 可选。 用于计算结果的最小和最大 hash 的数量，范围为 1 到 25 的任意数字。默认值为 6。 UInt8

返回值

返回包含两个元组的元组，每个元组都有 hashnum 个 n-grams。 Tuple(Tuple(String))

示例

使用示例

SELECT ngramMinHashArgCaseInsensitive('ClickHouse') AS Tuple;

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

ngramMinHashArgCaseInsensitiveUTF8​

Introduced in: v21.1

将 UTF-8 字符串拆分为 ngramsize 符号的 n-grams，并返回 minimum hash 和 maximum hash，计算方法为与相同输入的 ngramMinHashCaseInsensitiveUTF8 函数。 该函数对大小写不敏感。

语法

ngramMinHashArgCaseInsensitiveUTF8(string[, ngramsize, hashnum])

参数

  • string — 要计算 hash 的字符串。 String
  • ngramsize — 可选。 n-gram 的大小，范围为 1 到 25 的任意数字。默认值为 3。 UInt8
  • hashnum — 可选。 用于计算结果的最小和最大 hash 的数量，范围为 1 到 25 的任意数字。默认值为 6。 UInt8

返回值

返回包含两个元组的元组，每个元组都有 hashnum 个 n-grams。 Tuple(Tuple(String))

示例

使用示例

SELECT ngramMinHashArgCaseInsensitiveUTF8('ClickHouse') AS Tuple;

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

ngramMinHashArgUTF8​

Introduced in: v21.1

将 UTF-8 字符串拆分为 ngramsize 符号的 n-grams，并返回 minimum hash 和 maximum hash，计算方法为与相同输入的 ngramMinHashUTF8 函数。 该函数对大小写敏感。

语法

ngramMinHashArgUTF8(string[, ngramsize, hashnum])

参数

  • string — 要计算 hash 的字符串。 String
  • ngramsize — 可选。 n-gram 的大小，范围为 1 到 25 的任意数字。默认值为 3。 UInt8
  • hashnum — 可选。 用于计算结果的最小和最大 hash 的数量，范围为 1 到 25 的任意数字。默认值为 6。 UInt8

返回值

返回包含两个元组的元组，每个元组都有 hashnum 个 n-grams。 Tuple(Tuple(String))

示例

使用示例

SELECT ngramMinHashArgUTF8('ClickHouse') AS Tuple;

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

ngramMinHashCaseInsensitive​

Introduced in: v21.1

将 ASCII 字符串拆分为 ngramsize 符号的 n-grams，并计算每个 n-gram 的 hash 值，返回一个包含这些 hash 的元组 使用 hashnum 个最小 hash 来计算最小 hash，使用 hashnum 个最大 hash 来计算最大 hash。 该函数对大小写不敏感。

可用于使用 tupleHammingDistance 检测半重复字符串。 对于两个字符串，如果返回的 hash 对于这两个字符串是相同的，则这两个字符串是相同的。

语法

ngramMinHashCaseInsensitive(string[, ngramsize, hashnum])

参数

  • string — 字符串。 String。 - ngramsize — n-gram 的大小。可选。可能的值：范围为 1 到 25 的任意数字。默认值：3。 UInt8。 - hashnum — 用于计算结果的最小和最大 hash 的数量。可选。可能的值：范围为 1 到 25 的任意数字。默认值：6。 UInt8。

返回值

包含两个 hash 的元组 — 最小和最大。 Tuple(UInt64, UInt64). Tuple

示例

使用示例

SELECT ngramMinHashCaseInsensitive('ClickHouse') AS Tuple;

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

ngramMinHashCaseInsensitiveUTF8​

引入于：v21.1

将 UTF-8 字符串拆分为 ngramsize 符号的 n-grams，并计算每个 n-gram 的散列值，然后返回包含这些散列的元组。 使用 hashnum 个最小散列来计算最小散列，使用 hashnum 个最大散列来计算最大散列。 此功能对大小写不敏感。

可以与 tupleHammingDistance 一起使用来检测半重复字符串。 对于两个字符串，如果返回的散列对两个字符串都是相同的，则这两个字符串是相同的。

语法

ngramMinHashCaseInsensitiveUTF8(string [, ngramsize, hashnum])

参数

  • string — 要计算散列的字符串。 String
  • ngramsize — 可选。n-gram 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8
  • hashnum — 可选。用于计算结果的最小和最大散列的数量，范围从 1 到 25 的任何数字。默认值为 6。 UInt8

返回值

返回包含两个散列的元组 — 最小值和最大值。 Tuple

示例

用法示例

SELECT ngramMinHashCaseInsensitiveUTF8('ClickHouse') AS Tuple;

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

ngramMinHashUTF8​

引入于：v21.1

将 UTF-8 字符串拆分为 ngramsize 符号的 n-grams，并计算每个 n-gram 的散列值，然后返回包含这些散列的元组。 使用 hashnum 个最小散列来计算最小散列，使用 hashnum 个最大散列来计算最大散列。 此功能对大小写敏感。

可以与 tupleHammingDistance 一起使用来检测半重复字符串。 对于两个字符串，如果返回的散列对两个字符串都是相同的，则这两个字符串是相同的。

语法

ngramMinHashUTF8(string[, ngramsize, hashnum])

参数

  • string — 要计算散列的字符串。 String
  • ngramsize — 可选。n-gram 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8
  • hashnum — 可选。用于计算结果的最小和最大散列的数量，范围从 1 到 25 的任何数字。默认值为 6。 UInt8

返回值

返回包含两个散列的元组 — 最小值和最大值。 Tuple

示例

用法示例

SELECT ngramMinHashUTF8('ClickHouse') AS Tuple;

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

ngramSimHash​

引入于：v21.1

将 ASCII 字符串拆分为 ngramsize 符号的 n-grams，并返回 n-gram 的 simhash。

可以与 bitHammingDistance 一起使用来检测半重复字符串。 计算出的两个字符串的 simhash 之间的 汉明距离 越小，这两个字符串相同的可能性就越大。

语法

ngramSimHash(string[, ngramsize])

参数

  • string — 要计算的对大小写敏感的 simhash 的字符串。 String
  • ngramsize — 可选。n-gram 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8

返回值

返回输入字符串的计算散列。 UInt64

示例

用法示例

SELECT ngramSimHash('ClickHouse') AS Hash;

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

ngramSimHashCaseInsensitive​

引入于：v21.1

将 ASCII 字符串拆分为 ngramsize 符号的 n-grams，并返回 n-gram 的 simhash。 此功能对大小写不敏感。

可以与 bitHammingDistance 一起使用来检测半重复字符串。 计算出的两个字符串的 simhash 之间的 汉明距离 越小，这两个字符串相同的可能性就越大。

语法

ngramSimHashCaseInsensitive(string[, ngramsize])

参数

  • string — 要计算的对大小写不敏感的 simhash 的字符串。 String
  • ngramsize — 可选。n-gram 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8

返回值

散列值。 UInt64. UInt64

示例

用法示例

SELECT ngramSimHashCaseInsensitive('ClickHouse') AS Hash;

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

ngramSimHashCaseInsensitiveUTF8​

引入于：v21.1

将 UTF-8 字符串拆分为 ngramsize 符号的 n-grams，并返回 n-gram 的 simhash。 此功能对大小写不敏感。

可以与 bitHammingDistance 一起使用来检测半重复字符串。计算出的两个字符串的 simhash 之间的 汉明距离 越小，这两个字符串相同的可能性就越大。

语法

ngramSimHashCaseInsensitiveUTF8(string[, ngramsize])

参数

  • string — 要计算散列的字符串。 String
  • ngramsize — 可选。n-gram 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8

返回值

返回计算出的散列值。 UInt64

示例

用法示例

SELECT ngramSimHashCaseInsensitiveUTF8('ClickHouse') AS Hash;

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

ngramSimHashUTF8​

引入于：v21.1

将 UTF-8 编码的字符串拆分为 ngramsize 符号的 n-grams，并返回 n-gram 的 simhash。 此功能对大小写敏感。

可以与 bitHammingDistance 一起使用来检测半重复字符串。 计算出的两个字符串的 simhash 之间的 汉明距离 越小，这两个字符串相同的可能性就越大。

语法

ngramSimHashUTF8(string[, ngramsize])

参数

  • string — 要计算散列的字符串。 String
  • ngramsize — 可选。n-gram 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8

返回值

返回计算出的散列值。 UInt64

示例

用法示例

SELECT ngramSimHashUTF8('ClickHouse') AS Hash;

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

sipHash128​

引入于：v1.1

与 sipHash64 类似，但生成 128 位散列值，即最终的异或折叠状态处理到 128 位。

对于新项目请使用 sipHash128Reference

此 128 位变体与参考实现不同且更弱。 此版本存在的原因是，在编写时，没有官方的 128 位 SipHash 扩展。 建议新项目使用 sipHash128Reference。

语法

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

参数

  • arg1[, arg2, ...] — 要计算散列的输入参数的可变数量。 Any

返回值

返回 128 位 SipHash 散列值。 FixedString(16)

示例

用法示例

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

┌─hex(sipHash128('foo', '', 3))────┐
│ 9DE516A64A414D4B1B609415E4523F24 │
└──────────────────────────────────┘

sipHash128Keyed​

引入于：v23.2

与 sipHash128 相同，但额外提供一个明确的密钥参数，而不是使用固定密钥。

对于新项目请使用 sipHash128ReferenceKeyed

此 128 位变体与参考实现不同且更弱。 此版本存在的原因是，在编写时，没有官方的 128 位 SipHash 扩展。 新项目可能应该使用 sipHash128ReferenceKeyed。

语法

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

参数

  • (k0, k1) — 表示密钥的两个 UInt64 值的元组。 Tuple(UInt64, UInt64)
  • arg1[, arg2, ...] — 要计算散列的输入参数的可变数量。 Any

返回值

返回输入值的 128 位 SipHash 散列值。 FixedString(16)

示例

用法示例

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

┌─hex(sipHash128Keyed((506097522914230528, 1084818905618843912), 'foo', '', 3))─┐
│ B8467F65C8B4CFD9A5F8BD733917D9BF                                              │
└───────────────────────────────────────────────────────────────────────────────┘

sipHash128Reference​

引入于：v23.2

与 sipHash128 类似，但实现 SipHash 原作者的 128 位算法。

语法

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

参数

  • arg1[, arg2, ...] — 要计算散列的输入参数的可变数量。 Any

返回值

返回输入参数计算出的 128 位 SipHash 散列值。 FixedString(16)

示例

用法示例

SELECT hex(sipHash128Reference('foo', '', 3));

┌─hex(sipHash128Reference('foo', '', 3))─┐
│ 4D1BE1A22D7F5933C0873E1698426260       │
└────────────────────────────────────────┘

sipHash128ReferenceKeyed​

引入于：v23.2

与 sipHash128Reference 相同，但额外提供一个明确的密钥参数，而不是使用固定密钥。

语法

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

参数

  • (k0, k1) — 表示密钥的两个值的元组 Tuple(UInt64, UInt64)
  • arg1[, arg2, ...] — 要计算散列的输入参数的可变数量。 Any

返回值

返回输入参数计算出的 128 位 SipHash 散列值。 FixedString(16)

示例

用法示例

SELECT hex(sipHash128Reference('foo', '', 3));

┌─hex(sipHash128Reference('foo', '', 3))─┐
│ 4D1BE1A22D7F5933C0873E1698426260       │
└────────────────────────────────────────┘

sipHash64​

引入于：v1.1

生成 64 位 SipHash 散列值。

这是一个密码散列函数。其速度至少比 MD5 散列函数快三倍。

该函数 将所有输入参数解释 为字符串，并计算每个输入参数的散列值。 然后使用以下算法组合这些散列：

  1. 第一个和第二个散列值被连接到一个数组中，并进行散列。
  2. 先前计算的散列值和第三个输入参数的散列值以类似的方式进行散列。
  3. 对原始输入的所有剩余散列值重复此计算。
备注

对于不同参数类型的相同输入值，计算出的散列值可能相等。 这会影响例如不同大小的整数类型，具有相同数据的命名和未命名的 Tuple，以及具有相同数据的 Map 和相应的 Array(Tuple(key, value)) 类型。

语法

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

参数

  • arg1[, arg2, ...] — 可变数量的输入参数。 Any

返回值

返回计算的输入参数的散列值。 UInt64

示例

用法示例

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

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

sipHash64Keyed​

引入于：v23.2

与 sipHash64 类似，但额外提供一个明确的密钥参数，而不是使用固定密钥。

语法

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

参数

  • (k0, k1) — 表示密钥的两个值的元组。 Tuple(UInt64, UInt64)
  • arg1[,arg2, ...] — 要计算散列的输入参数的可变数量。 Any

返回值

返回输入值的计算散列。 UInt64

示例

用法示例

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───┐
│ 8017656310194184311 │ UInt64 │
└─────────────────────┴────────┘

wordShingleMinHash​

引入于：v21.1

将 ASCII 字符串拆分为 shinglesize 个单词的部分（shingles），计算每个单词 shingles 的散列值，并返回包含这些散列的元组。 使用 hashnum 个最小散列来计算最小散列，使用 hashnum 个最大散列来计算最大散列。 此功能对大小写敏感。

可以与 tupleHammingDistance 一起使用来检测半重复字符串。 对于两个字符串，如果返回的散列对两个字符串都是相同的，则这两个字符串是相同的。

语法

wordShingleMinHash(string[, shinglesize, hashnum])

参数

  • string — 要计算散列的字符串。 String
  • shinglesize — 可选。单词 shingles 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8
  • hashnum — 可选。用于计算结果的最小和最大散列的数量，范围从 1 到 25 的任何数字。默认值为 6。 UInt8

返回值

返回包含两个散列的元组 — 最小值和最大值。 Tuple(UInt64, UInt64)

示例

用法示例

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

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

wordShingleMinHashArg​

引入于：v1.1

将 ASCII 字符串拆分为 shinglesize 个单词的部分（shingles），并返回具有最小和最大单词散列的 shingles，这些散列是通过具有相同输入的 wordShingleMinHash 函数计算的。 此功能对大小写敏感。

语法

wordShingleMinHashArg(string[, shinglesize, hashnum])

参数

  • string — 要计算散列的字符串。 String
  • shinglesize — 可选。单词 shingles 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8
  • hashnum — 可选。用于计算结果的最小和最大散列的数量，范围从 1 到 25 的任何数字。默认值为 6。 UInt8

返回值

返回包含两个元组的元组，每个元组具有 hashnum 个单词 shingles。 Tuple(Tuple(String))

示例

用法示例

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​

引入于：v21.1

将 ASCII 字符串拆分为 shinglesize 个单词的部分（shingles），并返回具有最小和最大单词散列的 shingles，这些散列是通过 wordShingleMinHashCaseInsensitive 函数计算的。 此功能对大小写不敏感。

语法

wordShingleMinHashArgCaseInsensitive(string[, shinglesize, hashnum])

参数

  • string — 要计算散列的字符串。 String
  • shinglesize — 可选。单词 shingles 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8
  • hashnum — 可选。用于计算结果的最小和最大散列的数量，范围从 1 到 25 的任何数字。默认值为 6。 UInt8

返回值

返回包含两个元组的元组，每个元组具有 hashnum 个单词 shingles。 Tuple(Tuple(String))

示例

用法示例

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​

引入于：v21.1

将 UTF-8 字符串拆分为 shinglesize 个单词的部分（shingles），并返回具有最小和最大单词散列的 shingles，这些散列是通过 wordShingleMinHashCaseInsensitiveUTF8 函数计算的。 此功能对大小写不敏感。

语法

wordShingleMinHashArgCaseInsensitiveUTF8(string[, shinglesize, hashnum])

参数

  • string — 要计算散列的字符串。 String
  • shinglesize — 可选。单词 shingles 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8
  • hashnum — 可选。用于计算结果的最小和最大散列的数量，范围从 1 到 25 的任何数字。默认值为 6。 UInt8

返回值

返回包含两个元组的元组，每个元组具有 hashnum 个单词 shingles。 Tuple(Tuple(String))

示例

用法示例

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​

引入于：v21.1

将 UTF-8 字符串拆分为 shinglesize 个单词的部分（shingles），并返回具有最小和最大单词散列的 shingles，这些散列是通过 wordShingleMinHashUTF8 函数计算的。 此功能对大小写敏感。

语法

wordShingleMinHashArgUTF8(string[, shinglesize, hashnum])

参数

  • string — 要计算散列的字符串。 String
  • shinglesize — 可选。单词 shingles 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8
  • hashnum — 可选。用于计算结果的最小和最大散列的数量，范围从 1 到 25 的任何数字。默认值为 6。 UInt8

返回值

返回包含两个元组的元组，每个元组具有 hashnum 个单词 shingles。 Tuple(Tuple(String))

示例

用法示例

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​

引入于：v21.1

将 ASCII 字符串拆分为 shinglesize 个单词的部分（shingles），计算每个单词 shingles 的散列值，并返回包含这些散列的元组。 使用 hashnum 个最小散列来计算最小散列，使用 hashnum 个最大散列来计算最大散列。 此功能对大小写不敏感。

可以与 tupleHammingDistance 一起使用来检测半重复字符串。 对于两个字符串，如果返回的散列对两个字符串都是相同的，则这两个字符串是相同的。

语法

wordShingleMinHashCaseInsensitive(string[, shinglesize, hashnum])

参数

  • string — 要计算散列的字符串。 String
  • shinglesize — 可选。单词 shingles 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8
  • hashnum — 可选。用于计算结果的最小和最大散列的数量，范围从 1 到 25 的任何数字。默认值为 6。 UInt8

返回值

返回包含两个散列的元组 — 最小值和最大值。 Tuple(UInt64, UInt64)

示例

用法示例

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

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

wordShingleMinHashCaseInsensitiveUTF8​

引入于：v21.1

将 UTF-8 字符串拆分为 shinglesize 个单词的部分（shingles），计算每个单词 shingles 的散列值，并返回包含这些散列的元组。 使用 hashnum 个最小散列来计算最小散列，使用 hashnum 个最大散列来计算最大散列。 此功能对大小写不敏感。

可以与 tupleHammingDistance 一起使用来检测半重复字符串。 对于两个字符串，如果返回的散列对两个字符串都是相同的，则这两个字符串是相同的。

语法

wordShingleMinHashCaseInsensitiveUTF8(string[, shinglesize, hashnum])

参数

  • string — 要计算散列的字符串。 String
  • shinglesize — 可选。单词 shingles 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8
  • hashnum — 可选。用于计算结果的最小和最大散列的数量，范围从 1 到 25 的任何数字。默认值为 6。 UInt8

返回值

返回包含两个散列的元组 — 最小值和最大值。 Tuple(UInt64, UInt64)

示例

用法示例

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

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

wordShingleMinHashUTF8​

引入于：v21.1

将 UTF-8 字符串拆分为 shinglesize 个单词的部分（shingles），计算每个单词 shingles 的散列值，并返回包含这些散列的元组。 使用 hashnum 个最小散列来计算最小散列，使用 hashnum 个最大散列来计算最大散列。 此功能对大小写敏感。

可以与 tupleHammingDistance 一起使用来检测半重复字符串。 对于两个字符串，如果返回的散列对两个字符串都是相同的，则这两个字符串是相同的。

语法

wordShingleMinHashUTF8(string[, shinglesize, hashnum])

参数

  • string — 要计算散列的字符串。 String
  • shinglesize — 可选。单词 shingles 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8
  • hashnum — 可选。用于计算结果的最小和最大散列的数量，范围从 1 到 25 的任何数字。默认值为 6。 UInt8

返回值

返回包含两个散列的元组 — 最小值和最大值。 Tuple(UInt64, UInt64)

示例

用法示例

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

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

wordShingleSimHash​

引入于：v21.1

将 ASCII 字符串拆分为 shinglesize 个单词的部分（shingles），并返回单词 shingles 的 simhash。 此功能对大小写敏感。

可以与 bitHammingDistance 一起使用来检测半重复字符串。 计算出的两个字符串的 simhash 之间的 汉明距离 越小，这两个字符串相同的可能性就越大。

语法

wordShingleSimHash(string[, shinglesize])

参数

  • string — 要计算散列的字符串。 String
  • shinglesize — 可选。单词 shingles 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8

返回值

返回计算出的散列值。 UInt64

示例

用法示例

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

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

wordShingleSimHashCaseInsensitive​

引入于：v21.1

将 ASCII 字符串拆分为 shinglesize 个单词的部分（shingles），并返回单词 shingles 的 simhash。 此功能对大小写不敏感。

可以与 bitHammingDistance 一起使用来检测半重复字符串。 计算出的两个字符串的 simhash 之间的 汉明距离 越小，这两个字符串相同的可能性就越大。

语法

wordShingleSimHashCaseInsensitive(string[, shinglesize])

参数

  • string — 要计算散列的字符串。 String
  • shinglesize — 可选。单词 shingles 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8

返回值

返回计算出的散列值。 UInt64

示例

用法示例

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

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

wordShingleSimHashCaseInsensitiveUTF8​

引入于：v1.1

将 UTF-8 编码的字符串拆分为 shinglesize 个单词的部分（shingles），并返回单词 shingles 的 simhash。 此功能对大小写不敏感。

可以与 bitHammingDistance 一起使用来检测半重复字符串。 计算出的两个字符串的 simhash 之间的 汉明距离 越小，这两个字符串相同的可能性就越大。

语法

wordShingleSimHashCaseInsensitiveUTF8(string[, shinglesize])

参数

  • string — 要计算散列的字符串。 String
  • shinglesize — 可选。单词 shingles 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8

返回值

返回计算出的散列值。 UInt64

示例

用法示例

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

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

wordShingleSimHashUTF8​

引入于：v21.1

将 UTF-8 字符串拆分为 shinglesize 个单词的部分（shingles），并返回单词 shingles 的 simhash。 此功能对大小写敏感。

可以与 bitHammingDistance 一起使用来检测半重复字符串。 计算出的两个字符串的 simhash 之间的 汉明距离 越小，这两个字符串相同的可能性就越大。

语法

wordShingleSimHashUTF8(string[, shinglesize])

参数

  • string — 要计算散列的字符串。 String
  • shinglesize — 可选。单词 shingles 的大小，范围从 1 到 25 的任何数字。默认值为 3。 UInt8

返回值

返回计算出的散列值。 UInt64

示例

用法示例

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

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

wyHash64​

引入于：v22.7

计算 64 位 wyHash64 散列值。

语法

wyHash64(arg)

参数

  • arg — 要计算散列的字符串参数。 String

返回值

返回计算出的 64 位散列值 UInt64

示例

用法示例

SELECT wyHash64('ClickHouse') AS Hash;

12336419557878201794

xxHash32​

引入于：v20.1

从字符串计算 xxHash。

有关 64 位版本，请参见 xxHash64

语法

xxHash32(arg)

参数

  • arg — 输入字符串进行哈希。 String

返回值

返回计算出的输入字符串的 32 位散列。 UInt32

示例

用法示例

SELECT xxHash32('Hello, world!');

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

xxHash64​

引入于：v20.1

从字符串计算 xxHash。

有关 32 位版本，请参见 xxHash32

语法

xxHash64(arg)

参数

  • arg — 输入字符串进行哈希。 String

返回值

返回计算出的输入字符串的 64 位散列。 UInt64

示例

用法示例

SELECT xxHash64('Hello, world!');

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

xxh3​

引入于：v22.12

计算 XXH3 64 位散列值。

语法

xxh3(expr)

参数

  • expr — 任意数据类型的表达式列表。 Any

返回值

返回计算的 64 位 xxh3 散列值 UInt64

示例

用法示例

SELECT xxh3('ClickHouse')

18009318874338624809