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

BITSHIFTLEFT¶

Déplace les bits de l’expression numérique ou binaire de n positions vers la gauche.

Alias :: BIT_SHIFTLEFT
Voir aussi :: BITSHIFTRIGHT

Syntaxe¶

BITSHIFTLEFT( <expr1> , <n> )

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.
n: Le nombre de bits du déplacement.

Renvoie¶

Renvoie une valeur INTEGER, une valeur BINARY ou NULL :

Lorsque l’expression d’entrée contient une valeur INTEGER, renvoie un entier signé de 128 bits (16 octets), quels que soient la taille ou le type de données de la valeur de données d’entrée.
Lorsque l’expression d’entrée contient une valeur BINARY, renvoie une valeur BINARY.
Si un argument est NULL, renvoie NULL.

Notes sur l’utilisation¶

Si le type de données d’un argument est numérique mais pas INTEGER (par exemple, FLOAT, DECIMAL, etc.), l’argument sera alors converti en valeur INTEGER
Si le type de données d’un argument 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.
Si une valeur INTEGER signée est retournée et que la valeur du bit de poids fort change (de 0 à 1 ou de 1 à 0), le signe du résultat est inversé. Par exemple, BITSHIFTLEFT(1, 127) renvoie un nombre négatif.
Si une valeur INTEGER signée est retournée, les bits qui sont décalés au-delà de la fin de la valeur de sortie de 128 bits sont détruits.
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 BITSHIFTLEFT et BITSHIFTRIGHT avec des valeurs d’argument INTEGER¶

Créez une table et des données simples :

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, 
       BITSHIFTLEFT(bit1, 1), 
       BITSHIFTRIGHT(bit2, 1)
  FROM bits
  ORDER BY bit1;

+------+-------+-----------------------+------------------------+
| BIT1 |  BIT2 | BITSHIFTLEFT(BIT1, 1) | BITSHIFTRIGHT(BIT2, 1) |
|------+-------+-----------------------+------------------------|
|    0 | 65504 |                     0 |                  32752 |
|    1 |     1 |                     2 |                      0 |
|    2 |     4 |                     4 |                      2 |
|    4 |     2 |                     8 |                      1 |
|   16 |    24 |                    32 |                     12 |
| NULL |  NULL |                  NULL |                   NULL |
+------+-------+-----------------------+------------------------+

Utilisation de BITSHIFTLEFT 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écutez la requête :

SELECT bit1,
       bit3,
       BITSHIFTLEFT(bit1, 1),
       BITSHIFTLEFT(bit3, 1),
       BITSHIFTLEFT(bit1, 8),
       BITSHIFTLEFT(bit3, 16)
  FROM bits;

+------+----------+-----------------------+-----------------------+-----------------------+------------------------+
| BIT1 | BIT3     | BITSHIFTLEFT(BIT1, 1) | BITSHIFTLEFT(BIT3, 1) | BITSHIFTLEFT(BIT1, 8) | BITSHIFTLEFT(BIT3, 16) |
|------+----------+-----------------------+-----------------------+-----------------------+------------------------|
| 1010 | 11001010 | 2020                  | 22002020              | 1000                  | 10100000               |
| 1100 | 01011010 | 2200                  | 02022020              | 0000                  | 10100000               |
| BCBC | ABCDABCD | 7978                  | 579B579A              | BC00                  | ABCD0000               |
| NULL | NULL     | NULL                  | NULL                  | NULL                  | NULL                   |
+------+----------+-----------------------+-----------------------+-----------------------+------------------------+