Catégories :: Fonctions d’expression au niveau du bit

BITXOR¶

Renvoie le XOR au niveau du bit pour deux expressions numériques.

Alias :: BIT_XOR
Voir aussi :: BITXOR_AGG

Syntaxe¶

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

Arguments¶

expr1

Cette expression doit être évaluée à une valeur INTEGER, une valeur BINARY ou une valeur d’un type de données qui peut être convertie en une valeur INTEGER.

expr2

Cette expression doit être évaluée à une valeur INTEGER, une valeur BINARY ou une valeur d’un type de données qui peut être convertie en une valeur INTEGER.

'padside'

Quand deux valeurs d’argument BINARY n’ont pas la même longueur, spécifie de quel côté remplir la valeur avec la longueur la plus courte. Spécifie l’une des valeurs insensibles à la casse suivantes :

LEFT- Complétez la valeur à gauche.
RIGHT- Complétez la valeur à droite.

La valeur la plus courte est complétée par des zéros afin qu’elle soit égale à la longueur de la valeur la plus grande.

Cet argument n’est valable que lorsque les expressions BINARY sont spécifiées.

Si la longueur de deux valeurs BINARY est différente, cet argument est obligatoire.

Renvoie¶

Renvoie une valeur INTEGER, une valeur BINARY ou NULL :

Lorsque les expressions d’entrée contiennent des valeurs INTEGER, renvoie une valeur INTEGER qui représente le XOR au niveau du bit des expressions d’entrée.
Lorsque les expressions d’entrée contiennent des valeurs BINARY, renvoie une valeur BINARY qui représente le XOR au niveau du bit des expressions d’entrée.
Si l’une des valeurs d’entrée est NULL, renvoie NULL.

Notes sur l’utilisation¶

Les deux expressions d’entrée doivent être évaluées à une valeur du même type de données, INTEGER ou BINARY.
Si le type de données de l’un ou l’autre des arguments est numérique mais pas INTEGER (par exemple, FLOAT, DECIMAL, etc.), l’argument est alors converti en valeur INTEGER.
Si le type de données de l’un ou l’autre des arguments est une chaîne (par exemple, VARCHAR), l’argument est alors converti en une valeur INTEGER si possible. Par exemple, la chaîne 12.3 devient 12. Si la valeur ne peut pas être convertie en valeur INTEGER, elle est traitée comme NULL.
La fonction ne convertit pas implicitement les arguments en valeurs BINARY.

Exemples¶

Les sections suivantes contiennent des exemples de valeurs d’argument INTEGER et de valeurs d’argument BINARY.

Utilisation de BITAND, BITOR et BITXOR avec des valeurs d’argument INTEGER¶

Créez un tableau simple et insérez les données :

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.
  ;

Exécutez la requête :

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 |
+------+-------+--------------------+-------------------+--------------------+

Utilisation de BITAND, BITOR et BITXOR avec des valeurs d’argument BINARY¶

Créez un tableau simple et insérez les données :

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);

Note

Les valeurs BINARY sont insérées à l’aide de la notation x'value', où value contient des chiffres hexadécimaux. Pour plus d’informations, voir Entrée et sortie binaires.

Exécuter une requête sur des colonnes BINARY de même longueur :

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               |
+------+------+--------------------+-------------------+--------------------+

Si vous essayez d’exécuter une requête sur des colonnes BINARY de longueurs différentes sans spécifier l’argument 'padside', une erreur est renvoyée :

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

Exécuter une requête sur des colonnes BINARY de différentes longueurs et remplir la valeur d’argument la plus petite sur la gauche :

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                       |
+------+----------+----------------------------+---------------------------+----------------------------+

Exécuter une requête sur des colonnes BINARY de différentes longueurs et remplir la valeur d’argument la plus petite à droite :

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                        |
+------+----------+-----------------------------+----------------------------+-----------------------------+