哈希函数

哈希函数可用于对元素进行确定性的伪随机重排。

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

大多数哈希函数可以接受任意数量、任意类型的参数。

注意

NULL 的哈希值是 NULL。要获取 Nullable 列的非 NULL 哈希值，请将其包裹在一个元组（tuple）中：

SELECT cityHash64(tuple(NULL))

注意

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

BLAKE3

引入版本：v22.10

计算 BLAKE3 哈希，并将生成的字节序列以 FixedString 的形式返回。该密码学哈希函数通过 BLAKE3 Rust 库集成到 ClickHouse 中。该函数速度非常快，与 SHA-2 相比性能大约快两倍，同时生成与 SHA-256 相同长度的哈希值。它以类型为 FixedString(32) 的字节数组形式返回 BLAKE3 哈希值。

语法

BLAKE3(message)

参数

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

返回值

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

示例

hash

SELECT hex(BLAKE3('ABC'))

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

MD4

在 v21.11 版本中引入

计算给定字符串的 MD4 哈希值。

语法

MD4(s)

参数

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

返回值

返回给定输入字符串的 MD4 哈希值，形式为定长字符串。FixedString(16)

示例

使用示例

SELECT HEX(MD4('abc'));

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

MD5

在 v1.1 中引入

计算给定字符串的 MD5 哈希值。

语法

MD5(s)

参数

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

返回值

返回给定输入字符串的 MD5 哈希，结果为定长字符串。FixedString(16)

示例

用法示例

SELECT HEX(MD5('abc'));

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

RIPEMD160

首次引入版本：v24.10

计算给定字符串的 RIPEMD-160 哈希值。

语法

RIPEMD160(s)

参数

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

返回值

返回给定输入字符串的 RIPEMD160 哈希值，类型为定长字符串。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

自 v1.1 版本起提供

计算给定字符串的 SHA1 哈希值。

语法

SHA1(s)

参数

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

返回值

返回给定输入字符串的 SHA1 哈希值，作为定长字符串返回。FixedString(20)

示例

用法示例

SELECT HEX(SHA1('abc'));

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

SHA224

自 v1.1 起引入

计算给定字符串的 SHA224 散列值。

语法

SHA224(s)

参数

s — 要计算哈希值的输入。String

返回值

返回给定输入字符串的 SHA224 哈希值，作为定长字符串。FixedString(28)

示例

用法示例

SELECT HEX(SHA224('abc'));

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

SHA256

自 v1.1 起引入。

计算给定字符串的 SHA256 哈希值。

语法

SHA256(s)

参数

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

返回值

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

示例

使用示例

SELECT HEX(SHA256('abc'));

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

SHA384

在 v1.1 中引入

计算给定字符串的 SHA384 哈希值。

语法

SHA384(s)

参数

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

返回值

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

示例

使用示例

SELECT HEX(SHA384('abc'));

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

SHA512

自 v1.1 起引入。

计算给定字符串的 SHA512 哈希值。

语法

SHA512(s)

参数

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

返回值

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

示例

使用示例

SELECT HEX(SHA512('abc'));

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

SHA512_256

自 v1.1 版本引入

计算给定字符串的 SHA512_256 哈希值。

语法

SHA512_256(s)

参数

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

返回值

返回给定输入字符串的 SHA512_256 哈希值，以定长字符串形式表示。FixedString(32)

示例

用法示例

SELECT HEX(SHA512_256('abc'));

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

URLHash

引入自：v1.1

一种快速、质量较好的非加密哈希函数，用于对从 URL 中获取并经过某种规范化处理得到的字符串进行哈希计算。

此哈希函数有两种模式：

Mode	Description
`URLHash(url)`	计算字符串的哈希值，如果末尾存在 `/`、`?` 或 `#` 这类结尾符号，则会先去除末尾的一个此类符号再进行计算。
`URLHash(url, N)`	计算 URL 层级中前 N 级部分对应字符串的哈希值，如果末尾存在 `/`、`?` 或 `#` 这类结尾符号，则会先去除末尾的一个此类符号再进行计算。层级划分方式与 `URLHierarchy` 相同。

语法

URLHash(url[, N])

参数

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

返回值

返回对 url 计算得到的哈希值。UInt64

示例

使用示例

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

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

指定级别的 URL 的哈希值

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

引入版本：v1.1

生成一个 64 位的 CityHash 哈希值。

这是一个快速的非加密哈希函数。对字符串参数使用 CityHash 算法，对其他数据类型的参数使用与具体实现相关的快速非加密哈希函数。该函数使用 CityHash 组合器来获取最终结果。

参考资料

在将 CityHash 引入 ClickHouse 之后，Google 更改了 CityHash 的算法。换言之，ClickHouse 的 cityHash64 与 Google 上游的 CityHash 现在会产生不同的哈希值。 ClickHouse 的 cityHash64 对应 CityHash v1.0.2。

注意

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

语法

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

参数

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

返回值

返回对输入参数计算得到的哈希值。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

引入版本：v20.12

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

提示

与 farmHash64 相比，farmFingerprint64 更适合在需要稳定且可移植的值时使用。

注意

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

语法

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

参数

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

返回值

返回对输入参数计算得到的哈希值。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

引入自：v1.1

使用 Hash64 方法计算 64 位 FarmHash。

提示

为了获得稳定且可移植的值，推荐使用 farmFingerprint64。

注意

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

语法

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

参数

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

返回值

返回输入参数计算得到的哈希值。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

自 v20.1 引入。

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

在使用 Clang 和 GCC 编译器构建的版本之间具有良好的可移植性。

语法

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

参数

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

返回值

返回根据输入参数计算得到的哈希值。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

引入版本：v1.1

将所有输入参数重新解释为字符串，并为每个参数计算其 MD5 哈希值。然后将这些哈希连接起来，对所得字符串的哈希值取前 8 个字节，并按大端字节序将其解释为 UInt64。该函数相对较慢（每个处理器核心每秒可处理约 500 万个短字符串）。

建议改用 sipHash64 函数。

该函数接受可变数量的输入参数。参数可以是任意受支持的数据类型。对于某些数据类型，即使参数的类型不同（例如不同大小的整数、具有相同数据的命名和未命名 Tuple、以及具有相同数据的 Map 与对应的 Array(Tuple(key, value)) 类型），在相同取值下哈希函数的计算结果也可能相同。

语法

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

参数

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

返回值

返回根据给定输入参数计算得到的半长度 MD5 哈希值，以大端字节序的 UInt64 返回。UInt64

示例

用法示例

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

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

hiveHash

引入自：v20.1

从字符串计算一个 "HiveHash"。它只是将符号位清零后的 JavaHash。此函数用于 Apache Hive 3.0 之前的版本。

注意

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

语法

hiveHash(arg)

参数

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

返回值

返回输入字符串计算得到的 Hive 哈希值。Int32

示例

用法示例

SELECT hiveHash('Hello, world!');

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

icebergHash

自 v25.5 引入

实现了 iceberg 哈希变换的逻辑。

语法

icebergHash(value)

参数

value — 要进行哈希计算的源值，可为 Integer 或 Bool 或 Decimal 或 Float* 或 String 或 FixedString 或 UUID 或 Date 或 Time 或 DateTime

返回值

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

示例

SELECT icebergHash(1.0 :: Float32)

-142385009

intHash32

在 v1.1 中引入

计算整数的 32 位哈希值。

该哈希函数相对较快，但不属于密码学哈希函数。

语法

intHash32(arg)

参数

arg — 待进行哈希计算的整数。(U)Int*

返回值

返回输入整数计算得到的 32 位哈希值，类型为 UInt32

示例

用法示例

SELECT intHash32(42);

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

intHash64

引入于：v1.1

计算整数的 64 位哈希值。

该哈希函数速度相对较快（甚至比 intHash32 更快），但并非密码学哈希函数。

语法

intHash64(int)

参数

int — 要进行哈希的整数。(U)Int*

返回值

64 位哈希值。UInt64

示例

用法示例

SELECT intHash64(42);

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

javaHash

自 v20.1 引入

从以下类型计算 JavaHash：

string，
Byte，
Short，
Integer，
Long。

注意

此哈希函数性能不佳。仅当其他系统中已经在使用该算法且您需要计算相同结果时才使用它。

注意

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

语法

javaHash(arg)

参数

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

返回值

返回 arg 的计算哈希值，类型为 Int32

示例

用法示例 1

SELECT javaHash(toInt32(123));

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

使用示例 2

SELECT javaHash('Hello, world!');

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

javaHashUTF16LE

引入于：v20.1

从字符串计算 JavaHash，假定其包含的字节表示为 UTF-16LE 编码的字符串。

语法

javaHashUTF16LE(arg)

参数

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

返回值

返回该 UTF-16LE 编码字符串计算得到的哈希值。Int32

示例

使用示例

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

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

jumpConsistentHash

自 v1.1 引入

对整数计算 jump consistent hash。

语法

jumpConsistentHash(key, buckets)

参数

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

返回值

返回计算得到的哈希值。Int32

示例

用法示例

SELECT jumpConsistentHash(256, 4)

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

kafkaMurmurHash

引入于：v23.4

使用与 Kafka 相同的种子计算输入值的 32 位 MurmurHash2 哈希值，并清除最高位，以便与 Default Partitioner 兼容。

语法

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

参数

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

返回值

返回对输入参数计算得到的哈希值。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

引入版本：v25.4

计算给定字符串的 Keccak-256 密码学哈希值。此哈希函数被广泛应用于区块链领域，尤其是在 Ethereum 中。

语法

keccak256(message)

参数

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

返回值

返回输入字符串的 Keccak-256 哈希值（32 字节），结果为定长字符串。FixedString(32)

示例

使用示例

SELECT hex(keccak256('hello'))

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

kostikConsistentHash

引入版本：v22.6

由 Konstantin 'Kostik' Oblakov 提出的时间与空间复杂度为 O(1) 的一致性哈希算法。仅当 n <= 32768 时性能较好。

语法

kostikConsistentHash(input, n)

别名: yandexConsistentHash

参数

input — 整型键。UInt64
n — bucket 的数量。UInt16

返回值

返回计算得到的哈希值。UInt16

示例

用法示例

SELECT kostikConsistentHash(16045690984833335023, 2);

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

metroHash64

自 v1.1 起提供

生成 64 位 MetroHash 哈希值。

注意

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

语法

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

参数

arg1[, arg2, ...] — 用于计算哈希的一个或多个输入参数。Any

返回值

返回输入参数计算得到的哈希值。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

引入于：v18.5

计算输入值的 MurmurHash2 哈希值。

注意

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

语法

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

参数

arg1[, arg2, ...] — 要计算哈希值的任意数量输入参数。Any

返回值

返回对输入参数计算得到的哈希值。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

引入于：v18.10

计算输入值的 MurmurHash2 哈希值。

注意

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

语法

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

参数

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

返回值

返回根据输入参数计算得到的哈希值。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

自 v18.10 版本起引入。

计算输入值的 128 位 MurmurHash3 哈希值。

语法

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

参数

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

返回值

返回对输入参数计算得到的 128 位 MurmurHash3 哈希值。FixedString(16)

示例

使用示例

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

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

murmurHash3_32

引入版本：v18.10

生成一个 MurmurHash3 哈希值。

注意

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

语法

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

参数

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

返回值

返回输入参数计算得到的哈希值。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

引入版本：v18.10

计算输入值的 MurmurHash3 哈希值。

注意

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

语法

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

参数

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

返回值

返回对输入参数计算得到的哈希值。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

引入版本：v21.1

将一个 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

示例

用法示例

SELECT ngramMinHash('ClickHouse') AS Tuple;

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

ngramMinHashArg

引入版本：v21.1

将 ASCII 字符串拆分为由 ngramsize 个字符组成的 n-gram，并返回在使用相同输入调用 ngramMinHash 计算后，哈希值最小和最大的 n-gram。区分大小写。

语法

ngramMinHashArg(string[, ngramsize, hashnum])

参数

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

返回值

返回一个包含两个元组的元组，每个元组包含 hashnum 个 n-gram。Tuple(String)

示例

使用示例

SELECT ngramMinHashArg('ClickHouse') AS Tuple;

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

ngramMinHashArgCaseInsensitive

引入于：v21.1

将一个 ASCII 字符串按 ngramsize 个符号拆分为 n-gram，并返回哈希值最小和最大的 n-gram，这些哈希值是通过对相同输入调用 ngramMinHashCaseInsensitive 函数计算得到的。对大小写不敏感。

语法

ngramMinHashArgCaseInsensitive(string[, ngramsize, hashnum])

参数

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

返回值

返回一个元组，其中包含两个元组，每个元组包含 hashnum 个 n-gram。Tuple(Tuple(String))

示例

使用示例

SELECT ngramMinHashArgCaseInsensitive('ClickHouse') AS Tuple;

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

ngramMinHashArgCaseInsensitiveUTF8

引入于：v21.1

将 UTF-8 字符串拆分成由 ngramsize 个字符组成的 n-gram，并返回哈希值最小和最大的 n-gram，这些哈希值由使用相同输入的 ngramMinHashCaseInsensitiveUTF8 函数计算得出。该函数不区分大小写。

语法

ngramMinHashArgCaseInsensitiveUTF8(string[, ngramsize, hashnum])

参数

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

返回值

返回一个元组，其中包含两个元组，每个元组包含 hashnum 个 n-gram。Tuple(Tuple(String))

示例

用法示例

SELECT ngramMinHashArgCaseInsensitiveUTF8('ClickHouse') AS Tuple;

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

ngramMinHashArgUTF8

引入于：v21.1

将 UTF-8 字符串拆分为长度为 ngramsize 的 n-gram（按符号计），并返回具有最小和最大哈希值的 n-gram，这些哈希值由使用相同输入的 ngramMinHashUTF8 FUNCTION 计算得到。区分大小写。

语法

ngramMinHashArgUTF8(string[, ngramsize, hashnum])

参数

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

返回值

返回一个由两个元组组成的元组，每个元组包含 hashnum 个 n-gram。Tuple(Tuple(String))

示例

用法示例

SELECT ngramMinHashArgUTF8('ClickHouse') AS Tuple;

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

ngramMinHashCaseInsensitive

引入于：v21.1

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

可与 tupleHammingDistance 一起使用来检测近似重复的字符串。对于两个字符串，如果返回的哈希完全相同，则认为这两个字符串相同。

语法

ngramMinHashCaseInsensitive(string[, ngramsize, hashnum])

参数

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

返回值

包含两个哈希值（最小值和最大值）的 Tuple。Tuple(UInt64, UInt64). Tuple

示例

使用示例

SELECT ngramMinHashCaseInsensitive('ClickHouse') AS Tuple;

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

ngramMinHashCaseInsensitiveUTF8

引入版本：v21.1

将一个 UTF-8 字符串拆分为由 ngramsize 个符号组成的 n-gram，并为每个 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-gram，并为每个 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‑gram，并返回这些 n‑gram 的 simhash。

可与 bitHammingDistance 一起用于检测近似重复字符串。两个字符串计算得到的 simhashes 的汉明距离越小，这两个字符串相同的可能性就越大。

语法

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-gram，并返回这些 n-gram 的 simhash。大小写不敏感。

可以结合 bitHammingDistance 用于检测部分重复（近似重复）的字符串。两个字符串计算得到的 simhashes 之间的汉明距离越小，这两个字符串相同的可能性就越大。

语法

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-gram，并返回这些 n-gram 的 simhash。该函数对大小写不敏感。

可与 bitHammingDistance 一起用于检测近似重复的字符串。两个字符串计算得到的 simhash 值的 Hamming Distance 越小，这两个字符串越有可能是相同的。

语法

ngramSimHashCaseInsensitiveUTF8(string[, ngramsize])

参数

string — 要计算哈希值的字符串。String
ngramsize — 可选。n-gram（n 元语法）的大小，取值范围为 1 到 25 的任意数值。默认值为 3。UInt8

返回值

返回计算得到的哈希值。UInt64

示例

使用示例

SELECT ngramSimHashCaseInsensitiveUTF8('ClickHouse') AS Hash;

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

ngramSimHashUTF8

引入于：v21.1

将一个 UTF-8 编码的字符串按 ngramsize 个符号切分为 n-gram，并返回该 n-gram 的 simhash。区分大小写。

可与 bitHammingDistance 一起用于检测近似重复的字符串。两个字符串计算得到的 simhashes 之间的汉明距离越小，这两个字符串越有可能是相同的。

语法

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 位变体与参考实现不同，且更弱。之所以存在这个版本，是因为在编写它时，SipHash 还没有官方的 128 位扩展。建议新项目使用 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 位变体与参考实现有差异，且更弱。之所以存在该版本，是因为在编写它时，SipHash 还没有官方的 128 位扩展。新项目应优先考虑使用 sipHash128ReferenceKeyed。

语法

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

参数

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

返回值

类型为 FixedString(16) 的 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。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 哈希函数的三倍。

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

将第一个和第二个哈希值拼接成一个数组并对其进行哈希。
将上一步计算得到的哈希值与第三个输入参数的哈希值以类似方式再进行哈希。
对原始输入剩余的所有哈希值重复此计算过程。

注意

对于参数类型不同但输入值相同的情况，计算得到的哈希值可能相同。这会影响例如不同大小的整数类型、具有相同数据的已命名和未命名 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），对每个单词片段计算哈希值，并返回包含这些哈希值的元组。使用 hashnum 个最小哈希来计算最小哈希，使用 hashnum 个最大哈希来计算最大哈希。对大小写敏感。

可与 tupleHammingDistance 一起使用以检测近似重复字符串。对于两个字符串，如果返回的哈希值在两者之间完全相同，则这两个字符串是相同的。

语法

wordShingleMinHash(string[, shinglesize, hashnum])

参数

string — 要计算哈希的字符串。String
shinglesize — 可选。单词 shingle 的大小，取值范围为 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 个单词组成的片段（shingle），并返回其中单词哈希值最小和最大的 shingle，这些哈希值由使用相同输入的 wordShingleMinHash 函数计算。该函数区分大小写。

语法

wordShingleMinHashArg(string[, shinglesize, hashnum])

参数

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

返回值

返回一个由两个元组组成的元组，每个元组包含 hashnum 个 word shingle。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），并返回在相同输入下由 wordShingleMinHashCaseInsensitive 函数计算得到、具有最小和最大单词哈希值的 shingles。该函数不区分大小写。

语法

wordShingleMinHashArgCaseInsensitive(string[, shinglesize, hashnum])

参数

string — 要计算哈希值的字符串。String
shinglesize — 可选。单词 shingle 的长度，取值为 1 到 25 之间的任意整数，默认值为 3。UInt8
hashnum — 可选。用于计算结果的最小哈希和最大哈希的数量，取值为 1 到 25 之间的任意整数，默认值为 6。UInt8

返回值

返回一个包含两个元组的元组，每个元组包含 hashnum 个单词 shingle。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 个单词组成的 shingle 片段，并返回在相同输入下由 wordShingleMinHashCaseInsensitiveUTF8 函数计算出的、具有最小和最大单词哈希值的 shingle 片段。该函数对大小写不敏感。

语法

wordShingleMinHashArgCaseInsensitiveUTF8(string[, shinglesize, hashnum])

参数

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

返回值

返回一个元组，包含两个元组，每个元组包含 hashnum 个 word shingle。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），并返回其中单词哈希值最小和最大的片段，这些哈希值由使用相同输入的 wordShingleMinHashUTF8 计算得出。该函数区分大小写。

语法

wordShingleMinHashArgUTF8(string[, shinglesize, hashnum])

参数

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

返回值

返回一个包含两个元组的元组，每个内部元组包含 hashnum 个 word shingle。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），为每个单词短语片段计算哈希值，并返回一个包含这些哈希值的元组。使用 hashnum 个最小哈希来计算最小哈希，使用 hashnum 个最大哈希来计算最大哈希。该函数对大小写不敏感。

可与 tupleHammingDistance 一起使用来检测近似重复的字符串。对于两个字符串，如果返回的哈希在两个字符串中都相同，则可认为这两个字符串相同。

语法

wordShingleMinHashCaseInsensitive(string[, shinglesize, hashnum])

参数

string — 要计算哈希的字符串。String
shinglesize — 可选。word shingle 的长度，取值范围为 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 个单词组成的片段（shingle），为每个单词 shingle 计算哈希值，并返回包含这些哈希值的元组。使用 hashnum 个最小哈希值来计算最小哈希，使用 hashnum 个最大哈希值来计算最大哈希。不区分大小写。

可与 tupleHammingDistance 一起用于检测近似重复的字符串。对于两个字符串，如果两个字符串返回的哈希值相同，则这两个字符串相同。

语法

wordShingleMinHashCaseInsensitiveUTF8(string[, shinglesize, hashnum])

参数

string — 要计算哈希值的字符串。String
shinglesize — 可选。单词 shingle（词片段）的大小，取值范围为 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 个单词拆分成若干 shingle（词片），为每个单词 shingle 计算哈希值，并返回一个包含这些哈希值的元组。使用 hashnum 个最小哈希来计算最小哈希，使用 hashnum 个最大哈希来计算最大哈希。区分大小写。

可与 tupleHammingDistance 一起用于检测近似重复的字符串。对于两个字符串，如果返回的哈希在两者之间完全相同，则认为这两个字符串是相同的。

语法

wordShingleMinHashUTF8(string[, shinglesize, hashnum])

参数

string — 要计算哈希的字符串。String
shinglesize — 可选。词 shingle 的大小（连续单词片段的长度），取值范围为 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 个单词组成的片段（shingle），并返回该单词 shingle 的 simhash。区分大小写。

可配合 bitHammingDistance 用于检测近似重复字符串。两个字符串计算得到的 simhash 值之间的汉明距离越小，这两个字符串越有可能是相同的。

语法

wordShingleSimHash(string[, shinglesize])

参数

string — 要计算哈希值的字符串。String
shinglesize — 可选。词 shingle 的长度，取值范围为 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 个单词组成的词片（shingle），并返回这些词片的 simhash。该函数不区分大小写。

可与 bitHammingDistance 一起用于检测部分重复的字符串。两个字符串计算得到的 simhashes 的 Hamming 距离越小，这两个字符串相同的可能性就越大。

语法

wordShingleSimHashCaseInsensitive(string[, shinglesize])

参数

string — 要计算哈希的字符串。String
shinglesize — 可选。单词 shingle 的大小，取值范围为 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），并返回这些单词 shingle 的 simhash 值。该函数对大小写不敏感。

可用于配合 bitHammingDistance 检测近似重复的字符串。两个字符串计算得到的 simhash 值的汉明距离越小，这两个字符串相同的可能性就越大。

语法

wordShingleSimHashCaseInsensitiveUTF8(string[, shinglesize])

参数

string — 要计算哈希的字符串。String
shinglesize — 可选。词片（word shingle）的大小，取值范围为 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 个单词组成的 shingle 片段（shingles），并返回这些单词 shingle 的 simhash。区分大小写。

可与 bitHammingDistance 一起用于检测近似重复字符串。两个字符串计算得到的 simhashes 的 Hamming distance 越小，这两个字符串相同的可能性就越大。

语法

wordShingleSimHashUTF8(string[, shinglesize])

参数

string — 要计算哈希值的字符串。String
shinglesize — 可选。词 shingle 的大小，取值范围为 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

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​

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