Побитовые функции

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

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

bitAnd

Добавлено в: v1.1

Выполняет побитовую операцию 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

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

Синтаксис

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

Возвращает расстояние Хэмминга между битовыми представлениями двух чисел. Может использоваться с функциями 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

Выполняет побитовую операцию 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

Выполняет побитовое операция 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

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

Синтаксис

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

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

Синтаксис

bitSlice(s, offset[, length])

Аргументы

s — Строка или фиксированная строка, из которой выполняется извлечение. String или FixedString
offset — Начальная позиция бита (индексация с 1).
Положительные значения: отсчет от начала строки.
Отрицательные значения: отсчет от конца строки.

(U)Int8/16/32/64 или Float*
length — Необязательный параметр. Количество бит для извлечения.
Положительные значения: извлекается length бит.
Отрицательные значения: извлечение от смещения до (string_length - |length|).
Если параметр опущен: извлечение от смещения до конца строки.
Если длина не делится на 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.

Синтаксис

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

Возвращает результат логического И (оператор 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

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

Логическое ИЛИ между двумя битами истинно, если хотя бы один из входных битов истинен.

Синтаксис

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