> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Документация по битовым функциям

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

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

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

{/*AUTOGENERATED_START*/}

<div id="bitAnd">
  ## bitAnd
</div>

Добавленный в: v1.1.0

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

**Синтаксис**

```sql theme={null}
bitAnd(a, b)
```

**Аргументы**

* `a` — Первое значение. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `b` — Второе значение. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)

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

Возвращает результат побитовой операции `a AND b`

**Примеры**

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

```sql title=Query theme={null}
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 title=Response theme={null}
┌─a─┬─b─┬─bitAnd(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            0 │
│ 1 │ 0 │            0 │
│ 1 │ 1 │            1 │
└───┴───┴──────────────┘
```

<div id="bitCount">
  ## bitCount
</div>

Добавленный в: v20.3.0

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

**Синтаксис**

```sql theme={null}
bitCount(x)
```

**Аргументы**

* `x` — Целое число или число с плавающей точкой. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)

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

Возвращает количество битов в `x`, установленных в единицу. [`UInt8`](/ru/reference/data-types/int-uint).

<Note>
  Функция не преобразует входное значение к типу большего размера ([знаковое расширение](https://en.wikipedia.org/wiki/Sign_extension)).
  Например: `bitCount(toUInt8(-1)) = 8`.
</Note>

**Примеры**

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

```sql title=Query theme={null}
SELECT bin(333), bitCount(333);
```

```response title=Response theme={null}
┌─bin(333)─────────┬─bitCount(333)─┐
│ 0000000101001101 │             5 │
└──────────────────┴───────────────┘
```

<div id="bitHammingDistance">
  ## bitHammingDistance
</div>

Добавленный в: v21.1.0

Возвращает [расстояние Хэмминга](https://en.wikipedia.org/wiki/Hamming_distance) между битовыми представлениями двух чисел.
Может использоваться с функциями [`SimHash`](/ru/reference/functions/regular-functions/hash-functions#ngramSimHash) для обнаружения почти дублирующихся строк.
Чем меньше расстояние, тем больше они похожи друг на друга.

**Синтаксис**

```sql theme={null}
bitHammingDistance(x, y)
```

**Аргументы**

* `x` — Первое число для вычисления расстояния Хэмминга. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `y` — Второе число для вычисления расстояния Хэмминга. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)

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

Возвращает расстояние Хэмминга между `x` и `y`. [`UInt8`](/ru/reference/data-types/int-uint)

**Примеры**

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

```sql title=Query theme={null}
SELECT bitHammingDistance(111, 121);
```

```response title=Response theme={null}
┌─bitHammingDistance(111, 121)─┐
│                            3 │
└──────────────────────────────┘
```

<div id="bitNot">
  ## bitNot
</div>

Добавленный в: v1.1.0

Выполняет побитовую операцию НЕ.

**Синтаксис**

```sql theme={null}
bitNot(a)
```

**Аргументы**

* `a` — Значение, для которого выполняется операция побитового NOT. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`String`](/ru/reference/data-types/string)

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

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

**Примеры**

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

```sql title=Query theme={null}
SELECT
    CAST('5', 'UInt8') AS original,
    bin(original) AS original_binary,
    bitNot(original) AS result,
    bin(bitNot(original)) AS result_binary;
```

```response title=Response theme={null}
┌─original─┬─original_binary─┬─result─┬─result_binary─┐
│        5 │ 00000101        │    250 │ 11111010      │
└──────────┴─────────────────┴────────┴───────────────┘
```

<div id="bitOr">
  ## bitOr
</div>

Добавленный в: v1.1.0

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

**Синтаксис**

```sql theme={null}
bitOr(a, b)
```

**Аргументы**

* `a` — Первое значение. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `b` — Второе значение. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)

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

Возвращает результат побитовой операции `a OR b`

**Примеры**

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

```sql title=Query theme={null}
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 title=Response theme={null}
┌─a─┬─b─┬─bitOr(a, b)─┐
│ 0 │ 0 │           0 │
│ 0 │ 1 │           1 │
│ 1 │ 0 │           1 │
│ 1 │ 1 │           1 │
└───┴───┴─────────────┘
```

<div id="bitRotateLeft">
  ## bitRotateLeft
</div>

Добавленный в: v1.1.0

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

**Синтаксис**

```sql theme={null}
bitRotateLeft(a, N)
```

**Аргументы**

* `a` — Значение, которое нужно циклически сдвинуть. [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint)
* `N` — Количество позиций для циклического сдвига влево. [`UInt8/16/32/64`](/ru/reference/data-types/int-uint)

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

Возвращает значение после циклического сдвига; тип результата совпадает с типом `a`. [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint)

**Примеры**

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

```sql title=Query theme={null}
SELECT 99 AS a, bin(a), bitRotateLeft(a, 2) AS a_rotated, bin(a_rotated);
```

```response title=Response theme={null}
┌──a─┬─bin(a)───┬─a_rotated─┬─bin(a_rotated)─┐
│ 99 │ 01100011 │       141 │ 10001101       │
└────┴──────────┴───────────┴────────────────┘
```

<div id="bitRotateRight">
  ## bitRotateRight
</div>

Добавленный в: v1.1.0

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

**Синтаксис**

```sql theme={null}
bitRotateRight(a, N)
```

**Аргументы**

* `a` — Значение для циклического сдвига. [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint)
* `N` — Количество позиций для циклического сдвига вправо. [`UInt8/16/32/64`](/ru/reference/data-types/int-uint)

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

Возвращает значение после циклического сдвига; тип совпадает с типом `a`. [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint)

**Примеры**

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

```sql title=Query theme={null}
SELECT 99 AS a, bin(a), bitRotateRight(a, 2) AS a_rotated, bin(a_rotated);
```

```response title=Response theme={null}
┌──a─┬─bin(a)───┬─a_rotated─┬─bin(a_rotated)─┐
│ 99 │ 01100011 │       216 │ 11011000       │
└────┴──────────┴───────────┴────────────────┘
```

<div id="bitShiftLeft">
  ## bitShiftLeft
</div>

Добавленный в: v1.1.0

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

`FixedString` или `String` рассматривается как единое многобайтовое значение.

Биты значения `FixedString` теряются при сдвиге за его пределы.
Напротив, значение `String` дополняется дополнительными байтами, поэтому биты не теряются.

**Синтаксис**

```sql theme={null}
bitShiftLeft(a, N)
```

**Аргументы**

* `a` — значение, которое нужно сдвинуть. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
* `N` — число позиций сдвига. [`UInt8/16/32/64`](/ru/reference/data-types/int-uint)

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

Возвращает сдвинутое значение того же типа, что и `a`.

**Примеры**

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

```sql title=Query theme={null}
SELECT 99 AS a, bin(a), bitShiftLeft(a, 2) AS a_shifted, bin(a_shifted);
```

```response title=Response theme={null}
┌──a─┬─bin(99)──┬─a_shifted─┬─bin(bitShiftLeft(99, 2))─┐
│ 99 │ 01100011 │       140 │ 10001100                 │
└────┴──────────┴───────────┴──────────────────────────┘
```

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

```sql title=Query theme={null}
SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftLeft('abc', 4))─┐
│ abc │ 616263     │ &0        │ 06162630                    │
└─────┴────────────┴───────────┴─────────────────────────────┘
```

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

```sql title=Query theme={null}
SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftLeft(toFixedString('abc', 3), 4))─┐
│ abc │ 616263                       │ &0        │ 162630                                        │
└─────┴──────────────────────────────┴───────────┴───────────────────────────────────────────────┘
```

<div id="bitShiftRight">
  ## bitShiftRight
</div>

Добавленный в: v1.1.0

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

`FixedString` или `String` рассматривается как одно многобайтовое значение.

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

**Синтаксис**

```sql theme={null}
bitShiftRight(a, N)
```

**Аргументы**

* `a` — Значение, для которого выполняется сдвиг. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
* `N` — Число позиций сдвига. [`UInt8/16/32/64`](/ru/reference/data-types/int-uint)

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

Возвращает значение после сдвига; его тип совпадает с типом `a`.

**Примеры**

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

```sql title=Query theme={null}
SELECT 101 AS a, bin(a), bitShiftRight(a, 2) AS a_shifted, bin(a_shifted);
```

```response title=Response theme={null}
┌───a─┬─bin(101)─┬─a_shifted─┬─bin(bitShiftRight(101, 2))─┐
│ 101 │ 01100101 │        25 │ 00011001                   │
└─────┴──────────┴───────────┴────────────────────────────┘
```

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

```sql title=Query theme={null}
SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftRight('abc', 12))─┐
│ abc │ 616263     │           │ 0616                          │
└─────┴────────────┴───────────┴───────────────────────────────┘
```

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

```sql title=Query theme={null}
SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftRight(a, 12) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftRight(toFixedString('abc', 3), 12))─┐
│ abc │ 616263                       │           │ 000616                                          │
└─────┴──────────────────────────────┴───────────┴─────────────────────────────────────────────────┘
```

<div id="bitSlice">
  ## bitSlice
</div>

Добавленный в: v22.2.0

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

**Синтаксис**

```sql theme={null}
bitSlice(s, offset[, length])
```

**Аргументы**

* `s` — Строка `String` или `FixedString`, из которой извлекается срез. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
* `offset` —
  Задает начальную позицию бита (индексация начинается с 1).
* Положительные значения: отсчет от начала строки.
* Отрицательные значения: отсчет от конца строки.

  [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `length` —
  Необязательный параметр. Количество битов для извлечения.
* Положительные значения: извлекаются `length` битов.
* Отрицательные значения: извлечение выполняется от смещения до `(string_length - |length|)`.
* Не указано: извлечение выполняется от смещения до конца строки.
* Если длина не кратна 8, результат дополняется нулями справа.
  [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)

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

Строка, содержащая извлеченные биты, представленные в виде двоичной последовательности. Результат всегда дополняется до границ байта (кратных 8 битам). [`String`](/ru/reference/data-types/string)

**Примеры**

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

```sql title=Query theme={null}
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 title=Response theme={null}
┌─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                      │
└──────────────────────────────────────────┴───────────────────────────────┘
```

<div id="bitTest">
  ## bitTest
</div>

Добавленный в: v1.1.0

Принимает любое число и преобразует его в [двоичное представление](https://en.wikipedia.org/wiki/Binary_number), затем возвращает значение бита в указанной позиции. Отсчёт ведётся справа налево, начиная с 0.

**Синтаксис**

```sql theme={null}
bitTest(a, i)
```

**Аргументы**

* `a` — Число для преобразования. [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `i` — Позиция возвращаемого бита. [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)

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

Возвращает значение бита в позиции `i` в двоичном представлении `a`: [`UInt8`](/ru/reference/data-types/int-uint)

**Примеры**

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

```sql title=Query theme={null}
SELECT bin(2), bitTest(2, 1);
```

```response title=Response theme={null}
┌─bin(2)───┬─bitTest(2, 1)─┐
│ 00000010 │             1 │
└──────────┴───────────────┘
```

<div id="bitTestAll">
  ## bitTestAll
</div>

Добавленный в: v1.1.0

Возвращает результат [логического И](https://en.wikipedia.org/wiki/Logical_conjunction) (оператор AND) для всех битов в указанных позициях.
Отсчёт идёт справа налево, начиная с 0.

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

**Синтаксис**

```sql theme={null}
bitTestAll(a, index1[, index2, ... , indexN])
```

**Аргументы**

* `a` — Целочисленное значение. [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint)
* `index1, ...` — Одна или несколько битовых позиций. [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint)

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

Возвращает результат логической конъюнкции типа [`UInt8`](/ru/reference/data-types/int-uint)

**Примеры**

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

```sql title=Query theme={null}
SELECT bitTestAll(43, 0, 1, 3, 5);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAll(43, 0, 1, 3, 5)─┐
│ 00101011 │                          1 │
└──────────┴────────────────────────────┘
```

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

```sql title=Query theme={null}
SELECT bitTestAll(43, 0, 1, 3, 5, 2);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAll(4⋯1, 3, 5, 2)─┐
│ 00101011 │                        0 │
└──────────┴──────────────────────────┘
```

<div id="bitTestAny">
  ## bitTestAny
</div>

Добавленный в: v1.1.0

Возвращает результат [логической дизъюнкции](https://en.wikipedia.org/wiki/Logical_disjunction) (оператор OR) всех битов на указанных позициях в числе.
Отсчёт идёт справа налево, начиная с 0.

Логический OR двух битов равен true, если хотя бы один из входных битов равен true.

**Синтаксис**

```sql theme={null}
bitTestAny(a, index1[, index2, ... , indexN])
```

**Аргументы**

* `a` — Целочисленное значение. [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint)
* `index1, ...` — Одна или несколько позиций битов. [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint)

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

Возвращает результат логической дизъюнкции типа [`UInt8`](/ru/reference/data-types/int-uint)

**Примеры**

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

```sql title=Query theme={null}
SELECT bitTestAny(43, 0, 2);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAny(43, 0, 2)─┐
│ 00101011 │                    1 │
└──────────┴──────────────────────┘
```

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

```sql title=Query theme={null}
SELECT bitTestAny(43, 4, 2);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAny(43, 4, 2)─┐
│ 00101011 │                    0 │
└──────────┴──────────────────────┘
```

<div id="bitXor">
  ## bitXor
</div>

Добавленный в: v1.1.0

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

**Синтаксис**

```sql theme={null}
bitXor(a, b)
```

**Аргументы**

* `a` — Первое значение. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `b` — Второе значение. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)

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

Результат побитовой операции `a XOR b`

**Примеры**

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

```sql title=Query theme={null}
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 title=Response theme={null}
┌─a─┬─b─┬─bitXor(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            1 │
│ 1 │ 0 │            1 │
│ 1 │ 1 │            0 │
└───┴───┴──────────────┘
```