位函数

位函数适用于任意由 UInt8、UInt16、UInt32、UInt64、Int8、Int16、Int32、Int64、Float32 或 Float64 组成的类型对。部分函数还支持 String 和 FixedString 类型。

结果类型为一个整数，其位宽等于所有参数中最大的位宽。如果至少有一个参数是有符号类型，则结果为有符号数。如果某个参数是浮点数，则会被强制转换为 Int64。

bitAnd

自 v1.1 版本引入

对两个值执行按位与运算。

语法

bitAnd(a, b)

参数

a — 第一个值。(U)Int* 或 Float*
b — 第二个值。(U)Int* 或 Float*

返回值

返回按位与运算 a AND b 的结果。

示例

用法示例

CREATE TABLE bits
(
    `a` UInt8,
    `b` UInt8
)
ENGINE = Memory;

INSERT INTO bits VALUES (0, 0), (0, 1), (1, 0), (1, 1);

SELECT
    a,
    b,
    bitAnd(a, b)
FROM bits

┌─a─┬─b─┬─bitAnd(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            0 │
│ 1 │ 0 │            0 │
│ 1 │ 1 │            1 │
└───┴───┴──────────────┘

bitCount

引入版本：v20.3

计算一个数在二进制表示中为 1 的比特数量。

语法

bitCount(x)

参数

x — 整数或浮点数值。(U)Int* 或 Float*

返回值

返回 x 中值为 1 的比特位数量。UInt8。

注意

该函数不会通过符号扩展将输入值转换为更大类型（符号扩展）。例如：bitCount(toUInt8(-1)) = 8。

示例

用法示例

SELECT bin(333), bitCount(333);

┌─bin(333)─────────┬─bitCount(333)─┐
│ 0000000101001101 │             5 │
└──────────────────┴───────────────┘

bitHammingDistance

引入于：v21.1

返回两个数字二进制位表示之间的汉明距离。可与 SimHash 函数一起用于检测近似重复的字符串。距离越小，字符串越相似。

语法

bitHammingDistance(x, y)

参数

x — 用于计算汉明距离的第一个数值。(U)Int* 或 Float*
y — 用于计算汉明距离的第二个数值。(U)Int* 或 Float*

返回值

返回 x 和 y 之间的汉明距离，类型为 UInt8

示例

使用示例

SELECT bitHammingDistance(111, 121);

┌─bitHammingDistance(111, 121)─┐
│                            3 │
└──────────────────────────────┘

bitNot

自 v1.1 起引入

执行按位取反运算。

语法

bitNot(a)

参数

a — 要对其执行按位 NOT 运算的值。(U)Int* 或 Float* 或 String

返回值

返回 ~a 的结果，即对 a 的各比特位取反。

示例

用法示例

SELECT
    CAST('5', 'UInt8') AS original,
    bin(original) AS original_binary,
    bitNot(original) AS result,
    bin(bitNot(original)) AS result_binary;

┌─original─┬─original_binary─┬─result─┬─result_binary─┐
│        5 │ 00000101        │    250 │ 11111010      │
└──────────┴─────────────────┴────────┴───────────────┘

bitOr

自 v1.1 起引入

对两个值执行按位或运算。

语法

bitOr(a, b)

参数

a — 第一个值。(U)Int* 或 Float*
b — 第二个值。(U)Int* 或 Float*

返回值

返回按位或运算 a OR b 的结果。

示例

使用示例

CREATE TABLE bits
(
    `a` UInt8,
    `b` UInt8
)
ENGINE = Memory;

INSERT INTO bits VALUES (0, 0), (0, 1), (1, 0), (1, 1);

SELECT
    a,
    b,
    bitOr(a, b)
FROM bits;

┌─a─┬─b─┬─bitOr(a, b)─┐
│ 0 │ 0 │           0 │
│ 0 │ 1 │           1 │
│ 1 │ 0 │           1 │
│ 1 │ 1 │           1 │
└───┴───┴─────────────┘

bitRotateLeft

引入于：v1.1

将位向左旋转指定的位数。移出的位会从右侧回绕。

语法

bitRotateLeft(a, N)

参数

a — 要进行旋转的值。(U)Int8/16/32/64
N — 向左旋转的位数。UInt8/16/32/64

返回值

返回旋转后的值，其类型与 a 相同。(U)Int8/16/32/64

示例

使用示例

SELECT 99 AS a, bin(a), bitRotateLeft(a, 2) AS a_rotated, bin(a_rotated);

┌──a─┬─bin(a)───┬─a_rotated─┬─bin(a_rotated)─┐
│ 99 │ 01100011 │       141 │ 10001101       │
└────┴──────────┴───────────┴────────────────┘

bitRotateRight

自 v1.1 引入

按指定的位数将位向右旋转。右侧移出的位会从左侧补回。

语法

bitRotateRight(a, N)

参数

a — 要旋转的值。(U)Int8/16/32/64
N — 向右旋转的位数。UInt8/16/32/64

返回值

返回旋转后的值，类型与 a 相同。(U)Int8/16/32/64

示例

用法示例

SELECT 99 AS a, bin(a), bitRotateRight(a, 2) AS a_rotated, bin(a_rotated);

┌──a─┬─bin(a)───┬─a_rotated─┬─bin(a_rotated)─┐
│ 99 │ 01100011 │       216 │ 11011000       │
└────┴──────────┴───────────┴────────────────┘

bitShiftLeft

引入于：v1.1

将一个值的二进制表示按指定的位数向左移位。

FixedString 或 String 被视为一个多字节值。

FixedString 值在移位过程中被移出的位会丢失。相反，String 值会通过追加额外字节进行扩展，因此不会丢失任何位。

语法

bitShiftLeft(a, N)

参数

a — 要移位的值。(U)Int* 或 String 或 FixedString
N — 要移位的位数。UInt8/16/32/64

返回值

返回移位后的值，其类型与 a 相同。

示例

二进制编码用法示例

SELECT 99 AS a, bin(a), bitShiftLeft(a, 2) AS a_shifted, bin(a_shifted);

┌──a─┬─bin(99)──┬─a_shifted─┬─bin(bitShiftLeft(99, 2))─┐
│ 99 │ 01100011 │       140 │ 10001100                 │
└────┴──────────┴───────────┴──────────────────────────┘

十六进制编码的使用示例

SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);

┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftLeft('abc', 4))─┐
│ abc │ 616263     │ &0        │ 06162630                    │
└─────┴────────────┴───────────┴─────────────────────────────┘

使用 FixedString 编码的示例用法

SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);

┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftLeft(toFixedString('abc', 3), 4))─┐
│ abc │ 616263                       │ &0        │ 162630                                        │
└─────┴──────────────────────────────┴───────────┴───────────────────────────────────────────────┘

bitShiftRight

引入于：v1.1

将一个值的二进制表示向右移动指定位数。

FixedString 或 String 被视为一个多字节值。

FixedString 值在移出时会丢失位。相反，String 值会通过附加字节进行扩展，因此不会丢失任何位。

语法

bitShiftRight(a, N)

参数

a — 要移位的值。(U)Int* 或 String 或 FixedString
N — 要移位的位数。UInt8/16/32/64

返回值

返回移位后的值，类型与 a 相同。

示例

使用二进制编码的示例用法

SELECT 101 AS a, bin(a), bitShiftRight(a, 2) AS a_shifted, bin(a_shifted);

┌───a─┬─bin(101)─┬─a_shifted─┬─bin(bitShiftRight(101, 2))─┐
│ 101 │ 01100101 │        25 │ 00011001                   │
└─────┴──────────┴───────────┴────────────────────────────┘

十六进制编码用法示例

SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);

┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftRight('abc', 12))─┐
│ abc │ 616263     │           │ 0616                          │
└─────┴────────────┴───────────┴───────────────────────────────┘

FixedString 编码的使用示例

SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftRight(a, 12) AS a_shifted, hex(a_shifted);

┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftRight(toFixedString('abc', 3), 12))─┐
│ abc │ 616263                       │           │ 000616                                          │
└─────┴──────────────────────────────┴───────────┴─────────────────────────────────────────────────┘

bitSlice

自 v22.2 引入

返回一个子字符串，从位索引 'offset' 开始，长度为 'length' 位。

语法

bitSlice(s, offset[, length])

参数

s — 要进行切片的 String 或 Fixed String。String 或 FixedString
offset — 起始位位置（从 1 开始计数）。
正值：从字符串开头开始计数。
负值：从字符串末尾开始计数。

(U)Int8/16/32/64 或 Float*
length — 可选。要提取的位数。
正值：提取 length 位。
负值：从偏移位置提取到 (string_length - |length|) 位。
省略：从偏移位置提取到字符串末尾。
如果 length 不是 8 的倍数，则结果在右侧用 0 填充。 (U)Int8/16/32/64 或 Float*

返回值

返回一个包含提取位的字符串，以二进制序列表示。结果始终补齐到字节边界（8 位的倍数）String

示例

用法示例

SELECT bin('Hello'), bin(bitSlice('Hello', 1, 8));
SELECT bin('Hello'), bin(bitSlice('Hello', 1, 2));
SELECT bin('Hello'), bin(bitSlice('Hello', 1, 9));
SELECT bin('Hello'), bin(bitSlice('Hello', -4, 8));

┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', 1, 8))─┐
│ 0100100001100101011011000110110001101111 │ 01001000                     │
└──────────────────────────────────────────┴──────────────────────────────┘
┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', 1, 2))─┐
│ 0100100001100101011011000110110001101111 │ 01000000                     │
└──────────────────────────────────────────┴──────────────────────────────┘
┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', 1, 9))─┐
│ 0100100001100101011011000110110001101111 │ 0100100000000000             │
└──────────────────────────────────────────┴──────────────────────────────┘
┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', -4, 8))─┐
│ 0100100001100101011011000110110001101111 │ 11110000                      │
└──────────────────────────────────────────┴───────────────────────────────┘

bitTest

引入版本：v1.1

接受任意数值并将其转换为二进制形式，然后返回指定位置处的比特位值。计数从右向左进行，从 0 开始。

语法

bitTest(a, i)

参数

a — 要转换的数值。(U)Int8/16/32/64 或 Float*
i — 要返回的比特位位置。(U)Int8/16/32/64 或 Float*

返回值

返回 a 的二进制表示中第 i 个比特位的值，类型为 UInt8。

示例

用法示例

SELECT bin(2), bitTest(2, 1);

┌─bin(2)───┬─bitTest(2, 1)─┐
│ 00000010 │             1 │
└──────────┴───────────────┘

bitTestAll

引入于：v1.1

返回给定位置上所有位的逻辑与（AND 运算符）结果。从右到左计数，起始索引为 0。

两个位之间的逻辑与仅当两个输入位都为真时结果为真。

语法

bitTestAll(a, index1[, index2, ... , indexN])

参数

a — 整数值。(U)Int8/16/32/64
index1, ... — 一个或多个比特位的位置。(U)Int8/16/32/64

返回值

返回逻辑与运算结果，类型为 UInt8

示例

用法示例 1

SELECT bitTestAll(43, 0, 1, 3, 5);

┌─bin(43)──┬─bitTestAll(43, 0, 1, 3, 5)─┐
│ 00101011 │                          1 │
└──────────┴────────────────────────────┘

使用示例 2

SELECT bitTestAll(43, 0, 1, 3, 5, 2);

┌─bin(43)──┬─bitTestAll(4⋯1, 3, 5, 2)─┐
│ 00101011 │                        0 │
└──────────┴──────────────────────────┘

bitTestAny

自 v1.1 引入

返回对给定数字中指定位置上所有位执行逻辑析取（OR 运算符）的结果。从右向左计数，起始索引为 0。

两个位之间的逻辑 OR 只要至少有一个输入位为 true，结果就为 true。

语法

bitTestAny(a, index1[, index2, ... , indexN])

参数

a — 一个整数值。(U)Int8/16/32/64
index1, ... — 一个或多个位的位置。(U)Int8/16/32/64

返回值

返回逻辑或运算的结果 UInt8

示例

用法示例 1

SELECT bitTestAny(43, 0, 2);

┌─bin(43)──┬─bitTestAny(43, 0, 2)─┐
│ 00101011 │                    1 │
└──────────┴──────────────────────┘

使用示例 2

SELECT bitTestAny(43, 4, 2);

┌─bin(43)──┬─bitTestAny(43, 4, 2)─┐
│ 00101011 │                    0 │
└──────────┴──────────────────────┘

bitXor

自 v1.1 引入

对两个值执行按位异或（XOR）运算。

语法

bitXor(a, b)

参数

a — 第一个值。(U)Int* 或 Float*
b — 第二个值。(U)Int* 或 Float*

返回值

返回按位异或运算 a XOR b 的结果。

示例

用法示例

CREATE TABLE bits
(
    `a` UInt8,
    `b` UInt8
)
ENGINE = Memory;

INSERT INTO bits VALUES (0, 0), (0, 1), (1, 0), (1, 1);

SELECT
    a,
    b,
    bitXor(a, b)
FROM bits;

┌─a─┬─b─┬─bitXor(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            1 │
│ 1 │ 0 │            1 │
│ 1 │ 1 │            0 │
└───┴───┴──────────────┘

bitAnd​

bitCount​

bitHammingDistance​

bitNot​

bitOr​

bitRotateLeft​

bitRotateRight​

bitShiftLeft​

bitShiftRight​

bitSlice​

bitTest​

bitTestAll​

bitTestAny​

bitXor​

bitAnd

bitCount

bitHammingDistance

bitNot

bitOr

bitRotateLeft

bitRotateRight

bitShiftLeft

bitShiftRight

bitSlice

bitTest

bitTestAll

bitTestAny

bitXor