Categorias:: Funções de expressões bit a bit

BITXOR¶

Retorna o bit a bit XOR de duas expressões numéricas ou binárias.

Aliases:: BIT_XOR
Consulte também:: BITXOR_AGG

Sintaxe¶

BITXOR( <expr1> , <expr2> [ , '<padside>' ] )

Argumentos¶

expr1

Esta expressão deve ser avaliada como um valor INTEGER, um valor BINARY ou um valor de um tipo de dados que pode ser convertido em um valor INTEGER.

expr2

Esta expressão deve ser avaliada como um valor INTEGER, um valor BINARY ou um valor de um tipo de dados que pode ser convertido em um valor INTEGER.

'padside'

Quando dois valores de argumento BINARY não têm o mesmo comprimento, especifica qual lado preencher o valor com o comprimento menor. Especifique um dos seguintes valores sem distinção entre maiúsculas e minúsculas:

LEFT – Preencha o valor à esquerda.
RIGHT – Preencha o valor à direita.

O valor menor é preenchido com zeros para que seja igual ao comprimento do valor maior.

Este argumento é válido somente quando expressões BINARY são especificadas.

Se o comprimento de dois valores BINARY for diferente, este argumento será necessário.

Retornos¶

Retorna um valor INTEGER, BINARY ou NULL:

Quando as expressões de entrada contêm valores INTEGER, retorna um valor INTEGER que representa o bit a bit XOR das expressões de entrada.
Quando as expressões de entrada contêm valores BINARY, retorna um valor BINARY, que representa o bit a bit XOR das expressões de entrada.
Se qualquer valor de entrada for NULL, retorna NULL.

Notas de uso¶

Ambas as expressões de entrada devem ser avaliadas como um valor do mesmo tipo de dados INTEGER ou BINARY.
Se o tipo de dados de qualquer argumento for numérico, mas não INTEGER (por exemplo, FLOAT, DECIMAL etc.), o argumento será convertido em um valor INTEGER.
Se o tipo de dados de qualquer argumento for uma cadeia de caracteres (por exemplo, VARCHAR), o argumento será convertido para um valor INTEGER, se possível. Por exemplo, a cadeia de caracteres 12.3 é convertida para 12. Se o valor não puder ser convertido em um valor INTEGER, o valor será tratado como NULL.
A função não converte implicitamente argumentos em valores BINARY.

Exemplos¶

As seções a seguir contêm exemplos de valores de argumento INTEGER e valores de argumento BINARY.

Como usar BITAND, BITOR e BITXOR com valores de argumento INTEGER¶

Crie uma tabela simples e insira os dados:

CREATE OR REPLACE TABLE bits (ID INTEGER, bit1 INTEGER, bit2 INTEGER);

INSERT INTO bits (ID, bit1, bit2) VALUES 
  (   11,    1,     1),    -- Bits are all the same.
  (   24,    2,     4),    -- Bits are all different.
  (   42,    4,     2),    -- Bits are all different.
  ( 1624,   16,    24),    -- Bits overlap.
  (65504,    0, 65504),    -- Lots of bits (all but the low 6 bits).
  (    0, NULL,  NULL)     -- No bits.
  ;

Executar a consulta:

SELECT bit1, 
       bit2, 
       BITAND(bit1, bit2), 
       BITOR(bit1, bit2), 
       BITXOR(bit1, BIT2)
  FROM bits
  ORDER BY bit1;

+------+-------+--------------------+-------------------+--------------------+
| BIT1 |  BIT2 | BITAND(BIT1, BIT2) | BITOR(BIT1, BIT2) | BITXOR(BIT1, BIT2) |
|------+-------+--------------------+-------------------+--------------------|
|    0 | 65504 |                  0 |             65504 |              65504 |
|    1 |     1 |                  1 |                 1 |                  0 |
|    2 |     4 |                  0 |                 6 |                  6 |
|    4 |     2 |                  0 |                 6 |                  6 |
|   16 |    24 |                 16 |                24 |                  8 |
| NULL |  NULL |               NULL |              NULL |               NULL |
+------+-------+--------------------+-------------------+--------------------+

Como usar BITAND, BITOR e BITXOR com valores de argumento BINARY¶

Crie uma tabela simples e insira os dados:

CREATE OR REPLACE TABLE bits (ID INTEGER, bit1 BINARY(2), bit2 BINARY(2), bit3 BINARY(4));

INSERT INTO bits VALUES
  (1, x'1010', x'0101', x'11001010'),
  (2, x'1100', x'0011', x'01011010'),
  (3, x'BCBC', x'EEFF', x'ABCDABCD'),
  (4, NULL, NULL, NULL);

Nota

Os valores BINARY são inseridos usando a notação x'value', onde value contém dígitos hexadecimais. Para obter mais informações, consulte Entrada e saída de binários.

Execute uma consulta em colunas BINARY do mesmo comprimento:

SELECT bit1,
       bit2,
       BITAND(bit1, bit2),
       BITOR(bit1, bit2),
       BITXOR(bit1, bit2)
  FROM bits;

+------+------+--------------------+-------------------+--------------------+
| BIT1 | BIT2 | BITAND(BIT1, BIT2) | BITOR(BIT1, BIT2) | BITXOR(BIT1, BIT2) |
|------+------+--------------------+-------------------+--------------------|
| 1010 | 0101 | 0000               | 1111              | 1111               |
| 1100 | 0011 | 0000               | 1111              | 1111               |
| BCBC | EEFF | ACBC               | FEFF              | 5243               |
| NULL | NULL | NULL               | NULL              | NULL               |
+------+------+--------------------+-------------------+--------------------+

Se você tentar executar uma consulta em colunas BINARY de comprimentos diferentes sem especificar o argumento 'padside', um erro será retornado:

SELECT bit1,
       bit3,
       BITAND(bit1, bit3),
       BITOR(bit1, bit3),
       BITXOR(bit1, bit3)
  FROM bits;

100544 (22026): The lengths of two variable-sized fields do not match: first length 2, second length 4

Execute uma consulta em colunas BINARY de comprimentos diferentes e preencha o menor valor do argumento à esquerda:

SELECT bit1,
       bit3,
       BITAND(bit1, bit3, 'LEFT'),
       BITOR(bit1, bit3, 'LEFT'),
       BITXOR(bit1, bit3, 'LEFT')
  FROM bits;

+------+----------+----------------------------+---------------------------+----------------------------+
| BIT1 | BIT3     | BITAND(BIT1, BIT3, 'LEFT') | BITOR(BIT1, BIT3, 'LEFT') | BITXOR(BIT1, BIT3, 'LEFT') |
|------+----------+----------------------------+---------------------------+----------------------------|
| 1010 | 11001010 | 00001010                   | 11001010                  | 11000000                   |
| 1100 | 01011010 | 00001000                   | 01011110                  | 01010110                   |
| BCBC | ABCDABCD | 0000A88C                   | ABCDBFFD                  | ABCD1771                   |
| NULL | NULL     | NULL                       | NULL                      | NULL                       |
+------+----------+----------------------------+---------------------------+----------------------------+

Execute uma consulta em colunas BINARY de comprimentos diferentes e preencha o menor valor do argumento à direita:

SELECT bit1,
       bit3,
       BITAND(bit1, bit3, 'RIGHT'),
       BITOR(bit1, bit3, 'RIGHT'),
       BITXOR(bit1, bit3, 'RIGHT')
  FROM bits;

+------+----------+-----------------------------+----------------------------+-----------------------------+
| BIT1 | BIT3     | BITAND(BIT1, BIT3, 'RIGHT') | BITOR(BIT1, BIT3, 'RIGHT') | BITXOR(BIT1, BIT3, 'RIGHT') |
|------+----------+-----------------------------+----------------------------+-----------------------------|
| 1010 | 11001010 | 10000000                    | 11101010                   | 01101010                    |
| 1100 | 01011010 | 01000000                    | 11011010                   | 10011010                    |
| BCBC | ABCDABCD | A88C0000                    | BFFDABCD                   | 1771ABCD                    |
| NULL | NULL     | NULL                        | NULL                       | NULL                        |
+------+----------+-----------------------------+----------------------------+-----------------------------+