哈希函数

哈希函数可用于对元素进行确定性伪随机洗牌。

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: 输入字符串。字符串

返回值

类型为 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。

参数

返回值

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 哈希计算的输入字符串。字符串。

返回值

作为十六进制未编码的 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 哈希计算的输入字符串。字符串.

返回值

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 方法。

参数

返回值

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

从字符串、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 的符号位清零。此函数用于 Apache Hive 版本 3.0 之前的版本。此哈希函数既不快，质量也不好。使用它的唯一原因是，当此算法已在另一个系统中使用时，您必须计算完全相同的结果。

返回值

hiveHash 哈希值。 Int32.

示例

查询

SELECT hiveHash('Hello, world!');

結果

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

metroHash64

生成 64 位 MetroHash 哈希值。

metroHash64(par1, ...)

参数

返回值

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（保留用于向后兼容性）。

参数

input：UInt64 类型的键 UInt64.
n：桶的数量。 UInt16.

返回值

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)) 类型），哈希函数的计算值也可能相同。

返回值

murmurHash2_32 函数返回具有 UInt32 数据类型的哈希值。
murmurHash2_64 函数返回具有 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 │
└──────────────────────┴────────┘

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

使用与 Kafka 相同的哈希种子，计算 32 位 MurmurHash2 哈希值，并且最高位为零，以与默认分区器兼容。

语法

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, ...)

参数

返回值

murmurHash3_32 函数返回 UInt32 数据类型哈希值。
murmurHash3_64 函数返回 UInt64 数据类型哈希值。

示例

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)

参数

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 │
└───────────────────────────┘

另请参阅

xxHash.

ngramSimHash

将 ASCII 字符串拆分为 ngramsize 个符号的 n 元组，并返回 n 元组 simhash。区分大小写。

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

语法

ngramSimHash(string[, ngramsize])

参数

string — 字符串。字符串.
ngramsize — n 元组的大小。可选。可能的值：从 1 到 25 的任何数字。默认值：3。 UInt8.

返回值

哈希值。 UInt64.

示例

查询

SELECT ngramSimHash('ClickHouse') AS Hash;

結果

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

ngramSimHashCaseInsensitive

将 ASCII 字符串拆分为 ngramsize 个符号的 n 元组，并返回 n 元组 simhash。不区分大小写。

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

语法

ngramSimHashCaseInsensitive(string[, ngramsize])

参数

string — 字符串。字符串.
ngramsize — n 元组的大小。可选。可能的值：从 1 到 25 的任何数字。默认值：3。 UInt8.

返回值

哈希值。 UInt64.

示例

查询

SELECT ngramSimHashCaseInsensitive('ClickHouse') AS Hash;

結果

┌──────Hash─┐
│ 562180645 │
└───────────┘

ngramSimHashUTF8

将 UTF-8 字符串拆分为 ngramsize 个符号的 n 元组，并返回 n 元组 simhash。区分大小写。

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

语法

ngramSimHashUTF8(string[, ngramsize])

参数

string — 字符串。字符串.
ngramsize — n 元组的大小。可选。可能的值：从 1 到 25 的任何数字。默认值：3。 UInt8.

返回值

哈希值。 UInt64.

示例

查询

SELECT ngramSimHashUTF8('ClickHouse') AS Hash;

結果

┌───────Hash─┐
│ 1628157797 │
└────────────┘

ngramSimHashCaseInsensitiveUTF8

将 UTF-8 字符串拆分为 ngramsize 个符号的 n 元组，并返回 n 元组 simhash。不区分大小写。

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

语法

ngramSimHashCaseInsensitiveUTF8(string[, ngramsize])

参数

string — 字符串。字符串.
ngramsize — n 元组的大小。可选。可能的值：从 1 到 25 的任何数字。默认值：3。 UInt8.

返回值

哈希值。 UInt64.

示例

查询

SELECT ngramSimHashCaseInsensitiveUTF8('ClickHouse') AS Hash;

結果

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

wordShingleSimHash

将 ASCII 字符串拆分为 shinglesize 个单词的片段（瓦片），并返回单词瓦片 simhash。区分大小写。

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

语法

wordShingleSimHash(string[, shinglesize])

参数

string — 字符串。字符串.
shinglesize — 单词瓦片的大小。可选。可能的值：从 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

将 ASCII 字符串拆分为 shinglesize 个单词的片段（瓦片），并返回单词瓦片 simhash。不区分大小写。

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

语法

wordShingleSimHashCaseInsensitive(string[, shinglesize])

参数

string — 字符串。字符串.
shinglesize — 单词瓦片的大小。可选。可能的值：从 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 │
└────────────┘

wordShingleSimHashUTF8

将 UTF-8 字符串拆分为 shinglesize 个单词的部分（分片），并返回单词分片的 simhash。区分大小写。

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

语法

wordShingleSimHashUTF8(string[, shinglesize])

参数

string — 字符串。字符串.
shinglesize — 单词瓦片的大小。可选。可能的值：从 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 │
└────────────┘

wordShingleSimHashCaseInsensitiveUTF8

将 UTF-8 字符串拆分为 shinglesize 个单词的部分（分片），并返回单词分片的 simhash。不区分大小写。

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

语法

wordShingleSimHashCaseInsensitiveUTF8(string[, shinglesize])

参数

string — 字符串。字符串.
shinglesize — 单词瓦片的大小。可选。可能的值：从 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 │
└────────────┘

wyHash64

生成一个 64 位 wyHash64 哈希值。

语法

wyHash64(string)

参数

string — 字符串。字符串.

返回值

哈希值。 UInt64.

示例

查询

SELECT wyHash64('ClickHouse') AS Hash;

結果

┌─────────────────Hash─┐
│ 12336419557878201794 │
└──────────────────────┘

ngramMinHash

将 ASCII 字符串拆分为 ngramsize 个符号的 n 元组，并为每个 n 元组计算哈希值。使用 hashnum 个最小哈希来计算最小哈希，使用 hashnum 个最大哈希来计算最大哈希。返回包含这些哈希的元组。区分大小写。

可用于使用 tupleHammingDistance 检测半重复字符串。对于两个字符串：如果返回的哈希之一对于两个字符串都相同，我们认为这两个字符串相同。

语法

ngramMinHash(string[, ngramsize, hashnum])

参数

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

返回值

包含两个哈希值的元组 - 最小值和最大值。 Tuple(UInt64, UInt64).

示例

查询

SELECT ngramMinHash('ClickHouse') AS Tuple;

結果

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

ngramMinHashCaseInsensitive

将 ASCII 字符串拆分为 ngramsize 个符号的 n 元组，并为每个 n 元组计算哈希值。使用 hashnum 个最小哈希来计算最小哈希，使用 hashnum 个最大哈希来计算最大哈希。返回包含这些哈希的元组。不区分大小写。

可用于使用 tupleHammingDistance 检测半重复字符串。对于两个字符串：如果返回的哈希之一对于两个字符串都相同，我们认为这两个字符串相同。

语法

ngramMinHashCaseInsensitive(string[, ngramsize, hashnum])

参数

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

返回值

包含两个哈希值的元组 - 最小值和最大值。 Tuple(UInt64, UInt64).

示例

查询

SELECT ngramMinHashCaseInsensitive('ClickHouse') AS Tuple;

結果

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

ngramMinHashUTF8

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

可用于使用 tupleHammingDistance 检测半重复字符串。对于两个字符串：如果返回的哈希之一对于两个字符串都相同，我们认为这两个字符串相同。

语法

ngramMinHashUTF8(string[, ngramsize, hashnum])

参数

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

返回值

包含两个哈希值的元组 - 最小值和最大值。 Tuple(UInt64, UInt64).

示例

查询

SELECT ngramMinHashUTF8('ClickHouse') AS Tuple;

結果

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

ngramMinHashCaseInsensitiveUTF8

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

可用于使用 tupleHammingDistance 检测半重复字符串。对于两个字符串：如果返回的哈希之一对于两个字符串都相同，我们认为这两个字符串相同。

语法

ngramMinHashCaseInsensitiveUTF8(string [, ngramsize, hashnum])

参数

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

返回值

包含两个哈希值的元组 - 最小值和最大值。 Tuple(UInt64, UInt64).

示例

查询

SELECT ngramMinHashCaseInsensitiveUTF8('ClickHouse') AS Tuple;

結果

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

ngramMinHashArg

将 ASCII 字符串拆分为 ngramsize 个符号的 n 元组，并返回具有最小和最大哈希值的 n 元组，这些哈希值由具有相同输入的 ngramMinHash 函数计算。区分大小写。

语法

ngramMinHashArg(string[, ngramsize, hashnum])

参数

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

返回值

包含两个元组的元组，每个元组包含 hashnum 个 n 元组。 Tuple(Tuple(String), Tuple(String)).

示例

查询

SELECT ngramMinHashArg('ClickHouse') AS Tuple;

結果

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

ngramMinHashArgCaseInsensitive

将 ASCII 字符串拆分为 ngramsize 个符号的 n 元组，并返回具有最小和最大哈希值的 n 元组，这些哈希值由具有相同输入的 ngramMinHashCaseInsensitive 函数计算。不区分大小写。

语法

ngramMinHashArgCaseInsensitive(string[, ngramsize, hashnum])

参数

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

返回值

包含两个元组的元组，每个元组包含 hashnum 个 n 元组。 Tuple(Tuple(String), Tuple(String)).

示例

查询

SELECT ngramMinHashArgCaseInsensitive('ClickHouse') AS Tuple;

結果

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

ngramMinHashArgUTF8

将 UTF-8 字符串拆分为 ngramsize 个符号的 n 元组，并返回具有最小和最大哈希值的 n 元组，这些哈希值由具有相同输入的 ngramMinHashUTF8 函数计算。区分大小写。

语法

ngramMinHashArgUTF8(string[, ngramsize, hashnum])

参数

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

返回值

包含两个元组的元组，每个元组包含 hashnum 个 n 元组。 Tuple(Tuple(String), Tuple(String)).

示例

查询

SELECT ngramMinHashArgUTF8('ClickHouse') AS Tuple;

結果

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

ngramMinHashArgCaseInsensitiveUTF8

将 UTF-8 字符串拆分为 ngramsize 个符号的 n 元组，并返回具有最小和最大哈希值的 n 元组，这些哈希值由具有相同输入的 ngramMinHashCaseInsensitiveUTF8 函数计算。不区分大小写。

语法

ngramMinHashArgCaseInsensitiveUTF8(string[, ngramsize, hashnum])

参数

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

返回值

包含两个元组的元组，每个元组包含 hashnum 个 n 元组。 Tuple(Tuple(String), Tuple(String)).

示例

查询

SELECT ngramMinHashArgCaseInsensitiveUTF8('ClickHouse') AS Tuple;

結果

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

wordShingleMinHash

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

可用于使用 tupleHammingDistance 检测半重复字符串。对于两个字符串：如果返回的哈希之一对于两个字符串都相同，我们认为这两个字符串相同。

语法

wordShingleMinHash(string[, shinglesize, hashnum])

参数

string — 字符串。字符串.
shinglesize — 单词瓦片的大小。可选。可能的值：从 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) │
└────────────────────────────────────────────┘

wordShingleMinHashCaseInsensitive

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

可用于使用 tupleHammingDistance 检测半重复字符串。对于两个字符串：如果返回的哈希之一对于两个字符串都相同，我们认为这两个字符串相同。

语法

wordShingleMinHashCaseInsensitive(string[, shinglesize, hashnum])

参数

string — 字符串。字符串.
shinglesize — 单词瓦片的大小。可选。可能的值：从 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) │
└───────────────────────────────────────────┘

wordShingleMinHashUTF8

将 UTF-8 字符串拆分为 shinglesize 个单词的部分（分片），并为每个单词分片计算哈希值。使用 hashnum 个最小哈希来计算最小哈希，使用 hashnum 个最大哈希来计算最大哈希。返回包含这些哈希的元组。区分大小写。

可用于使用 tupleHammingDistance 检测半重复字符串。对于两个字符串：如果返回的哈希之一对于两个字符串都相同，我们认为这两个字符串相同。

语法

wordShingleMinHashUTF8(string[, shinglesize, hashnum])

参数

string — 字符串。字符串.
shinglesize — 单词瓦片的大小。可选。可能的值：从 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) │
└────────────────────────────────────────────┘

wordShingleMinHashCaseInsensitiveUTF8

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

可用于使用 tupleHammingDistance 检测半重复字符串。对于两个字符串：如果返回的哈希之一对于两个字符串都相同，我们认为这两个字符串相同。

语法

wordShingleMinHashCaseInsensitiveUTF8(string[, shinglesize, hashnum])

参数

string — 字符串。字符串.
shinglesize — 单词瓦片的大小。可选。可能的值：从 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) │
└───────────────────────────────────────────┘

wordShingleMinHashArg

将 ASCII 字符串拆分为每个 shinglesize 个单词的部分（分片），并返回具有最小和最大单词哈希值的单词分片，这些哈希值由具有相同输入的 wordshingleMinHash 函数计算。区分大小写。

语法

wordShingleMinHashArg(string[, shinglesize, hashnum])

参数

string — 字符串。字符串.
shinglesize — 单词瓦片的大小。可选。可能的值：从 1 到 25 的任何数字。默认值：3。 UInt8.
hashnum — 用于计算结果的最小和最大哈希数量。可选。可能的值：从 1 到 25 的任何数字。默认值：6。 UInt8.

返回值

包含两个元组的元组，每个元组包含 hashnum 个单词分片。 Tuple(Tuple(String), 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

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

语法

wordShingleMinHashArgCaseInsensitive(string[, shinglesize, hashnum])

参数

string — 字符串。字符串.
shinglesize — 单词瓦片的大小。可选。可能的值：从 1 到 25 的任何数字。默认值：3。 UInt8.
hashnum — 用于计算结果的最小和最大哈希数量。可选。可能的值：从 1 到 25 的任何数字。默认值：6。 UInt8.

返回值

包含两个元组的元组，每个元组包含 hashnum 个单词分片。 Tuple(Tuple(String), 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')) │
└────────────────────────────────────────────────────────────────────────┘

wordShingleMinHashArgUTF8

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

语法

wordShingleMinHashArgUTF8(string[, shinglesize, hashnum])

参数

string — 字符串。字符串.
shinglesize — 单词瓦片的大小。可选。可能的值：从 1 到 25 的任何数字。默认值：3。 UInt8.
hashnum — 用于计算结果的最小和最大哈希数量。可选。可能的值：从 1 到 25 的任何数字。默认值：6。 UInt8.

返回值

包含两个元组的元组，每个元组包含 hashnum 个单词分片。 Tuple(Tuple(String), 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')) │
└───────────────────────────────────────────────────────────────────────┘

wordShingleMinHashArgCaseInsensitiveUTF8

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

语法

wordShingleMinHashArgCaseInsensitiveUTF8(string[, shinglesize, hashnum])

参数

string — 字符串。字符串.
shinglesize — 单词瓦片的大小。可选。可能的值：从 1 到 25 的任何数字。默认值：3。 UInt8.
hashnum — 用于计算结果的最小和最大哈希数量。可选。可能的值：从 1 到 25 的任何数字。默认值：6。 UInt8.

返回值

包含两个元组的元组，每个元组包含 hashnum 个单词分片。 Tuple(Tuple(String), 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')) │
└────────────────────────────────────────────────────────────────────────┘

sqidEncode

将数字编码为 Sqid，它是一种类似 YouTube 的 ID 字符串。输出字母表是 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789。不要将此函数用于哈希 - 生成的 ID 可以解码回原始数字。

语法

sqidEncode(number1, ...)

别名：sqid

参数

可变数量的 UInt8、UInt16、UInt32 或 UInt64 数字。

返回值

sqid String.

示例

SELECT sqidEncode(1, 2, 3, 4, 5);

┌─sqidEncode(1, 2, 3, 4, 5)─┐
│ gXHfJ1C6dN                │
└───────────────────────────┘

sqidDecode

将 Sqid 解码回其原始数字。如果输入字符串不是有效的 sqid，则返回空数组。

语法

sqidDecode(sqid)

参数

sqid - String

返回值

将 sqid 转换为数字 Array(UInt64).

示例

SELECT sqidDecode('gXHfJ1C6dN');

┌─sqidDecode('gXHfJ1C6dN')─┐
│ [1,2,3,4,5]              │
└──────────────────────────┘

哈希函数

halfMD5​

MD4​

MD5​

RIPEMD160​

sipHash64​

sipHash64Keyed​

sipHash128​

sipHash128Keyed​

sipHash128Reference​

sipHash128ReferenceKeyed​

cityHash64​

intHash32​

intHash64​

SHA1、SHA224、SHA256、SHA512、SHA512_256​

BLAKE3​

URLHash(url[, N])​

farmFingerprint64​

farmHash64​

javaHash​

javaHashUTF16LE​

hiveHash​

metroHash64​

jumpConsistentHash​

kostikConsistentHash​

murmurHash2_32, murmurHash2_64​

gccMurmurHash​

kafkaMurmurHash​

murmurHash3_32, murmurHash3_64​

murmurHash3_128​

xxh3​

xxHash32, xxHash64​

ngramSimHash​

ngramSimHashCaseInsensitive​

ngramSimHashUTF8​

ngramSimHashCaseInsensitiveUTF8​

wordShingleSimHash​

wordShingleSimHashCaseInsensitive​

wordShingleSimHashUTF8​

wordShingleSimHashCaseInsensitiveUTF8​

wyHash64​

ngramMinHash​

ngramMinHashCaseInsensitive​

ngramMinHashUTF8​

ngramMinHashCaseInsensitiveUTF8​

ngramMinHashArg​

ngramMinHashArgCaseInsensitive​

ngramMinHashArgUTF8​

ngramMinHashArgCaseInsensitiveUTF8​

wordShingleMinHash​

wordShingleMinHashCaseInsensitive​

wordShingleMinHashUTF8​

wordShingleMinHashCaseInsensitiveUTF8​

wordShingleMinHashArg​

wordShingleMinHashArgCaseInsensitive​

wordShingleMinHashArgUTF8​

wordShingleMinHashArgCaseInsensitiveUTF8​

sqidEncode​

sqidDecode​

halfMD5

MD4

MD5

RIPEMD160

sipHash64

sipHash64Keyed

sipHash128

sipHash128Keyed

sipHash128Reference

sipHash128ReferenceKeyed

cityHash64

intHash32

intHash64

SHA1、SHA224、SHA256、SHA512、SHA512_256

BLAKE3

URLHash(url[, N])

farmFingerprint64

farmHash64

javaHash

javaHashUTF16LE

hiveHash

metroHash64

jumpConsistentHash

kostikConsistentHash

murmurHash2_32, murmurHash2_64

gccMurmurHash

kafkaMurmurHash

murmurHash3_32, murmurHash3_64

murmurHash3_128

xxh3

xxHash32, xxHash64

ngramSimHash

ngramSimHashCaseInsensitive

ngramSimHashUTF8

ngramSimHashCaseInsensitiveUTF8

wordShingleSimHash

wordShingleSimHashCaseInsensitive

wordShingleSimHashUTF8

wordShingleSimHashCaseInsensitiveUTF8

wyHash64

ngramMinHash

ngramMinHashCaseInsensitive

ngramMinHashUTF8

ngramMinHashCaseInsensitiveUTF8

ngramMinHashArg

ngramMinHashArgCaseInsensitive

ngramMinHashArgUTF8

ngramMinHashArgCaseInsensitiveUTF8

wordShingleMinHash

wordShingleMinHashCaseInsensitive

wordShingleMinHashUTF8

wordShingleMinHashCaseInsensitiveUTF8

wordShingleMinHashArg

wordShingleMinHashArgCaseInsensitive

wordShingleMinHashArgUTF8

wordShingleMinHashArgCaseInsensitiveUTF8

sqidEncode

sqidDecode