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

> Documentation des fonctions bit à bit

# Fonctions bit à bit

Les fonctions bit à bit s'appliquent à toute paire de types parmi `UInt8`, `UInt16`, `UInt32`, `UInt64`, `Int8`, `Int16`, `Int32`, `Int64`, `Float32` ou `Float64`. Certaines fonctions prennent également en charge les types `String` et `FixedString`.

Le type du résultat est un entier dont le nombre de bits est égal au nombre maximal de bits de ses arguments. Si au moins un des arguments est signé, le résultat est un nombre signé. Si un argument est un nombre à virgule flottante, il est converti en Int64.

{/*AUTOGENERATED_START*/}

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

Introduit dans : v1.1.0

Effectue une opération bit à bit ET entre deux valeurs.

**Syntaxe**

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

**Arguments**

* `a` — Première valeur. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `b` — Deuxième valeur. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)

**Valeur renvoyée**

Renvoie le résultat de l’opération bit à bit `a AND b`

**Exemples**

**Exemple d'utilisation**

```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>

Introduit dans : v20.3.0

Calcule le nombre de bits à 1 dans la représentation binaire d'un nombre.

**Syntaxe**

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

**Arguments**

* `x` — Une valeur entière ou à virgule flottante. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)

**Valeur renvoyée**

Renvoie le nombre de bits égaux à un dans `x`. [`UInt8`](/fr/reference/data-types/int-uint).

<Note>
  La fonction ne convertit pas la valeur d'entrée en un type plus grand ([extension de signe](https://en.wikipedia.org/wiki/Sign_extension)).
  Par exemple : `bitCount(toUInt8(-1)) = 8`.
</Note>

**Exemples**

**Exemple d'utilisation**

```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>

Introduit dans : v21.1.0

Renvoie la [distance de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre les représentations binaires de deux nombres.
Peut être utilisée avec les fonctions [`SimHash`](/fr/reference/functions/regular-functions/hash-functions#ngramSimHash) pour détecter des chaînes semi-dupliquées.
Plus la distance est faible, plus les chaînes se ressemblent.

**Syntaxe**

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

**Arguments**

* `x` — Premier nombre pour calculer la distance de Hamming. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `y` — Deuxième nombre pour calculer la distance de Hamming. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)

**Valeur renvoyée**

Renvoie la distance de Hamming entre `x` et `y` [`UInt8`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

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

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

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

Introduit dans : v1.1.0

Effectue l’opération de négation bit à bit.

**Syntaxe**

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

**Arguments**

* `a` — Valeur à laquelle appliquer l'opération de négation bit à bit. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie le résultat de `~a`, c'est-à-dire `a` avec les bits inversés.

**Exemples**

**Exemple d'utilisation**

```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>

Introduit dans : v1.1.0

Effectue une opération OU bit à bit entre deux valeurs.

**Syntaxe**

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

**Arguments**

* `a` — Première valeur. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `b` — Deuxième valeur. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)

**Valeur renvoyée**

Renvoie le résultat de l'opération bit à bit `a OR b`

**Exemples**

**Exemple d'utilisation**

```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>

Introduit dans : v1.1.0

Fait pivoter les bits vers la gauche d’un certain nombre de positions. Les bits qui dépassent reviennent à droite.

**Syntaxe**

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

**Arguments**

* `a` — Une valeur sur laquelle effectuer une rotation. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint)
* `N` — Le nombre de positions de rotation vers la gauche. [`UInt8/16/32/64`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur obtenue après rotation, avec un type identique à celui de `a`. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```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>

Introduit dans : v1.1.0

Fait pivoter les bits vers la droite d’un certain nombre de positions. Les bits qui sortent d’un côté réapparaissent à gauche.

**Syntaxe**

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

**Arguments**

* `a` — Une valeur sur laquelle effectuer une rotation. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint)
* `N` — Le nombre de positions de rotation vers la droite. [`UInt8/16/32/64`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur obtenue par rotation, de même type que `a`. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```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>

Introduit dans : v1.1.0

Décale la représentation binaire d'une valeur vers la gauche d'un nombre spécifié de positions de bit.

Un `FixedString` ou un `String` est traité comme une seule valeur multioctet.

Les bits d'une valeur `FixedString` sont perdus lorsqu'ils sont décalés hors de la valeur.
À l'inverse, une valeur `String` est étendue avec des octets supplémentaires, de sorte qu'aucun bit n'est perdu.

**Syntaxe**

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

**Arguments**

* `a` — Une valeur à décaler. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
* `N` — Le nombre de positions à décaler. [`UInt8/16/32/64`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur décalée, d'un type identique à celui de `a`.

**Exemples**

**Exemple d'utilisation avec encodage binaire**

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

**Exemple d’utilisation avec encodage hexadécimal**

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

**Exemple d'utilisation avec un encodage 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>

Introduite dans : v1.1.0

Décale la représentation binaire d’une valeur vers la droite d’un nombre spécifié de positions de bits.

Une `FixedString` ou une `String` est traitée comme une seule valeur multioctet.

Les bits d’une valeur `FixedString` sont perdus lorsqu’ils sont décalés hors de la valeur.
À l’inverse, une valeur `String` est étendue avec des octets supplémentaires, de sorte qu’aucun bit n’est perdu.

**Syntaxe**

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

**Arguments**

* `a` — Une valeur à décaler. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
* `N` — Le nombre de positions à décaler. [`UInt8/16/32/64`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur décalée, du même type que `a`.

**Exemples**

**Exemple d’utilisation avec encodage binaire**

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

**Exemple d’utilisation avec encodage hexadécimal**

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

**Exemple d’utilisation avec l’encodage 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>

Introduit dans : v22.2.0

Renvoie une sous-chaîne commençant au bit d’indice 'offset' et d’une longueur de 'length' bits.

**Syntaxe**

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

**Arguments**

* `s` — La chaîne de type String ou Fixed String à découper. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
* `offset` —
  Indique la position du bit de départ (indexé à partir de 1).
* Valeurs positives : comptent à partir du début de la chaîne.
* Valeurs négatives : comptent à partir de la fin de la chaîne.

  [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `length` —
  Facultatif. Le nombre de bits à extraire.
* Valeurs positives : extraient `length` bits.
* Valeurs négatives : extraient depuis l'offset jusqu'à `(string_length - |length|)`.
* Omis : extrait depuis l'offset jusqu'à la fin de la chaîne.
* Si la longueur n'est pas un multiple de 8, le résultat est complété par des zéros à droite.
  [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)

**Valeur renvoyée**

Renvoie une chaîne contenant les bits extraits, représentés sous forme de séquence binaire. Le résultat est toujours complété sur des limites d'octet (multiples de 8 bits) [`String`](/fr/reference/data-types/string)

**Exemples**

**Exemple d'utilisation**

```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>

Introduit dans : v1.1.0

Prend un nombre quelconque et le convertit en [forme binaire](https://en.wikipedia.org/wiki/Binary_number), puis renvoie la valeur du bit à une position donnée. Le comptage s’effectue de droite à gauche, à partir de 0.

**Syntaxe**

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

**Arguments**

* `a` — Nombre à convertir. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `i` — Position du bit à extraire. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)

**Valeur renvoyée**

Renvoie la valeur du bit en position `i` dans la représentation binaire de `a` [`UInt8`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```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>

Introduit dans : v1.1.0

Renvoie le résultat de la [conjonction logique](https://en.wikipedia.org/wiki/Logical_conjunction) (opérateur AND) de tous les bits situés aux positions données.
Le comptage s’effectue de droite à gauche, à partir de 0.

L’opération AND logique entre deux bits est true si et seulement si les deux bits d’entrée sont true.

**Syntaxe**

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

**Arguments**

* `a` — Une valeur entière. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint)
* `index1, ...` — Une ou plusieurs positions de bit. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie le résultat de la conjonction logique [`UInt8`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation 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 │
└──────────┴────────────────────────────┘
```

**Exemple d’utilisation 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>

Introduit dans : v1.1.0

Renvoie le résultat de la [disjonction logique](https://en.wikipedia.org/wiki/Logical_disjunction) (opérateur OR) appliquée à tous les bits situés aux positions données dans un nombre.
Le comptage s’effectue de droite à gauche, à partir de 0.

L’OR logique entre deux bits vaut true si au moins l’un des bits d’entrée vaut true.

**Syntaxe**

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

**Arguments**

* `a` — Une valeur entière. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint)
* `index1, ...` — Une ou plusieurs positions de bits. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie le résultat de la disjonction logique [`UInt8`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation 1**

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

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

**Exemple d’utilisation 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>

Introduit dans : v1.1.0

Effectue une opération OU exclusif (XOR) bit à bit entre deux valeurs.

**Syntaxe**

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

**Arguments**

* `a` — Première valeur. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `b` — Deuxième valeur. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)

**Valeur renvoyée**

Renvoie le résultat de l'opération bit à bit `a XOR b`.

**Exemples**

**Exemple d'utilisation**

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