哈希函数

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

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

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

注意

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

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 哈希值，作为长度为 20 的定长字符串类型返回。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 的符号位清零后的结果。此函数用于 3.0 之前版本的 Apache Hive。

注意

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

语法

hiveHash(arg)

参数

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

返回值

返回输入字符串计算得到的 Hive 哈希值（“hive hash”）。Int32

示例

用法示例

SELECT hiveHash('Hello, world!');

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

icebergHash

在 v25.5 中引入

实现 Iceberg hashing transform 逻辑

语法

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 仅支持计算有符号整数的哈希值，因此如果需要计算无符号整数的哈希值，必须先将它们转换（cast）为相应的有符号 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 — 输入的 key。UInt64
buckets — 桶的数量。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

返回值

返回输入字符串的 32 字节 Keccak-256 哈希值，作为定长字符串。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 — 桶的数量。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 计算哈希值，然后返回包含这些哈希值的元组。使用 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（n 元语法），并返回哈希值最小和最大的 n-gram，这些哈希值由使用相同输入的 ngramMinHash 函数计算得到。区分大小写。

语法

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 函数计算得到的。该函数区分大小写。

语法

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 一起用于检测近似重复字符串。两字符串计算得到的 simhash 值之间的 Hamming 距离越小，这两个字符串相同的可能性就越大。

语法

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 用于检测近似重复字符串。两个字符串计算得到的 simhashes 之间的 Hamming Distance 越小，这两个字符串相同的可能性越大。

语法

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-gram，并返回该 n-gram 的 simhash 值。该函数区分大小写。

可结合 bitHammingDistance 用于检测近似重复字符串。两个字符串计算得到的 simhashes 之间的 Hamming 距离越小，这两个字符串相同的可能性就越高。

语法

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 位哈希值，即最终的异或折叠（xor-folding）操作会进行到 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(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 哈希函数快 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），为每个 shingle 计算哈希值，并返回一个包含这些哈希值的 tuple。使用 hashnum 个最小哈希值来计算最小哈希，使用 hashnum 个最大哈希值来计算最大哈希。大小写敏感。

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

语法

wordShingleMinHash(string[, shinglesize, hashnum])

参数

string — 要计算哈希值的字符串。String
shinglesize — 可选。word 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 个单词组成的分区片段（shingles），并返回其中单词哈希值最小和最大的 shingles，这些哈希值由在相同输入下调用 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 个单词划分为若干分区片段（shingle），并返回其中单词哈希值最小和最大的分区片段。这些哈希值通过使用相同输入的 wordShingleMinHashCaseInsensitive 函数计算得到。该函数不区分大小写。

语法

wordShingleMinHashArgCaseInsensitive(string[, shinglesize, hashnum])

参数

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

返回值

返回一个元组，其中包含两个元组，每个元组包含 hashnum 个 word 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 个单词拆分为多个分区片段（shingles），并返回其中单词哈希值最小和最大的分区片段，这些哈希值是通过对相同输入调用 wordShingleMinHashCaseInsensitiveUTF8 FUNCTION 计算得到的。该函数不区分大小写。

语法

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 函数时，其最小和最大单词哈希值所对应的 shingles。该函数区分大小写。

语法

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），为每个单词 shingle 计算哈希值，并返回包含这些哈希值的元组。使用 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 个单词组成的分区片段（shingles），为每个 word 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 个单词组成的分区片段（shingles），为每个单词 shingle 计算哈希值，并返回包含这些哈希值的元组。使用 hashnum 个最小哈希来计算最小哈希，使用 hashnum 个最大哈希来计算最大哈希。区分大小写。

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

语法

wordShingleMinHashUTF8(string[, shinglesize, hashnum])

参数

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

可与 bitHammingDistance 一起使用，用于检测近似重复的字符串。两个字符串计算得到的 simhash 值之间的汉明距离越小，这两个字符串为同一内容的可能性就越大。

语法

wordShingleSimHash(string[, shinglesize])

参数

string — 要计算哈希值的字符串。String
shinglesize — 可选。word 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 个单词组成的片段（shingles），并返回这些词片段的 simhash。该函数对大小写不敏感。

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

语法

wordShingleSimHashCaseInsensitive(string[, shinglesize])

参数

string — 要计算哈希值的字符串。String
shinglesize — 可选。word 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（词片段），并返回这些词片段的 simhash。比较时不区分大小写。

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

语法

wordShingleSimHashCaseInsensitiveUTF8(string[, shinglesize])

参数

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

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

语法

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

xxh3_128

首次引入：v26.2

计算 XXH3 128 位哈希值。

语法

xxh3_128(expr)

参数

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

返回值

返回计算得到的 128 位 xxh3 哈希值 UInt128

示例

使用示例

SELECT hex(xxh3_128('ClickHouse'))

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