Funciones de bits - ClickHouse Documentation

Las funciones de bits funcionan con cualquier par de tipos entre UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32 o Float64. Algunas funciones admiten los tipos String y FixedString. El tipo de resultado es un entero cuyo número de bits es igual al número máximo de bits de sus argumentos. Si al menos uno de los argumentos es de tipo con signo, el resultado será un número con signo. Si un argumento es un número de coma flotante, se convierte a Int64.

bitAnd

Introducido en: v1.1.0 Realiza una operación AND bit a bit entre dos valores. Sintaxis

bitAnd(a, b)

Argumentos

a — Primer valor. (U)Int* o Float*
b — Segundo valor. (U)Int* o Float*

Valor devuelto Devuelve el resultado de la operación bit a bit a AND b Ejemplos Ejemplo de uso

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

Introducido en: v20.3.0 Calcula la cantidad de bits con valor uno en la representación binaria de un número. Sintaxis

bitCount(x)

Argumentos

x — Un valor entero o de punto flotante. (U)Int* o Float*

Valor devuelto Devuelve el número de bits establecidos en uno en x. UInt8.

La función no convierte el valor de entrada a un tipo de mayor tamaño (extensión de signo). Por ejemplo: bitCount(toUInt8(-1)) = 8.

Ejemplos Ejemplo de uso

Query

SELECT bin(333), bitCount(333);

Response

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

bitHammingDistance

Introducido en: v21.1.0 Devuelve la distancia de Hamming entre las representaciones en bits de dos números. Puede utilizarse con las funciones SimHash para detectar cadenas casi duplicadas. Cuanto menor sea la distancia, más similares serán las cadenas. Sintaxis

bitHammingDistance(x, y)

Argumentos

x — Primer número para calcular la distancia de Hamming. (U)Int* o Float*
y — Segundo número para calcular la distancia de Hamming. (U)Int* o Float*

Valor devuelto Devuelve la distancia de Hamming entre x e y UInt8 Ejemplos Ejemplo de uso

Query

SELECT bitHammingDistance(111, 121);

Response

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

bitNot

Introducido en: v1.1.0 Realiza la operación NOT bit a bit. Sintaxis

bitNot(a)

Argumentos

a — Valor al que se aplicará la operación NOT bit a bit. (U)Int* o Float* o String

Valor devuelto Devuelve el resultado de ~a, es decir, a con los bits invertidos. Ejemplos Ejemplo de uso

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

Introducido en: v1.1.0 Realiza una operación OR bit a bit entre dos valores. Sintaxis

bitOr(a, b)

Argumentos

a — Primer valor. (U)Int* o Float*
b — Segundo valor. (U)Int* o Float*

Valor devuelto Devuelve el resultado de la operación bit a bit a OR b Ejemplos Ejemplo de uso

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

Introducido en: v1.1.0 Rota los bits hacia la izquierda un número determinado de posiciones. Los bits que se desplazan fuera reaparecen por la derecha. Sintaxis

bitRotateLeft(a, N)

Argumentos

a — Un valor que se va a rotar. (U)Int8/16/32/64
N — El número de posiciones que se rota a la izquierda. UInt8/16/32/64

Valor devuelto Devuelve el valor rotado con el mismo tipo que a. (U)Int8/16/32/64 Ejemplos Ejemplo de uso

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

Introducido en: v1.1.0 Rota los bits a la derecha un número determinado de posiciones. Los bits que se desplazan fuera vuelven al lado izquierdo. Sintaxis

bitRotateRight(a, N)

Argumentos

a — Un valor que se va a rotar. (U)Int8/16/32/64
N — El número de posiciones que se rota a la derecha. UInt8/16/32/64

Valor devuelto Devuelve el valor rotado, con el mismo tipo que a. (U)Int8/16/32/64 Ejemplos Ejemplo de uso

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

Introducido en: v1.1.0 Desplaza la representación binaria de un valor hacia la izquierda el número de posiciones de bit especificado. Un FixedString o un String se trata como un único valor multibyte. Los bits de un valor FixedString se pierden al desplazarse fuera. Por el contrario, un valor String se amplía con bytes adicionales, por lo que no se pierde ningún bit. Sintaxis

bitShiftLeft(a, N)

Argumentos

a — Un valor que desplazar. (U)Int* o String o FixedString
N — El número de posiciones que se van a desplazar. UInt8/16/32/64

Valor devuelto Devuelve el valor desplazado con el mismo tipo que a. Ejemplos Ejemplo de uso con codificación binaria

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

Ejemplo de uso con codificación hexadecimal

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

Ejemplo de uso con codificación 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

Introducido en: v1.1.0 Desplaza la representación binaria de un valor hacia la derecha el número especificado de posiciones de bit. Un FixedString o un String se trata como un único valor multibyte. Los bits de un valor FixedString se pierden al desplazarse fuera. En cambio, un valor String se extiende con bytes adicionales, por lo que no se pierde ningún bit. Sintaxis

bitShiftRight(a, N)

Argumentos

a — Un valor que se va a desplazar. (U)Int* o String o FixedString
N — El número de posiciones que se desplazan. UInt8/16/32/64

Valor devuelto Devuelve el valor desplazado con el mismo tipo que a. Ejemplos Ejemplo de uso con codificación binaria

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

Ejemplo de uso con codificación hexadecimal

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

Ejemplo de uso con codificación de 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

Introducido en: v22.2.0 Devuelve una subcadena que comienza en el bit del índice ‘offset’ y tiene una longitud de ‘length’ bits. Sintaxis

bitSlice(s, offset[, length])

Argumentos

s — La String o Fixed String que se va a dividir. String o FixedString
offset — Devuelve la posición inicial del bit (indexación basada en 1).
Valores positivos: cuentan desde el principio de la cadena.
Valores negativos: cuentan desde el final de la cadena. (U)Int8/16/32/64 o Float*
length — Opcional. El número de bits que se van a extraer.
Valores positivos: extraen length bits.
Valores negativos: extraen desde el desplazamiento hasta (string_length - |length|).
Si se omite: extrae desde el desplazamiento hasta el final de la cadena.
Si length no es un múltiplo de 8, el resultado se rellena con ceros a la derecha. (U)Int8/16/32/64 o Float*

Valor devuelto Devuelve una cadena que contiene los bits extraídos, representados como una secuencia binaria. El resultado siempre se rellena hasta los límites de byte (múltiplos de 8 bits) String Ejemplos Ejemplo de uso

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

Introducido en: v1.1.0 Toma cualquier número y lo convierte a binario; luego devuelve el valor del bit en una posición especificada. El conteo se realiza de derecha a izquierda, empezando en 0. Sintaxis

bitTest(a, i)

Argumentos

a — Número que se va a evaluar. (U)Int8/16/32/64 o Float*
i — Posición del bit que se devolverá. (U)Int8/16/32/64 o Float*

Valor devuelto Devuelve el valor del bit situado en la posición i en la representación binaria de a UInt8 Ejemplos Ejemplo de uso

Query

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

Response

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

bitTestAll

Introducido en: v1.1.0 Devuelve el resultado de la conjunción lógica (operador AND) de todos los bits en las posiciones especificadas. Cuenta de derecha a izquierda, empezando en 0. El AND lógico entre dos bits es verdadero si y solo si ambos bits de entrada son verdaderos. Sintaxis

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

Argumentos

a — Un valor entero. (U)Int8/16/32/64
index1, ... — Una o varias posiciones de bits. (U)Int8/16/32/64

Valor devuelto Devuelve el resultado de la conjunción lógica UInt8 Ejemplos Ejemplo de uso 1

Query

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

Response

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

Ejemplo de uso 2

Query

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

Response

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

bitTestAny

Introducido en: v1.1.0 Devuelve el resultado de la disyunción lógica (operador OR) de todos los bits situados en las posiciones indicadas de un número. Se cuenta de derecha a izquierda, comenzando en 0. El OR lógico entre dos bits es verdadero si al menos uno de los bits de entrada es verdadero. Sintaxis

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

Argumentos

a — Un valor entero. (U)Int8/16/32/64
index1, ... — Una o varias posiciones de bits. (U)Int8/16/32/64

Valor devuelto Devuelve el resultado de la disyunción lógica UInt8 Ejemplos Ejemplo de uso 1

Query

SELECT bitTestAny(43, 0, 2);

Response

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

Ejemplo de uso 2

Query

SELECT bitTestAny(43, 4, 2);

Response

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

bitXor

Introducido en: v1.1.0 Realiza una operación de o exclusiva bit a bit (XOR) entre dos valores. Sintaxis

bitXor(a, b)

Argumentos

a — Primer valor. (U)Int* o Float*
b — Segundo valor. (U)Int* o Float*

Valor devuelto Devuelve el resultado de la operación bit a bit a XOR b Ejemplos Ejemplo de uso

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