Fonctions bit à bit | ClickHouse Docs

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.

bitAnd

Introduit dans : v1.1.0

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

Syntaxe

bitAnd(a, b)

Arguments

a — Première valeur. (U)Int* ou Float*
b — Deuxième valeur. (U)Int* ou Float*

Valeur renvoyée

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

Exemples

Exemple d'utilisation

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

Introduit dans : v20.3.0

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

Syntaxe

bitCount(x)

Arguments

x — Une valeur entière ou à virgule flottante. (U)Int* ou Float*

Valeur renvoyée

Renvoie le nombre de bits égaux à un dans x. UInt8.

Exemples

Exemple d'utilisation

SELECT bin(333), bitCount(333);

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

bitHammingDistance

Introduit dans : v21.1.0

Renvoie la distance de Hamming entre les représentations binaires de deux nombres. Peut être utilisée avec les fonctions SimHash pour détecter des chaînes semi-dupliquées. Plus la distance est faible, plus les chaînes se ressemblent.

Syntaxe

bitHammingDistance(x, y)

Arguments

x — Premier nombre pour calculer la distance de Hamming. (U)Int* ou Float*
y — Deuxième nombre pour calculer la distance de Hamming. (U)Int* ou Float*

Valeur renvoyée

Renvoie la distance de Hamming entre x et y UInt8

Exemples

Exemple d'utilisation

SELECT bitHammingDistance(111, 121);

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

bitNot

Introduit dans : v1.1.0

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

Syntaxe

bitNot(a)

Arguments

a — Valeur à laquelle appliquer l'opération de négation bit à bit. (U)Int* ou Float* ou String

Valeur renvoyée

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

Exemples

Exemple d'utilisation

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

Introduit dans : v1.1.0

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

Syntaxe

bitOr(a, b)

Arguments

a — Première valeur. (U)Int* ou Float*
b — Deuxième valeur. (U)Int* ou Float*

Valeur renvoyée

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

Exemples

Exemple d'utilisation

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

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

bitRotateLeft(a, N)

Arguments

a — Une valeur sur laquelle effectuer une rotation. (U)Int8/16/32/64
N — Le nombre de positions de rotation vers la gauche. UInt8/16/32/64

Valeur renvoyée

Renvoie la valeur obtenue après rotation, avec un type identique à celui de a. (U)Int8/16/32/64

Exemples

Exemple d'utilisation

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

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

bitRotateRight(a, N)

Arguments

a — Une valeur sur laquelle effectuer une rotation. (U)Int8/16/32/64
N — Le nombre de positions de rotation vers la droite. UInt8/16/32/64

Valeur renvoyée

Renvoie la valeur obtenue par rotation, de même type que a. (U)Int8/16/32/64

Exemples

Exemple d'utilisation

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

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

bitShiftLeft(a, N)

Arguments

a — Une valeur à décaler. (U)Int* ou String ou FixedString
N — Le nombre de positions à décaler. UInt8/16/32/64

Valeur renvoyée

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

Exemples

Exemple d'utilisation avec encodage binaire

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

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

Exemple d’utilisation avec encodage hexadécimal

-- The shifted value is binary, so it is shown with `hex`.
SELECT 'abc' AS a, hex(a), hex(bitShiftLeft(a, 4)) AS a_shifted;

┌─a───┬─hex(a)─┬─a_shifted─┐
│ abc │ 616263 │ 06162630  │
└─────┴────────┴───────────┘

Exemple d'utilisation avec un encodage Fixed String

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

┌─a───┬─hex(a)─┬─a_shifted─┐
│ abc │ 616263 │ 162630    │
└─────┴────────┴───────────┘

bitShiftRight

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

bitShiftRight(a, N)

Arguments

a — Une valeur à décaler. (U)Int* ou String ou FixedString
N — Le nombre de positions à décaler. UInt8/16/32/64

Valeur renvoyée

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

Exemples

Exemple d’utilisation avec encodage binaire

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

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

Exemple d’utilisation avec encodage hexadécimal

-- The shifted value is binary, so it is shown with `hex`.
SELECT 'abc' AS a, hex(a), hex(bitShiftRight(a, 12)) AS a_shifted;

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

Exemple d’utilisation avec l’encodage Fixed String

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

┌─a───┬─hex(a)─┬─a_shifted─┐
│ abc │ 616263 │ 000616    │
└─────┴────────┴───────────┘

bitSlice

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

bitSlice(s, offset[, length])

Arguments

s — La chaîne de type String ou Fixed String à découper. String ou 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 ou 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 ou 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

Exemples

Exemple d'utilisation

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

Introduit dans : v1.1.0

Prend un nombre quelconque et le convertit en forme binaire, puis renvoie la valeur du bit à une position donnée. Le comptage s’effectue de droite à gauche, à partir de 0.

Syntaxe

bitTest(a, i)

Arguments

a — Nombre à convertir. (U)Int8/16/32/64 ou Float*
i — Position du bit à extraire. (U)Int8/16/32/64 ou Float*

Valeur renvoyée

Renvoie la valeur du bit en position i dans la représentation binaire de a UInt8

Exemples

Exemple d'utilisation

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

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

bitTestAll

Introduit dans : v1.1.0

Renvoie le résultat de la conjonction logique (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

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

Arguments

a — Une valeur entière. (U)Int8/16/32/64
index1, ... — Une ou plusieurs positions de bit. (U)Int8/16/32/64

Valeur renvoyée

Renvoie le résultat de la conjonction logique UInt8

Exemples

Exemple d'utilisation 1

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

┌─bitTestAll(43, 0, 1, 3, 5)─┐
│                          1 │
└────────────────────────────┘

Exemple d’utilisation 2

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

┌─bitTestAll(43, 0, 1, 3, 5, 2)─┐
│                             0 │
└───────────────────────────────┘

bitTestAny

Introduit dans : v1.1.0

Renvoie le résultat de la disjonction logique (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

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

Arguments

a — Une valeur entière. (U)Int8/16/32/64
index1, ... — Une ou plusieurs positions de bits. (U)Int8/16/32/64

Valeur renvoyée

Renvoie le résultat de la disjonction logique UInt8

Exemples

Exemple d'utilisation 1

SELECT bitTestAny(43, 0, 2);

┌─bitTestAny(43, 0, 2)─┐
│                    1 │
└──────────────────────┘

Exemple d’utilisation 2

SELECT bitTestAny(43, 4, 2);

┌─bitTestAny(43, 4, 2)─┐
│                    0 │
└──────────────────────┘

bitXor

Introduit dans : v1.1.0

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

Syntaxe

bitXor(a, b)

Arguments

a — Première valeur. (U)Int* ou Float*
b — Deuxième valeur. (U)Int* ou Float*

Valeur renvoyée

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

Exemples

Exemple d'utilisation

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