Fonctions bit à bit - ClickHouse Documentation

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

Query

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

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

La fonction ne convertit pas la valeur d’entrée en un type plus grand (extension de signe). Par exemple : bitCount(toUInt8(-1)) = 8.

Exemples Exemple d’utilisation

Query

SELECT bin(333), bitCount(333);

Response

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

Query

SELECT bitHammingDistance(111, 121);

Response

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

Query

SELECT
    CAST('5', 'UInt8') AS original,
    bin(original) AS original_binary,
    bitNot(original) AS result,
    bin(bitNot(original)) AS result_binary;

Response

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

Query

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

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

Query

SELECT 99 AS a, bin(a), bitRotateLeft(a, 2) AS a_rotated, bin(a_rotated);

Response

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

Query

SELECT 99 AS a, bin(a), bitRotateRight(a, 2) AS a_rotated, bin(a_rotated);

Response

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

Query

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

Response

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

Exemple d’utilisation avec encodage hexadécimal

Query

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

Response

┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftLeft('abc', 4))─┐
│ abc │ 616263     │ &0        │ 06162630                    │
└─────┴────────────┴───────────┴─────────────────────────────┘

Exemple d’utilisation avec un encodage Fixed String

Query

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

Response

┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftLeft(toFixedString('abc', 3), 4))─┐
│ abc │ 616263                       │ &0        │ 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

Query

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

Response

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

Exemple d’utilisation avec encodage hexadécimal

Query

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

Response

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

Exemple d’utilisation avec l’encodage Fixed String

Query

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

Response

┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftRight(toFixedString('abc', 3), 12))─┐
│ 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

Query

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

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

Query

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

Response

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

Query

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

Response

┌─bin(43)──┬─bitTestAll(43, 0, 1, 3, 5)─┐
│ 00101011 │                          1 │
└──────────┴────────────────────────────┘

Exemple d’utilisation 2

Query

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

Response

┌─bin(43)──┬─bitTestAll(4⋯1, 3, 5, 2)─┐
│ 00101011 │                        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

Query

SELECT bitTestAny(43, 0, 2);

Response

┌─bin(43)──┬─bitTestAny(43, 0, 2)─┐
│ 00101011 │                    1 │
└──────────┴──────────────────────┘

Exemple d’utilisation 2

Query

SELECT bitTestAny(43, 4, 2);

Response

┌─bin(43)──┬─bitTestAny(43, 4, 2)─┐
│ 00101011 │                    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

Query

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

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