PostgreSQL Operatoren

Ein Operator ist ein Symbol, das den Compiler anweist, bestimmte mathematische oder logische Operationen auszuführen.

PostgreSQL-Operatoren sind reservierte Schlüsselwörter oder Zeichen, die im Allgemeinen in WHERE-Anweisungen als Filterbedingungen verwendet werden.

Zu den üblichen Operatoren gehören:

  • Arithmetische Operatoren
  • Vergleichsoperatoren
  • Logische Operatoren
  • Bitweise Operatoren

Arithmetische Operatoren

Angenommen, Variable a ist 2 und Variable b ist 3, dann:

Operator Beschreibung Beispiel
+ hinzufügen Das Ergebnis von a + b ist 5
- subtrahieren Das Ergebnis von a - b ist -1
* multiply a * b Ergebnis ist 6
/ divide b / a Ergebnis ist 1
% Modulo (Rest) b % a Ergebnis ist 1
^ Potenzierung a ^ b Ergebnis ist 8
|/ Quadratwurzel |/ 25.0 Ergebnis ist 5
||/ Kubikwurzel ||/ 27.0 Ergebnis ist 3
! Fakultät 5 ! Ergebnis ist 120
!! Fakultät (Präfixoperator) !! 5 Ergebnis ist 120

Beispiele

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)

Vergleichsoperatoren

Angenommen, Variable a ist 10 und Variable b ist 20, dann:

Operator Beschreibung Beispiel
= Gleich (a = b) ist falsch.
!= Ungleich (a != b) ist wahr.
<> Ungleich (a <> b) ist wahr.
> Größer als (a > b) ist falsch.
< Kleiner als (a < b) ist wahr.
>= Größer als oder gleich (a >= b) ist falsch.
<= Kleiner als oder gleich (a <= b) ist wahr.

Beispiele

Erstellen Sie die COMPANY-Tabelle (Laden Sie die COMPANY-SQL-Datei herunter), der Dateninhalt lautet wie folgt:

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)

Daten lesen, bei denen das Feld SALARY größer als 50000 ist:

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)

Daten lesen, bei denen das Feld SALARY gleich 20000 ist:

exampledb=#  SELECT * FROM COMPANY WHERE SALARY = 20000;
 id | name  | age |  address    | salary
 ----+-------+-----+-------------+--------
   1 | Paul  |  32 | California  |  20000
   3 | Teddy |  23 | Norway      |  20000
(2 rows)

Daten lesen, bei denen das Feld SALARY ungleich 20000 ist:

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)

Daten lesen, bei denen das Feld SALARY größer oder gleich 65000 ist:

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)

Logische Operatoren

PostgreSQL hat die folgenden logischen Operatoren:

Nein. Operator & Beschreibung
1

AND

Logischer AND-Operator. Wenn beide Operanden ungleich null sind, ist die Bedingung wahr.

In PostgreSQL kann die WHERE-Anweisung AND verwenden, um mehrere Filterbedingungen einzubeziehen.

2

NICHT

Logischer NOT-Operator. Wird verwendet, um den logischen Zustand eines Operanden umzukehren. Wenn die Bedingung wahr ist, macht der logische NOT-Operator sie falsch.

PostgreSQL verfügt über Operatoren wie NOT EXISTS, NOT BETWEEN, NOT IN usw.
3

OR

Logischer OR-Operator. Wenn einer der beiden Operanden ungleich null ist, ist die Bedingung wahr.

In PostgreSQL kann die WHERE-Anweisung OR verwenden, um mehrere Filterbedingungen einzubeziehen.

SQL verwendet ein dreiwertiges Logiksystem mit true, false und null, wobei null für "unbekannt" steht.

aba AND ba OR b
WAHRWAHRWAHRWAHR
WAHRFALSEFALSEWAHR
WAHRNULLNULLWAHR
FALSEFALSEFALSEFALSE
FALSENULLFALSENULL
NULLNULLNULLNULL
aNICHT a
WAHRFALSE
FALSEWAHR
NULLNULL

Beispiele

Erstellen Sie die COMPANY-Tabelle (Laden Sie die COMPANY-SQL-Datei herunter), der Dateninhalt lautet wie folgt:

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)

Daten lesen, bei denen das Feld AGE größer oder gleich 25 ist AND das Feld SALARY größer oder gleich 6500 ist:

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)

Daten lesen, bei denen das Feld AGE größer oder gleich 25 ist OR das Feld SALARY größer als 6500 ist:

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)

Daten lesen, bei denen das Feld SALARY nicht NULL ist:

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)

Bitweise Operatoren

Bitweise Operatoren arbeiten mit Bits und führen Operationen Bit für Bit aus. Die Wahrheitstabellen für &, | und ^ sind wie folgt:

pqp & qp | q
0000
0101
1111
1001

Angenommen, A = 60 und B = 13, nun im Binärformat ausgedrückt, lauten sie wie folgt:

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

Die folgende Tabelle zeigt die von PostgreSQL unterstützten bitweisen Operatoren. Angenommen, VariableAhat den Wert 60 und VariableBhat den Wert 13, dann:

OperatorBeschreibungBeispiel
&

Bitweise UND-Operation, führt eine "UND"-Operation an binären Bits aus. Operationsregeln:

0&0=0;   
0&1=0;    
1&0=0;     
1&1=1;
(A & B) ergibt 12, was 0000 1100 entspricht
|

Bitweiser OR-Operator, führt eine "OR"-Operation an binären Bits aus. Operationsregeln:

0|0=0;   
0|1=1;   
1|0=1;    
1|1=1;
(A | B) ergibt 61, was 0011 1101 entspricht
#

XOR-Operator, führt eine "XOR"-Operation an binären Bits aus. Operationsregeln:

0#0=0;   
0#1=1;   
1#0=1;  
1#1=0;
(A # B) ergibt 49, was 0011 0001 entspricht
~

Bitweiser NOT-Operator, führt eine "NOT"-Operation an binären Bits aus. Operationsregeln:

~1=0;   
~0=1;
(~A) ergibt -61, was 1100 0011 ist, die Zweierkomplementdarstellung einer vorzeichenbehafteten Binärzahl.
<<Binärer Linksverschiebungsoperator. Verschiebt alle Binärbits eines Operanden um eine bestimmte Anzahl von Bits nach links (die am weitesten links stehenden Bits werden verworfen, die rechte Seite wird mit 0 aufgefüllt).A << 2 ergibt 240, was 1111 0000 entspricht
>>Binärer Rechtsverschiebungsoperator. Verschiebt alle Binärbits einer Zahl um eine bestimmte Anzahl von Bits nach rechts. Positive Zahlen werden links mit 0 aufgefüllt, negative Zahlen links mit 1, und die rechte Seite wird verworfen.A >> 2 ergibt 15, was 0000 1111 entspricht

Beispiele

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)
Andere Erweiterungen