SQLite Operatoren
Was ist ein SQLite-Operator?
Ein Operator ist ein reserviertes Wort oder Zeichen, das hauptsächlich in der WHERE-Klausel einer SQLite-Anweisung verwendet wird, um Operationen wie Vergleiche und arithmetische Operationen auszuführen.
Operatoren werden verwendet, um Bedingungen in einer SQLite-Anweisung anzugeben und mehrere Bedingungen in der Anweisung zu kombinieren.
Arithmetische Operatoren
Vergleichsoperatoren
Logische Operatoren
Bitweise Operatoren
SQLite-Arithmetikoperatoren
Angenommen, Variable a=10 und Variable b=20, dann:
| Operator | Beschreibung | Beispiel |
|---|---|---|
| + | Addition - Addiert Werte auf beiden Seiten des Operators | a + b ergibt 30 |
| - | Subtraktion - Subtrahiert den rechten Operanden vom linken Operanden | a - b ergibt -10 |
| * | Multiplikation - Multipliziert Werte auf beiden Seiten des Operators | a * b ergibt 200 |
| / | Division - Dividiert den linken Operanden durch den rechten Operanden | b / a ergibt 2 |
| % | Modulo - Gibt den Rest nach Division des linken Operanden durch den rechten Operanden | b % a ergibt 0 |
Beispiele
Das folgende ist ein einfaches Beispiel für arithmetische Operatoren in SQLite:
sqlite> .mode line sqlite> select 10 + 20; 10 + 20 = 30 sqlite> select 10 - 20; 10 - 20 = -10 sqlite> select 10 * 20; 10 * 20 = 200 sqlite> select 10 / 5; 10 / 5 = 2 sqlite> select 12 % 5; 12 % 5 = 2
SQLite-Vergleichsoperatoren
Angenommen, Variable a=10 und Variable b=20, dann:
| Operator | Beschreibung | Beispiel |
|---|---|---|
| == | Prüft, ob die Werte zweier Operanden gleich sind; wenn ja, wird die Bedingung wahr. | (a == b) ist nicht wahr. |
| = | Prüft, ob die Werte zweier Operanden gleich sind; wenn ja, wird die Bedingung wahr. | (a = b) ist nicht wahr. |
| != | Prüft, ob die Werte zweier Operanden gleich sind; wenn nicht, wird die Bedingung wahr. | (a != b) ist wahr. |
| <> | Prüft, ob die Werte zweier Operanden gleich sind; wenn nicht, wird die Bedingung wahr. | (a <> b) ist wahr. |
| > | Prüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist; wenn ja, wird die Bedingung wahr. | (a > b) ist nicht wahr. |
| < | Prüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist; wenn ja, wird die Bedingung wahr. | (a < b) ist wahr. |
| >= | Prüft, ob der Wert des linken Operanden größer als oder gleich dem Wert des rechten Operanden ist; wenn ja, wird die Bedingung wahr. | (a >= b) ist nicht wahr. |
| <= | Prüft, ob der Wert des linken Operanden kleiner als oder gleich dem Wert des rechten Operanden ist; wenn ja, wird die Bedingung wahr. | (a <= b) ist wahr. |
| !< | Prüft, ob der Wert des linken Operanden nicht kleiner als der Wert des rechten Operanden ist; wenn ja, wird die Bedingung wahr. | (a !< b) ist falsch. |
| !> | Prüft, ob der Wert des linken Operanden nicht größer als der Wert des rechten Operanden ist; wenn ja, wird die Bedingung wahr. | (a !> b) ist wahr. |
Beispiele
Angenommen, die COMPANY-Tabelle enthält die folgenden Datensätze:
ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 1 Paul 32 California 20000.0 2 Allen 25 Texas 15000.0 3 Teddy 23 Norway 20000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0 6 Kim 22 South-Hall 45000.0 7 James 24 Houston 10000.0
Die folgenden Beispiele demonstrieren die Verwendung verschiedener SQLite-Vergleichsoperatoren.
Hier verwenden wir dieWHERE -Klausel, die später in einem separaten Kapitel erklärt wird, aber vorerst müssen Sie verstehen, dass die WHERE-Klausel verwendet wird, um Bedingungen in einer SELECT-Anweisung festzulegen.
Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen SALARY größer als 50,000.00 ist:
sqlite> SELECT * FROM COMPANY WHERE SALARY > 50000; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0
Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen SALARY gleich 20,000.00 ist:
sqlite> SELECT * FROM COMPANY WHERE SALARY = 20000; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 1 Paul 32 California 20000.0 3 Teddy 23 Norway 20000.0
Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen SALARY nicht gleich 20,000.00 ist:
sqlite> SELECT * FROM COMPANY WHERE SALARY != 20000; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 2 Allen 25 Texas 15000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0 6 Kim 22 South-Hall 45000.0 7 James 24 Houston 10000.0
Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen SALARY nicht gleich 20,000.00 ist:
sqlite> SELECT * FROM COMPANY WHERE SALARY <> 20000; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 2 Allen 25 Texas 15000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0 6 Kim 22 South-Hall 45000.0 7 James 24 Houston 10000.0
Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen SALARY größer als oder gleich 65,000.00 ist:
sqlite> SELECT * FROM COMPANY WHERE SALARY >= 65000; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0
Logische Operatoren in SQLite
Im Folgenden finden Sie eine Liste aller logischen Operatoren in SQLite.
| Operator | Beschreibung |
|---|---|
| AND | Der AND-Operator ermöglicht das Vorhandensein mehrerer Bedingungen in der WHERE-Klausel einer SQL-Anweisung. |
| ZWISCHEN | Der BETWEEN-Operator wird verwendet, um Werte innerhalb eines Wertebereichs zu suchen, wobei ein Minimalwert und ein Maximalwert angegeben werden. |
| EXISTS | Der EXISTS-Operator wird verwendet, um nach der Existenz einer Zeile in einer angegebenen Tabelle zu suchen, die bestimmte Kriterien erfüllt. |
| IN | Der IN-Operator wird verwendet, um einen Wert mit einer Liste angegebener Werte zu vergleichen. |
| NOT IN | Das Gegenteil des IN-Operators; es wird verwendet, um einen Wert mit Werten zu vergleichen, die nicht in einer angegebenen Liste enthalten sind. |
| LIKE | Der LIKE-Operator wird verwendet, um einen Wert mithilfe von Wildcard-Operatoren mit ähnlichen Werten zu vergleichen. |
| GLOB | Der GLOB-Operator wird verwendet, um einen Wert mithilfe von Wildcard-Operatoren mit ähnlichen Werten zu vergleichen. GLOB unterscheidet sich von LIKE dadurch, dass es zwischen Groß- und Kleinschreibung unterscheidet. |
| NICHT | Der NOT-Operator ist das Gegenteil des verwendeten logischen Operators. Zum Beispiel NOT EXISTS, NOT BETWEEN, NOT IN usw.Er ist ein negierender Operator. |
| OR | Der OR-Operator wird verwendet, um mehrere Bedingungen in der WHERE-Klausel einer SQL-Anweisung zu kombinieren. |
| IS NULL | Der NULL-Operator wird verwendet, um einen Wert mit einem NULL-Wert zu vergleichen. |
| IS | Der IS-Operator ist ähnlich wie =. |
| IS NOT | Der IS NOT-Operator ist vergleichbar mit !=. |
| || | Verkettet zwei verschiedene Zeichenketten zu einer neuen Zeichenkette. |
| UNIQUE | Der UNIQUE-Operator durchsucht jede Zeile einer angegebenen Tabelle, um Eindeutigkeit sicherzustellen (keine Duplikate). |
Beispiele
Angenommen, die COMPANY-Tabelle enthält die folgenden Datensätze:
ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 1 Paul 32 California 20000.0 2 Allen 25 Texas 15000.0 3 Teddy 23 Norway 20000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0 6 Kim 22 South-Hall 45000.0 7 James 24 Houston 10000.0
Die folgenden Beispiele demonstrieren die Verwendung der logischen Operatoren von SQLite.
Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen AGE größer oder gleich 25undund SALARY größer oder gleich 65000.00 ist:
sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0
Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen AGE größer oder gleich 25oderund SALARY größer oder gleich 65000.00 ist:
sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 1 Paul 32 California 20000.0 2 Allen 25 Texas 15000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0
Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen AGE nicht NULL ist; das Ergebnis zeigt alle Datensätze, was bedeutet, dass kein Datensatz ein AGE gleich NULL hat:
sqlite> SELECT * FROM COMPANY WHERE AGE IS NOT NULL; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 1 Paul 32 California 20000.0 2 Allen 25 Texas 15000.0 3 Teddy 23 Norway 20000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0 6 Kim 22 South-Hall 45000.0 7 James 24 Houston 10000.0
Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen NAME mit 'Ki' beginnt, ohne Einschränkung der Zeichen nach 'Ki':
sqlite> SELECT * FROM COMPANY WHERE NAME LIKE 'Ki%'; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 6 Kim 22 South-Hall 45000.0
Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen NAME mit 'Ki' beginnt, ohne Einschränkung der Zeichen nach 'Ki':
sqlite> SELECT * FROM COMPANY WHERE NAME GLOB 'Ki*'; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 6 Kim 22 South-Hall 45000.0
Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen AGE 25 oder 27 ist:
sqlite> SELECT * FROM COMPANY WHERE AGE IN ( 25, 27 ); ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 2 Allen 25 Texas 15000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0
Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen AGE weder 25 noch 27 ist:
sqlite> SELECT * FROM COMPANY WHERE AGE NOT IN ( 25, 27 ); ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 1 Paul 32 California 20000.0 3 Teddy 23 Norway 20000.0 6 Kim 22 South-Hall 45000.0 7 James 24 Houston 10000.0
Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen AGE zwischen 25 und 27 liegt:
sqlite> SELECT * FROM COMPANY WHERE AGE BETWEEN 25 AND 27; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 2 Allen 25 Texas 15000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0
Die folgende SELECT-Anweisung verwendet eine SQL-Unterabfrage, die alle Datensätze mit AGE-Feldern findet, bei denen SALARY > 65000 ist. Die anschließende WHERE-Klausel, die mit dem EXISTS-Operator verwendet wird, listet alle Datensätze in der äußeren Abfrage auf, bei denen AGE in den von der Unterabfrage zurückgegebenen Ergebnissen vorkommt:
sqlite> SELECT AGE FROM COMPANY
WHERE EXISTS (SELECT AGE FROM COMPANY WHERE SALARY > 65000);
AGE
----------
32
25
23
25
27
22
24
Die folgende SELECT-Anweisung verwendet eine SQL-Unterabfrage, die alle Datensätze mit AGE-Feldern findet, bei denen SALARY > 65000 ist. Die anschließende WHERE-Klausel, die mit dem >-Operator verwendet wird, listet alle Datensätze in der äußeren Abfrage auf, bei denen AGE größer als die AGE-Werte in den von der Unterabfrage zurückgegebenen Ergebnissen ist:
sqlite> SELECT * FROM COMPANY
WHERE AGE > (SELECT AGE FROM COMPANY WHERE SALARY > 65000);
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
Bitweise Operatoren in SQLite
Bitweise Operatoren wirken auf 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, im Binärformat sind sie wie folgt:
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
~A = 1100 0011
Die folgende Tabelle listet die von der SQLite-Sprache unterstützten bitweisen Operatoren auf. Angenommen, Variable A=60 und Variable B=13, dann:
| Operator | Beschreibung | Beispiel |
|---|---|---|
| & | Der binäre AND-Operator kopiert ein Bit in das Ergebnis, wenn es in beiden Operanden vorhanden ist. | (A & B) ergibt 12, was 0000 1100 ist |
| | | Der binäre OR-Operator kopiert ein Bit in das Ergebnis, wenn es in einem der beiden Operanden vorhanden ist. | (A | B) ergibt 61, was 0011 1101 ist |
| ~ | Der binäre Komplement-Operator ist ein unärer Operator, der die Wirkung hat, Bits zu "kippen", d. h., 0 wird zu 1 und 1 wird zu 0. | (~A ) ergibt -61, was 1100 0011 ist, die Zweierkomplementform einer vorzeichenbehafteten Binärzahl. |
| << | Binärer Linksverschiebungsoperator. Der Wert des linken Operanden wird um die Anzahl der vom rechten Operanden angegebenen Bits nach links verschoben. | A << 2 ergibt 240, was 1111 0000 ist |
| >> | Binärer Rechtsverschiebeoperator. Der Wert des linken Operanden wird um die Anzahl der durch den rechten Operanden angegebenen Bits nach rechts verschoben. | A >> 2 ergibt 15, was 0000 1111 ist |
Beispiele
Das folgende Beispiel demonstriert die Verwendung von SQLite-Bitwise-Operatoren:
sqlite> .mode line sqlite> select 60 | 13; 60 | 13 = 61 sqlite> select 60 & 13; 60 & 13 = 12 sqlite> select (~60); (~60) = -61 sqlite> select (60 << 2); (60 << 2) = 240 sqlite> select (60 >> 2); (60 >> 2) = 15Andere Erweiterungen