Documentation PostgreSQL 15.15 » Langage SQL » Fonctions et opérateurs » Fonctions et opérateurs pour les chaînes de bit

Précédent | Niveau supérieur | Suivant
9.5. Fonctions et opérateurs pour les chaînes binaires | Sommaire | 9.7. Correspondance de motif

## 9.6. Fonctions et opérateurs pour les chaînes de bit

Cette section décrit les fonctions et opérateurs pour examiner et manipuler les chaînes de bit, c'est-à-dire des valeurs de type `bit` et `bit varying`. (Alors que seul le type `bit` est mentionné dans ces tables, les valeurs de type `bit varying` peuvent être utilisées de façon interchangeable.) Les chaînes de bit supportent les opérateurs de comparaison habituels indiqués dans Tableau 9.1, ainsi que les opérateurs montrés dans Tableau 9.14.

Tableau 9.14. Opérateurs pour les chaînes de bit

Opérateur Description Exemple(s)
`bit` `||` `bit` → `bit` Concaténation `B'10001' || B'011'` → `10001011`
`bit` `&` `bit` → `bit` AND bit à bit (les arguments doivent être de même longueur) `B'10001' & B'01101'` → `00001`
`bit` `|` `bit` → `bit` OR bit à bit (les arguments doivent être de même longueur) `B'10001' | B'01101'` → `11101`
`bit` `#` `bit` → `bit` OR exclusif bit à bit (les arguments doivent être de même longueur) `B'10001' # B'01101'` → `11100`
`~` `bit` → `bit` NOT bit à bit `~ B'10001'` → `01110`
`bit` `<<` `integer` → `bit` Décalage à gauche bit à bit (la longueur de la chaîne est préservée) `B'10001' << 3` → `01000`
`bit` `>>` `integer` → `bit` Décalage à droite bit à bit (la longueur de la chaîne est préservée) `B'10001' >> 2` → `00100`

Certaines des fonctions disponibles pour les chaînes binaires sont aussi disponibles pour les chaînes de bit, comme indiquées dans Tableau 9.15.

Tableau 9.15. Fonctions pour les chaînes de bit

Fonction Description Exemple(s)
`bit_count` ( `bit` ) → `bigint` Retourne le nombre de bits initialisés dans la chaîne de bits (aussi appelée « popcount »). `bit_count(B'10111')` → `4`
`bit_length` ( `bit` ) → `integer` Renvoie le nombre de bits d'une chaîne de bit. `bit_length(B'10111')` → `5`
`length` ( `bit` ) → `integer` Renvoie le nombre de bits d'une chaîne de bit. `length(B'10111')` → `5`
`octet_length` ( `bit` ) → `integer` Renvoie le nombre d'octets d'une chaîne de bit. `octet_length(B'1011111011')` → `2`
`overlay` ( `bits` `bit` `PLACING` `newsubstring` `bit` `FROM` `start` `integer` [ `FOR` `count` `integer` ] ) → `bit` Remplace la sous-chaîne de `bits` commençant au `start`-ième bit et s'étendant sur `count` bits avec `newsubstring`. Si `count` est omis, sa valeur par défaut est la longueur de `newsubstring`. `overlay(B'01010101010101010' placing B'11111' from 2 for 3)` → `0111110101010101010`
`position` ( `substring` `bit` `IN` `bits` `bit` ) → `integer` Renvoie la position de départ de `substring` dans `bits`, ou zéro s'il n'est pas présent. `position(B'010' in B'000001101011')` → `8`
`substring` ( `bits` `bit` [ `FROM` `start` `integer` ] [ `FOR` `count` `integer` ] ) → `bit` Extrait la sous-chaîne de `bits` commençant au `start`-ième bit s'il est précisé, et s'arrêtant après `count` bits s'il est précisé. Il est requis qu'au moins soit `start` soit `count` soient renseignés. `substring(B'110010111111' from 3 for 2)` → `00`
`get_bit` ( `bits` `bit`, `n` `integer` ) → `integer` Extrait le `n`-ième bit de la chaîne de bits. Le premier bit (le plus à gauche) est le bit 0. `get_bit(B'101010101010101010', 6)` → `1`
`set_bit` ( `bits` `bit`, `n` `integer`, `newvalue` `integer` ) → `bit` Initialise le `n`-ième bit dans la chaîne de bit avec `newvalue`. Le premier bit (le plus à gauche) est le bit 0. `set_bit(B'101010101010101010', 6, 0)` → `101010001010101010`

De plus, il est possible de convertir les valeurs intégrales à partir ou vers le type `bit`. Convertir un entier en `bit(n)` copie les `n` bits les plus à droite. Convertir un entier en une chaîne de bits, dont la largeur est plus importante que l'entier lui-même, l'étendra sur la gauche. Quelques exemples :

    44::bit(10)                    0000101100
    44::bit(3)                     100
    cast(-44 as bit(12))           111111010100
    '1110'::bit(4)::integer        14

Il faut noter que la conversion vers simplement « bit » signifie une conversion vers `bit(1)`, et ne renverra donc que le bit le moins significatif de l'entier.