Funções de Bit

Documentação para Funções de Bit

As funções de bit operam sobre qualquer par dos tipos UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32 ou Float64. Algumas funções também oferecem suporte aos tipos String e FixedString.

O tipo do resultado é um inteiro com número de bits igual ao maior número de bits entre seus argumentos. Se pelo menos um dos argumentos tiver sinal, o resultado será um número com sinal. Se um argumento for um número de ponto flutuante, ele será convertido em Int64.

​

bitAnd

Introduzido em: v1.1.0

Realiza a operação AND bit a bit entre dois valores.

Sintaxe

bitAnd(a, b)

Argumentos

• a — Primeiro valor. (U)Int* ou Float*
• b — Segundo valor. (U)Int* ou Float*

Valor retornado

Retorna o resultado da operação bit a bit a AND b

Exemplos

Exemplo 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

Introduzido em: v20.3.0

Calcula o número de bits definidos como 1 na representação binária de um número.

Sintaxe

bitCount(x)

Argumentos

• x — Um valor inteiro ou de ponto flutuante. (U)Int* ou Float*

Valor retornado

Retorna o número de bits com valor um em x. UInt8.

A função não converte o valor de entrada para um tipo maior (extensão de sinal). Por exemplo: bitCount(toUInt8(-1)) = 8.

Exemplos

Exemplo de uso

Query

SELECT bin(333), bitCount(333);

Response

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

​

bitHammingDistance

Introduzido em: v21.1.0

Retorna a distância de Hamming entre as representações em bits de dois números. Pode ser usada com funções SimHash para detectar strings quase duplicadas. Quanto menor a distância, mais semelhantes são as strings.

Sintaxe

bitHammingDistance(x, y)

Argumentos

• x — Primeiro número para calcular a distância de Hamming. (U)Int* ou Float*
• y — Segundo número para calcular a distância de Hamming. (U)Int* ou Float*

Valor retornado

Retorna a distância de Hamming entre x e y UInt8

Exemplos

Exemplo de uso

Query

SELECT bitHammingDistance(111, 121);

Response

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

​

bitNot

Introduzido em: v1.1.0

Realiza a operação NOT bit a bit.

Sintaxe

bitNot(a)

Argumentos

• a — Valor ao qual aplicar a operação NOT bit a bit. (U)Int* ou Float* ou String

Valor retornado

Retorna o resultado de ~a, ou seja, a com os bits invertidos.

Exemplos

Exemplo 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

Introduzido em: v1.1.0

Realiza a operação OR bit a bit entre dois valores.

Sintaxe

bitOr(a, b)

Argumentos

• a — Primeiro valor. (U)Int* ou Float*
• b — Segundo valor. (U)Int* ou Float*

Valor retornado

Retorna o resultado da operação bit a bit a OR b

Exemplos

Exemplo 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

Introduzido na versão: v1.1.0

Rotaciona os bits para a esquerda em um determinado número de posições. Os bits que saem de uma extremidade reaparecem à direita.

Sintaxe

bitRotateLeft(a, N)

Argumentos

• a — Um valor a ser rotacionado. (U)Int8/16/32/64
• N — O número de posições de rotação à esquerda. UInt8/16/32/64

Valor retornado

Retorna o valor rotacionado, com o mesmo tipo de a. (U)Int8/16/32/64

Exemplos

Exemplo 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

Introduzido em: v1.1.0

Rotacione os bits para a direita em um determinado número de posições. Os bits que saem de uma extremidade reaparecem à esquerda.

Sintaxe

bitRotateRight(a, N)

Argumentos

• a — Um valor a ser rotacionado. (U)Int8/16/32/64
• N — O número de posições para rotacionar para a direita. UInt8/16/32/64

Valor retornado

Retorna o valor rotacionado, com o mesmo tipo de a. (U)Int8/16/32/64

Exemplos

Exemplo 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

Introduzido em: v1.1.0

Desloca a representação binária de um valor para a esquerda por um número especificado de posições de bit.

Um FixedString ou uma String é tratado como um único valor multibyte.

Os bits de um valor FixedString são perdidos à medida que são deslocados para fora. Em contrapartida, um valor String é expandido com bytes adicionais, portanto nenhum bit é perdido.

Sintaxe

bitShiftLeft(a, N)

Argumentos

• a — Um valor a ser deslocado. (U)Int* ou String ou FixedString
• N — O número de posições a deslocar. UInt8/16/32/64

Valor retornado

Retorna o valor deslocado com o mesmo tipo de a.

Exemplos

Exemplo de uso com codificação binária

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

Exemplo de uso com codificação em 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                    │
└─────┴────────────┴───────────┴─────────────────────────────┘

Exemplo de uso com a codificação 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

Introduzido em: v1.1.0

Desloca a representação binária de um valor para a direita por um número especificado de posições de bit.

Um FixedString ou uma String é tratado como um único valor multibyte.

Os bits de um valor FixedString são perdidos à medida que são deslocados. Em contrapartida, um valor String é expandido com bytes adicionais, de modo que nenhum bit é perdido.

Sintaxe

bitShiftRight(a, N)

Argumentos

• a — Um valor a ser deslocado. (U)Int* ou String ou FixedString
• N — O número de posições do deslocamento. UInt8/16/32/64

Valor retornado

Retorna o valor deslocado com tipo igual ao de a.

Exemplos

Exemplo de uso com codificação binária

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

Exemplo de uso com codificação 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                          │
└─────┴────────────┴───────────┴───────────────────────────────┘

Exemplo de uso com codificação 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

Introduzido na versão: v22.2.0

Retorna uma substring que começa no bit do índice ‘offset’ e possui ‘length’ bits.

Sintaxe

bitSlice(s, offset[, length])

Argumentos

• s — A String ou Fixed String a ser recortada. String ou FixedString

• offset — Retorna a posição inicial do bit (indexação baseada em 1).

• Valores positivos: contam a partir do início da string.

• Valores negativos: contam a partir do fim da string.

  (U)Int8/16/32/64 ou Float*

• length — Opcional. O número de bits a extrair.

• Valores positivos: extraem length bits.

• Valores negativos: extraem do offset até (string_length - |length|).

• Omitido: extrai do offset até o fim da string.

• Se o comprimento não for múltiplo de 8, o resultado será preenchido com zeros à direita. (U)Int8/16/32/64 ou Float*

Valor retornado

Retorna uma string contendo os bits extraídos, representados como uma sequência binária. O resultado é sempre preenchido até os limites de byte (múltiplos de 8 bits) String

Exemplos

Exemplo 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

Introduzido em: v1.1.0

Aceita qualquer número e o converte em binário, depois retorna o valor do bit em uma posição especificada. A contagem é feita da direita para a esquerda, começando em 0.

Sintaxe

bitTest(a, i)

Argumentos

• a — Número a ser convertido. (U)Int8/16/32/64 ou Float*
• i — Posição do bit a ser retornado. (U)Int8/16/32/64 ou Float*

Valor retornado

Retorna o valor do bit na posição i na representação binária de a UInt8

Exemplos

Exemplo de uso

Query

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

Response

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

​

bitTestAll

Introduzido na versão: v1.1.0

Retorna o resultado da conjunção lógica (operador AND) de todos os bits nas posições indicadas. A contagem é feita da direita para a esquerda, começando em 0.

O AND lógico entre dois bits é true se, e somente se, ambos os bits de entrada forem true.

Sintaxe

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

Argumentos

• a — Um valor inteiro. (U)Int8/16/32/64
• index1, ... — Uma ou mais posições de bits. (U)Int8/16/32/64

Valor retornado

Retorna o resultado da conjunção lógica em UInt8

Exemplos

Exemplo de uso 1

Query

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

Response

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

Exemplo de uso 2

Query

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

Response

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

​

bitTestAny

Introduzido na versão: v1.1.0

Retorna o resultado da disjunção lógica (operador OR) de todos os bits nas posições especificadas em um número. A contagem é feita da direita para a esquerda, começando em 0.

O OR lógico entre dois bits é true se pelo menos um dos bits de entrada for true.

Sintaxe

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

Argumentos

• a — Um valor inteiro. (U)Int8/16/32/64
• index1, ... — Uma ou mais posições de bits. (U)Int8/16/32/64

Valor retornado

Retorna o resultado da disjunção lógica UInt8

Exemplos

Exemplo de uso 1

Query

SELECT bitTestAny(43, 0, 2);

Response

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

Exemplo de uso 2

Query

SELECT bitTestAny(43, 4, 2);

Response

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

​

bitXor

Introduzido na versão: v1.1.0

Executa a operação OU exclusivo bit a bit (XOR) entre dois valores.

Sintaxe

bitXor(a, b)

Argumentos

• a — Primeiro valor. (U)Int* ou Float*
• b — Segundo valor. (U)Int* ou Float*

Valor retornado

Retorna o resultado da operação XOR bit a bit entre a e b

Exemplos

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