PostgreSQL Opérateurs
Un opérateur est un symbole qui indique au compilateur d'effectuer des opérations mathématiques ou logiques spécifiques.
Les opérateurs PostgreSQL sont des mots-clés réservés ou des caractères, généralement utilisés dans les instructions WHERE comme conditions de filtre.
Les opérateurs courants incluent :
- Opérateurs arithmétiques
- Opérateurs de comparaison
- Opérateurs logiques
- Opérateurs bit à bit
Opérateurs arithmétiques
Supposons que la variable a vaut 2 et la variable b vaut 3, alors :
| Operator | Description | Exemple |
|---|---|---|
| + | ajoutez | le résultat de a + b est 5 |
| - | soustraction | le résultat de a - b est -1 |
| * | multiply | a * b a pour résultat 6 |
| / | divide | b / a a pour résultat 1 |
| % | Modulo (reste) | b % a a pour résultat 1 |
| ^ | Exponentiation | a ^ b a pour résultat 8 |
| |/ | Racine carrée | |/ 25.0 a pour résultat 5 |
| ||/ | Racine cubique | ||/ 27.0 a pour résultat 3 |
| ! | Factorielle | 5 ! a pour résultat 120 |
| !! | Factorielle (opérateur préfixe) | !! 5 a pour résultat 120 |
Exemples
exampledb=# select 2+3;
?column?
----------
5
(1 row)
exampledb=# select 2*3;
?column?
----------
6
(1 row)
exampledb=# select 10/5;
?column?
----------
2
(1 row)
exampledb=# select 12%5;
?column?
----------
2
(1 row)
exampledb=# select 2^3;
?column?
----------
8
(1 row)
exampledb=# select |/ 25.0;
?column?
----------
5
(1 row)
exampledb=# select ||/ 27.0;
?column?
----------
3
(1 row)
exampledb=# select 5 !;
?column?
----------
120
(1 row)
exampledb=# select !!5;
?column?
----------
120
(1 row)
Opérateurs de comparaison
Supposons que la variable a soit 10 et que la variable b soit 20, alors :
| Operator | Description | Exemple |
|---|---|---|
| = | Égal à | (a = b) est faux. |
| != | Différent de | (a != b) est vrai. |
| <> | Différent de | (a <> b) est vrai. |
| > | Supérieur à | (a > b) est faux. |
| < | Inférieur à | (a < b) est vrai. |
| >= | Supérieur ou égal à | (a >= b) est faux. |
| <= | Inférieur ou égal à | (a <= b) est vrai. |
Exemples
Créer la table COMPANY (Télécharger le fichier SQL COMPANY), le contenu des données est le suivant :
exampledb=# select * from COMPANY; id | name | age | address | salary ----+-------+-----+-----------+-------- 1 | Paul | 32 | California| 20000 2 | Allen | 25 | Texas | 15000 3 | Teddy | 23 | Norway | 20000 4 | Mark | 25 | Rich-Mond | 65000 5 | David | 27 | Texas | 85000 6 | Kim | 22 | South-Hall| 45000 7 | James | 24 | Houston | 10000 (7 rows)
Lire les données où le champ SALARY est supérieur à 50000 :
exampledb=# SELECT * FROM COMPANY WHERE SALARY > 50000; id | name | age |address | salary ----+-------+-----+-----------+-------- 4 | Mark | 25 | Rich-Mond | 65000 5 | David | 27 | Texas | 85000 (2 rows)
Lire les données où le champ SALARY est égal à 20000 :
exampledb=# SELECT * FROM COMPANY WHERE SALARY = 20000; id | name | age | address | salary ----+-------+-----+-------------+-------- 1 | Paul | 32 | California | 20000 3 | Teddy | 23 | Norway | 20000 (2 rows)
Lire les données où le champ SALARY n'est pas égal à 20000 :
exampledb=# SELECT * FROM COMPANY WHERE SALARY != 20000; id | name | age | address | salary ----+-------+-----+-------------+-------- 2 | Allen | 25 | Texas | 15000 4 | Mark | 25 | Rich-Mond | 65000 5 | David | 27 | Texas | 85000 6 | Kim | 22 | South-Hall | 45000 7 | James | 24 | Houston | 10000 (5 rows) exampledb=# SELECT * FROM COMPANY WHERE SALARY <> 20000; id | name | age | address | salary ----+-------+-----+------------+-------- 2 | Allen | 25 | Texas | 15000 4 | Mark | 25 | Rich-Mond | 65000 5 | David | 27 | Texas | 85000 6 | Kim | 22 | South-Hall | 45000 7 | James | 24 | Houston | 10000 (5 rows)
Lire les données où le champ SALARY est supérieur ou égal à 65000 :
exampledb=# SELECT * FROM COMPANY WHERE SALARY >= 65000; id | name | age | address | salary ----+-------+-----+-----------+-------- 4 | Mark | 25 | Rich-Mond | 65000 5 | David | 27 | Texas | 85000 (2 rows)
Opérateurs logiques
PostgreSQL possède les opérateurs logiques suivants :
| Non. | Opérateur & Description |
|---|---|
| 1 | ET Opérateur logique AND. Si les deux opérandes sont non nuls, la condition est vraie. Dans PostgreSQL, l'instruction WHERE peut utiliser AND pour inclure plusieurs conditions de filtre. |
| 2 | NON Opérateur logique NOT. Utilisé pour inverser l'état logique d'un opérande. Si la condition est vraie, l'opérateur logique NOT la rendra fausse. PostgreSQL dispose d'opérateurs tels que NOT EXISTS, NOT BETWEEN, NOT IN, etc. |
| 3 | OR Opérateur logique OR. Si l'un des deux opérandes est non nul, la condition est vraie. Dans PostgreSQL, l'instruction WHERE peut utiliser OR pour inclure plusieurs conditions de filtre. |
SQL utilise un système de logique à trois valeurs, comprenant true, false et null, où null représente « inconnu ».
a | b | a ET b | a OR b |
|---|---|---|---|
| VRAI | VRAI | VRAI | VRAI |
| VRAI | FALSE | FALSE | VRAI |
| VRAI | NULL | NULL | VRAI |
| FALSE | FALSE | FALSE | FALSE |
| FALSE | NULL | FALSE | NULL |
| NULL | NULL | NULL | NULL |
a | NON a |
|---|---|
| VRAI | FALSE |
| FALSE | VRAI |
| NULL | NULL |
Exemples
Créer la table COMPANY (Télécharger le fichier SQL COMPANY), le contenu des données est le suivant :
exampledb=# select * from COMPANY; id | name | age | address | salary ----+-------+-----+-----------+-------- 1 | Paul | 32 | California| 20000 2 | Allen | 25 | Texas | 15000 3 | Teddy | 23 | Norway | 20000 4 | Mark | 25 | Rich-Mond | 65000 5 | David | 27 | Texas | 85000 6 | Kim | 22 | South-Hall| 45000 7 | James | 24 | Houston | 10000 (7 rows)
Lire les données où le champ AGE est supérieur ou égal à 25 AND le champ SALARY est supérieur ou égal à 6500 :
exampledb=# SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 6500; id | name | age | address | salary ----+-------+-----+-----------------------------------------------+-------- 1 | Paul | 32 | California | 20000 2 | Allen | 25 | Texas | 15000 4 | Mark | 25 | Rich-Mond | 65000 5 | David | 27 | Texas | 85000 (4 rows)
Lire les données où le champ AGE est supérieur ou égal à 25 OR le champ SALARY est supérieur à 6500 :
exampledb=# SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 6500; id | name | age | address | salary ----+-------+-----+-------------+-------- 1 | Paul | 32 | California | 20000 2 | Allen | 25 | Texas | 15000 3 | Teddy | 23 | Norway | 20000 4 | Mark | 25 | Rich-Mond | 65000 5 | David | 27 | Texas | 85000 6 | Kim | 22 | South-Hall | 45000 7 | James | 24 | Houston | 10000 8 | Paul | 24 | Houston | 20000 9 | James | 44 | Norway | 5000 10 | James | 45 | Texas | 5000 (10 rows)
Lire les données où le champ SALARY n'est pas NULL :
exampledb=# SELECT * FROM COMPANY WHERE SALARY IS NOT NULL; id | name | age | address | salary ----+-------+-----+-------------+-------- 1 | Paul | 32 | California | 20000 2 | Allen | 25 | Texas | 15000 3 | Teddy | 23 | Norway | 20000 4 | Mark | 25 | Rich-Mond | 65000 5 | David | 27 | Texas | 85000 6 | Kim | 22 | South-Hall | 45000 7 | James | 24 | Houston | 10000 8 | Paul | 24 | Houston | 20000 9 | James | 44 | Norway | 5000 10 | James | 45 | Texas | 5000 (10 rows)
Opérateurs bit à bit
Les opérateurs bit à bit opèrent sur des bits et effectuent des opérations bit par bit. Les tables de vérité pour &, | et ^ sont les suivantes :
| p | q | p & q | p | q |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 |
| 1 | 1 | 1 | 1 |
| 1 | 0 | 0 | 1 |
Supposons que A = 60 et B = 13, maintenant exprimés en format binaire, ils sont les suivants :
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
Le tableau suivant présente les opérateurs bit à bit pris en charge par PostgreSQL. Supposons que la variableAait une valeur de 60, et que la variableBait une valeur de 13, alors :
| Operator | Description | Exemple |
|---|---|---|
| & | Opération AND bit à bit, effectue une opération « AND » sur les bits binaires. Règles de l'opération : 0&0=0; 0&1=0; 1&0=0; 1&1=1; | (A & B) donnera 12, soit 0000 1100 |
| | | Opérateur OR bit à bit, effectue une opération « OR » sur les bits binaires. Règles de l'opération : 0|0=0; 0|1=1; 1|0=1; 1|1=1; | (A | B) donnera 61, soit 0011 1101 |
| # | Opérateur XOR, effectue une opération « XOR » sur les bits binaires. Règles de l'opération : 0#0=0; 0#1=1; 1#0=1; 1#1=0; | (A # B) donnera 49, soit 0011 0001 |
| ~ | Opérateur NOT bit à bit, effectue une opération « NOT » sur les bits binaires. Règles de l'opération : ~1=0; ~0=1; | (~A) donnera -61, soit 1100 0011, la forme en complément à deux d'un nombre binaire signé. |
| << | Opérateur de décalage binaire à gauche. Décale tous les bits binaires d'un opérande vers la gauche d'un certain nombre de bits (les bits les plus à gauche sont supprimés, le côté droit est rempli de 0). | A << 2 donnera 240, soit 1111 0000 |
| >> | Opérateur de décalage binaire à droite. Décale tous les bits binaires d'un nombre vers la droite d'un certain nombre de bits. Les nombres positifs sont remplis de 0 à gauche, les nombres négatifs de 1 à gauche, et le côté droit est supprimé. | A >> 2 donnera 15, ce qui correspond à 0000 1111 |
Exemples
exampledb=# select 60 | 13;
?column?
----------
61
(1 row)
exampledb=# select 60 & 13;
?column?
----------
12
(1 row)
exampledb=# select (~60);
?column?
----------
-61
(1 row)
exampledb=# select (60 << 2);
?column?
----------
240
(1 row)
exampledb=# select (60 >> 2);
?column?
----------
15
(1 row)
exampledb=# select 60 # 13;
?column?
----------
49
(1 row) Autres extensions