Wenn Sie mit relationalen Datenbanksystemen gearbeitet haben, haben Sie wahrscheinlich schon von populären Datenbanksystemen wie MySQL, SQL Server oder PostgreSQL gehört. SQLite ist ein weiteres äußerst nützliches RDBMS, das sehr einfach einzurichten und zu bedienen ist. Außerdem hat es viele unterschiedliche Merkmale gegenüber anderen relationalen Datenbanken. Dieses SQLite-Lernprogramm vermittelt grundlegende Konzepte, die Sie kennen müssen, mit Hilfe umfangreicher praktischer Übungen.
Die in diesem Artikel behandelten Themen sind:
- Was ist SQLite?
- Funktionen von SQLite
- Installieren von SQLite unter Windows
- SQLite-Befehle
- Datenbankbefehle
- Tabellenbefehle
- CRUD-Operationen
- SQLite-Klauseln/Bedingungen
- Joins in SQLite
- Nachteile von SQLite
SQLite-Tutorial:Was ist SQLite?
Hier ist die branchenübliche Definition von SQLite:
SQLite ist eine Open-Source-, konfigurationsfreie, eigenständige, transaktionsrelationale Datenbank-Engine, die für die Einbettung in eine Anwendung entwickelt wurde.
Sie können SQLite in Betracht ziehen als „Feuerzeug ” Version anderer komplexer RDBMS (Oracle, SQL usw.), deren Datenbank-Engine für unabhängige Verarbeitung (In-Process-Bibliothek) konfiguriert ist d. h. ein serverloser, eigenständiger, konfigurationsfreier und transaktionaler . Es ist bekannt für seine Portabilität, Zuverlässigkeit und starke Leistung selbst in Umgebungen mit wenig Arbeitsspeicher. Außerdem ist SQLite eine beliebte Wahl als eingebettete Datenbank für die lokale/Client-Speicherung in Endprogrammen oder Anwendungen, im Gegensatz zu anderen RDBMS, bei denen die Client-Server-DB-Engine konfiguriert ist.
Funktionen von SQLite
SQLite bietet viele unterschiedliche Funktionen wie:
- Serverlos: Die meisten SQL-Datenbanken sind als separate Serverprozesse implementiert, aber SQLite hat keinen separaten Serverprozess. Es ist eine serverlose Datenbank-Engine. Es liest und schreibt direkt in gewöhnliche Festplattendateien.
- Zero-Configuration: Es erfordert keine Konfiguration, um es zum Laufen zu bringen. Das bedeutet, dass kein Serverprozess wie in einem Client/Server-System gestartet, gestoppt oder konfiguriert werden muss.
- Manifesttypisierung: SQLite verwendet die Manifesttypisierung, die das Speichern einer beliebigen Menge eines beliebigen Datentyps in einer beliebigen Spalte ermöglicht, unabhängig vom deklarierten Datentyp der Spalte. Beachten Sie, dass es bestimmte Ausnahmen von dieser Regel gibt.
- Leicht: Wie der Name schon sagt, ist die SQLite-Bibliothek sehr leichtgewichtig. Obwohl der verwendete Speicherplatz je nach System, auf dem es installiert ist, unterschiedlich ist, kann es weniger als 600 KB Speicherplatz beanspruchen.
- Portabel: Im Gegensatz zu anderen DBMS wird eine gesamte SQLite-Datenbank in einer einzigen Datei gespeichert. Diese Datei kann sehr einfach über Wechselmedien oder das Dateiübertragungsprotokoll geteilt werden.
- Verschiedene Auswahlmöglichkeiten: Viele Programmiersprachen bieten Bindungen für SQLite, darunter C, C++, C#, Java, JavaScript, Ruby, Python und viele mehr.
- Kostenlos: SQLite ist kostenlos und Open Source. Um mit SQLite zu arbeiten, ist keine kommerzielle Lizenz erforderlich.
Wie oben erwähnt, ist SQLite für seine Nullkonfiguration bekannt, was bedeutet, dass keine komplexe Einrichtung oder Verwaltung wirklich erforderlich ist. Im nächsten Teil dieses SQLite-Tutorials sehen wir uns an, wie Sie SQLite auf Ihrem System installieren.
SQLite-Tutorial:Installieren von SQLite unter Windows
Die folgenden Schritte sind:
Schritt 1: Gehen Sie zur offiziellen SQLite-Website und klicken Sie auf den entsprechenden Link, um vorkompilierte Binärdateien herunterzuladen.
Schritt 2: Laden Sie die SQLite-Befehlszeilen-ZIP-Datei herunter (hier:sqlite-tools-win32-x86-3270200.zip) und entpacken Sie diese Dateien in einem Ordner Ihrer Wahl.
Dieses SQLite-Befehlszeilentool enthält die folgenden SQLite-Produkte
- SQLite-Kern :Der SQLite-Kern enthält die eigentliche Datenbank-Engine und die öffentliche API.
- SQLite3-Befehlszeilentool :Die sqlite3-Anwendung ist ein Befehlszeilentool, das auf dem SQLite-Kern aufbaut.
- Tcl-Erweiterung :Diese Bibliothek ist im Wesentlichen eine Kopie des SQLite-Kerns mit angehängten Tcl-Bindungen.
- SQLite-Analysetool :Das Analysetool SQLite wird zur Analyse von Datenbankdateien verwendet.
Schritt 3: Danach ist das Starten der SQLite-Befehlszeile so einfach wie das Klicken auf die sqlite3-Anwendung, wodurch die Befehlszeile eingeblendet wird.
Wenn Sie weiter testen möchten, geben Sie einfach .help ein Befehl von sqlite> Eingabeaufforderung, um alle verfügbaren Befehle in sqlite3 anzuzeigen wie unten gezeigt.
Hinweis: Standardmäßig verwendet eine SQLite-Sitzung die In-Memory-Datenbank, daher werden alle Änderungen gelöscht, wenn die Sitzung beendet wird.
Einfach genug, oder? Beginnen wir dann mit SQLite-Befehlen.
SQLite-Tutorial:SQLite-Befehle
Dieser Abschnitt des SQLite-Lernprogramms stellt grundlegende SQL-Anweisungen vor, die Sie mit SQLite verwenden können.
Hinweis: SQLite-Befehle enden mit einem Semikolon (; ). Es teilt SQLite mit, dass Ihr Befehl abgeschlossen ist und ausgeführt werden sollte. Sie können Ihren Befehl auch über mehrere Zeilen verteilen und das Semikolon in der letzten Zeile verwenden.
Datenbankbefehle
Dieser Abschnitt besteht aus den Befehlen, mit denen Sie mit Ihrer Datenbank umgehen können. Die Befehle sind:
- SQLite-Datenbank erstellen
SQLite verwendet nicht die CREATE DATABASE-Anweisung wie in anderen relationalen Datenbankverwaltungssystemen wie MySQL, SQL Server usw. Um eine neue Datenbank in SQLite zu erstellen, geben Sie einfach sqlite3 gefolgt von ein nach dem Namen der Datei, die Sie für die Datenbank verwenden möchten. Der folgende Code erstellt eine Datenbankdatei namens StudentDetails.db:
Beispiel
sqlite3 StudentDetails.db; sqlite> .databases main: D:sqliteStudentDetails.db;
- SQLite Attach Database
Wenn Sie mehrere Datenbanken haben, können Sie jeweils nur eine verwenden. In SQLite wird die Anweisung ATTACH DATABASE verwendet, um eine bestimmte Datenbank für die aktuelle Verbindung anzuhängen. Nach diesem Befehl werden alle SQLite-Anweisungen unter der angehängten Datenbank ausgeführt.
Beispiel
sqlite> ATTACH DATABASE 'DepartmentDetails.db' AS 'Department'; sqlite> .databases main: D:sqliteStudentDetails.db; Department: D:sqliteDepartmentDetails.db
- SQLite-Datenbank trennen
In SQLite wird die DETACH DATABASE-Anweisung verwendet, um die Datenbank mit dem Aliasnamen von einer Datenbankverbindung zu trennen, die zuvor mit der ATTACH-Anweisung verbunden wurde. Wenn dieselbe Datenbankdatei mit mehreren Aliasen angehängt wurde, trennt dieser Befehl nur den angegebenen Namen und der Rest des Anhangs bleibt bestehen. Die Datenbanken innerhalb der In-Memory- oder temporären Datenbank werden vollständig zerstört und der Inhalt geht verloren.
Beispiel
sqlite> .databases main: D:sqliteStudentDetails.db; Department: D:sqliteDepartmentDetails.db Student: D:sqliteStudentDetails.db DeptInformation: D:sqliteDepartmentDetails.db sqlite> DETACH DATABASE 'Department'; sqlite> .databases main: D:sqliteStudentDetails.db; Student: D:sqliteStudentDetails.db DeptInformation: D:sqliteDepartmentDetails.db
Tabellenbefehle
Hier lernen wir den Umgang mit Tabellen bei der Verwendung von SQLite.
- SQL-Tabelle erstellen
In SQLite wird die CREATE TABLE-Anweisung verwendet, um eine neue Tabelle zu erstellen. Beim Erstellen der Tabelle müssen Sie der Tabelle einen Namen geben und ihre Spalte und Datentypen jeder Spalte definieren.
Syntax:
CREATE TABLE table_name( Column1 column_type [constraints] Column2 column_type [constraints] [.....] );
Beispiel
CREATE TABLE StudentInfo( ID INT PRIMARY KEY NOT NULL, NAME TEXT NOT NULL, AGE INT NOT NULL, ADDRESS CHAR(50), DEPARTMENTID INTEGER NOT NULL, PHONE TEXT DEFAULT 'UNKNOWN', FOREIGN KEY(DEPARTMENTID) REFERENCES DepartmentInfo(DeptID) );
Sie können überprüfen, ob die Tabelle erstellt wurde oder nicht, indem Sie die .tables verwenden Befehl wie unten gezeigt. Beachten Sie, dass ich bereits eine Tabelle namens DepartmentInfo erstellt habe wobei DeptID der Primärschlüssel ist. Die Tabelle „Departments“ hat eine Fremdschlüsseleinschränkung für die Tabelle „Students“.
sqlite> .tables StudentInfo Contacts Emp_Master
- SQLite-Drop-Tabelle
In SQLite können Sie mit der DROP TABLE-Anweisung eine Tabelle aus der SQLite-Datenbank entfernen oder löschen. Sobald die Tabelle gelöscht wird, werden alle darin enthaltenen Daten dauerhaft aus der Datenbank entfernt. Alle zugehörigen Indizes und Trigger werden ebenfalls entfernt. Wenn für diese Tabelle eine Fremdschlüsseleinschränkung aktiviert ist, wird dies für jede Zeile in der Tabelle entsprechend entfernt, und alle mit der Tabelle verknüpften Trigger werden ebenfalls gelöscht.
Syntax
DROP TABLE [ IF EXISTS ] table_name;
Beispiel
DROP TABLE Department; Error: no such table: Department DROP TABLE Company; sqlite> .tables StudentInfo
Hinweis: IF EXISTS ist eine optionale Klausel. Falls angegeben, löst die DROP TABLE-Anweisung keinen Fehler aus, wenn eine der Tabellen nicht existiert.
Außerdem gibt es eine SQLite Alter Table-Anweisung , die wir in den nächsten Abschnitten dieses Artikels verstehen werden. Nachdem wir nun eine Tabelle erstellt haben, sehen wir uns an, wie die Daten eingefügt, gelöscht und geändert werden.
SQLite-Tutorial:CRUD-Operationen
- SQLite-Abfrage einfügen
Nach dem Erstellen der Tabelle kann der SQLite-Einfügen-Befehl verwendet werden, um neue Zeilen in der angegebenen Tabelle zu erstellen. Es gibt zwei sinnvolle Formen der SQLite-Insert-Anweisung. Die erste Form verwendet eine VALUES-Klausel, um eine Liste mit einzufügenden Werten anzugeben.
Syntax
INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)] VALUES (value1, value2, value3,...valueN);
Beispiel
INSERT INTO StudentInfo ( ID, NAME, AGE, ADDRESS, DEPARTMENTID, PHONE) VALUES (1,'Dean', 20, 'California', 2, '934*******');
Ausgabe
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934*******
Hier wird eine einzelne neue Zeile erstellt und jeder Wert in seiner entsprechenden Spalte aufgezeichnet. Beachten Sie, dass beide Listen dasselbe haben müssen Anzahl der Teile. Hier die Liste der Spalten es ist optional. Wir können auch Daten in die Tabelle einfügen ohne die Liste der Spalten anzugeben .
Beispiel
INSERT INTO StudentInfo VALUES ( 2, 'SAM', 22, 'Texas', 2, '976*******');
Ausgabe
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 2 976*******
SQLite bietet auch eine Funktion zumEinfügen mehrerer Zeilen in einer einzigen INSERT-Anweisung. Die Syntax ist wie unten gezeigt.
Beispiel
INSERT INTO StudentInfo VALUES (3,'John',23,'Norway',1,'923*******'), (4,'Mitch',22,'Houston',3,'934*******');
Ausgabe
Select *from StudentInfo; 1|Dean|20|California|2|934******* 2|SAM|22|Texas|2|976******* 3|John|23|Norway|1|923******* 4|Mitch|22|Houston|3|934*******
Wie Sie sehen können, ist das Format der Ausgabe dem vorherigen nicht ganz ähnlich. Wie ändern Sie also das Ausgabeformat in SQLite? Lassen Sie uns die Ausgabe so formatieren, dass unsere Ergebnisse etwas besser lesbar sind.
- Formatieren
Sie können .mode verwenden, um den Ausgabemodus zu ändern. Das obige Beispiel verwendet .mode list, die die Ergebnisse als Liste anzeigt. Sie können auch .headers verwenden -Anweisung, um anzugeben, ob Spaltenüberschriften angezeigt werden sollen oder nicht. Nachdem Sie die Änderungen vorgenommen haben, können Sie die Einstellung mit .show anzeigen Befehl.
Beispiel
sqlite>.mode 'column' sqlite> .headers on sqlite> .show echo: off eqp: off explain: auto headers: on mode: column nullvalue: "" output: stdout colseparator: "|" rowseparator: "n" stats: off width: filename: StudentDetails.db
Ausgabe
SELECT *FROM StudentInfo; ID NAME AGE ADDRESS DEPARTMENT PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 2 976******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934*******
- SQLite-Auswahlabfrage
In SQLite wird die Select-Anweisung verwendet, um Daten aus einer Tabelle zu holen, die Daten in Form einer Ergebnistabelle zurückgibt. Diese Ergebnistabellen werden auch Ergebnismengen genannt. Mit der SQLite-Select-Anweisung können wir einfache Berechnungen oder mehrere Ausdrücke basierend auf unseren Anforderungen durchführen. Wir haben bereits früher beim Einfügen von Daten eine SELECT-Anweisung verwendet.
Syntax
SELECT [ALL | DISTINCT] result [FROM table-list] [WHERE expr]
- DISTINCT – Wenn wir das Schlüsselwort „distinct“ in einer select-Anweisung verwenden, werden nur unterschiedliche Datenzeilen zurückgegeben.
- ALLE – Wenn wir das Schlüsselwort ALL in einer Select-Anweisung verwenden, werden alle Datenzeilen zurückgegeben, auch wenn sie dupliziert sind.
- VON Tabellenliste – Es ist eine Liste von Tabellen, aus denen Sie Daten erhalten möchten.
- WHERE-Ausdruck – Der WHERE-Ausdruck wird verwendet, um unsere benutzerdefinierten Bedingungen zu definieren, um die erforderlichen Daten aus Tabellen zu erhalten.
Beispiel1
SELECT ID, NAME FROM StudentInfo WHERE AGE < 21;
Ausgabe
ID NAME ---------- ---------- 1 Dean
Beispiel2
Select NAME FROM StudentInfo WHERE DEPARTMENTID = (SELECT DeptID FROM DepartmentInfo WHERE DeptName = 'Psychology');
Ausgabe
//fetches people from department whose id is 2 NAME ---------- Dean SAM
- SQLite-Aktualisierungsabfrage
In SQLite kann die UPDATE-Anweisung verwendet werden, um die bestehenden Datensätze in einer Tabelle zu ändern. Die WHERE-Klausel von SQLite kann verwendet werden, um genau anzugeben, welche Zeilen aktualisiert werden sollen. Abhängig von den Filterbedingungen, die von der WHERE-Klausel angewendet werden, können Sie problemlos alle Zeilen, einige Zeilen oder keine aktualisieren.
Syntax
UPDATE table_name SET column1 = value1, column2 = value2...., columnN = valueN WHERE [condition];
Beispiel
UPDATE StudentInfo SET DEPARTMENTID = 4 WHERE ID = '2';
Ausgabe
SELECT *FROM StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 4 976******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934*******
- SQLite-Abfrage löschen
In SQLite kann die DELETE-Anweisung verwendet werden, um den Datensatz aus der Tabelle zu löschen. Abhängig von den Filterbedingungen, die von der WHERE-Klausel angewendet werden, können Sie ganz einfach alle Zeilen, einige Zeilen oder keine löschen.
Beispiel
DELETE FROM DepartmentInfo WHERE DeptName = 'Science';
Ausgabe
SELECT *FROM DepartmentInfo; DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports 4 Music
Wenn Sie versuchen, einen Datensatz zu löschen, der von einem Fremdschlüssel referenziert wird, erhalten Sie eine Fehlermeldung. Sie müssen zuerst die Fremdschlüsseldatensätze löschen, bevor Sie den Primärschlüsseldatensatz löschen. Versuchen wir, die Abteilung Wissenschaft zu löschen.
Beispiel
DELETE FROM DepartmentInfo WHERE DeptName = 'Music'; Error: FOREIGN KEY constraint failed
Daher müssen wir die Fremdschlüsseldatensätze löschen, bevor wir den Primärschlüssel löschen.
DELETE FROM StudentInfo WHERE DEPARTMENTID = 4; sqlite> DELETE FROM DepartmentInfo WHERE DeptName = 'Music'; sqlite> SELECT *FROM DepartmentInfo; DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports SELECT *FROM StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 California 2 934******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934*******
Jetzt wissen Sie, wie Sie die Datensätze in der SQLite-Datenbanktabelle bearbeiten. Lassen Sie uns in diesem SQLite-Tutorial-Blog weiter gehen und verschiedene Klauseln und Bedingungen besprechen, denen Sie in SQLite am häufigsten begegnen.
SQLite-Klauseln/Bedingungen
Bevor Sie mit Klauseln beginnen, finden Sie hier die vollständige Syntax der SELECT-Anweisung in SQLite.
Syntax
SELECT [ALL | DISTINCT] result [FROM table-list] [WHERE expr] [GROUP BY expr-list] [HAVING expr] [compound-op select]* [ORDER BY sort-expr-list] [LIMIT integer [(OFFSET|,) integer]]
Hinweis:Ich habe die Tabellen StudentInfo und DepartmentInfo wie unten gezeigt aktualisiert.
//Student Table ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 California 2 934******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934******* 2 SAM 22 Texas 4 976******* 5 Johny 23 Norway 2 945******* 6 Robin 23 Norway 2 UNKNOWN //Department Details DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports 4 Music 5 Science
- SQLite WO
In SQLite wird die WHERE-Klausel verwendet, um der SELECT-Anweisung Einschränkungen aufzuerlegen, indem eine oder mehrere Bedingungen definiert werden, um die erforderlichen Daten aus Tabellen in der Datenbank zu erhalten. Wenn die angegebene Bedingung erfüllt oder wahr ist, wird ein bestimmter Wert aus der Tabelle zurückgegeben. Wie Sie bereits gesehen haben, wird die WHERE-Klausel nicht nur in der SELECT-Anweisung, sondern auch in der UPDATE-, DELETE-Anweisung usw. verwendet.
Beispiel
SELECT NAME FROM StudentInfo WHERE AGE = 23;NAME ---------- John Johny Robin
In SQLite gibt es eine Reihe von Vergleichsoperatoren, die mit der WHERE-Klausel verwendet werden können.
- SQLite GROUP BY
In SQLite wird die GROUP BY-Klausel verwendet, um Daten in einer einzelnen Zeile zusammenzufassen, in der der Wert einer oder mehrerer angegebener Spalten wiederholt wird. Diese Klausel wird mit der WHERE-Klausel in der SELECT-Anweisung verwendet und steht vor der ORDER BY-Klausel.
Syntax
SELECT result FROM [table-list] GROUP BY [expr-list]
SELECT NAME, ADDRESS FROM StudentInfo GROUP BY NAME; NAME ADDRESS ---------- ---------- Dean California John Norway Johny Norway Mitch Houston Robin Norway SAM Texas
Beachten Sie, dass der Gruppierungsprozess aus zwei Schritten besteht. Zunächst wird der GROUP BY-Ausdruck verwendet, um Tabellenzeilen in verschiedenen Gruppen anzuordnen. Sobald die Gruppen definiert sind, definiert die SELECT-Anweisung, wie diese Gruppen auf eine einzelne Zeile reduziert werden.
- SQLite-ORDER BY
Im Allgemeinen speichern SQLite-Tabellen Daten in unbestimmter Reihenfolge und geben Datensätze in derselben unbestimmten Reihenfolge zurück, während Daten mit der SQLite-Anweisung select abgerufen werden. In solchen Fällen können Sie die ORDER BY-Klausel verwenden, um Spaltendatensätze entweder in aufsteigender oder absteigender Reihenfolge zu sortieren. Im folgenden Beispiel habe ich die Daten basierend auf der Adresse gruppiert und sortiert (in absteigender Reihenfolge).
Syntax
SELECT expressions FROM tables-list [WHERE conditions] ORDER BY column1, column2,... [ ASC | DESC ];
Beispiel
SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo GROUP BY ADDRESS ORDER BY ADDRESS DESC; ADDRESS COUNT(ADDRESS) ---------- -------------- Texas 1 Norway 3 Houston 1 California 1
- SQLite HAVING BY
In SQLite ist das HABEN -Klausel ist identisch mit WHERE Klausel. Die HAVING-Klausel ist eine weitere Bedingung, die angewendet wird, nachdem die Aggregation zusammen mit der group by in der select-Anweisung stattgefunden hat. Allgemein in SQLite, WHERE -Klausel wird verwendet, um eine Bedingung auf einzelne Elemente in einer Tabelle anzuwenden, und die HAVING -Klausel wird verwendet, um Filterbedingungen basierend auf den durch die Group By-Klausel erstellten Gruppen hinzuzufügen.
Beispiel
SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo GROUP BY ADDRESS HAVING COUNT(*)>1; ADDRESS COUNT(ADDRESS) ---------- -------------- Norway 3
- SQLite-Beschränkungsklausel
In SQLite wird die LIMIT-Klausel verwendet, um die Datensätze zu begrenzen, die von der select-Anweisung zurückgegeben werden. Betrachten wir ein Beispiel, um das Konzept zu verstehen.
Syntax
SELECT expressions FROM tables-list [WHERE conditions] LIMIT number_rows OFFSET offset_value;
Beispiel
SELECT NAME, ADDRESS FROM StudentInfo LIMIT 4 OFFSET 2; NAME ADDRESS ---------- ---------- Mitch Houston SAM Texas Johny Norway Robin Norway
OFFSET ist optional und definiert, wie viele Zeilen am Anfang der Ergebnismenge basierend auf offset_value übersprungen werden .
- SQLite UND &ODER
In SQLite werden die AND &OR-Operatoren verwendet, um basierend auf unseren Anforderungen mehrere Bedingungen für select-, insert-, update- und delete-Anweisungen auszuführen. Der SQLite AND-Operator gibt Zeilen oder Datensätze zurück, die die Bedingungen erfüllen, die durch die Verwendung des AND-Operators definiert wurden.
Beispiel1
SELECT NAME FROM StudentInfo WHERE AGE = 22 AND ADDRESS = 'Texas'; NAME ---------- SAM
Die ODER-Bedingung wird verwendet, um mehrere Bedingungen in SQLite-Anweisungen zu definieren, und sie gibt Zeilen oder Datensätze aus der Anweisung zurück, wenn eine der Bedingungen erfüllt ist.
Beispiel2
SELECT NAME FROM StudentInfo WHERE (AGE = 22 AND ADDRESS = 'Norway') OR ADDRESS = 'Norway'; NAME ---------- John Johny Robin
- SQLite GLOB-Operator
In SQLite wird der GLOB-Operator verwendet, um zu prüfen, ob der angegebene String-Wert einem bestimmten Muster entspricht oder nicht. Falls der Stringwert mit dem Musterwert übereinstimmt, wird true zurückgegeben und es ähnelt dem LIKE-Operator. Außerdem wird bei GLOB die Groß- und Kleinschreibung beachtet.
Syntax
SELECT * FROM table_name WHERE column_name GLOB 'search-expression'
Beispiel
SELECT *FROM StudentInfo WHERE NAME GLOB 'Joh*'; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 3 John 23 Norway 1 923******* 5 Johny 23 Norway 2 945*******
- SQLite Distinct
In SQLite scannt das Schlüsselwort DISTINCT die Ergebnismenge der SELECT-Anweisung und eliminiert alle doppelten Zeilen. Außerdem werden NULL-Werte als Duplikate betrachtet. Wenn wir also die DISTINCT-Klausel mit einer Spalte verwenden, die NULL-Werte enthält, wird nur eine Zeile mit einem NULL-Wert beibehalten. Wenn Sie DISTINCT auf mehrere Spalten anwenden, gibt die Anweisung jede eindeutige Kombination von coulnm1 zurück und Spalte2.
Beispiel
SELECT DISTINCT AGE FROM StudentInfo; AGE ---------- 20 23 22
- SQLite-IN-Operator
In SQLite wird der IN-Operator verwendet, um festzustellen, ob der angegebene Wert mit einer Liste angegebener Werte oder dem von der Unterabfrage zurückgegebenen Ergebnis übereinstimmt.
Beispiel
SELECT NAME FROM StudentInfo WHERE ADDRESS IN ('Texas', 'Houston');
NAME
----------
Mitch
SAM - SQLite UNION &UNION ALL
In SQLite wird der UNION-Operator verwendet, um die Ergebnismengen von 2 zu kombinieren oder mehr SELECT-Anweisungen und es entfernt doppelte Zeilen zwischen den verschiedenen SELECT-Anweisungen. Denken Sie daran, dass die SELECT-Anweisungen, die wir mit dem UNION-Operator verwendet haben, die gleiche Anzahl von Feldern in den Ergebnismengen mit ähnlichen Datentypen haben müssen.
Syntax
SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions] UNION / UNION ALL SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions];
Beispiel
SELECT DEPARTMENTID FROM StudentInfo UNION SELECT DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC; DEPARTMENTID ------------ 1 2 3 4 5
Der UNION ALL-Operator wird verwendet, um die Ergebnismengen von 2 oder mehr SELECT-Anweisungen zu kombinieren, und er gibt alle Zeilen einschließlich der Duplikate zurück.
Beispiel
SELECT DEPARTMENTID FROM StudentInfo UNION ALL SELECT DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC; DEPARTMENTID ------------ 1 1 2 2 2 2 3 3 4 4 5
Damit haben wir die grundlegendsten Befehle behandelt, die Sie möglicherweise verwenden müssen, wenn Sie mit SQLite arbeiten. Um mit diesem SQLite-Tutorial fortzufahren, sehen wir uns die Join-Anweisung in SQLite an.
Beitritte in SQLite
In SQLite werden Joins verwendet, um Datensätze aus zwei oder mehr Tabellen in einer Datenbank zu kombinieren und Datensätze basierend auf unseren Anforderungen zu erhalten. Verschiedene Arten von JOINS, die in SQLite verfügbar sind, sind:
- Innere Verbindung – INNER JOIN wird verwendet, um basierend auf den in SQLite-Anweisungen definierten Bedingungen nur übereinstimmende Datensätze aus mehreren Tabellen zu kombinieren und zurückzugeben.
- Outer Join – SQLite Outer Join wählt übereinstimmende Zeilen aus mehreren Tabellen aus, genauso wie Inner Join und einige andere Zeilen außerhalb der Beziehung. Einfach ausgedrückt können wir sagen, dass SQLite OUTER JOIN eine Ergänzung von INNER JOIN ist. Im Allgemeinen haben wir drei Arten von Outer Joins im SQL-Standard, nämlich LEFT, RIGHT und FULL Outer Joins, aber SQLite unterstützt nur LEFT OUTER JOIN.
- Cross Join – Es wird verwendet, um das kartesische Produkt von Zeilen zu erhalten, indem jede Zeile der ersten Tabelle mit jeder Zeile der zweiten Tabelle abgeglichen wird.
- Self Join – Es wird verwendet, um dieselbe Tabelle mit sich selbst zu verknüpfen. Um Self Join zu verwenden, müssen wir verschiedene Aliasnamen für dieselbe Tabelle erstellen, um Operationen basierend auf unseren Anforderungen auszuführen.
Das Konzept ähnelt dem anderer relationaler Datenbanksysteme wie SQL. Weitere Informationen finden Sie in diesem Artikel über SQL-Joins.
Damit haben wir die grundlegenden SQLite-Befehle abgedeckt. Fortgeschrittene Konzepte werden hier nicht behandelt. Bleiben Sie also gespannt auf einen weiteren Artikel zu fortgeschrittenen SQLite-Konzepten. Trotz all der guten Eigenschaften, die SQLite zu bieten hat, hat es auch gewisse Nachteile.
SQLite-Tutorial:Nachteile von SQLite
Nachfolgend sind die Nachteile der Verwendung von SQLite aufgeführt:
- Es funktioniert nicht gut in der Client/Server-Architektur.
- Die Größe einer SQLite-Datenbank ist in den meisten Fällen auf 2 GB begrenzt.
- SQLite hat RIGHT OUTER JOIN und FULL OUTER JOIN nicht implementiert. Mit SQLite können wir nur LEFT OUTER JOIN implementieren.
- Ansichten in SQLite sind schreibgeschützt. Wir können keine DML-Anweisungen (Insert, Update und Delete) mit Views verwenden.
- Wir können keine GRANT- und REVOKE-Anweisungen mit SQLite verwenden.
Damit beenden wir dieses SQLite-Tutorial.
Wenn Sie mehr über MySQL erfahren und diese relationale Open-Source-Datenbank kennenlernen möchten, sehen Sie sich unsere MySQL-DBA-Zertifizierungsschulung an Dazu gehören von einem Kursleiter geleitete Live-Schulungen und reale Projekterfahrung. Dieses Training wird Ihnen dabei helfen, MySQL gründlich zu verstehen und das Thema zu beherrschen.
Haben Sie eine Frage an uns? Bitte erwähnen Sie es im Kommentarbereich dieses SQLite-Tutorials und ich werde mich bei Ihnen melden.
