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

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

Тип результата — целое число с количеством бит, равным максимальному количеству бит среди аргументов. Если хотя бы один из аргументов знаковый, результат является знаковым числом. Если аргумент — число с плавающей запятой, оно приводится к типу Int64.

bitAnd

Добавлено в версии: v1.1.0

Выполняет побитовую операцию AND между двумя значениями.

Синтаксис

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.0

Вычисляет количество единичных битов в двоичном представлении числа.

Синтаксис

bitCount(x)

Аргументы

• x — целочисленное или вещественное значение. (U)Int* или Float*

Возвращаемое значение

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

Примечание

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

Примеры

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

SELECT bin(333), bitCount(333);

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

Примеры

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

SELECT bitHammingDistance(111, 121);

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

bitNot

Добавлена в версии: v1.1.0

Выполняет побитовое отрицание (операцию NOT).

Синтаксис

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.0

Выполняет побитовую операцию OR между двумя значениями.

Синтаксис

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.0

Циклически сдвигает биты влево на заданное количество позиций. Биты, вышедшие за границу слева, появляются справа.

Синтаксис

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.0

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

Синтаксис

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.0

Сдвигает двоичное представление значения влево на указанное количество битовых позиций.

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

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

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.0

Сдвигает двоичное представление значения вправо на заданное количество битовых позиций.

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.0

Возвращает подстроку, начиная с бита с индексом 'offset' и длиной 'length' бит.

Синтаксис

bitSlice(s, offset[, length])

Аргументы

• s — Строка или фиксированная строка, из которой извлекаются биты. String или FixedString

• offset — Возвращает начальную позицию бита (индексация начинается с 1).

• Положительные значения: отсчёт от начала строки.

• Отрицательные значения: отсчёт с конца строки.

  (U)Int8/16/32/64 или Float*

• length — Необязательный параметр. Количество извлекаемых битов.

• Положительные значения: извлечь length бит.

• Отрицательные значения: извлечь от offset до (string_length - |length|).

• Если параметр опущен: извлечь от offset до конца строки.

• Если длина не кратна 8, результат дополняется нулями справа. (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

Принимает произвольное число, преобразует его в двоичную форму и возвращает значение бита на указанной позиции. Подсчёт битов ведётся справа налево, начиная с 0.

Синтаксис

bitTest(a, i)

Аргументы

• a — Число для преобразования. (U)Int8/16/32/64 или Float*
• i — Позиция бита, который нужно вернуть. (U)Int8/16/32/64 или Float*

Возвращаемое значение

Возвращает значение бита на позиции i в двоичном представлении a, типа UInt8

Примеры

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

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

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

bitTestAll

Введена в версии v1.1.0

Возвращает результат логической конъюнкции (оператор AND) всех битов на указанных позициях. Подсчёт ведётся справа налево, начиная с 0.

Логическая операция AND между двумя битами истинна тогда и только тогда, когда оба входных бита истинны.

Синтаксис

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.0

Возвращает результат логической дизъюнкции (оператор OR) всех битов на заданных позициях в числе. Подсчёт позиций ведётся справа налево, начиная с 0.

Результат логического OR между двумя битами равен 1, если хотя бы один из входных битов равен 1.

Синтаксис

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

Второй пример использования

SELECT bitTestAny(43, 4, 2);

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

Примеры

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

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