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.
a | b | a AND b | a OR b |
|---|---|---|---|
| WAHR | WAHR | WAHR | WAHR |
| WAHR | FALSE | FALSE | WAHR |
| WAHR | NULL | NULL | WAHR |
| FALSE | FALSE | FALSE | FALSE |
| FALSE | NULL | FALSE | NULL |
| NULL | NULL | NULL | NULL |
a | NICHT a |
|---|---|
| WAHR | FALSE |
| FALSE | WAHR |
| NULL | NULL |
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:
| p | q | p & q | p | q |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 |
| 1 | 1 | 1 | 1 |
| 1 | 0 | 0 | 1 |
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:
| Operator | Beschreibung | Beispiel |
|---|---|---|
| & | 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