跳至主要内容
跳至主要内容
编辑此页

哈希函数

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

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

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

注意

NULL 的哈希值为 NULL。要获取可为空列的非 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 哈希值，作为固定长度的字符串。 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 获得的字符串。

此哈希函数有两种模式

模式描述
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 组合器来获得最终结果。

参考

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

注意

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

语法

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

参数

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

返回值

返回输入参数的计算哈希值。 UInt64

示例

调用示例

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

返回值

返回以大端字节序表示的给定输入参数的计算 half 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)

参数

返回值

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

从一个字符串计算 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 — 桶的数量。 Int32

返回值

返回计算出的哈希值。 Int32

示例

使用示例

SELECT jumpConsistentHash(256, 4)

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

kafkaMurmurHash​

引入于：v23.4

计算输入值的 32 位 MurmurHash2 哈希值，使用与 Kafka 相同的种子，并且不设置最高位，以与 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 加密哈希值。此哈希函数广泛用于区块链应用程序，特别是以太坊。

语法

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，并返回使用相同的输入通过 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，并返回使用相同的输入通过 ngramMinHashCaseInsensitive 函数计算的最小和最大哈希值的 n-gram。不区分大小写。

语法

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，并返回使用相同的输入通过 ngramMinHashCaseInsensitiveUTF8 函数计算的最小和最大哈希值的 n-gram。不区分大小写。

语法

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，并返回使用相同的输入通过 ngramMinHashUTF8 函数计算的最小和最大哈希值的 n-gram。区分大小写。

语法

ngramMinHashArgUTF8(string[, ngramsize, hashnum])

参数

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

返回值

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

示例

使用示例

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(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。计算出的两个字符串的 simhashes 的 汉明距离 越小，这些字符串相同的可能性就越大。

语法

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 的 汉明距离 越小，这些字符串相同的可能性就越大。

语法

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─┬─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 的哈希值，然后返回一个包含这些哈希值的元组。使用 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 个单词的部分（shingles），并返回使用相同输入计算的 wordShingleMinHash 函数计算的最小和最大单词哈希值。区分大小写。

语法

wordShingleMinHashArg(string[, shinglesize, hashnum])

参数

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

返回值

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

示例

使用示例

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

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

wordShingleMinHashArgCaseInsensitive​

引入于：v21.1

将 ASCII 字符串拆分为每个 shinglesize 个单词的部分（shingles），并返回使用相同输入计算的 wordShingleMinHashCaseInsensitive 函数计算的最小和最大单词哈希值。不区分大小写。

语法

wordShingleMinHashArgCaseInsensitive(string[, shinglesize, hashnum])

参数

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

返回值

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

示例

使用示例

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

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

wordShingleMinHashArgCaseInsensitiveUTF8​

引入于：v21.1

将 UTF-8 字符串拆分为每个 shinglesize 个单词的部分（shingles），并返回使用相同输入计算的 wordShingleMinHashCaseInsensitiveUTF8 函数计算的最小和最大单词哈希值。不区分大小写。

语法

wordShingleMinHashArgCaseInsensitiveUTF8(string[, shinglesize, hashnum])

参数

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

返回值

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

示例

使用示例

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

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

wordShingleMinHashArgUTF8​

引入于：v21.1

将 UTF-8 字符串拆分为每个 shinglesize 个单词的部分（shingles），并返回使用相同输入计算的 wordShingleMinHashUTF8 函数计算的最小和最大单词哈希值。区分大小写。

语法

wordShingleMinHashArgUTF8(string[, shinglesize, hashnum])

参数

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

返回值

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

示例

使用示例

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

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

wordShingleMinHashCaseInsensitive​

引入于：v21.1

将 ASCII 字符串拆分为 shinglesize 个单词的部分（shingles），计算每个单词 shingle 的哈希值，然后返回一个包含这些哈希值的元组。使用 hashnum 个最小哈希值来计算最小哈希值，并使用 hashnum 个最大哈希值来计算最大哈希值。不区分大小写。

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

语法

wordShingleMinHashCaseInsensitive(string[, shinglesize, hashnum])

参数

  • string — 要计算哈希值的字符串。 String
  • shinglesize — 可选。单词 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），计算每个单词 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 — 可选。单词 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。计算出的两个字符串的 simhashes 的 汉明距离 越小，这些字符串相同的可能性就越大。

语法

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），并返回单词 shingle 的 simhash。不区分大小写。

可用于检测半重复字符串，方法是使用 bitHammingDistance。计算出的两个字符串的 simhashes 的 汉明距离 越小，这些字符串相同的可能性就越大。

语法

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 个单词的部分（shingle），并返回单词 shingle 的 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 个单词的部分（shingle），并返回单词 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
    © . This site is unofficial and not affiliated with ClickHouse, Inc.