哈希函数 - ClickHouse Documentation

哈希函数可用于以确定性的伪随机方式打乱元素顺序。 simhash 是一种哈希函数，对于接近 (相似) 的参数会返回接近的哈希值。大多数哈希函数都接受任意数量、任意类型的参数。

NULL 的哈希值为 NULL。要获取 Nullable 列的非 NULL 哈希值，请将其包装在 tuple 中：

SELECT cityHash64(tuple(NULL))

要计算整个表内容的哈希值，请使用 sum(cityHash64(tuple(*))) (或其他哈希函数) 。tuple 可确保包含 NULL 值的行不会被跳过。sum 可确保行的顺序不会影响结果。

BLAKE3

在 v22.10.0 中引入计算 BLAKE3 哈希字符串，并以 FixedString 返回结果字节集。该加密哈希函数通过 BLAKE3 Rust 库集成到 ClickHouse 中。该函数速度很快，与 SHA-2 相比，性能大约快两倍，同时生成的哈希长度与 SHA-256 相同。它将 BLAKE3 哈希作为类型为 FixedString(32) 的字节数组返回。语法

BLAKE3(message)

参数

message — 要进行哈希运算的输入字符串。String

返回值 返回输入字符串的 32 字节 BLAKE3 哈希值，类型为定长字符串。FixedString(32) 示例 hash

Query

SELECT hex(BLAKE3('ABC'))

Response

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

MD4

引入版本：v21.11.0 计算给定字符串的 MD4 哈希。语法

MD4(s)

参数

s — 要计算哈希的输入字符串。String

返回值 返回给定输入字符串的 MD4 哈希值，格式为定长字符串。FixedString(16) 示例 使用示例

Query

SELECT HEX(MD4('abc'));

Response

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

MD5

引入于：v1.1.0 计算给定字符串的 MD5 哈希值。语法

MD5(s)

参数

s — 待计算哈希的输入字符串。String

返回值 以定长字符串形式返回给定输入字符串的 MD5 哈希值。FixedString(16) 示例 使用示例

Query

SELECT HEX(MD5('abc'));

Response

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

RIPEMD160

引入版本：v24.10.0 计算给定字符串的 RIPEMD-160 哈希。语法

RIPEMD160(s)

参数

s — 要计算哈希的输入字符串。String

返回值 返回给定输入字符串的 RIPEMD160 哈希值，类型为定长字符串。FixedString(20) 示例 使用示例

Query

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

Response

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

SHA1

引入版本：v1.1.0 计算给定字符串的 SHA1 哈希值。语法

SHA1(s)

参数

s — 要进行哈希计算的输入字符串 String

返回值 以定长字符串形式返回给定输入字符串的 SHA1 哈希值。FixedString(20) 示例 使用示例

Query

SELECT HEX(SHA1('abc'));

Response

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

SHA224

引入版本：v1.1.0 计算给定字符串的 SHA224 哈希值。语法

SHA224(s)

参数

s — 要哈希的输入值。String

返回值 返回给定输入字符串的 SHA224 哈希值，类型为定长字符串。FixedString(28) 示例 使用示例

Query

SELECT HEX(SHA224('abc'));

Response

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

SHA256

Introduced in: v1.1.0 计算给定字符串的 SHA256 哈希值。语法

SHA256(s)

参数

s — 要计算哈希的输入字符串。String

返回值 返回给定输入字符串的 SHA256 哈希，类型为定长字符串。FixedString(32) 示例 使用示例

Query

SELECT HEX(SHA256('abc'));

Response

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

SHA384

引入版本：v1.1.0 计算给定字符串的 SHA384 哈希值。语法

SHA384(s)

参数

s — 要进行哈希计算的输入字符串。String

返回值 返回给定输入字符串的 SHA384 哈希值，类型为定长字符串。FixedString(48) 示例 使用示例

Query

SELECT HEX(SHA384('abc'));

Response

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

SHA512

引入于：v1.1.0 计算给定字符串的 SHA512 哈希值。语法

SHA512(s)

参数

s — 要哈希的输入字符串 String

返回值 返回给定输入字符串的 SHA512 哈希值，类型为定长字符串。FixedString(64) 示例 使用示例

Query

SELECT HEX(SHA512('abc'));

Response

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

SHA512_256

引入版本：v1.1.0 计算给定字符串的 SHA512_256 哈希值。语法

SHA512_256(s)

参数

s — 要计算哈希的输入字符串。String

返回值 返回给定输入字符串的 SHA512_256 哈希值，类型为定长字符串。FixedString(32) 示例 用法示例

Query

SELECT HEX(SHA512_256('abc'));

Response

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

URLHash

引入版本：v1.1.0 一种快速、质量较好的非加密哈希函数，用于对经过某种规范化处理后从 URL 得到的字符串计算哈希值。该哈希函数有两种模式：

Mode	Description
`URLHash(url)`	基于字符串计算哈希值；如果末尾存在 `/`、`?` 或 `#`，则会先去掉其中之一。
`URLHash(url, N)`	基于 URL 层级中直到第 N 级的字符串计算哈希值；如果末尾存在 `/`、`?` 或 `#`，则会先去掉其中之一。级别与 `URLHierarchy` 中相同。

语法

URLHash(url[, N])

参数

url — 要计算哈希的 URL 字符串。String
N — 可选。URL 层级中的层级。(U)Int*

返回值 返回 url 的哈希计算结果。UInt64 示例 用法示例

Query

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

Response

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

指定层级的 url 哈希值

Query

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

Response

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

cityHash64

引入版本：v1.1.0 生成一个 64 位 CityHash 哈希值。这是一种快速的非加密哈希函数。对于字符串参数，它使用 CityHash 算法；对于其他数据类型的参数，则使用特定于实现的快速非加密哈希函数。该函数使用 CityHash 组合器来生成最终结果。

Google 在将 CityHash 引入 ClickHouse 后修改了该算法。换句话说，ClickHouse 的 cityHash64 与 Google 上游的 CityHash 现在会产生不同的结果。 ClickHouse 的 cityHash64 对应于 CityHash v1.0.2。

对于参数类型不同但输入值相同的情况，计算得到的哈希值可能相同。例如，这会影响不同位宽的整数类型、数据相同的具名和非具名 Tuple，以及数据相同的 Map 和对应的 Array(Tuple(key, value)) 类型。

语法

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

参数

arg1[, arg2, ...] — 用于计算哈希的可变数量输入参数。(Any)

返回值 返回根据输入参数计算出的哈希值。(UInt64) 示例 调用示例

Query

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

Response

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

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

Query

CREATE TABLE users (
    id UInt32,
    name String,
    age UInt8,
    city String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO users VALUES
(1, 'Alice', 25, 'New York'),
(2, 'Bob', 30, 'London'),
(3, 'Charlie', 35, 'Tokyo');

SELECT groupBitXor(cityHash64(*)) FROM users;

Response

┌─groupBitXor(⋯age, city))─┐
│     11639977218258521182 │
└──────────────────────────┘

farmFingerprint64

引入版本：v20.12.0 使用 Fingerprint64 方法生成 64 位的 FarmHash 值。

相比 farmHash64，为了获得稳定且可移植的值，优先使用 farmFingerprint64。

对于参数类型不同但输入值相同的情况，计算出的哈希值可能相同。例如，这会影响不同大小的整数类型、具有相同数据的具名和非具名 Tuple，以及具有相同数据的 Map 和对应的 Array(Tuple(key, value)) 类型。

语法

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

参数

arg1[, arg2, ...] — 用于计算哈希值的可变数量输入参数。Any

返回值 返回根据输入参数计算得出的哈希值。UInt64 示例 用法示例

Query

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

Response

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

farmHash64

引入版本：v1.1.0 使用 Hash64 方法生成 64 位 FarmHash 值。

如需稳定且可移植的值，建议优先使用 farmFingerprint64。

对于参数类型不同但输入值相同的情况，计算得到的哈希值可能相同。例如，不同位宽的整数类型、数据相同的具名与非具名 Tuple，以及数据相同的 Map 与对应的 Array(Tuple(key, value)) 类型都会受到影响。

语法

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

参数

arg1[, arg2, ...] — 要计算哈希的输入参数，数量可变。Any

返回值 返回根据输入参数计算得到的哈希值。UInt64 示例 使用示例

Query

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

Response

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

gccMurmurHash

引入版本：v20.1.0 使用与 GCC 相同的 seed，计算输入值的 64 位 MurmurHash2 哈希值。它在 Clang 和 GCC 的构建之间具有可移植性。语法

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

参数

arg1[, arg2, ...] — 要计算哈希的可变数量参数。Any

返回值 返回输入参数计算得到的哈希值。UInt64 示例 使用示例

Query

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

Response

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

halfMD5

引入于：v1.1.0 将所有输入参数都解释为字符串，并分别计算其 MD5 哈希值。然后将这些哈希组合起来，取结果字符串哈希值的前 8 个字节，并按大端字节序将其解释为 UInt64。该函数相对较慢 (每个处理器核心每秒可处理 500 万个短字符串) 。建议改用 sipHash64 函数。该函数接受数量可变的输入参数。参数可以是任意受支持的数据类型。对于某些数据类型，即使参数类型不同，相同的值计算出的哈希值也可能相同 (例如不同大小的整数、包含相同数据的命名和未命名 Tuple，以及包含相同数据的 Map 和对应的 Array(Tuple(key, value)) 类型) 。语法

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

参数

arg1[, arg2, ..., argN] — 用于计算哈希的数量可变的参数。Any

返回值 返回根据给定输入参数计算得出的一半 MD5 哈希值，结果以大端字节序的 UInt64 形式表示。UInt64 示例 使用示例

Query

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

Response

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

hiveHash

引入版本：v20.1.0 根据字符串计算 “HiveHash”。它实际上就是将符号位清零后的 JavaHash。在 3.0 之前的版本中，Apache Hive 使用此函数。

此哈希函数性能较差。仅当其他系统已使用此算法，且你需要计算相同结果时，才应使用它。

语法

hiveHash(arg)

参数

arg — 要计算哈希的输入字符串。String

返回值 返回输入字符串的“hive 哈希”计算结果。Int32 示例 使用示例

Query

SELECT hiveHash('Hello, world!');

Response

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

icebergHash

首次引入于：v25.5.0 实现了 Iceberg 哈希转换的逻辑语法

icebergHash(value)

参数

value — 要计算哈希的源值，类型可以是 Integer、Bool、Decimal、Float*、String、FixedString、UUID、Date、Time 或 DateTime

返回值 返回一个 32 位的 Murmur3 哈希值 (x86 变体) ，种子为 0，类型为 Int32 示例示例

Query

SELECT icebergHash(1.0 :: Float32)

Response

-142385009

intHash32

引入版本：v1.1.0 计算整数的 32 位哈希值。该哈希函数速度较快，但不是加密哈希函数。语法

intHash32(arg)

参数

arg — 要计算哈希值的整数。(U)Int*

返回值 返回输入整数计算得到的 32 位哈希值 UInt32 示例 用法示例

Query

SELECT intHash32(42);

Response

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

intHash64

引入版本：v1.1.0 计算整数的 64 位哈希值。该哈希函数速度较快 (甚至比 intHash32 还快) ，但不是加密哈希函数。语法

intHash64(int)

参数

int — 要计算哈希的整数。(U)Int*

返回值 64 位哈希值。UInt64 示例 使用示例

Query

SELECT intHash64(42);

Response

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

javaHash

引入版本：v20.1.0 根据以下类型的值计算 JavaHash：

此哈希函数性能较差。仅当其他系统已在使用该算法，且你需要计算相同结果时，才应使用它。

Java 仅支持计算有符号整数的哈希，因此，如果你想计算无符号整数的哈希，必须先将它们转换为相应的有符号 ClickHouse 类型。

语法

javaHash(arg)

参数

arg — 要进行哈希计算的输入值。Any

返回值 返回 arg 的计算哈希值 Int32 示例 使用示例 1

Query

SELECT javaHash(toInt32(123));

Response

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

使用示例 2

Query

SELECT javaHash('Hello, world!');

Response

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

javaHashUTF16LE

引入版本：v20.1.0 根据一个字符串计算 JavaHash，假定其中包含的是表示 UTF-16LE 编码字符串的字节。语法

javaHashUTF16LE(arg)

参数

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

返回值 返回该 UTF-16LE 编码字符串的哈希值。Int32 示例 用法示例

Query

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

Response

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

jumpConsistentHash

版本引入：v1.1.0 计算一个整数的跳跃一致性哈希。语法

jumpConsistentHash(key, buckets)

参数

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

返回值 返回计算出的哈希值。Int32 示例 使用示例

Query

SELECT jumpConsistentHash(256, 4)

Response

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

kafkaMurmurHash

引入版本：v23.4.0 使用与 Kafka 相同的种子值，计算输入值的 32 位 MurmurHash2 哈希，并去除最高位，以兼容 Default Partitioner。语法

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

参数

arg1[, arg2, ...] — 用于计算哈希的可变数量的参数。Any

返回值 返回根据输入参数计算得到的哈希值。UInt32 示例 使用示例

Query

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

Response

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

keccak256

引入版本：v25.4.0 计算给定字符串的 Keccak-256 加密哈希值。这种哈希函数广泛用于区块链应用，尤其是以太坊。语法

keccak256(message)

参数

message — 要进行哈希计算的输入字符串。String

返回值 返回输入字符串的 32 字节 Keccak-256 哈希，类型为定长字符串。FixedString(32) 示例 使用示例

Query

SELECT hex(keccak256('hello'))

Response

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

kostikConsistentHash

Introduced in：v22.6.0 这是 Konstantin ‘Kostik’ Oblakov 提出的一种时间和空间复杂度均为 O(1) 的一致性哈希算法。仅在 n <= 32768 时才高效。 Syntax

kostikConsistentHash(input, n)

别名: yandexConsistentHash 参数

input — 一个整型键。UInt64
n — 桶的数量。UInt16

返回值 返回计算得到的哈希值。UInt16 示例 使用示例

Query

SELECT kostikConsistentHash(16045690984833335023, 2);

Response

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

metroHash64

引入版本：v1.1.0 生成一个 64 位的 MetroHash 哈希值。

对于不同参数类型中相同的输入值，计算出的哈希值可能相同。例如，这会影响不同位宽的整数类型、数据相同的具名和非具名 Tuple，以及数据相同的 Map 和对应的 Array(Tuple(key, value)) 类型。

语法

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

参数

arg1[, arg2, ...] — 用于计算哈希的可变数量输入参数。Any

返回值 返回根据输入参数计算出的哈希值。UInt64 示例 使用示例

Query

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

Response

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

murmurHash2_32

Introduced in：v18.5.0 计算输入值的 MurmurHash2 哈希值。

对于数值相同但参数类型不同的输入，计算得到的哈希值可能相同。例如，这会影响不同位宽的整数类型、数据相同的具名和非具名 Tuple，以及数据相同的 Map 和对应的 Array(Tuple(key, value)) 类型。

Syntax

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

参数

arg1[, arg2, ...] — 用于计算哈希的可变数量的输入参数。Any

返回值 返回根据输入参数计算出的哈希值。UInt32 示例 用法示例

Query

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

Response

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

murmurHash2_64

引入版本：v18.10.0 计算输入值的 MurmurHash2 哈希值。

对于参数类型不同但输入值相同的情况，计算出的哈希值可能相同。例如，这会影响不同位宽的整数类型、数据相同的具名和非具名 Tuple，以及数据相同的 Map 与对应的 Array(Tuple(key, value)) 类型。

语法

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

参数

arg1[, arg2, ...] — 用于计算哈希的输入参数，数量可变。Any

返回值 返回输入参数计算得到的哈希值。UInt64 示例 使用示例

Query

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

Response

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

murmurHash3_128

引入版本：v18.10.0 计算输入值的 128 位 MurmurHash3 哈希值。语法

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

参数

arg1[, arg2, ...] — 用于计算哈希的可变数量输入参数。Any

返回值 返回输入参数计算得出的 128 位 MurmurHash3 哈希值。FixedString(16) 示例 使用示例

Query

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

Response

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

murmurHash3_32

引入版本：v18.10.0 生成 MurmurHash3 哈希值。

对于 argument 类型不同但输入值相同的情况，计算出的哈希值可能会相同。例如，这会影响不同大小的整数类型、数据相同的具名和非具名 Tuple，以及数据相同的 Map 与对应的 Array(Tuple(key, value)) 类型。

语法

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

参数

arg1[, arg2, ...] — 用于计算哈希的数量可变的输入参数。Any

返回值 返回根据输入参数计算得到的哈希值。UInt32 示例 使用示例

Query

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

Response

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

murmurHash3_64

引入版本：v18.10.0 计算输入值的 MurmurHash3 哈希。

对于参数类型不同但输入值相同的情况，计算得到的哈希值可能相同。例如，这会影响不同位宽的整数类型、数据相同的具名和非具名 Tuple，以及数据相同的 Map 与对应的 Array(Tuple(key, value)) 类型。

语法

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

参数

arg1[, arg2, ...] — 用于计算哈希的可变数量输入参数。Any

返回值 返回输入参数计算得到的哈希值。UInt64 示例 用法示例

Query

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

Response

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

ngramMinHash

引入版本：v21.1.0 将 ASCII 字符串拆分为由 ngramsize 个符号组成的 n-gram，计算每个 n-gram 的哈希值，并返回包含这些哈希值的 Tuple。使用 hashnum 个最小哈希值计算最小哈希，使用 hashnum 个最大哈希值计算最大哈希。该函数区分大小写。可结合 tupleHammingDistance 用于检测半重复字符串。对于两个字符串，如果返回的哈希值对两者都相同，则这两个字符串相同。语法

ngramMinHash(string[, ngramsize, hashnum])

参数

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

返回值 返回一个包含两个哈希值 (最小值和最大值) 的 Tuple。Tuple 示例 用法示例

Query

SELECT ngramMinHash('ClickHouse') AS Tuple;

Response

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

ngramMinHashArg

引入版本：v21.1.0 将 ASCII 字符串拆分为由 ngramsize 个符号组成的 n-gram，并返回基于相同输入由 ngramMinHash 函数计算出的哈希值最小和最大的 n-gram。该函数区分大小写。语法

ngramMinHashArg(string[, ngramsize, hashnum])

参数

string — 要计算哈希的 String。String
ngramsize — 可选。n-gram 的长度，可为 1 到 25 之间的任意数值。默认值为 3。UInt8
hashnum — 可选。用于计算结果的最小哈希和最大哈希的数量，可为 1 到 25 之间的任意数值。默认值为 6。UInt8

返回值 返回一个 Tuple，其中包含两个 Tuple，每个 Tuple 各含 hashnum 个 n-gram。Tuple(String) 示例 使用示例

Query

SELECT ngramMinHashArg('ClickHouse') AS Tuple;

Response

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

ngramMinHashArgCaseInsensitive

引入于：v21.1.0 将 ASCII 字符串拆分为由 ngramsize 个符号组成的 n-grams，并返回在相同输入下由 ngramMinHashCaseInsensitive 函数计算得到的哈希值最小和最大的 n-grams。该函数不区分大小写。语法

ngramMinHashArgCaseInsensitive(string[, ngramsize, hashnum])

参数

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

返回值 返回一个由两个 Tuple 组成的 Tuple，每个 Tuple 包含 hashnum 个 n-gram。Tuple(Tuple(String)) 示例 使用示例

Query

SELECT ngramMinHashArgCaseInsensitive('ClickHouse') AS Tuple;

Response

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

ngramMinHashArgCaseInsensitiveUTF8

引入于：v21.1.0 将 UTF-8 字符串按 ngramsize 个符号拆分为 n-grams，并返回使用相同输入由 ngramMinHashCaseInsensitiveUTF8 函数计算出的哈希值最小和最大的 n-grams。该函数不区分大小写。语法

ngramMinHashArgCaseInsensitiveUTF8(string[, ngramsize, hashnum])

参数

string — 要计算哈希的 String。String
ngramsize — 可选。n-gram 的长度，可为 1 到 25 之间的任意数值。默认值为 3。UInt8
hashnum — 可选。用于计算结果的最小哈希和最大哈希的数量，可为 1 到 25 之间的任意数值。默认值为 6。UInt8

返回值 返回一个 Tuple，其中包含两个 Tuple，每个 Tuple 各含有 hashnum 个 n-gram。Tuple(Tuple(String)) 示例 用法示例

Query

SELECT ngramMinHashArgCaseInsensitiveUTF8('ClickHouse') AS Tuple;

Response

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

ngramMinHashArgUTF8

引入版本：v21.1.0 将一个 UTF-8 字符串拆分为由 ngramsize 个符号组成的 n-gram，并返回在相同输入下由 ngramMinHashUTF8 函数计算得到的哈希值最小和最大的 n-gram。该函数区分大小写。语法

ngramMinHashArgUTF8(string[, ngramsize, hashnum])

参数

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

返回值 返回一个元组，其中包含两个元组，每个元组各有 hashnum 个 n-gram。Tuple(Tuple(String)) 示例 使用示例

Query

SELECT ngramMinHashArgUTF8('ClickHouse') AS Tuple;

Response

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

ngramMinHashCaseInsensitive

引入版本：v21.1.0 将 ASCII 字符串拆分为由 ngramsize 个符号组成的 n-gram，计算每个 n-gram 的哈希值，并返回包含这些哈希值的 Tuple。使用 hashnum 个最小哈希值计算最小哈希，使用 hashnum 个最大哈希值计算最大哈希。该函数不区分大小写。可与 tupleHammingDistance 配合使用，以检测近似重复字符串。对于两个字符串，如果两者返回的哈希值相同，则这两个字符串相同。语法

ngramMinHashCaseInsensitive(string[, ngramsize, hashnum])

参数

string — String。String。- ngramsize — n-gram 的大小。可选。可能的值：1 到 25 之间的任意数值。默认值：3。UInt8。- hashnum — 用于计算结果的最小哈希值和最大哈希值的数量。可选。可能的值：1 到 25 之间的任意数值。默认值：6。UInt8。

返回值 包含两个哈希值 (最小值和最大值) 的 Tuple。Tuple(UInt64, UInt64)。Tuple 示例 使用示例

Query

SELECT ngramMinHashCaseInsensitive('ClickHouse') AS Tuple;

Response

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

ngramMinHashCaseInsensitiveUTF8

引入版本：v21.1.0 将 UTF-8 字符串拆分为由 ngramsize 个符号组成的 n-gram，计算每个 n-gram 的哈希值，并返回一个包含这些哈希值的 Tuple。使用 hashnum 个最小哈希值来计算最小哈希，使用 hashnum 个最大哈希值来计算最大哈希。此函数不区分大小写。可结合 tupleHammingDistance 用于检测半重复字符串。对于两个字符串，如果两者返回的哈希值相同，则这两个字符串相同。语法

ngramMinHashCaseInsensitiveUTF8(string [, ngramsize, hashnum])

参数

string — 用于计算哈希的 String。String
ngramsize — 可选。n-gram 的大小，可为 1 到 25 之间的任意数值。默认值为 3。UInt8
hashnum — 可选。用于计算结果的最小和最大哈希值的数量，可为 1 到 25 之间的任意数值。默认值为 6。UInt8

返回值 返回一个包含两个哈希值 (最小值和最大值) 的 Tuple。Tuple 示例 使用示例

Query

SELECT ngramMinHashCaseInsensitiveUTF8('ClickHouse') AS Tuple;

Response

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

ngramMinHashUTF8

引入版本：v21.1.0 将 UTF-8 字符串按 ngramsize 个符号切分为 n-gram，计算每个 n-gram 的哈希值，并返回包含这些哈希值的 Tuple。使用 hashnum 个最小哈希值计算最小哈希，使用 hashnum 个最大哈希值计算最大哈希。该函数区分大小写。可与 tupleHammingDistance 配合使用，以检测半重复字符串。对于两个字符串，如果两者返回的哈希值相同，则这两个字符串相同。语法

ngramMinHashUTF8(string[, ngramsize, hashnum])

参数

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

返回值 返回一个包含两个哈希值 (最小值和最大值) 的 Tuple。Tuple 示例 使用示例

Query

SELECT ngramMinHashUTF8('ClickHouse') AS Tuple;

Response

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

ngramSimHash

引入版本：v21.1.0 将 ASCII 字符串拆分为由 ngramsize 个符号组成的 n-gram，并返回这些 n-gram 的 simhash。可结合 bitHammingDistance 用于检测近似重复字符串。两个字符串计算得到的 simhashes 的 Hamming 距离越小，这两个字符串越可能相同。语法

ngramSimHash(string[, ngramsize])

参数

string — 用于计算区分大小写 simhash 的字符串。String
ngramsize — 可选。n-gram 的大小，可为 1 到 25 之间的任意数值。默认值为 3。UInt8

返回值 返回输入字符串计算得到的哈希值。UInt64 示例 使用示例

Query

SELECT ngramSimHash('ClickHouse') AS Hash;

Response

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

ngramSimHashCaseInsensitive

引入版本：v21.1.0 将 ASCII 字符串拆分为由 ngramsize 个符号组成的 n-gram，并返回该 n-gram 的 simhash。它不区分大小写。可结合 bitHammingDistance 用于检测半重复字符串。两个字符串计算得到的 simhashes 的 Hamming 距离越小，这些字符串就越可能相同。语法

ngramSimHashCaseInsensitive(string[, ngramsize])

参数

string — 用于计算不区分大小写的 simhash 的字符串。String
ngramsize — 可选。n-gram 的大小，可为 1 到 25 之间的任意数值。默认值为 3。UInt8

返回值 哈希值。UInt64。UInt64 示例 使用示例

Query

SELECT ngramSimHashCaseInsensitive('ClickHouse') AS Hash;

Response

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

ngramSimHashCaseInsensitiveUTF8

引入版本：v21.1.0 将 UTF-8 字符串按 ngramsize 个符号切分为 n-gram，并返回这些 n-gram 的 simhash。该函数不区分大小写。可结合 bitHammingDistance 用于检测半重复字符串。两个字符串计算出的 simhashes 的 Hamming 距离越小，这些字符串就越可能相同。语法

ngramSimHashCaseInsensitiveUTF8(string[, ngramsize])

参数

string — 用于计算哈希的 String。String
ngramsize — 可选。n-gram 的大小，可以是从 1 到 25 的任意数值。默认值为 3。UInt8

返回值 返回计算得到的哈希值。UInt64 示例 使用示例

Query

SELECT ngramSimHashCaseInsensitiveUTF8('ClickHouse') AS Hash;

Response

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

ngramSimHashUTF8

引入版本：v21.1.0 将一个 UTF-8 编码的字符串按 ngramsize 个符号切分为 n-grams，并返回这些 n-gram 的 simhash。该函数区分大小写。可结合 bitHammingDistance 用于检测近似重复字符串。两个字符串计算得到的 simhashes 的 Hamming 距离越小，这些字符串就越有可能相同。语法

ngramSimHashUTF8(string[, ngramsize])

参数

string — 要计算其哈希值的字符串。String
ngramsize — 可选。n-gram 的大小，可以是从 1 到 25 的任意数值。默认值为 3。UInt8

返回值 返回计算得到的哈希值。UInt64 示例 使用示例

Query

SELECT ngramSimHashUTF8('ClickHouse') AS Hash;

Response

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

sipHash128

引入版本：v1.1.0 与 sipHash64 类似，但会生成 128 位哈希值，即最终的异或折叠状态会一直处理到 128 位。

新项目请使用 sipHash128Reference这个 128 位变体与参考实现不同，且强度更弱。之所以保留这个版本，是因为编写它时，SipHash 还没有官方的 128 位扩展。建议新项目使用 sipHash128Reference。

语法

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

参数

arg1[, arg2, ...] — 用于计算哈希值的可变数量输入参数。Any

返回值 返回一个 128 位的 SipHash 哈希值。FixedString(16) 示例 使用示例

Query

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

Response

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

sipHash128Keyed

引入版本：v23.2.0 与 sipHash128 相同，但会额外接受一个显式指定的密钥参数，而不是使用固定密钥。

新项目请使用 sipHash128ReferenceKeyed这个 128 位变体与参考实现不同，而且安全性更弱。之所以保留这个版本，是因为在编写它时，SipHash 还没有官方的 128 位扩展。新项目应优先使用 sipHash128ReferenceKeyed。

语法

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

参数

(k0, k1) — 由两个 UInt64 值组成、表示键的元组。Tuple(UInt64, UInt64)
arg1[, arg2, ...] — 用于计算哈希的数量可变的输入参数。Any

返回值 类型为 FixedString(16) 的 128 位 SipHash 哈希值。FixedString(16) 示例 使用示例

Query

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

Response

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

sipHash128Reference

引入版本：v23.2.0 与 sipHash128 类似，但实现了由 SipHash 原作者提出的 128 位算法。语法

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

参数

arg1[, arg2, ...] — 用于计算哈希值的可变数量输入参数。Any

返回值 返回根据输入参数计算出的 128 位 SipHash 哈希值。FixedString(16) 示例 使用示例

Query

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

Response

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

sipHash128ReferenceKeyed

引入版本：v23.2.0 与 sipHash128Reference 相同，但会额外接受一个显式指定的密钥参数，而不是使用固定密钥。语法

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

参数

(k0, k1) — 由两个值组成、表示键的 Tuple。Tuple(UInt64, UInt64)
arg1[, arg2, ...] — 用于计算哈希的可变数量输入参数。Any

返回值 返回根据输入参数计算得出的 128 位 SipHash 哈希值。FixedString(16) 示例 使用示例

Query

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

Response

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

sipHash64

引入版本：v1.1.0 生成 64 位的 SipHash 哈希值。这是一种加密哈希函数。它的运行速度至少比 MD5 哈希函数快 3 倍。该函数会将所有输入参数都解释为字符串，并分别计算每个参数的哈希值。然后，它会使用以下算法组合这些哈希值：

将第一个和第二个哈希值拼接为一个数组，并对其进行哈希计算。
将前一步计算出的哈希值与第三个输入参数的哈希值，按类似方式再次进行哈希计算。
对原始输入中其余所有哈希值重复这一计算过程。

对于参数类型不同但输入值相同的情况，计算出的哈希值可能相同。例如，这会影响不同大小的整数类型、具有相同数据的具名和匿名 Tuple，以及具有相同数据的 Map 和对应的 Array(Tuple(key, value)) 类型。

语法

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

参数

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

返回值 返回根据输入参数计算出的哈希值。UInt64 示例 用法示例

Query

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

Response

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

sipHash64Keyed

引入版本：v23.2.0 与 sipHash64 类似，但它额外接受一个显式指定的 key 参数，而不是使用固定键。语法

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

参数

(k0, k1) — 由两个值组成、用于表示键的 Tuple。Tuple(UInt64, UInt64)
arg1[,arg2, ...] — 数量可变的输入参数。Any

返回值 返回根据输入值计算得到的哈希值。UInt64 示例 用法示例

Query

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

Response

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

wordShingleMinHash

引入版本：v21.1.0 将 ASCII 字符串拆分成由 shinglesize 个单词组成的多个部分 (分区片段) ，计算每个单词分区片段的哈希值，并返回包含这些哈希值的元组。使用 hashnum 个最小哈希值来计算最小哈希，使用 hashnum 个最大哈希值来计算最大哈希。该函数区分大小写。可借助 tupleHammingDistance 检测近似重复字符串。对于两个字符串，如果两者返回的哈希值相同，则这两个字符串相同。语法

wordShingleMinHash(string[, shinglesize, hashnum])

参数

string — 要计算其哈希值的字符串。String
shinglesize — 可选。分区片段的大小，可为 1 到 25 之间的任意数值。默认值为 3。UInt8
hashnum — 可选。用于计算结果的最小和最大哈希值数量，可为 1 到 25 之间的任意数值。默认值为 6。UInt8

返回值 返回一个包含两个哈希值 (最小值和最大值) 的 Tuple。Tuple(UInt64, UInt64) 示例 使用示例

Query

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

Response

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

wordShingleMinHashArg

引入版本：v1.1.0 将一个 ASCII 字符串拆分为若干部分 (shingles) ，每个部分包含 shinglesize 个单词，并返回在相同输入下由 wordShingleMinHash 函数计算得到的单词哈希值最小和最大的 shingles。它区分大小写。语法

wordShingleMinHashArg(string[, shinglesize, hashnum])

参数

string — 要计算哈希的 String。String
shinglesize — 可选。分区片段的大小，取值范围为 1 到 25。默认值为 3。UInt8
hashnum — 可选。用于计算结果的最小哈希和最大哈希的数量，取值范围为 1 到 25。默认值为 6。UInt8

返回值 返回一个包含两个元组的元组，每个元组包含 hashnum 个分区片段。Tuple(Tuple(String)) 示例 使用示例

Query

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

Response

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

wordShingleMinHashArgCaseInsensitive

引入版本：v21.1.0 将 ASCII 字符串按每 shinglesize 个单词切分为若干部分 (shingles) ，并返回在相同输入下由 wordShingleMinHashCaseInsensitive 函数计算出的单词哈希值最小和最大的 shingles。该函数不区分大小写。语法

wordShingleMinHashArgCaseInsensitive(string[, shinglesize, hashnum])

参数

string — 要计算哈希的字符串。 String
shinglesize — 可选。分区片段的大小，取值范围为 1 到 25。默认值为 3。 UInt8
hashnum — 可选。用于计算结果的最小和最大哈希的数量，取值范围为 1 到 25。默认值为 6。 UInt8

返回值 返回一个 Tuple，其中包含两个 Tuple，每个 Tuple 包含 hashnum 个分区片段。 Tuple(Tuple(String)) 示例 使用示例

Query

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

Response

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

wordShingleMinHashArgCaseInsensitiveUTF8

引入于：v21.1.0 将 UTF-8 字符串按每 shinglesize 个单词切分为若干部分 (shingles) ，并返回在相同输入下由 wordShingleMinHashCaseInsensitiveUTF8 函数计算出的单词哈希值最小和最大的 shingles。它不区分大小写。语法

wordShingleMinHashArgCaseInsensitiveUTF8(string[, shinglesize, hashnum])

参数

string — 要计算哈希的 String。String
shinglesize — 可选。单个分区片段的大小，可为 1 到 25 之间的任意数值。默认值为 3。UInt8
hashnum — 可选。用于计算结果的最小哈希值和最大哈希值的数量，可为 1 到 25 之间的任意数值。默认值为 6。UInt8

返回值 返回一个包含两个 Tuple 的 Tuple，每个 Tuple 都包含 hashnum 个分区片段。Tuple(Tuple(String)) 示例 使用示例

Query

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

Response

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

wordShingleMinHashArgUTF8

引入版本：v21.1.0 将一个 UTF-8 字符串按每 shinglesize 个单词切分为若干部分 (shingles) ，并返回在相同输入下由 wordShingleMinHashUTF8 函数计算出的单词哈希值最小和最大的 shingles。它区分大小写。语法

wordShingleMinHashArgUTF8(string[, shinglesize, hashnum])

参数

string — 要计算哈希的 String。String
shinglesize — 可选。分区片段的大小，可为 1 到 25 之间的任意数值。默认值为 3。UInt8
hashnum — 可选。用于计算结果的最小哈希和最大哈希的数量，可为 1 到 25 之间的任意数值。默认值为 6。UInt8

返回值 返回一个 Tuple，其中包含两个 Tuple，每个 Tuple 包含 hashnum 个分区片段。Tuple(Tuple(String)) 示例 使用示例

Query

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

Response

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

wordShingleMinHashCaseInsensitive

引入版本：v21.1.0 将 ASCII 字符串按每 shinglesize 个单词一组拆分为多个分区片段，计算每个分区片段的哈希值，并返回一个包含这些哈希值的元组。使用 hashnum 个最小哈希值计算最小哈希，使用 hashnum 个最大哈希值计算最大哈希。它不区分大小写。可用于通过 tupleHammingDistance 检测近似重复字符串。对于两个字符串，如果两者返回的哈希值相同，则这两个字符串相同。语法

wordShingleMinHashCaseInsensitive(string[, shinglesize, hashnum])

参数

string — 用于计算哈希的字符串。String
shinglesize — 可选。分区片段的大小，取值范围为 1 到 25。默认值为 3。UInt8
hashnum — 可选。用于计算结果的最小和最大哈希数量，取值范围为 1 到 25。默认值为 6。UInt8

返回值 返回一个包含两个哈希值的 Tuple，即最小哈希和最大哈希。Tuple(UInt64, UInt64) 示例 用法示例

Query

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

Response

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

wordShingleMinHashCaseInsensitiveUTF8

引入版本：v21.1.0 将一个 UTF-8 字符串拆分为由 shinglesize 个单词组成的分区片段 (shingles) ，计算每个分区片段的哈希值，并返回一个包含这些哈希的 Tuple。使用 hashnum 个最小哈希值计算最小哈希，使用 hashnum 个最大哈希值计算最大哈希。该函数不区分大小写。可结合 tupleHammingDistance 用于检测半重复字符串。对于两个字符串，如果两者返回的哈希相同，则这两个字符串相同。语法

wordShingleMinHashCaseInsensitiveUTF8(string[, shinglesize, hashnum])

参数

string — 用于计算哈希的字符串。String
shinglesize — 可选。分区片段的大小，取值范围为 1 到 25。默认值为 3。UInt8
hashnum — 可选。用于计算结果的最小和最大哈希值个数，取值范围为 1 到 25。默认值为 6。UInt8

返回值 返回一个包含两个哈希的 Tuple——最小哈希和最大哈希。Tuple(UInt64, UInt64) 示例 使用示例

Query

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

Response

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

wordShingleMinHashUTF8

引入版本：v21.1.0 将 UTF-8 字符串拆分为由 shinglesize 个单词组成的片段 (分区片段) ，计算每个分区片段的哈希值，并返回包含这些哈希值的元组。使用 hashnum 个最小哈希值来计算最小哈希，使用 hashnum 个最大哈希值来计算最大哈希。该函数区分大小写。可结合 tupleHammingDistance 使用，以检测近似重复字符串。对于两个字符串，如果返回的哈希值在两者中都相同，则这两个字符串相同。语法

wordShingleMinHashUTF8(string[, shinglesize, hashnum])

参数

string — 要计算其哈希值的字符串。String
shinglesize — 可选。词分区片段的大小，可为 1 到 25 之间的任意数值。默认值为 3。UInt8
hashnum — 可选。用于计算结果的最小哈希和最大哈希的数量，可为 1 到 25 之间的任意数值。默认值为 6。UInt8

返回值 返回一个包含两个哈希值的元组——最小哈希和最大哈希。Tuple(UInt64, UInt64) 示例 使用示例

Query

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

Response

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

wordShingleSimHash

引入版本：v21.1.0 将 ASCII 字符串拆分为由 shinglesize 个单词组成的分区片段 (shingles) ，并返回这些分区片段的 simhash。该函数区分大小写。可结合 bitHammingDistance 用于检测近似重复字符串。两个字符串计算得到的 simhashes 的 Hamming 距离越小，这些字符串就越可能相同。语法

wordShingleSimHash(string[, shinglesize])

参数

string — 用于计算哈希的 String。String
shinglesize — 可选。词分区片段的大小，可为 1 到 25 之间的任意数值。默认值为 3。UInt8

返回值 返回计算得到的哈希值。UInt64 示例 用法示例

Query

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

Response

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

wordShingleSimHashCaseInsensitive

引入版本：v21.1.0 将 ASCII 字符串按 shinglesize 个单词拆分为若干部分 (shingles) ，并返回这些词分区片段的 simhash。它不区分大小写。可与 bitHammingDistance 结合使用，以检测近似重复字符串。两个字符串计算得到的 simhash 的 Hamming 距离越小，这些字符串相同的可能性就越大。语法

wordShingleSimHashCaseInsensitive(string[, shinglesize])

参数

string — 用于计算哈希的 String。 String
shinglesize — 可选。词分区片段的大小，可为 1 到 25 之间的任意数值。默认值为 3。 UInt8

返回值 返回计算得到的哈希值。 UInt64 示例 使用示例

Query

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

Response

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

wordShingleSimHashCaseInsensitiveUTF8

引入版本：v1.1.0 将 UTF-8 编码的字符串拆分为由 shinglesize 个单词组成的多个片段 (shingles) ，并返回这些词分区片段的 simhash。此函数不区分大小写。可与 bitHammingDistance 配合使用，以检测近似重复字符串。两个字符串计算得到的 simhashes 的 Hamming 距离越小，它们越有可能相同。语法

wordShingleSimHashCaseInsensitiveUTF8(string[, shinglesize])

参数

string — 要计算其哈希值的 String。String
shinglesize — 可选。分区片段的长度，可为 1 到 25 之间的任意数值。默认值为 3。UInt8

返回值 返回计算得到的哈希值。UInt64 示例 使用示例

Query

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

Response

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

wordShingleSimHashUTF8

引入版本：v21.1.0 将 UTF-8 字符串按每 shinglesize 个单词拆分为若干部分 (shingles) ，并返回单词分区片段的 simhash。它区分大小写。可与 bitHammingDistance 结合使用，以检测近似重复字符串。两个字符串计算得到的 simhashes 的 Hamming 距离越小，这两个字符串越可能相同。语法

wordShingleSimHashUTF8(string[, shinglesize])

参数

string — 要计算哈希值的字符串。String
shinglesize — 可选。分区片段的大小，可为 1 到 25 之间的任意数值。默认值为 3。UInt8

返回值 返回计算得到的哈希值。UInt64 示例 用法示例

Query

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

Response

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

wyHash64

引入版本：v22.7.0 计算 wyHash64 的 64 位哈希值。语法

wyHash64(arg)

参数

arg — 要计算哈希的 String 参数。String

返回值 返回计算得到的 64 位哈希值 UInt64 示例 使用示例

Query

SELECT wyHash64('ClickHouse') AS Hash;

Response

12336419557878201794

xxHash32

引入版本：v20.1.0 计算字符串的 xxHash 哈希值。 64 位版本参见 xxHash64 语法

xxHash32(arg)

参数

arg — 要计算哈希值的输入字符串。String

返回值 返回输入字符串的 32 位哈希值。UInt32 示例 用法示例

Query

SELECT xxHash32('Hello, world!');

Response

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

xxHash64

引入版本：v20.1.0 计算字符串的 xxHash 哈希值。 32 位版本请参见 xxHash32 语法

xxHash64(arg)

参数

arg — 要计算哈希值的输入字符串。String

返回值 返回输入字符串的 64 位哈希值。UInt64 示例 使用示例

Query

SELECT xxHash64('Hello, world!');

Response

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

xxh3

引入版本：v22.12.0 计算 XXH3 的 64 位哈希值。语法

xxh3(expr)

参数

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

返回值 返回计算出的 64 位 xxh3 哈希值 UInt64 示例 使用示例

Query

SELECT xxh3('ClickHouse')

Response

18009318874338624809

xxh3_128

引入版本：v26.2.0 计算 XXH3 的 128 位哈希值。语法

xxh3_128(expr)

参数

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

返回值 返回计算出的 128 位 xxh3 哈希值 UInt128 示例 使用示例

Query

SELECT hex(xxh3_128('ClickHouse'))

Response

3A038784C52804B4DBA43A038784C528

​BLAKE3

​MD4

​MD5

​RIPEMD160

​SHA1

​SHA224

​SHA256

​SHA384

​SHA512

​SHA512_256

​URLHash

​cityHash64

​farmFingerprint64

​farmHash64

​gccMurmurHash

​halfMD5

​hiveHash

​icebergHash

​intHash32

​intHash64

​javaHash

​javaHashUTF16LE

​jumpConsistentHash

​kafkaMurmurHash

​keccak256

​kostikConsistentHash

​metroHash64

​murmurHash2_32

​murmurHash2_64

​murmurHash3_128

​murmurHash3_32

​murmurHash3_64

​ngramMinHash

​ngramMinHashArg

​ngramMinHashArgCaseInsensitive

​ngramMinHashArgCaseInsensitiveUTF8

​ngramMinHashArgUTF8

​ngramMinHashCaseInsensitive

​ngramMinHashCaseInsensitiveUTF8

​ngramMinHashUTF8

​ngramSimHash

​ngramSimHashCaseInsensitive

​ngramSimHashCaseInsensitiveUTF8

​ngramSimHashUTF8

​sipHash128

​sipHash128Keyed

​sipHash128Reference

​sipHash128ReferenceKeyed

​sipHash64

​sipHash64Keyed

​wordShingleMinHash

​wordShingleMinHashArg

​wordShingleMinHashArgCaseInsensitive

​wordShingleMinHashArgCaseInsensitiveUTF8

​wordShingleMinHashArgUTF8

​wordShingleMinHashCaseInsensitive

​wordShingleMinHashCaseInsensitiveUTF8

​wordShingleMinHashUTF8

​wordShingleSimHash

​wordShingleSimHashCaseInsensitive

​wordShingleSimHashCaseInsensitiveUTF8

​wordShingleSimHashUTF8

​wyHash64

​xxHash32

​xxHash64

​xxh3

​xxh3_128

BLAKE3

MD4

MD5

RIPEMD160

SHA1

SHA224

SHA256

SHA384

SHA512

SHA512_256

URLHash

cityHash64

farmFingerprint64

farmHash64

gccMurmurHash

halfMD5

hiveHash

icebergHash

intHash32

intHash64

javaHash

javaHashUTF16LE

jumpConsistentHash

kafkaMurmurHash

keccak256

kostikConsistentHash

metroHash64

murmurHash2_32

murmurHash2_64

murmurHash3_128

murmurHash3_32

murmurHash3_64

ngramMinHash

ngramMinHashArg

ngramMinHashArgCaseInsensitive

ngramMinHashArgCaseInsensitiveUTF8

ngramMinHashArgUTF8

ngramMinHashCaseInsensitive

ngramMinHashCaseInsensitiveUTF8

ngramMinHashUTF8

ngramSimHash

ngramSimHashCaseInsensitive

ngramSimHashCaseInsensitiveUTF8

ngramSimHashUTF8

sipHash128

sipHash128Keyed

sipHash128Reference

sipHash128ReferenceKeyed

sipHash64

sipHash64Keyed

wordShingleMinHash

wordShingleMinHashArg

wordShingleMinHashArgCaseInsensitive

wordShingleMinHashArgCaseInsensitiveUTF8

wordShingleMinHashArgUTF8

wordShingleMinHashCaseInsensitive

wordShingleMinHashCaseInsensitiveUTF8

wordShingleMinHashUTF8

wordShingleSimHash

wordShingleSimHashCaseInsensitive

wordShingleSimHashCaseInsensitiveUTF8

wordShingleSimHashUTF8

wyHash64

xxHash32

xxHash64

xxh3

xxh3_128