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

aba ET ba OR b
VRAIVRAIVRAIVRAI
VRAIFALSEFALSEVRAI
VRAINULLNULLVRAI
FALSEFALSEFALSEFALSE
FALSENULLFALSENULL
NULLNULLNULLNULL
aNON a
VRAIFALSE
FALSEVRAI
NULLNULL

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 :

pqp & qp | q
0000
0101
1111
1001

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 :

OperatorDescriptionExemple
&

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