English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

SQLite-Basis-Tutorial

SQLite-Advanced-Tutorial

SQLite-Programmierschnittstelle

SQLite-Operator

Was ist ein SQLite-Operator?

Ein Operator ist ein Reservwort oder ein Zeichen, das hauptsächlich in WHERE-Klauseln von SQLite-Anweisungen verwendet wird, um Operationen wie Vergleiche und Arithmetik auszuführen.

Operatoren werden verwendet, um Bedingungen in SQLite-Anweisungen zu spezifizieren und mehrere Bedingungen in einer Anweisung zu verbinden.

  • Arithmetische Operatoren

  • Vergleichsoperatoren

  • Logische Operatoren

  • Bit-Operatoren

SQLite-Arithmetische Operatoren

Annehmen Sie, dass die Variable a=10, Variable b=20, dann:

OperatorBeschreibungBeispiel
+Addition - Wert auf beiden Seiten des Operators addierena + b erhält 30
-Subtraktion - Der linke Operanden minus der rechte Operandena - b erhält -10
*Multiplikation - Wert auf beiden Seiten des Operators multiplizierena * b erhält 200
/Division - Der linke Operanden dividiert durch den rechten Operandenb / a erhält 2
%Modulo - Der Rest, der durch die Division des linken Operanden durch den rechten Operanden erhalten wirdb % a ergibt 0

Online-Beispiel

Hier ist ein einfaches Beispiel für SQLite-Arithmetische Operatoren:

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-Vergleichsoperator

Annehmen Sie, dass die Variable a=10, Variable b=20, dann:

OperatorBeschreibungBeispiel
==Überprüfen Sie den Wert der beiden Operanden, ob sie gleich sind, wenn ja, dann ist die Bedingung wahr.(a == b) ist nicht wahr.
=Überprüfen Sie den Wert der beiden Operanden, ob sie gleich sind, wenn ja, dann ist die Bedingung wahr.(a = b) ist nicht wahr.
!=Überprüfen Sie den Wert der beiden Operanden, ob sie gleich sind, wenn nicht, dann ist die Bedingung wahr.(a != b) ist wahr.
<>Überprüfen Sie den Wert der beiden Operanden, ob sie gleich sind, wenn nicht, dann ist die Bedingung wahr.(a <> b) ist wahr.
>Überprüfen Sie, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist, und wenn ja, ist die Bedingung wahr.(a > b) ist nicht wahr.
<Überprüfen Sie, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist, und wenn ja, ist die Bedingung wahr.(a < b) ist wahr.
>=Überprüfen Sie, ob der Wert des linken Operanden größer gleich dem Wert des rechten Operanden ist, und wenn ja, ist die Bedingung wahr.(a >= b) ist nicht wahr.
<=Überprüfen Sie, ob der Wert des linken Operanden kleiner gleich dem Wert des rechten Operanden ist, und wenn ja, ist die Bedingung wahr.(a <= b) ist wahr.
!<Überprüfen Sie, ob der Wert des linken Operanden nicht kleiner als der Wert des rechten Operanden ist, und wenn ja, ist die Bedingung wahr.(a !< b) ist falsch.
!>Überprüfen Sie, ob der Wert des linken Operanden nicht größer als der Wert des rechten Operanden ist, und wenn ja, ist die Bedingung wahr.(a !> b) ist wahr.

Online-Beispiel

假设 COMPANY 表有以下记录：

ID                           NAME                           AGE                                   ADDRESS                       SALARY
----------　　----------　　----------　　----------　　----------
1　　　　　　　　　　　Paul　　　　　　　　32　　　　　　　　　　Kalifornien　　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

Der folgende Beispiel zeigt die Verwendung verschiedener SQLite-Vergleichsoperatoren.

Hier verwenden wir WHERE Der WHERE-Teil, der in einem separaten Kapitel erläutert wird, sollte verstanden werden, dass der WHERE-Teil eine Bedingungssatz ist, der in einem SELECT-Ausdruck verwendet wird, um Bedingungen zu setzen.

Der folgende SELECT-Ausdruck listet SALARY größer 5000,00 aller Aufzeichnungen:

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

Der folgende SELECT-Ausdruck listet SALARY gleich 2000,00 aller Aufzeichnungen:

sqlite> SELECT　*　FROM COMPANY WHERE SALARY =　20000;
ID                           NAME                           AGE                                   ADDRESS                       SALARY
----------　　----------　　----------　　----------　　----------
1　　　　　　　　　　　Paul　　　　　　　　32　　　　　　　　　　Kalifornien　　20000.0
3　　　　　　　　　　　Teddy　　　　　　　23　　　　　　　　　　Norway　　　　　　20000.0

Der folgende SELECT-Ausdruck listet SALARY ungleich 2000,00 aller Aufzeichnungen:

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

Der folgende SELECT-Ausdruck listet SALARY ungleich 2000,00 aller Aufzeichnungen:

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

Der folgende SELECT-Ausdruck listet SALARY größer gleich 65000,00 aller Aufzeichnungen:

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

SQLite-Logische Betriebsoperator

Hier ist eine Liste aller logischen Betriebsoperators in SQLite.

OperatorBeschreibung
UNDDer AND-Betriebsoperator ermöglicht die Existenz mehrerer Bedingungen in einem WHERE-Teil eines SQL-Ausdrucks.
BETWEENDer BETWEEN-Betriebsoperator wird verwendet, um Werte in einer Reihe von Werten zwischen einem angegebenen Mindestwert und einem angegebenen Höchstwert zu suchen.
EXISTSDer EXISTS-Betriebsoperator wird verwendet, um die Existenz von Zeilen in einer bestimmten Tabelle unter bestimmten Bedingungen zu suchen.
INDer IN-Betriebsoperator wird verwendet, um einen Wert mit einer Reihe von angegebenen Listenwerten zu vergleichen.
NOT INDer Gegensatz zum IN-Betriebsoperator, der verwendet wird, um einen Wert mit einem Wert zu vergleichen, der nicht in einer Reihe von angegebenen Listenwerten enthalten ist.
LIKEDer LIKE-Betriebsoperator wird verwendet, um einen Wert mit einem ähnlichen Wert, der mit dem Wildcard-Betriebsoperator verglichen wird, zu vergleichen.
GLOBGLOB 运算符用于把某个值与使用通配符运算符的相似值进行比较。GLOB 与 LIKE 不同之处在于，它是大小写敏感的。
NOTNOT 运算符是所用的逻辑运算符的对立面。比如 NOT EXISTS、NOT BETWEEN、NOT IN，等等。它是否定运算符。
OROR 运算符用于结合一个 SQL 语句的 WHERE 子句中的多个条件。
IS NULLNULL 运算符用于把某个值与 NULL 值进行比较。
ISIS 运算符与 = 相似。
IS NOTIS NOT 运算符与 != 相似。
||连接两个不同的字符串，得到一个新的字符串。
UNIQUEUNIQUE 运算符搜索指定表中的每一行，确保唯一性（无重复）。

Online-Beispiel

假设 COMPANY 表有以下记录：

ID                           NAME                           AGE                                   ADDRESS                       SALARY
----------　　----------　　----------　　----------　　----------
1　　　　　　　　　　　Paul　　　　　　　　32　　　　　　　　　　Kalifornien　　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

下面的示例演示了 SQLite 逻辑运算符的用法。

下面的 SELECT 语句列出了 AGE 大于等于 25 且工资大于等于 65000.00 的所有记录：

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

下面的 SELECT 语句列出了 AGE 大于等于 25 或工资大于等于 65000.00 的所有记录：

sqlite> SELECT　*　FROM COMPANY WHERE AGE >=　25　OR SALARY >=　65000;
ID                           NAME                           AGE                                   ADDRESS                       SALARY
----------　　----------　　----------　　----------　　----------
1　　　　　　　　　　　Paul　　　　　　　　32　　　　　　　　　　Kalifornien　　20000.0
2　　　　　　　　　　　Allen　　　　　　　25　　　　　　　　　　Texas　　　　　　　15000.0
4　　　　　　　　　　　Mark　　　　　　　　25　　　　　　　　　　Rich-Mond　　　65000.0
5　　　　　　　　　　　David　　　　　　　27　　　　　　　　　　Texas　　　　　　　85000.0

下面的 SELECT 语句列出了 AGE 不为 NULL 的所有记录，结果显示所有的记录，意味着没有一个记录的 AGE 等于 NULL：

sqlite> SELECT　*　FROM COMPANY WHERE AGE IS NOT NULL;
ID                           NAME                           AGE                                   ADDRESS                       SALARY
----------　　----------　　----------　　----------　　----------
1　　　　　　　　　　　Paul　　　　　　　　32　　　　　　　　　　Kalifornien　　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

下面的 SELECT 语句列出了 NAME 以 'Ki' 开始的所有记录，'Ki' 之后的字符不做限制：

sqlite> SELECT　*　FROM COMPANY WHERE NAME LIKE 'Ki%';
ID                           NAME                           AGE                                   ADDRESS                       SALARY
----------　　----------　　----------　　----------　　----------
6　　　　　　　　　　　Kim　　　　　　　　　22　　　　　　　　　　South-Hall　　45000.0

下面的 SELECT 语句列出了 NAME 以 'Ki' 开始的所有记录，'Ki' 之后的字符不做限制：

sqlite> SELECT　*　FROM COMPANY WHERE NAME GLOB 'Ki'*;
ID                           NAME                           AGE                                   ADDRESS                       SALARY
----------　　----------　　----------　　----------　　----------
6　　　　　　　　　　　Kim　　　　　　　　　22　　　　　　　　　　South-Hall　　45000.0

下面的 SELECT 语句列出了 AGE 的值为 25 或 27 的所有记录：

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

下面的 SELECT 语句列出了 AGE 的值既不是 25 也不是 27 的所有记录：

sqlite> SELECT　*　FROM COMPANY WHERE AGE NOT IN (　25,　27　);
ID                           NAME                           AGE                                   ADDRESS                       SALARY
----------　　----------　　----------　　----------　　----------
1　　　　　　　　　　　Paul　　　　　　　　32　　　　　　　　　　Kalifornien　　20000.0
3　　　　　　　　　　　Teddy　　　　　　　23　　　　　　　　　　Norway　　　　　　20000.0
6　　　　　　　　　　　Kim　　　　　　　　　22　　　　　　　　　　South-Hall　　45000.0
7　　　　　　　　　　　James　　　　　　　24　　　　　　　　　　Houston　　　　　10000.0

下面的 SELECT 语句列出了 AGE 的值在 25 与 27 之间的所有记录：

sqlite> SELECT　*　FROM COMPANY WHERE AGE BETWEEN　25　UND　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 nachstehende SELECT-Anweisung verwendet eine SQL-Subanfrage, die SALARY > 65000 der alle Aufzeichnungen mit dem Feld AGE, die nachfolgende WHERE-Klausel wird zusammen mit dem EXISTS-Operator verwendet, um alle Aufzeichnungen anzuzeigen, bei denen das AGE im externen Abfrageergebnis im Ergebnis der Subanfrage existiert:

sqlite> SELECT AGE FROM COMPANY　
　　　　　　　　WHERE EXISTS (SELECT AGE FROM COMPANY WHERE SALARY >　65000);
AGE
----------
32
25
23
25
27
22
24

Die nachstehende SELECT-Anweisung verwendet eine SQL-Subanfrage, die SALARY > 65000 der alle Aufzeichnungen mit dem Feld AGE, die nachfolgende WHERE-Klausel wird zusammen mit dem >-Operator verwendet, um alle Aufzeichnungen anzuzeigen, bei denen das AGE im externen Abfrageergebnis größer als das Ergebnis des Subqueries ist:

sqlite> SELECT　*　FROM COMPANY　
　　　　　　　　WHERE AGE > (SELECT AGE FROM COMPANY WHERE SALARY >　65000);
ID                           NAME                           AGE                                   ADDRESS                       SALARY
----------　　----------　　----------　　----------　　----------
1　　　　　　　　　　　Paul　　　　　　　　32　　　　　　　　　　Kalifornien　　20000.0

SQLite Bit-Operatoren

Bit-Operatoren wirken auf Bits und führen die Operationen bitweise aus. Die Wahrheitstabelle & und | sind wie folgt:

pqp & qp | q
0000
0101
1111
1001

Angenommen, wenn A = 60, und B = 13, jetzt in binärem Format, siehe unten:

A = 0011 1100

B = 0000 1101

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

A&B = 0000 1100

A|B = 0011 1101

~A = 1100 0011

Die nachstehende Tabelle zeigt die bitweisen Operatoren, die von SQLite unterstützt werden. Angenommen, Variable A=60, Variable B=13, dann:

OperatorBeschreibungBeispiel
&Wenn ein Bit gleichzeitig in beiden Operanden existiert, kopiert der binäre AND-Operator ein Bit in das Ergebnis.(A & B) wird 12，daher 0000 1100
|Wenn ein Bit in irgendeinem Operanden existiert, kopiert der binäre OR-Operator ein Bit in das Ergebnis.(A | B) wird 61, entspricht 0011 1101
~Der binärische Komplement-Operator ist ein einwertiger Operator mit dem "Verkehrten" Effekt, d.h. 0 wird1,1in 0 umgewandelt.(~A) wird -61, entspricht 1100 0011, die Komplementform einer signierten binären Zahl ist.
<<Der binärische Linksverschiebe-Operator. Der Wert des linken Operanden wird um die Anzahl der Stellen links verschoben, die der rechte Operand angegeben hat.A << 2 wird erhalten 240, entspricht 1111 0000
>>binärer rechter Schiebeoperator. Der Wert des linken Operanden wird um die Anzahl der Stellen des rechten Operanden nach rechts verschoben.A >> 2 wird erhalten 15，daher 0000 1111

Online-Beispiel

Der folgende Beispiel zeigt die Verwendung der SQLite Bit-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)　=　15
SQLite AusdrückeSQLite SELECT Abfrage