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

哈希函数

哈希函数可用于以确定性的伪随机方式打乱元素顺序（洗牌）。

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('敏捷的棕色狐狸跳过了懒狗'));

┌─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 — 要计算哈希值的输入字符串。String

返回值

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

示例

用法示例

SELECT HEX(SHA224('abc'));

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

SHA256​

自 v1.1 引入

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

语法

SHA256（s）

参数

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

返回值

返回给定输入字符串的 SHA-256 哈希值，作为定长字符串。FixedString(32)

示例

用法示例

SELECT HEX(SHA256('abc'));

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

SHA384​

引入版本：v1.1

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

语法

SHA384（字节）

参数

  • 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 获取的字符串的快速、质量良好的非加密哈希函数。

此哈希函数有两种模式：

模式描述
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);

-- https://www.clickhouse.com 的哈希值
┌─URLHash('htt⋯m/docs', 0)─┐
│     13614512636072854701 │
└──────────────────────────┘
-- 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─┬─类型───┐
│ 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 哈希值”。Int32

示例

用法示例

SELECT hiveHash('Hello, world!');

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

icebergHash​

自 v25.5 版本引入

实现 iceberg 哈希变换 的逻辑

语法

icebergHash(值)

参数

返回值

返回一个 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 值：

注意

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

注意

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

在假定字符串的字节表示为 UTF-16LE 编码的前提下，从字符串计算 JavaHash。

语法

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 — 输入键值。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

参数

返回值

返回计算得到的哈希值。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─┬─类型───┐
│ 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─┬─类型───┐
│ 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─┬─类型───┐
│ 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-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─────────────────────────────────────────────────────────────────────────┐
│ (('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(字符串[, n-gram大小, 哈希数])

参数

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

返回值

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

示例

使用示例

SELECT ngramMinHashCaseInsensitive('ClickHouse') AS Tuple;

┌─元组──────────────────────────────────────┐
│ (2106263556442004574,13203602793651726206) │
└────────────────────────────────────────────┘

ngramMinHashCaseInsensitiveUTF8​

引入版本：v21.1

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

可以与 tupleHammingDistance 结合使用以检测近似重复字符串。 对于两个字符串，如果返回的哈希在两者中完全相同，则这两个字符串被视为相同。

语法

ngramMinHashCaseInsensitiveUTF8(字符串 [, ngram大小, 哈希数])

参数

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

返回值

返回一个包含两个哈希值（最小值和最大值）的元组。Tuple

示例

用法示例

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

┌─元组──────────────────────────────────────┐
│ (18333312859352735453,6742163577938632877) │
└────────────────────────────────────────────┘

ngramSimHash​

在 v21.1 中引入

将一个 ASCII 字符串拆分为由 ngramsize 个字符组成的 n-gram，并返回其 n-gram 的 simhash 值。

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

语法

ngramSimHash(string[, ngramsize])

参数

  • string — 要计算区分大小写 simhash 的字符串。String
  • ngramsize — 可选。n-gram 的长度，取值范围为 1 到 25，默认值为 3。UInt8

返回值

返回输入字符串的计算哈希值。UInt64

示例

用法示例

SELECT ngramSimHash('ClickHouse') AS Hash;

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

ngramSimHashCaseInsensitive​

引入于：v21.1

将一个 ASCII 字符串按 ngramsize 个符号拆分为 n-gram，并返回这些 n-gram 的 simhash。 不区分大小写。

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

语法

ngramSimHashCaseInsensitive(字符串[, n元大小])

参数

  • string — 要计算不区分大小写的 simhash 的字符串。String
  • ngramsize — 可选。n-gram 的大小，取值范围为 1 到 25。默认值为 3。UInt8

返回值

哈希值。UInt64。UInt64

示例

用法示例

SELECT ngramSimHashCaseInsensitive('ClickHouse') AS Hash;

┌──────哈希─┐
│ 562180645 │
└───────────┘

ngramSimHashCaseInsensitiveUTF8​

引入于：v21.1

将一个 UTF-8 字符串拆分为由 ngramsize 个符号组成的 n-gram，并返回这些 n-gram 的 simhash 值。
此函数不区分大小写。

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

语法

ngramSimHashCaseInsensitiveUTF8(字符串[, n元语法大小])

参数

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

返回值

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

示例

使用示例

SELECT ngramSimHashCaseInsensitiveUTF8('ClickHouse') AS 哈希值;

┌───────哈希─┐
│ 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(UInt64, UInt64)
  • arg1[, arg2, ...] — 需要计算哈希的一组可变数量的输入参数。Any

返回值

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

示例

使用示例

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

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

sipHash64​

引入版本：v1.1

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

这是一个密码学哈希函数。其运行速度至少是 MD5 哈希函数的三倍。

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

  1. 将第一个和第二个哈希值拼接成一个数组并对其进行哈希。
  2. 将前一步计算出的哈希值与第三个输入参数的哈希值以类似方式进行哈希。
  3. 对原始输入剩余的所有哈希值重复此计算。
注意

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

语法

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

参数

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

返回值

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

示例

使用示例

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

┌──────────────SipHash─┬─类型───┐
│ 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─┬─类型───┐
│ 8017656310194184311 │ UInt64 │
└─────────────────────┴────────┘

wordShingleMinHash​

引入于：v21.1

将一个 ASCII 字符串按 shinglesize 个单词划分成若干片段（shingle），计算每个单词片段的哈希值，并返回包含这些哈希值的元组。 使用 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® 是用于联机分析处理（OLAP）查询的列式数据库管理系统（DBMS）。') AS Tuple;

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

wordShingleMinHashArg​

引入版本：v1.1

将一个 ASCII 字符串按每 shinglesize 个单词拆分为若干部分（shingle），并返回其中单词哈希值最小和最大的这些 shingle，这些哈希值是通过在相同输入上调用 wordShingleMinHash 函数计算得到的。 区分大小写。

语法

wordShingleMinHashArg(string[, shinglesize, hashnum])

参数

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

返回值

返回一个包含两个元组的元组，每个元组包含 hashnum 个单词 shingle。Tuple(Tuple(String))

示例

使用示例

SELECT wordShingleMinHashArg('ClickHouse® 是一款列式数据库管理系统 (DBMS)，用于联机分析处理 (OLAP) 查询。', 1, 3) AS Tuple;

┌─Tuple─────────────────────────────────────────────────────────────────┐
│ (('OLAP','数据库','分析型'),('在线','面向','处理')) │
└───────────────────────────────────────────────────────────────────────┘

wordShingleMinHashArgCaseInsensitive​

引入版本：v21.1

将一个 ASCII 字符串按每 shinglesize 个单词拆分为若干部分（shingles），并返回其中单词哈希值最小和最大的 shingles，这些哈希值是通过使用相同输入的 wordShingleMinHashCaseInsensitive 函数计算得到的。 该函数不区分大小写。

语法

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® 是一款列式数据库管理系统（DBMS），用于对查询进行联机分析处理（OLAP）。', 1, 3) AS Tuple;

┌─Tuple──────────────────────────────────────────────────────────────────┐
│ (('查询','数据库','分析型'),('面向','处理','数据库管理系统')) │
└────────────────────────────────────────────────────────────────────────┘

wordShingleMinHashArgCaseInsensitiveUTF8​

引入版本：v21.1

将一个 UTF-8 字符串按每段包含 shinglesize 个单词拆分为多个部分（shingle），并返回按单词哈希值计算出的最小和最大的 shingle。这些哈希值由在相同输入下调用的 wordShingleMinHashCaseInsensitiveUTF8 函数计算。 该函数对大小写不敏感。

语法

wordShingleMinHashArgCaseInsensitiveUTF8(string[, shinglesize, hashnum])

参数

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

返回值

返回一个包含两个元组的元组，每个元组包含 hashnum 个词 shingle。Tuple(Tuple(String))

示例

使用示例

SELECT wordShingleMinHashArgCaseInsensitiveUTF8('ClickHouse® 是一款面向联机分析处理 (OLAP) 查询的列式数据库管理系统 (DBMS)。', 1, 3) AS Tuple;

┌─Tuple──────────────────────────────────────────────────────────────────┐
│ (('查询','数据库','分析型'),('面向','处理','数据库管理系统')) │
└────────────────────────────────────────────────────────────────────────┘

wordShingleMinHashArgUTF8​

引入版本：v21.1

将一个 UTF-8 字符串按每 shinglesize 个单词拆分为若干部分（shingles），并返回其中具有最小和最大单词哈希值的 shingles，这些哈希值由使用相同输入的 wordShingleMinHashUTF8 函数计算得到。 区分大小写。

语法

wordShingleMinHashArgUTF8(string[, shinglesize, hashnum])

参数

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

返回值

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

示例

使用示例

SELECT wordShingleMinHashArgUTF8('ClickHouse® 是一款用于联机分析处理 (OLAP) 查询的列式数据库管理系统 (DBMS)。', 1, 3) AS Tuple;

┌─Tuple─────────────────────────────────────────────────────────────────┐
│ (('OLAP','数据库','分析型'),('联机','面向','处理')) │
└───────────────────────────────────────────────────────────────────────┘

wordShingleMinHashCaseInsensitive​

引入于：v21.1

将一个 ASCII 字符串按 shinglesize 个单词切分成若干部分（shingle），为每个单词 shingle 计算哈希值，并返回包含这些哈希值的元组。 使用 hashnum 个最小哈希来计算最小哈希，使用 hashnum 个最大哈希来计算最大哈希。 该函数不区分大小写。

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

语法

wordShingleMinHashCaseInsensitive(字符串[, 片段大小, 哈希数量])

参数

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

返回值

返回一个包含两个哈希值（最小值和最大值）的元组。Tuple(UInt64, UInt64)

示例

用法示例

SELECT wordShingleMinHashCaseInsensitive('ClickHouse® 是一款列式数据库管理系统 (DBMS)，用于对查询执行联机分析处理 (OLAP)。') AS Tuple;

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

wordShingleMinHashCaseInsensitiveUTF8​

引入版本：v21.1

将 UTF-8 字符串按 shinglesize 个单词拆分为若干单词片段（shingles），对每个单词 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® 是一款面向列的数据库管理系统（DBMS），用于执行查询的联机分析处理（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® 是一款面向联机分析处理 (OLAP) 查询的列式数据库管理系统 (DBMS)。') AS Tuple;

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

wordShingleSimHash​

自 v21.1 起引入

将 ASCII 字符串按每 shinglesize 个单词切分为若干片段（shingle），并返回这些单词 shingle 的 simhash 值。 区分大小写。

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

语法

wordShingleSimHash(string[, shinglesize])

参数

  • string — 要计算哈希值的字符串。String
  • shinglesize — 可选。单词 shingle 的大小，取值范围为 1 到 25。默认值为 3。UInt8

返回值

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

示例

用法示例

SELECT wordShingleSimHash('ClickHouse® 是一款列式数据库管理系统（DBMS），用于联机分析处理（OLAP）查询。') AS Hash;

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

wordShingleSimHashCaseInsensitive​

引入版本：v21.1

将一个 ASCII 字符串按 shinglesize 个单词拆分成若干部分（shingle），并返回这些单词 shingle 的 simhash。 该函数不区分大小写。

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

语法

wordShingleSimHashCaseInsensitive(string[, shinglesize])

参数

  • string — 要计算哈希的字符串。String
  • shinglesize — 可选。词组（shingle）的长度，取值范围为 1 到 25，默认值为 3。UInt8

返回值

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

示例

用法示例

SELECT wordShingleSimHashCaseInsensitive('ClickHouse® 是用于联机分析处理(OLAP)查询的列式数据库管理系统(DBMS)。') AS Hash;

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

wordShingleSimHashCaseInsensitiveUTF8​

引入版本：v1.1

将 UTF-8 编码的字符串按 shinglesize 个单词拆分成多个部分（shingles），并返回这些单词 shingle 的 simhash。 该函数不区分大小写。

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

语法

wordShingleSimHashCaseInsensitiveUTF8(字符串[, shingle大小])

参数

  • string — 要计算哈希值的字符串。String
  • shinglesize — 可选。词 shingle 的长度，取值范围为 1 到 25 的任意数值。默认值为 3。UInt8

返回值

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

示例

用法示例

SELECT wordShingleSimHashCaseInsensitiveUTF8('ClickHouse® 是一款列式数据库管理系统 (DBMS)，用于联机分析处理 (OLAP) 查询。') AS Hash;

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

wordShingleSimHashUTF8​

引入于：v21.1

将一个 UTF-8 字符串按 shinglesize 个单词划分为若干部分（shingle），并返回这些词片段的 simhash。 区分大小写。

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

语法

wordShingleSimHashUTF8(string[, shinglesize])

参数

  • string — 需要计算哈希值的字符串。String
  • shinglesize — 可选参数。单词 shingle 的长度，取值范围为 1 到 25，默认值为 3。UInt8

返回值

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

示例

使用示例

SELECT wordShingleSimHashUTF8('ClickHouse® 是用于对查询进行联机分析处理 (OLAP) 的列式数据库管理系统 (DBMS)。') AS Hash;

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

wyHash64​

自 v22.7 引入

计算 64 位 wyHash64 哈希值。

语法

wyHash64(arg)

参数

  • arg — 要计算哈希值的字符串参数。String

返回值

返回计算得到的 64 位哈希值 UInt64

示例

使用示例

SELECT wyHash64('ClickHouse') AS 哈希;

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