Битовые функции - ClickHouse Documentation

Битовые функции работают с любой парой типов из UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32 или Float64. Некоторые функции также поддерживают типы String и FixedString. Тип результата — целое число с количеством битов, равным максимальному количеству битов среди аргументов. Если хотя бы один из аргументов является знаковым, результат тоже будет знаковым числом. Если аргумент является числом с плавающей запятой, он приводится к Int64.

bitAnd

Добавленный в: v1.1.0 Выполняет операцию побитового И над двумя значениями. Синтаксис

bitAnd(a, b)

Аргументы

a — Первое значение. (U)Int* или Float*
b — Второе значение. (U)Int* или Float*

Возвращаемое значение Возвращает результат побитовой операции a AND b Примеры Пример использования

Query

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

Response

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

bitCount

Добавленный в: v20.3.0 Вычисляет количество битов, равных единице, в двоичном представлении числа. Синтаксис

bitCount(x)

Аргументы

x — Целое число или число с плавающей точкой. (U)Int* или Float*

Возвращаемое значение Возвращает количество битов в x, установленных в единицу. UInt8.

Функция не преобразует входное значение к типу большего размера (знаковое расширение). Например: bitCount(toUInt8(-1)) = 8.

Примеры Пример использования

Query

SELECT bin(333), bitCount(333);

Response

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

bitHammingDistance

Добавленный в: v21.1.0 Возвращает расстояние Хэмминга между битовыми представлениями двух чисел. Может использоваться с функциями SimHash для обнаружения почти дублирующихся строк. Чем меньше расстояние, тем больше они похожи друг на друга. Синтаксис

bitHammingDistance(x, y)

Аргументы

x — Первое число для вычисления расстояния Хэмминга. (U)Int* или Float*
y — Второе число для вычисления расстояния Хэмминга. (U)Int* или Float*

Возвращаемое значение Возвращает расстояние Хэмминга между x и y. UInt8 Примеры Пример использования

Query

SELECT bitHammingDistance(111, 121);

Response

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

bitNot

Добавленный в: v1.1.0 Выполняет побитовую операцию НЕ. Синтаксис

bitNot(a)

Аргументы

a — Значение, для которого выполняется операция побитового NOT. (U)Int* или Float* или String

Возвращаемое значение Возвращает результат ~a, то есть a с инвертированными битами. Примеры Пример использования

Query

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

Response

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

bitOr

Добавленный в: v1.1.0 Выполняет побитовую операцию OR над двумя значениями. Синтаксис

bitOr(a, b)

Аргументы

a — Первое значение. (U)Int* или Float*
b — Второе значение. (U)Int* или Float*

Возвращаемое значение Возвращает результат побитовой операции a OR b Примеры Пример использования

Query

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;

Response

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

bitRotateLeft

Добавленный в: v1.1.0 Циклически сдвигает биты влево на заданное число позиций. Биты, выходящие за пределы, переносятся на правую сторону. Синтаксис

bitRotateLeft(a, N)

Аргументы

a — Значение, которое нужно циклически сдвинуть. (U)Int8/16/32/64
N — Количество позиций для циклического сдвига влево. UInt8/16/32/64

Возвращаемое значение Возвращает значение после циклического сдвига; тип результата совпадает с типом a. (U)Int8/16/32/64 Примеры Пример использования

Query

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

Response

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

bitRotateRight

Добавленный в: v1.1.0 Циклически сдвигает биты вправо на заданное число позиций. Биты, выходящие за пределы справа, переносятся влево. Синтаксис

bitRotateRight(a, N)

Аргументы

a — Значение для циклического сдвига. (U)Int8/16/32/64
N — Количество позиций для циклического сдвига вправо. UInt8/16/32/64

Возвращаемое значение Возвращает значение после циклического сдвига; тип совпадает с типом a. (U)Int8/16/32/64 Примеры Пример использования

Query

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

Response

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

bitShiftLeft

Добавленный в: v1.1.0 Сдвигает двоичное представление значения влево на указанное число битовых позиций. FixedString или String рассматривается как единое многобайтовое значение. Биты значения FixedString теряются при сдвиге за его пределы. Напротив, значение String дополняется дополнительными байтами, поэтому биты не теряются. Синтаксис

bitShiftLeft(a, N)

Аргументы

a — значение, которое нужно сдвинуть. (U)Int* или String или FixedString
N — число позиций сдвига. UInt8/16/32/64

Возвращаемое значение Возвращает сдвинутое значение того же типа, что и a. Примеры Пример использования с двоичным кодированием

Query

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

Response

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

Пример использования с шестнадцатеричным кодированием

Query

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

Response

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

Пример использования с кодировкой Fixed String

Query

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

Response

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

bitShiftRight

Добавленный в: v1.1.0 Сдвигает двоичное представление значения вправо на указанное количество битов. FixedString или String рассматривается как одно многобайтовое значение. Биты значения FixedString теряются по мере их сдвига за пределы строки. Напротив, значение String расширяется дополнительными байтами, поэтому биты не теряются. Синтаксис

bitShiftRight(a, N)

Аргументы

a — Значение, для которого выполняется сдвиг. (U)Int* или String или FixedString
N — Число позиций сдвига. UInt8/16/32/64

Возвращаемое значение Возвращает значение после сдвига; его тип совпадает с типом a. Примеры Пример использования с двоичным кодированием

Query

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

Response

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

Пример использования в шестнадцатеричном кодировании

Query

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

Response

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

Пример использования с кодировкой Fixed String

Query

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

Response

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

bitSlice

Добавленный в: v22.2.0 Возвращает подстроку длиной ‘length’ бит, начиная с бита с индексом ‘offset’. Синтаксис

bitSlice(s, offset[, length])

Аргументы

s — Строка String или FixedString, из которой извлекается срез. String или FixedString
offset — Задает начальную позицию бита (индексация начинается с 1).
Положительные значения: отсчет от начала строки.
Отрицательные значения: отсчет от конца строки. (U)Int8/16/32/64 или Float*
length — Необязательный параметр. Количество битов для извлечения.
Положительные значения: извлекаются length битов.
Отрицательные значения: извлечение выполняется от смещения до (string_length - |length|).
Не указано: извлечение выполняется от смещения до конца строки.
Если длина не кратна 8, результат дополняется нулями справа. (U)Int8/16/32/64 или Float*

Возвращаемое значение Строка, содержащая извлеченные биты, представленные в виде двоичной последовательности. Результат всегда дополняется до границ байта (кратных 8 битам). String Примеры Пример использования

Query

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));

Response

┌─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 Принимает любое число и преобразует его в двоичное представление, затем возвращает значение бита в указанной позиции. Отсчёт ведётся справа налево, начиная с 0. Синтаксис

bitTest(a, i)

Аргументы

a — Число для преобразования. (U)Int8/16/32/64 или Float*
i — Позиция возвращаемого бита. (U)Int8/16/32/64 или Float*

Возвращаемое значение Возвращает значение бита в позиции i в двоичном представлении a: UInt8 Примеры Пример использования

Query

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

Response

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

bitTestAll

Добавленный в: v1.1.0 Возвращает результат логического И (оператор AND) для всех битов в указанных позициях. Отсчёт идёт справа налево, начиная с 0. Логическое И между двумя битами истинно тогда и только тогда, когда оба входных бита истинны. Синтаксис

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

Аргументы

a — Целочисленное значение. (U)Int8/16/32/64
index1, ... — Одна или несколько битовых позиций. (U)Int8/16/32/64

Возвращаемое значение Возвращает результат логической конъюнкции типа UInt8 Примеры Пример использования 1

Query

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

Response

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

Пример использования 2

Query

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

Response

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

bitTestAny

Добавленный в: v1.1.0 Возвращает результат логической дизъюнкции (оператор OR) всех битов на указанных позициях в числе. Отсчёт идёт справа налево, начиная с 0. Логический OR двух битов равен true, если хотя бы один из входных битов равен true. Синтаксис

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

Аргументы

a — Целочисленное значение. (U)Int8/16/32/64
index1, ... — Одна или несколько позиций битов. (U)Int8/16/32/64

Возвращаемое значение Возвращает результат логической дизъюнкции типа UInt8 Примеры Пример использования 1

Query

SELECT bitTestAny(43, 0, 2);

Response

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

Пример использования 2

Query

SELECT bitTestAny(43, 4, 2);

Response

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

bitXor

Добавленный в: v1.1.0 Выполняет операцию побитового исключающего ИЛИ (XOR) над двумя значениями. Синтаксис

bitXor(a, b)

Аргументы

a — Первое значение. (U)Int* или Float*
b — Второе значение. (U)Int* или Float*

Возвращаемое значение Результат побитовой операции a XOR b Примеры Пример использования

Query

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;

Response

┌─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