哈希函数
哈希函数可以用于元素的确定性伪随机混排。
Simhash 是一种哈希函数，它为接近（相似）的参数返回接近的哈希值。
halfMD5
将所有输入参数解释为字符串，并计算每个参数的 MD5 哈希值。然后组合哈希值，取结果字符串哈希值的前 8 个字节，并将它们解释为大端字节序的 UInt64。
halfMD5(par1, ...)
该函数相对较慢（每个处理器核心每秒 500 万个短字符串）。考虑改用 sipHash64 函数。
参数
该函数接受可变数量的输入参数。参数可以是支持的数据类型中的任何一种。对于某些数据类型，即使参数类型不同，相同值的哈希函数计算值也可能相同（不同大小的整数，具有相同数据的命名和未命名 Tuple，具有相同数据的 Map 和相应的 Array(Tuple(key, value)) 类型）。
返回值
UInt64 数据类型哈希值。
示例
SELECT halfMD5(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS halfMD5hash, toTypeName(halfMD5hash) AS type;
┌────────halfMD5hash─┬─type───┐
│ 186182704141653334 │ UInt64 │
└────────────────────┴────────┘
MD4
从字符串计算 MD4，并将结果字节集作为 FixedString(16) 返回。
MD5
从字符串计算 MD5，并将结果字节集作为 FixedString(16) 返回。如果您不需要特定的 MD5，但需要一个体面的加密 128 位哈希，请改用 ‘sipHash128’ 函数。如果您想获得与 md5sum 实用程序输出相同的结果，请使用 lower(hex(MD5(s)))。
RIPEMD160
生成 RIPEMD-160 哈希值。
语法
RIPEMD160(input)
参数
input: 输入字符串。 String
返回值
- 类型为 FixedString(20) 的 160 位
RIPEMD-160哈希值。
示例
使用 hex 函数将结果表示为十六进制编码的字符串。
查询
SELECT HEX(RIPEMD160('The quick brown fox jumps over the lazy dog'));
┌─HEX(RIPEMD160('The quick brown fox jumps over the lazy dog'))─┐
│ 37F332F68DB77BD9D7EDD4969571AD671CF9DD3B │
└───────────────────────────────────────────────────────────────┘
sipHash64
生成 64 位 SipHash 哈希值。
sipHash64(par1,...)
这是一种加密哈希函数。它的工作速度至少比 MD5 哈希函数快三倍。
函数 将所有输入参数解释为字符串，并计算每个参数的哈希值。然后，它通过以下算法组合哈希值
- 第一个和第二个哈希值被连接到一个数组，该数组被哈希处理。
- 先前计算的哈希值和第三个输入参数的哈希值以类似的方式进行哈希处理。
- 对于原始输入的所有剩余哈希值，重复此计算。
参数
该函数接受可变数量的输入参数，这些参数可以是支持的数据类型中的任何一种。
返回值
UInt64 数据类型哈希值。
请注意，对于不同参数类型的相同输入值，计算出的哈希值可能相等。这会影响例如不同大小的整数类型、具有相同数据的命名和未命名 Tuple、Map 和相应的 Array(Tuple(key, value)) 类型以及相同的数据。
示例
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
与 sipHash64 相同，但另外接受显式密钥参数，而不是使用固定密钥。
语法
sipHash64Keyed((k0, k1), par1,...)
参数
与 sipHash64 相同，但第一个参数是表示密钥的两个 UInt64 值的元组。
返回值
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 │
└─────────────────────┴────────┘
sipHash128
类似于 sipHash64，但生成 128 位哈希值，即最终异或折叠状态最多完成 128 位。
此 128 位变体与参考实现不同，并且较弱。此版本存在的原因是，在编写时，SipHash 没有官方的 128 位扩展。新项目可能应该使用 sipHash128Reference。
语法
sipHash128(par1,...)
参数
与 sipHash64 相同。
返回值
类型为 FixedString(16) 的 128 位 SipHash 哈希值。
示例
查询
SELECT hex(sipHash128('foo', '\x01', 3));
结果
┌─hex(sipHash128('foo', '', 3))────┐
│ 9DE516A64A414D4B1B609415E4523F24 │
└──────────────────────────────────┘
sipHash128Keyed
与 sipHash128 相同，但另外接受显式密钥参数，而不是使用固定密钥。
此 128 位变体与参考实现不同，并且较弱。此版本存在的原因是，在编写时，SipHash 没有官方的 128 位扩展。新项目可能应该使用 sipHash128ReferenceKeyed。
语法
sipHash128Keyed((k0, k1), par1,...)
参数
与 sipHash128 相同，但第一个参数是表示密钥的两个 UInt64 值的元组。
返回值
类型为 FixedString(16) 的 128 位 SipHash 哈希值。
示例
查询
SELECT hex(sipHash128Keyed((506097522914230528, 1084818905618843912),'foo', '\x01', 3));
结果
┌─hex(sipHash128Keyed((506097522914230528, 1084818905618843912), 'foo', '', 3))─┐
│ B8467F65C8B4CFD9A5F8BD733917D9BF │
└───────────────────────────────────────────────────────────────────────────────┘
sipHash128Reference
类似于 sipHash128，但实现了来自 SipHash 原始作者的 128 位算法。
语法
sipHash128Reference(par1,...)
参数
与 sipHash128 相同。
返回值
类型为 FixedString(16) 的 128 位 SipHash 哈希值。
示例
查询
SELECT hex(sipHash128Reference('foo', '\x01', 3));
结果
┌─hex(sipHash128Reference('foo', '', 3))─┐
│ 4D1BE1A22D7F5933C0873E1698426260 │
└────────────────────────────────────────┘
sipHash128ReferenceKeyed
与 sipHash128Reference 相同，但另外接受显式密钥参数，而不是使用固定密钥。
语法
sipHash128ReferenceKeyed((k0, k1), par1,...)
参数
与 sipHash128Reference 相同，但第一个参数是表示密钥的两个 UInt64 值的元组。
返回值
类型为 FixedString(16) 的 128 位 SipHash 哈希值。
示例
查询
SELECT hex(sipHash128ReferenceKeyed((506097522914230528, 1084818905618843912),'foo', '\x01', 3));
结果
┌─hex(sipHash128ReferenceKeyed((506097522914230528, 1084818905618843912), 'foo', '', 3))─┐
│ 630133C9722DC08646156B8130C4CDC8 │
└────────────────────────────────────────────────────────────────────────────────────────┘
cityHash64
生成 64 位 CityHash 哈希值。
cityHash64(par1,...)
这是一个快速的非加密哈希函数。它对字符串参数使用 CityHash 算法，对其他数据类型的参数使用特定于实现的快速非加密哈希函数。该函数使用 CityHash 组合器来获得最终结果。
请注意，在 CityHash 添加到 ClickHouse 后，Google 更改了 CityHash 的算法。换句话说，ClickHouse 的 cityHash64 和 Google 的上游 CityHash 现在产生不同的结果。ClickHouse cityHash64 对应于 CityHash v1.0.2。
参数
该函数接受可变数量的输入参数。参数可以是支持的数据类型中的任何一种。对于某些数据类型，即使参数类型不同，相同值的哈希函数计算值也可能相同（不同大小的整数，具有相同数据的命名和未命名 Tuple，具有相同数据的 Map 和相应的 Array(Tuple(key, value)) 类型）。
返回值
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 │
└──────────────────────┴────────┘
以下示例显示了如何计算整个表的校验和，精度达到行顺序
SELECT groupBitXor(cityHash64(*)) FROM table
intHash32
从任何类型的整数计算 32 位哈希码。这是一种相对快速的非加密哈希函数，对于数字来说质量一般。
语法
intHash32(int)
参数
int— 要哈希的整数。 (U)Int*。
返回值
- 32 位哈希码。 UInt32。
示例
查询
SELECT intHash32(42);
结果
┌─intHash32(42)─┐
│ 1228623923 │
└───────────────┘
intHash64
从任何类型的整数计算 64 位哈希码。这是一种相对快速的非加密哈希函数，对于数字来说质量一般。它的工作速度比 intHash32 快。
语法
intHash64(int)
参数
int— 要哈希的整数。 (U)Int*。
返回值
- 64 位哈希码。 UInt64。
示例
查询
SELECT intHash64(42);
结果
┌────────intHash64(42)─┐
│ 11490350930367293593 │
└──────────────────────┘
SHA1、SHA224、SHA256、SHA512、SHA512_256
从字符串计算 SHA-1、SHA-224、SHA-256、SHA-512、SHA-512-256 哈希值，并将结果字节集作为 FixedString 返回。
语法
SHA1('s')
...
SHA512('s')
该函数的工作速度相当慢（SHA-1 每秒每个处理器核心处理约 500 万个短字符串，而 SHA-224 和 SHA-256 处理约 220 万个）。我们建议仅在您需要特定的哈希函数且无法选择它时才使用此函数。即使在这些情况下，我们建议离线应用该函数并在将值插入表时预先计算值，而不是在 SELECT 查询中应用它。
参数
s— 用于 SHA 哈希计算的输入字符串。 String。
返回值
- 作为十六进制未编码 FixedString 的 SHA 哈希。SHA-1 作为 FixedString(20) 返回，SHA-224 作为 FixedString(28) 返回，SHA-256 — FixedString(32)，SHA-512 — FixedString(64)。 FixedString。
示例
使用 hex 函数将结果表示为十六进制编码的字符串。
查询
SELECT hex(SHA1('abc'));
结果
┌─hex(SHA1('abc'))─────────────────────────┐
│ A9993E364706816ABA3E25717850C26C9CD0D89D │
└──────────────────────────────────────────┘
BLAKE3
计算 BLAKE3 哈希字符串，并将结果字节集作为 FixedString 返回。
语法
BLAKE3('s')
此加密哈希函数已通过 BLAKE3 Rust 库集成到 ClickHouse 中。该函数相当快，并且显示出比 SHA-2 快大约两倍的性能，同时生成与 SHA-256 长度相同的哈希值。
参数
- s - 用于 BLAKE3 哈希计算的输入字符串。 String。
返回值
- BLAKE3 哈希，作为类型为 FixedString(32) 的字节数组。 FixedString。
示例
使用函数 hex 将结果表示为十六进制编码的字符串。
查询
SELECT hex(BLAKE3('ABC'))
结果
┌─hex(BLAKE3('ABC'))───────────────────────────────────────────────┐
│ D1717274597CF0289694F75D96D444B992A096F1AFD8E7BBFA6EBB1D360FEDFC │
└──────────────────────────────────────────────────────────────────┘
URLHash(url[, N])
一种快速、高质量的非加密哈希函数，用于从 URL 获取的字符串，使用某种类型的规范化。 URLHash(s) – 计算字符串的哈希值，如果末尾存在尾随符号 /、? 或 #，则不包含其中之一。 URLHash(s, N) – 计算 URL 层次结构中最多 N 级的字符串的哈希值，如果末尾存在尾随符号 /、? 或 #，则不包含其中之一。级别与 URLHierarchy 中的级别相同。
farmFingerprint64
farmHash64
生成 64 位 FarmHash 或 Fingerprint 值。farmFingerprint64 是首选的稳定且可移植的值。
farmFingerprint64(par1, ...)
farmHash64(par1, ...)
这些函数分别使用所有可用方法中的 Fingerprint64 和 Hash64 方法。
参数
该函数接受可变数量的输入参数。参数可以是支持的数据类型中的任何一种。对于某些数据类型，即使参数类型不同，相同值的哈希函数计算值也可能相同（不同大小的整数，具有相同数据的命名和未命名 Tuple，具有相同数据的 Map 和相应的 Array(Tuple(key, value)) 类型）。
返回值
UInt64 数据类型哈希值。
示例
SELECT farmHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmHash, toTypeName(FarmHash) AS type;
┌─────────────FarmHash─┬─type───┐
│ 17790458267262532859 │ UInt64 │
└──────────────────────┴────────┘
javaHash
从 string、Byte、Short、Integer、Long 计算 JavaHash。此哈希函数既不快速也不具有良好的质量。使用它的唯一原因是当此算法已在另一个系统中使用，并且您必须计算完全相同的结果时。
请注意，Java 仅支持计算有符号整数哈希，因此如果您要计算无符号整数哈希，则必须将其强制转换为适当的有符号 ClickHouse 类型。
语法
SELECT javaHash('')
返回值
Int32 数据类型哈希值。
示例
查询
SELECT javaHash(toInt32(123));
结果
┌─javaHash(toInt32(123))─┐
│ 123 │
└────────────────────────┘
查询
SELECT javaHash('Hello, world!');
结果
┌─javaHash('Hello, world!')─┐
│ -1880044555 │
└───────────────────────────┘
javaHashUTF16LE
从字符串计算 JavaHash，假设它包含表示 UTF-16LE 编码字符串的字节。
语法
javaHashUTF16LE(stringUtf16le)
参数
stringUtf16le— UTF-16LE 编码的字符串。
返回值
Int32 数据类型哈希值。
示例
使用 UTF-16LE 编码字符串的正确查询。
查询
SELECT javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'));
结果
┌─javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'))─┐
│ 3556498 │
└──────────────────────────────────────────────────────────────┘
hiveHash
从字符串计算 HiveHash。
SELECT hiveHash('')
这只是符号位归零的 JavaHash。此函数在 3.0 之前的 Apache Hive 版本中使用。此哈希函数既不快速也不具有良好的质量。使用它的唯一原因是当此算法已在另一个系统中使用，并且您必须计算完全相同的结果时。
返回值
hiveHash哈希值。 Int32。
示例
查询
SELECT hiveHash('Hello, world!');
结果
┌─hiveHash('Hello, world!')─┐
│ 267439093 │
└───────────────────────────┘
metroHash64
生成 64 位 MetroHash 哈希值。
metroHash64(par1, ...)
参数
该函数接受可变数量的输入参数。参数可以是支持的数据类型中的任何一种。对于某些数据类型，即使参数类型不同，相同值的哈希函数计算值也可能相同（不同大小的整数，具有相同数据的命名和未命名 Tuple，具有相同数据的 Map 和相应的 Array(Tuple(key, value)) 类型）。
返回值
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 │
└──────────────────────┴────────┘
jumpConsistentHash
从 UInt64 计算 JumpConsistentHash。接受两个参数：UInt64 类型键和桶数。返回 Int32。有关更多信息，请参阅链接：JumpConsistentHash
kostikConsistentHash
Konstantin 'kostik' Oblakov 的 O(1) 时间和空间一致哈希算法。以前是 yandexConsistentHash。
语法
kostikConsistentHash(input, n)
别名：yandexConsistentHash（为了向后兼容性而保留）。
参数
返回值
- UInt16 数据类型哈希值。
实现细节
仅当 n <= 32768 时才有效。
示例
查询
SELECT kostikConsistentHash(16045690984833335023, 2);
┌─kostikConsistentHash(16045690984833335023, 2)─┐
│ 1 │
└───────────────────────────────────────────────┘
murmurHash2_32, murmurHash2_64
生成 MurmurHash2 哈希值。
murmurHash2_32(par1, ...)
murmurHash2_64(par1, ...)
参数
这两个函数都接受可变数量的输入参数。参数可以是支持的数据类型中的任何一种。对于某些数据类型，即使参数类型不同，相同值的哈希函数计算值也可能相同（不同大小的整数，具有相同数据的命名和未命名 Tuple，具有相同数据的 Map 和相应的 Array(Tuple(key, value)) 类型）。
返回值
示例
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 │
└──────────────────────┴────────┘
gccMurmurHash
使用与 gcc 相同的哈希种子计算 64 位 MurmurHash2 哈希值。它在 Clang 和 GCC 构建之间是可移植的。
语法
gccMurmurHash(par1, ...)
参数
par1, ...— 可变数量的参数，可以是支持的数据类型中的任何一种。
返回值
- 计算的哈希值。 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 │
└──────────────────────┴─────────────────────┘
kafkaMurmurHash
使用与 MurmurHash2 相同的哈希种子计算 32 位 Kafka 哈希值，并且不带最高位，以便与 Default Partitioner 兼容。
语法
MurmurHash(par1, ...)
参数
par1, ...— 可变数量的参数，可以是支持的数据类型中的任何一种。
返回值
- 计算的哈希值。 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 │
└────────────┴──────────┘
murmurHash3_32, murmurHash3_64
生成 MurmurHash3 哈希值。
murmurHash3_32(par1, ...)
murmurHash3_64(par1, ...)
参数
这两个函数都接受可变数量的输入参数。参数可以是支持的数据类型中的任何一种。对于某些数据类型，即使参数类型不同，相同值的哈希函数计算值也可能相同（不同大小的整数，具有相同数据的命名和未命名 Tuple，具有相同数据的 Map 和相应的 Array(Tuple(key, value)) 类型）。
返回值
示例
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_128
生成 128 位 MurmurHash3 哈希值。
语法
murmurHash3_128(expr)
参数
返回值
128 位 MurmurHash3 哈希值。 FixedString(16)。
示例
查询
SELECT hex(murmurHash3_128('foo', 'foo', 'foo'));
结果
┌─hex(murmurHash3_128('foo', 'foo', 'foo'))─┐
│ F8F7AD9B6CD4CF117A71E277E2EC2931 │
└───────────────────────────────────────────┘
xxh3
生成 64 位 xxh3 哈希值。
语法
xxh3(expr)
参数
expr— 任何数据类型的表达式列表。
返回值
64 位 xxh3 哈希值。 UInt64。
示例
查询
SELECT xxh3('Hello', 'world')
结果
┌─xxh3('Hello', 'world')─┐
│ 5607458076371731292 │
└────────────────────────┘
xxHash32, xxHash64
从字符串计算 xxHash。它以两种形式提出，32 位和 64 位。
SELECT xxHash32('')
OR
SELECT xxHash64('')
返回值
- 哈希值。 UInt32/64。
对于 xxHash32，返回类型将为 UInt32，对于 xxHash64，返回类型将为 UInt64。
示例
查询
SELECT xxHash32('Hello, world!');
结果
┌─xxHash32('Hello, world!')─┐
│ 834093149 │
└───────────────────────────┘
另请参阅
ngramSimHash
将 ASCII 字符串拆分为 ngramsize 个符号的 n-gram，并返回 n-gram simhash。区分大小写。
可用于使用 bitHammingDistance 检测半重复字符串。两个字符串的计算出的 simhashes 的 海明距离 越小，这些字符串相同的可能性就越大。
语法
ngramSimHash(string[, ngramsize])
参数
返回值
- 哈希值。 UInt64。
示例
查询
SELECT ngramSimHash('ClickHouse') AS Hash;
结果
┌───────Hash─┐
│ 1627567969 │
└────────────┘
ngramSimHashCaseInsensitive
将 ASCII 字符串拆分为 ngramsize 个符号的 n-gram，并返回 n-gram simhash。不区分大小写。
可用于使用 bitHammingDistance 检测半重复字符串。两个字符串的计算出的 simhashes 的 海明距离 越小，这些字符串相同的可能性就越大。
语法
ngramSimHashCaseInsensitive(string[, ngramsize])
参数
返回值
- 哈希值。 UInt64。
示例
查询
SELECT ngramSimHashCaseInsensitive('ClickHouse') AS Hash;
结果
┌──────Hash─┐
│ 562180645 │
└───────────┘
ngramSimHashUTF8
将 UTF-8 字符串拆分为 ngramsize 个符号的 n-gram，并返回 n-gram simhash。区分大小写。
可用于使用 bitHammingDistance 检测半重复字符串。两个字符串的计算出的 simhashes 的 海明距离 越小，这些字符串相同的可能性就越大。
语法
ngramSimHashUTF8(string[, ngramsize])
参数
返回值
- 哈希值。 UInt64。
示例
查询
SELECT ngramSimHashUTF8('ClickHouse') AS Hash;
结果
┌───────Hash─┐
│ 1628157797 │
└────────────┘
ngramSimHashCaseInsensitiveUTF8
将 UTF-8 字符串拆分为 ngramsize 个符号的 n-gram，并返回 n-gram simhash。不区分大小写。
可用于使用 bitHammingDistance 检测半重复字符串。两个字符串的计算出的 simhashes 的 海明距离 越小，这些字符串相同的可能性就越大。
语法
ngramSimHashCaseInsensitiveUTF8(string[, ngramsize])
参数
返回值
- 哈希值。 UInt64。
示例
查询
SELECT ngramSimHashCaseInsensitiveUTF8('ClickHouse') AS Hash;
结果
┌───────Hash─┐
│ 1636742693 │
└────────────┘
wordShingleSimHash
将 ASCII 字符串拆分为 shinglesize 个单词的部分（shingle），并返回单词 shingle simhash。区分大小写。
可用于使用 bitHammingDistance 检测半重复字符串。两个字符串的计算出的 simhashes 的 海明距离 越小，这些字符串相同的可能性就越大。
语法
wordShingleSimHash(string[, shinglesize])
参数
返回值
- 哈希值。 UInt64。
示例
查询
SELECT wordShingleSimHash('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
结果
┌───────Hash─┐
│ 2328277067 │
└────────────┘
wordShingleSimHashCaseInsensitive
将 ASCII 字符串拆分为 shinglesize 个单词的部分（shingle），并返回单词 shingle simhash。不区分大小写。
可用于使用 bitHammingDistance 检测半重复字符串。两个字符串的计算出的 simhashes 的 海明距离 越小，这些字符串相同的可能性就越大。
语法
wordShingleSimHashCaseInsensitive(string[, shinglesize])
参数
返回值
- 哈希值。 UInt64。
示例
查询
SELECT wordShingleSimHashCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
结果
┌───────Hash─┐
│ 2194812424 │
└────────────┘
wordShingleSimHashUTF8
将 UTF-8 字符串拆分为 shinglesize 个单词的部分（shingle），并返回单词 shingle simhash。区分大小写。
可用于使用 bitHammingDistance 检测半重复字符串。两个字符串的计算出的 simhashes 的 海明距离 越小，这些字符串相同的可能性就越大。
语法
wordShingleSimHashUTF8(string[, shinglesize])
参数
返回值
- 哈希值。 UInt64。
示例
查询
SELECT wordShingleSimHashUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
结果
┌───────Hash─┐
│ 2328277067 │
└────────────┘
wordShingleSimHashCaseInsensitiveUTF8
将 UTF-8 字符串分割成 shinglesize 个词语的部分（shingles），并返回词语 shingle simhash。不区分大小写。
可用于使用 bitHammingDistance 检测半重复字符串。两个字符串的计算出的 simhashes 的 海明距离 越小，这些字符串相同的可能性就越大。
语法
wordShingleSimHashCaseInsensitiveUTF8(string[, shinglesize])
参数
返回值
- 哈希值。 UInt64。
示例
查询
SELECT wordShingleSimHashCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
结果
┌───────Hash─┐
│ 2194812424 │
└────────────┘
wyHash64
生成一个 64 位的 wyHash64 哈希值。
语法
wyHash64(string)
参数
string— 字符串。 String。
返回值
- 哈希值。 UInt64。
示例
查询
SELECT wyHash64('ClickHouse') AS Hash;
结果
┌─────────────────Hash─┐
│ 12336419557878201794 │
└──────────────────────┘
ngramMinHash
将 ASCII 字符串分割成 ngramsize 个符号的 n-grams，并计算每个 n-gram 的哈希值。使用 hashnum 个最小哈希值来计算最小哈希值，并使用 hashnum 个最大哈希值来计算最大哈希值。返回包含这些哈希值的元组。区分大小写。
可用于使用 tupleHammingDistance 检测半重复字符串。对于两个字符串：如果两个字符串返回的哈希值之一相同，我们认为这两个字符串是相同的。
语法
ngramMinHash(string[, ngramsize, hashnum])
参数
string— 字符串。 String。ngramsize— n-gram 的大小。可选。可能的值：从1到25的任何数字。默认值：3。 UInt8。hashnum— 用于计算结果的最小和最大哈希值的数量。可选。可能的值：1到25之间的任何数字。默认值：6。UInt8。
返回值
示例
查询
SELECT ngramMinHash('ClickHouse') AS Tuple;
结果
┌─Tuple──────────────────────────────────────┐
│ (18333312859352735453,9054248444481805918) │
└────────────────────────────────────────────┘
ngramMinHashCaseInsensitive
将 ASCII 字符串分割成 ngramsize 个符号的 n-grams，并计算每个 n-gram 的哈希值。使用 hashnum 个最小哈希值来计算最小哈希值，并使用 hashnum 个最大哈希值来计算最大哈希值。返回包含这些哈希值的元组。不区分大小写。
可用于使用 tupleHammingDistance 检测半重复字符串。对于两个字符串：如果两个字符串返回的哈希值之一相同，我们认为这两个字符串是相同的。
语法
ngramMinHashCaseInsensitive(string[, ngramsize, hashnum])
参数
string— 字符串。 String。ngramsize— n-gram 的大小。可选。可能的值：从1到25的任何数字。默认值：3。 UInt8。hashnum— 用于计算结果的最小和最大哈希值的数量。可选。可能的值：1到25之间的任何数字。默认值：6。UInt8。
返回值
示例
查询
SELECT ngramMinHashCaseInsensitive('ClickHouse') AS Tuple;
结果
┌─Tuple──────────────────────────────────────┐
│ (2106263556442004574,13203602793651726206) │
└────────────────────────────────────────────┘
ngramMinHashUTF8
将 UTF-8 字符串分割成 ngramsize 个符号的 n-grams，并计算每个 n-gram 的哈希值。使用 hashnum 个最小哈希值来计算最小哈希值，并使用 hashnum 个最大哈希值来计算最大哈希值。返回包含这些哈希值的元组。区分大小写。
可用于使用 tupleHammingDistance 检测半重复字符串。对于两个字符串：如果两个字符串返回的哈希值之一相同，我们认为这两个字符串是相同的。
语法
ngramMinHashUTF8(string[, ngramsize, hashnum])
参数
string— 字符串。 String。ngramsize— n-gram 的大小。可选。可能的值：从1到25的任何数字。默认值：3。 UInt8。hashnum— 用于计算结果的最小和最大哈希值的数量。可选。可能的值：1到25之间的任何数字。默认值：6。UInt8。
返回值
示例
查询
SELECT ngramMinHashUTF8('ClickHouse') AS Tuple;
结果
┌─Tuple──────────────────────────────────────┐
│ (18333312859352735453,6742163577938632877) │
└────────────────────────────────────────────┘
ngramMinHashCaseInsensitiveUTF8
将 UTF-8 字符串分割成 ngramsize 个符号的 n-grams，并计算每个 n-gram 的哈希值。使用 hashnum 个最小哈希值来计算最小哈希值，并使用 hashnum 个最大哈希值来计算最大哈希值。返回包含这些哈希值的元组。不区分大小写。
可用于使用 tupleHammingDistance 检测半重复字符串。对于两个字符串：如果两个字符串返回的哈希值之一相同，我们认为这两个字符串是相同的。
语法
ngramMinHashCaseInsensitiveUTF8(string [, ngramsize, hashnum])
参数
string— 字符串。 String。ngramsize— n-gram 的大小。可选。可能的值：从1到25的任何数字。默认值：3。 UInt8。hashnum— 用于计算结果的最小和最大哈希值的数量。可选。可能的值：1到25之间的任何数字。默认值：6。UInt8。
返回值
示例
查询
SELECT ngramMinHashCaseInsensitiveUTF8('ClickHouse') AS Tuple;
结果
┌─Tuple───────────────────────────────────────┐
│ (12493625717655877135,13203602793651726206) │
└─────────────────────────────────────────────┘
ngramMinHashArg
将 ASCII 字符串分割成 ngramsize 个符号的 n-grams，并返回具有最小和最大哈希值的 n-grams，这些哈希值由具有相同输入的 ngramMinHash 函数计算得出。区分大小写。
语法
ngramMinHashArg(string[, ngramsize, hashnum])
参数
string— 字符串。 String。ngramsize— n-gram 的大小。可选。可能的值：从1到25的任何数字。默认值：3。 UInt8。hashnum— 用于计算结果的最小和最大哈希值的数量。可选。可能的值：1到25之间的任何数字。默认值：6。UInt8。
返回值
示例
查询
SELECT ngramMinHashArg('ClickHouse') AS Tuple;
结果
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ous','ick','lic','Hou','kHo','use'),('Hou','lic','ick','ous','ckH','Cli')) │
└───────────────────────────────────────────────────────────────────────────────┘
ngramMinHashArgCaseInsensitive
将 ASCII 字符串分割成 ngramsize 个符号的 n-grams，并返回具有最小和最大哈希值的 n-grams，这些哈希值由具有相同输入的 ngramMinHashCaseInsensitive 函数计算得出。不区分大小写。
语法
ngramMinHashArgCaseInsensitive(string[, ngramsize, hashnum])
参数
string— 字符串。 String。ngramsize— n-gram 的大小。可选。可能的值：从1到25的任何数字。默认值：3。 UInt8。hashnum— 用于计算结果的最小和最大哈希值的数量。可选。可能的值：1到25之间的任何数字。默认值：6。UInt8。
返回值
示例
查询
SELECT ngramMinHashArgCaseInsensitive('ClickHouse') AS Tuple;
结果
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ous','ick','lic','kHo','use','Cli'),('kHo','lic','ick','ous','ckH','Hou')) │
└───────────────────────────────────────────────────────────────────────────────┘
ngramMinHashArgUTF8
将 UTF-8 字符串分割成 ngramsize 个符号的 n-grams，并返回具有最小和最大哈希值的 n-grams，这些哈希值由具有相同输入的 ngramMinHashUTF8 函数计算得出。区分大小写。
语法
ngramMinHashArgUTF8(string[, ngramsize, hashnum])
参数
string— 字符串。 String。ngramsize— n-gram 的大小。可选。可能的值：从1到25的任何数字。默认值：3。 UInt8。hashnum— 用于计算结果的最小和最大哈希值的数量。可选。可能的值：1到25之间的任何数字。默认值：6。UInt8。
返回值
示例
查询
SELECT ngramMinHashArgUTF8('ClickHouse') AS Tuple;
结果
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ous','ick','lic','Hou','kHo','use'),('kHo','Hou','lic','ick','ous','ckH')) │
└───────────────────────────────────────────────────────────────────────────────┘
ngramMinHashArgCaseInsensitiveUTF8
将 UTF-8 字符串分割成 ngramsize 个符号的 n-grams，并返回具有最小和最大哈希值的 n-grams，这些哈希值由具有相同输入的 ngramMinHashCaseInsensitiveUTF8 函数计算得出。不区分大小写。
语法
ngramMinHashArgCaseInsensitiveUTF8(string[, ngramsize, hashnum])
参数
string— 字符串。 String。ngramsize— n-gram 的大小。可选。可能的值：从1到25的任何数字。默认值：3。 UInt8。hashnum— 用于计算结果的最小和最大哈希值的数量。可选。可能的值：1到25之间的任何数字。默认值：6。UInt8。
返回值
示例
查询
SELECT ngramMinHashArgCaseInsensitiveUTF8('ClickHouse') AS Tuple;
结果
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ckH','ous','ick','lic','kHo','use'),('kHo','lic','ick','ous','ckH','Hou')) │
└───────────────────────────────────────────────────────────────────────────────┘
wordShingleMinHash
将 ASCII 字符串分割成 shinglesize 个词语的部分（shingles），并计算每个词语 shingle 的哈希值。使用 hashnum 个最小哈希值来计算最小哈希值，并使用 hashnum 个最大哈希值来计算最大哈希值。返回包含这些哈希值的元组。区分大小写。
可用于使用 tupleHammingDistance 检测半重复字符串。对于两个字符串：如果两个字符串返回的哈希值之一相同，我们认为这两个字符串是相同的。
语法
wordShingleMinHash(string[, shinglesize, hashnum])
参数
string— 字符串。 String。shinglesize— 单词 shingle 的大小。可选。可能的值：从1到25的任何数字。默认值：3。 UInt8。hashnum— 用于计算结果的最小和最大哈希值的数量。可选。可能的值：1到25之间的任何数字。默认值：6。UInt8。
返回值
示例
查询
SELECT wordShingleMinHash('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
结果
┌─Tuple──────────────────────────────────────┐
│ (16452112859864147620,5844417301642981317) │
└────────────────────────────────────────────┘
wordShingleMinHashCaseInsensitive
将 ASCII 字符串分割成 shinglesize 个词语的部分（shingles），并计算每个词语 shingle 的哈希值。使用 hashnum 个最小哈希值来计算最小哈希值，并使用 hashnum 个最大哈希值来计算最大哈希值。返回包含这些哈希值的元组。不区分大小写。
可用于使用 tupleHammingDistance 检测半重复字符串。对于两个字符串：如果两个字符串返回的哈希值之一相同，我们认为这两个字符串是相同的。
语法
wordShingleMinHashCaseInsensitive(string[, shinglesize, hashnum])
参数
string— 字符串。 String。shinglesize— 单词 shingle 的大小。可选。可能的值：从1到25的任何数字。默认值：3。 UInt8。hashnum— 用于计算结果的最小和最大哈希值的数量。可选。可能的值：1到25之间的任何数字。默认值：6。UInt8。
返回值
示例
查询
SELECT wordShingleMinHashCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
结果
┌─Tuple─────────────────────────────────────┐
│ (3065874883688416519,1634050779997673240) │
└───────────────────────────────────────────┘
wordShingleMinHashUTF8
将 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。
返回值
示例
查询
SELECT wordShingleMinHashUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
结果
┌─Tuple──────────────────────────────────────┐
│ (16452112859864147620,5844417301642981317) │
└────────────────────────────────────────────┘
wordShingleMinHashCaseInsensitiveUTF8
将 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。
返回值
示例
查询
SELECT wordShingleMinHashCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
结果
┌─Tuple─────────────────────────────────────┐
│ (3065874883688416519,1634050779997673240) │
└───────────────────────────────────────────┘
wordShingleMinHashArg
将 ASCII 字符串分割成每部分 shinglesize 个词语的部分（shingles），并返回具有最小和最大词语哈希值的 shingles，这些哈希值由具有相同输入的 wordshingleMinHash 函数计算得出。区分大小写。
语法
wordShingleMinHashArg(string[, shinglesize, hashnum])
参数
string— 字符串。 String。shinglesize— 单词 shingle 的大小。可选。可能的值：从1到25的任何数字。默认值：3。 UInt8。hashnum— 用于计算结果的最小和最大哈希值的数量。可选。可能的值：1到25之间的任何数字。默认值：6。UInt8。
返回值
示例
查询
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
将 ASCII 字符串分割成每部分 shinglesize 个词语的部分（shingles），并返回具有最小和最大词语哈希值的 shingles，这些哈希值由具有相同输入的 wordShingleMinHashCaseInsensitive 函数计算得出。不区分大小写。
语法
wordShingleMinHashArgCaseInsensitive(string[, shinglesize, hashnum])
参数
string— 字符串。 String。shinglesize— 单词 shingle 的大小。可选。可能的值：从1到25的任何数字。默认值：3。 UInt8。hashnum— 用于计算结果的最小和最大哈希值的数量。可选。可能的值：1到25之间的任何数字。默认值：6。UInt8。
返回值
示例
查询
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')) │
└────────────────────────────────────────────────────────────────────────┘
wordShingleMinHashArgUTF8
将 UTF-8 字符串分割成每部分 shinglesize 个词语的部分（shingles），并返回具有最小和最大词语哈希值的 shingles，这些哈希值由具有相同输入的 wordShingleMinHashUTF8 函数计算得出。区分大小写。
语法
wordShingleMinHashArgUTF8(string[, shinglesize, hashnum])
参数
string— 字符串。 String。shinglesize— 单词 shingle 的大小。可选。可能的值：从1到25的任何数字。默认值：3。 UInt8。hashnum— 用于计算结果的最小和最大哈希值的数量。可选。可能的值：1到25之间的任何数字。默认值：6。UInt8。
返回值
示例
查询
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')) │
└───────────────────────────────────────────────────────────────────────┘
wordShingleMinHashArgCaseInsensitiveUTF8
将 UTF-8 字符串分割成每部分 shinglesize 个词语的部分（shingles），并返回具有最小和最大词语哈希值的 shingles，这些哈希值由具有相同输入的 wordShingleMinHashCaseInsensitiveUTF8 函数计算得出。不区分大小写。
语法
wordShingleMinHashArgCaseInsensitiveUTF8(string[, shinglesize, hashnum])
参数
string— 字符串。 String。shinglesize— 单词 shingle 的大小。可选。可能的值：从1到25的任何数字。默认值：3。 UInt8。hashnum— 用于计算结果的最小和最大哈希值的数量。可选。可能的值：1到25之间的任何数字。默认值：6。UInt8。
返回值
示例
查询
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')) │
└────────────────────────────────────────────────────────────────────────┘
sqidEncode
将数字编码为 Sqid，这是一种类似 YouTube ID 的字符串。输出字母表为 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789。请勿将此函数用于哈希 — 生成的 ID 可以解码回原始数字。
语法
sqidEncode(number1, ...)
别名：sqid
参数
- 可变数量的 UInt8、UInt16、UInt32 或 UInt64 数字。
返回值
一个 sqid 字符串。
示例
SELECT sqidEncode(1, 2, 3, 4, 5);
┌─sqidEncode(1, 2, 3, 4, 5)─┐
│ gXHfJ1C6dN │
└───────────────────────────┘
sqidDecode
将 Sqid 解码回其原始数字。如果输入字符串不是有效的 sqid，则返回一个空数组。
语法
sqidDecode(sqid)
参数
- 一个 sqid - 字符串
返回值
转换为数字的 sqid Array(UInt64)。
示例
SELECT sqidDecode('gXHfJ1C6dN');
┌─sqidDecode('gXHfJ1C6dN')─┐
│ [1,2,3,4,5] │
└──────────────────────────┘