SQLite - Kurzanleitung

In diesem Kapitel erfahren Sie, was SQLite ist, wie es sich von SQL unterscheidet, warum es benötigt wird und wie es mit der Anwendungsdatenbank umgeht.

SQLite ist eine Softwarebibliothek, die ein in sich geschlossenes, serverloses SQL-Datenbankmodul ohne Konfiguration und Transaktionsdaten implementiert. SQLite ist eine der am schnellsten wachsenden Datenbank-Engines, aber das ist ein Anstieg der Popularität, der nichts mit seiner Größe zu tun hat. Der Quellcode für SQLite ist gemeinfrei.

Was ist SQLite?

SQLite ist eine In-Process-Bibliothek, die ein in sich geschlossenes, serverloses, transaktionsfreies SQL-Datenbankmodul ohne Konfiguration implementiert. Es handelt sich um eine Datenbank, die auf Null konfiguriert ist. Dies bedeutet, dass Sie sie wie andere Datenbanken nicht in Ihrem System konfigurieren müssen.

Die SQLite-Engine ist kein eigenständiger Prozess wie andere Datenbanken. Sie können sie je nach Anforderung statisch oder dynamisch mit Ihrer Anwendung verknüpfen. SQLite greift direkt auf seine Speicherdateien zu.

Warum SQLite?

• Für den Betrieb von SQLite ist kein separater Serverprozess oder -system erforderlich (ohne Server).

• SQLite wird mit einer Nullkonfiguration geliefert, was bedeutet, dass keine Einrichtung oder Verwaltung erforderlich ist.

• Eine vollständige SQLite-Datenbank wird in einer einzelnen plattformübergreifenden Festplattendatei gespeichert.

• SQLite ist sehr klein und leicht, weniger als 400 KB vollständig konfiguriert oder weniger als 250 KB, wobei optionale Funktionen weggelassen wurden.

• SQLite ist in sich geschlossen, dh es gibt keine externen Abhängigkeiten.

• SQLite-Transaktionen sind vollständig ACID-kompatibel und ermöglichen den sicheren Zugriff von mehreren Prozessen oder Threads.

• SQLite unterstützt die meisten Funktionen der Abfragesprache im SQL92 (SQL2) -Standard.

• SQLite ist in ANSI-C geschrieben und bietet eine einfache und benutzerfreundliche API.

• SQLite ist unter UNIX (Linux, Mac OS-X, Android, iOS) und Windows (Win32, WinCE, WinRT) verfügbar.

SQLite Eine kurze Geschichte

• 2000 - D. Richard Hipp hat SQLite so konzipiert, dass für den Betrieb eines Programms keine Administration erforderlich ist.

• 2000 - Im August wurde SQLite 1.0 mit GNU Database Manager veröffentlicht.

• 2011 - Hipp kündigte an, der SQLite-Datenbank eine UNQl-Schnittstelle hinzuzufügen und UNQLite (Document Oriented Database) zu entwickeln.

SQLite-Einschränkungen

Es gibt einige nicht unterstützte Funktionen von SQL92 in SQLite, die in der folgenden Tabelle aufgeführt sind.

Sr.Nr.	Funktion & Beschreibung
1	RIGHT OUTER JOIN Es ist nur LEFT OUTER JOIN implementiert.
2	FULL OUTER JOIN Es ist nur LEFT OUTER JOIN implementiert.
3	ALTER TABLE Die Varianten RENAME TABLE und ADD COLUMN des Befehls ALTER TABLE werden unterstützt. Die DROP COLUMN, ALTER COLUMN und ADD CONSTRAINT werden nicht unterstützt.
4	Trigger support Für jede Zeile werden Trigger unterstützt, jedoch nicht für jede Anweisung.
5	VIEWs VIEWs in SQLite sind schreibgeschützt. Sie dürfen keine DELETE-, INSERT- oder UPDATE-Anweisung für eine Ansicht ausführen.
6	GRANT and REVOKE Die einzigen Zugriffsberechtigungen, die angewendet werden können, sind die normalen Dateizugriffsberechtigungen des zugrunde liegenden Betriebssystems.

SQLite-Befehle

Die Standard-SQLite-Befehle für die Interaktion mit relationalen Datenbanken ähneln SQL. Sie sind CREATE, SELECT, INSERT, UPDATE, DELETE und DROP. Diese Befehle können aufgrund ihrer Funktionsweise in Gruppen eingeteilt werden.

DDL - Data Definition Language

Sr.Nr.	Befehl & Beschreibung
1	CREATE Erstellt eine neue Tabelle, eine Ansicht einer Tabelle oder ein anderes Objekt in der Datenbank.
2	ALTER Ändert ein vorhandenes Datenbankobjekt, z. B. eine Tabelle.
3	DROP Löscht eine gesamte Tabelle, eine Ansicht einer Tabelle oder ein anderes Objekt in der Datenbank.

DML - Data Manipulation Language

Sr.Nr.	Befehl & Beschreibung
1	INSERT Erstellt einen Datensatz
2	UPDATE Ändert Datensätze
3	DELETE Löscht Datensätze

DQL - Data Query Language

Sr.Nr.	Befehl & Beschreibung
1	SELECT Ruft bestimmte Datensätze aus einer oder mehreren Tabellen ab

SQLite ist bekannt für seine großartige Konfiguration ohne Funktionen, sodass keine komplexe Einrichtung oder Verwaltung erforderlich ist. Dieses Kapitel führt Sie durch die Einrichtung von SQLite unter Windows, Linux und Mac OS X.

Installieren Sie SQLite unter Windows

• Step 1- Gehen Sie zur SQLite-Downloadseite und laden Sie vorkompilierte Binärdateien aus dem Windows-Bereich herunter.

• Step 2 - Laden Sie die Dateien sqlite-shell-win32 - *. Zip und sqlite-dll-win32 - *. Zip herunter.

• Step 3 - Erstellen Sie einen Ordner C: \> sqlite und entpacken Sie über zwei komprimierten Dateien in diesem Ordner, wodurch Sie die Dateien sqlite3.def, sqlite3.dll und sqlite3.exe erhalten.

• Step 4 - Fügen Sie C: \> sqlite in Ihre PATH-Umgebungsvariable ein, gehen Sie schließlich zur Eingabeaufforderung und geben Sie den Befehl sqlite3 ein, der das folgende Ergebnis anzeigen soll.

C:\>sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

Installieren Sie SQLite unter Linux

Heutzutage werden fast alle Varianten des Linux-Betriebssystems mit SQLite ausgeliefert. Geben Sie einfach den folgenden Befehl ein, um zu überprüfen, ob SQLite bereits auf Ihrem Computer installiert ist.

$sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

Wenn Sie das obige Ergebnis nicht sehen, bedeutet dies, dass SQLite nicht auf Ihrem Linux-Computer installiert ist. Im Folgenden finden Sie die folgenden Schritte zum Installieren von SQLite:

• Step 1- Gehen Sie zur SQLite-Download-Seite und laden Sie sqlite-autoconf - *. Tar.gz aus dem Quellcode-Bereich herunter.

• Step 2 - Führen Sie den folgenden Befehl aus:

$tar xvfz sqlite-autoconf-3071502.tar.gz
$cd sqlite-autoconf-3071502 $./configure --prefix=/usr/local
$make $make install

Der obige Befehl endet mit der SQLite-Installation auf Ihrem Linux-Computer. Was Sie wie oben erläutert überprüfen können.

Installieren Sie SQLite unter Mac OS X.

Die neueste Version von Mac OS X ist zwar mit SQLite vorinstalliert, aber wenn Sie keine Installation zur Verfügung haben, führen Sie einfach die folgenden Schritte aus:

• Step 1- Gehen Sie zur SQLite-Download-Seite und laden Sie sqlite-autoconf - *. Tar.gz aus dem Quellcode-Bereich herunter.

• Step 2 - Führen Sie den folgenden Befehl aus:

$tar xvfz sqlite-autoconf-3071502.tar.gz $cd sqlite-autoconf-3071502
$./configure --prefix=/usr/local $make
$make install

Das obige Verfahren endet mit der Installation von SQLite auf Ihrem Mac OS X-Computer. Was Sie überprüfen können, indem Sie den folgenden Befehl eingeben:

$sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

Schließlich haben Sie eine SQLite-Eingabeaufforderung, an der Sie SQLite-Befehle für Ihre Übungen ausgeben können.

Dieses Kapitel führt Sie durch einfache und nützliche Befehle, die von SQLite-Programmierern verwendet werden. Diese Befehle werden als SQLite-Punktbefehle bezeichnet. Die Ausnahme bei diesen Befehlen besteht darin, dass sie nicht durch ein Semikolon (;) abgeschlossen werden dürfen.

Beginnen wir mit der Eingabe eines einfachen sqlite3 Befehl an der Eingabeaufforderung, der Ihnen die SQLite-Eingabeaufforderung zur Verfügung stellt, an der Sie verschiedene SQLite-Befehle ausgeben.

$sqlite3
SQLite version 3.3.6
Enter ".help" for instructions
sqlite>

Für eine Liste der verfügbaren Punktbefehle können Sie jederzeit ".help" eingeben. Zum Beispiel -

sqlite>.help

Der obige Befehl zeigt eine Liste verschiedener wichtiger SQLite-Punktbefehle an, die in der folgenden Tabelle aufgeführt sind.

Sr.Nr.	Befehl & Beschreibung
1	.backup ?DB? FILE Sichern Sie die Datenbank (Standard "main") in FILE
2	.bail ON|OFF Stoppen Sie nach einem Fehler. Standard AUS
3	.databases Listen Sie Namen und Dateien angehängter Datenbanken auf
4	.dump ?TABLE? Speichern Sie die Datenbank in einem SQL-Textformat. Wenn TABLE angegeben ist, werden nur Dump-Tabellen ausgegeben, die dem LIKE-Muster TABLE entsprechen
5	.echo ON|OFF Schalten Sie das Befehlsecho ein oder aus
6	.exit Beenden Sie die SQLite-Eingabeaufforderung
7	.explain ON|OFF Schalten Sie den für EXPLAIN geeigneten Ausgabemodus ein oder aus. Ohne Argumente wird EXPLAIN aktiviert
8	.header(s) ON|OFF Schalten Sie die Anzeige der Header ein oder aus
9	.help Diese Nachricht anzeigen
10	.import FILE TABLE Importieren Sie Daten aus FILE in TABLE
11	.indices ?TABLE? Namen aller Indizes anzeigen. Wenn TABLE angegeben ist, werden nur Indizes für Tabellen angezeigt, die mit LIKE pattern TABLE übereinstimmen
12	.load FILE ?ENTRY? Laden Sie eine Erweiterungsbibliothek
13	.log FILE|off Aktivieren oder deaktivieren Sie die Protokollierung. DATEI kann stderr / stdout sein
14	.mode MODE Stellen Sie den Ausgabemodus ein, wobei MODE einer von - ist. csv - Durch Kommas getrennte Werte column - Links ausgerichtete Spalten. html - HTML <table> Code insert - SQL-Einfügeanweisungen für TABLE line - Ein Wert pro Zeile list - Durch die Trennzeichenfolge getrennte Werte tabs - Tabulatorgetrennte Werte tcl - TCL-Listenelemente
15	.nullvalue STRING Drucken Sie STRING anstelle von NULL-Werten
16	.output FILENAME Ausgabe an FILENAME senden
17	.output stdout Ausgabe an den Bildschirm senden
18	.print STRING... Literal STRING drucken
19	.prompt MAIN CONTINUE Ersetzen Sie die Standardansagen
20	.quit Beenden Sie die SQLite-Eingabeaufforderung
21	.read FILENAME Führen Sie SQL in FILENAME aus
22	.schema ?TABLE? Zeigen Sie die CREATE-Anweisungen an. Wenn TABLE angegeben ist, werden nur Tabellen angezeigt, die dem LIKE-Muster TABLE entsprechen
23	.separator STRING Ändern Sie das vom Ausgabemodus und .import verwendete Trennzeichen
24	.show Zeigen Sie die aktuellen Werte für verschiedene Einstellungen an
25	.stats ON|OFF Aktivieren oder deaktivieren Sie die Statistiken
26	.tables ?PATTERN? Listen Sie die Namen der Tabellen auf, die einem LIKE-Muster entsprechen
27	.timeout MS Versuchen Sie, gesperrte Tabellen für MS Millisekunden zu öffnen
28	.width NUM NUM Stellen Sie die Spaltenbreiten für den "Spalten" -Modus ein
29	.timer ON|OFF Schalten Sie die CPU-Timer-Messung ein oder aus

Lass es uns versuchen .show Befehl, um die Standardeinstellung für Ihre SQLite-Eingabeaufforderung anzuzeigen.

sqlite>.show
     echo: off
  explain: off
  headers: off
     mode: column
nullvalue: ""
   output: stdout
separator: "|"
    width:
sqlite>

Stellen Sie sicher, dass zwischen sqlite> prompt und dot command kein Leerzeichen steht, da dies sonst nicht funktioniert.

Ausgabe formatieren

Sie können die folgende Folge von Punktbefehlen verwenden, um Ihre Ausgabe zu formatieren.

sqlite>.header on
sqlite>.mode column
sqlite>.timer on
sqlite>

Die obige Einstellung erzeugt die Ausgabe im folgenden Format.

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
CPU Time: user 0.000000 sys 0.000000

Die sqlite_master-Tabelle

Die Mastertabelle enthält die wichtigsten Informationen zu Ihren Datenbanktabellen und wird aufgerufen sqlite_master. Sie können das Schema wie folgt sehen:

sqlite>.schema sqlite_master

Dies führt zu folgendem Ergebnis.

CREATE TABLE sqlite_master (
   type text,
   name text,
   tbl_name text,
   rootpage integer,
   sql text
);

Auf SQLite folgen eindeutige Regeln und Richtlinien namens Syntax. In diesem Kapitel werden alle grundlegenden SQLite-Syntaxen aufgelistet.

Groß- und Kleinschreibung

Der wichtige Punkt ist, dass SQLite ist case insensitivedh die Klauseln GLOB und glob haben in SQLite-Anweisungen dieselbe Bedeutung.

Bemerkungen

SQLite-Kommentare sind zusätzliche Notizen, die Sie in Ihren SQLite-Code einfügen können, um die Lesbarkeit zu verbessern. Sie können überall angezeigt werden. Leerzeichen können auftreten, einschließlich innerer Ausdrücke und in der Mitte anderer SQL-Anweisungen, sie können jedoch nicht verschachtelt werden.

SQL-Kommentare beginnen mit zwei aufeinanderfolgenden "-" Zeichen (ASCII 0x2d) und erstrecken sich bis einschließlich des nächsten Zeilenumbruchzeichens (ASCII 0x0a) oder bis zum Ende der Eingabe, je nachdem, was zuerst eintritt.

Sie können auch Kommentare im C-Stil verwenden, die mit "/ *" beginnen und sich bis einschließlich des nächsten "* /" - Zeichenpaars oder bis zum Ende der Eingabe erstrecken, je nachdem, was zuerst eintritt. Kommentare im C-Stil können mehrere Zeilen umfassen.

sqlite> .help -- This is a single line comment

SQLite-Anweisungen

Alle SQLite-Anweisungen beginnen mit einem der Schlüsselwörter wie SELECT, INSERT, UPDATE, DELETE, ALTER, DROP usw., und alle Anweisungen enden mit einem Semikolon (;).

SQLite ANALYZE-Anweisung

ANALYZE;
or
ANALYZE database_name;
or
ANALYZE database_name.table_name;

SQLite AND / OR-Klausel

SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION-1 {AND|OR} CONDITION-2;

SQLite ALTER TABLE-Anweisung

ALTER TABLE table_name ADD COLUMN column_def...;

SQLite ALTER TABLE-Anweisung (Umbenennen)

ALTER TABLE table_name RENAME TO new_table_name;

SQLite ATTACH DATABASE-Anweisung

ATTACH DATABASE 'DatabaseName' As 'Alias-Name';

SQLite BEGIN TRANSACTION-Anweisung

BEGIN;
or
BEGIN EXCLUSIVE TRANSACTION;

SQLite ZWISCHEN Klausel

SELECT column1, column2....columnN
FROM table_name
WHERE column_name BETWEEN val-1 AND val-2;

SQLite COMMIT-Anweisung

COMMIT;

SQLite CREATE INDEX-Anweisung

CREATE INDEX index_name
ON table_name ( column_name COLLATE NOCASE );

SQLite CREATE UNIQUE INDEX-Anweisung

CREATE UNIQUE INDEX index_name
ON table_name ( column1, column2,...columnN);

SQLite CREATE TABLE-Anweisung

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
   PRIMARY KEY( one or more columns )
);

SQLite CREATE TRIGGER-Anweisung

CREATE TRIGGER database_name.trigger_name 
BEFORE INSERT ON table_name FOR EACH ROW
BEGIN 
   stmt1; 
   stmt2;
   ....
END;

SQLite CREATE VIEW-Anweisung

CREATE VIEW database_name.view_name AS
SELECT statement....;

SQLite CREATE VIRTUAL TABLE-Anweisung

CREATE VIRTUAL TABLE database_name.table_name USING weblog( access.log );
or
CREATE VIRTUAL TABLE database_name.table_name USING fts3( );

SQLite COMMIT TRANSACTION-Anweisung

COMMIT;

SQLite COUNT-Klausel

SELECT COUNT(column_name)
FROM table_name
WHERE CONDITION;

SQLite DELETE-Anweisung

DELETE FROM table_name
WHERE {CONDITION};

SQLite DETACH DATABASE-Anweisung

DETACH DATABASE 'Alias-Name';

SQLite DISTINCT-Klausel

SELECT DISTINCT column1, column2....columnN
FROM table_name;

SQLite DROP INDEX-Anweisung

DROP INDEX database_name.index_name;

SQLite DROP TABLE-Anweisung

DROP TABLE database_name.table_name;

SQLite DROP VIEW-Anweisung

DROP INDEX database_name.view_name;

SQLite DROP TRIGGER-Anweisung

DROP INDEX database_name.trigger_name;

SQLite EXISTS-Klausel

SELECT column1, column2....columnN
FROM table_name
WHERE column_name EXISTS (SELECT * FROM   table_name );

SQLite EXPLAIN-Anweisung

EXPLAIN INSERT statement...;
or 
EXPLAIN QUERY PLAN SELECT statement...;

SQLite GLOB-Klausel

SELECT column1, column2....columnN
FROM table_name
WHERE column_name GLOB { PATTERN };

SQLite GROUP BY-Klausel

SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name;

SQLite HAVING-Klausel

SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name
HAVING (arithematic function condition);

SQLite INSERT INTO-Anweisung

INSERT INTO table_name( column1, column2....columnN)
VALUES ( value1, value2....valueN);

SQLite IN-Klausel

SELECT column1, column2....columnN
FROM table_name
WHERE column_name IN (val-1, val-2,...val-N);

SQLite Like-Klausel

SELECT column1, column2....columnN
FROM table_name
WHERE column_name LIKE { PATTERN };

SQLite NOT IN-Klausel

SELECT column1, column2....columnN
FROM table_name
WHERE column_name NOT IN (val-1, val-2,...val-N);

SQLite ORDER BY-Klausel

SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION
ORDER BY column_name {ASC|DESC};

SQLite PRAGMA-Anweisung

PRAGMA pragma_name;

For example:

PRAGMA page_size;
PRAGMA cache_size = 1024;
PRAGMA table_info(table_name);

SQLite RELEASE SAVEPOINT-Anweisung

RELEASE savepoint_name;

SQLite REINDEX-Anweisung

REINDEX collation_name;
REINDEX database_name.index_name;
REINDEX database_name.table_name;

SQLite ROLLBACK-Anweisung

ROLLBACK;
or
ROLLBACK TO SAVEPOINT savepoint_name;

SQLite SAVEPOINT-Anweisung

SAVEPOINT savepoint_name;

SQLite SELECT-Anweisung

SELECT column1, column2....columnN
FROM table_name;

SQLite UPDATE-Anweisung

UPDATE table_name
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE  CONDITION ];

SQLite VACUUM-Anweisung

VACUUM;

SQLite WHERE-Klausel

SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION;

Der SQLite-Datentyp ist ein Attribut, das den Datentyp eines Objekts angibt. Jede Spalte, Variable und jeder Ausdruck hat einen zugehörigen Datentyp in SQLite.

Sie würden diese Datentypen beim Erstellen Ihrer Tabellen verwenden. SQLite verwendet ein allgemeineres dynamisches Typsystem. In SQLite ist der Datentyp eines Werts dem Wert selbst zugeordnet, nicht seinem Container.

SQLite-Speicherklassen

Jeder in einer SQLite-Datenbank gespeicherte Wert verfügt über eine der folgenden Speicherklassen:

Sr.Nr.	Speicherklasse & Beschreibung
1	NULL Der Wert ist ein NULL-Wert.
2	INTEGER Der Wert ist eine vorzeichenbehaftete Ganzzahl, die je nach Größe des Werts in 1, 2, 3, 4, 6 oder 8 Byte gespeichert wird.
3	REAL Der Wert ist ein Gleitkommawert, der als 8-Byte-IEEE-Gleitkommazahl gespeichert wird.
4	TEXT Der Wert ist eine Textzeichenfolge, die mithilfe der Datenbankcodierung (UTF-8, UTF-16BE oder UTF-16LE) gespeichert wird.
5	BLOB Der Wert ist ein Datenblock, der genau so gespeichert wird, wie er eingegeben wurde.

Die SQLite-Speicherklasse ist etwas allgemeiner als ein Datentyp. Die INTEGER-Speicherklasse enthält beispielsweise 6 verschiedene ganzzahlige Datentypen unterschiedlicher Länge.

SQLite-Affinitätstyp

SQLite unterstützt das Konzept von type affinityauf Spalten. Jede Spalte kann weiterhin jeden Datentyp speichern, aber die bevorzugte Speicherklasse für eine Spalte heißt itsaffinity. Jeder Tabellenspalte in einer SQLite3-Datenbank wird eine der folgenden Typaffinitäten zugewiesen:

Sr.Nr.	Affinität & Beschreibung
1	TEXT In dieser Spalte werden alle Daten mit den Speicherklassen NULL, TEXT oder BLOB gespeichert.
2	NUMERIC Diese Spalte kann Werte enthalten, die alle fünf Speicherklassen verwenden.
3	INTEGER Verhält sich wie eine Spalte mit NUMERISCHER Affinität, mit Ausnahme eines CAST-Ausdrucks.
4	REAL Verhält sich wie eine Spalte mit NUMERISCHER Affinität, außer dass sie ganzzahlige Werte in die Gleitkommadarstellung zwingt.
5	NONE Eine Spalte mit der Affinität NONE bevorzugt keine Speicherklasse gegenüber einer anderen, und es wird kein Versuch unternommen, Daten von einer Speicherklasse in eine andere zu zwingen.

SQLite-Affinitäts- und Typnamen

In der folgenden Tabelle sind verschiedene Datentypnamen aufgeführt, die beim Erstellen von SQLite3-Tabellen mit der entsprechenden angewendeten Affinität verwendet werden können.

Datentyp	Affinität
INT INTEGER TINYINT SMALLINT MEDIUMINT BIGINT UNSIGNED BIG INT INT2 INT8	GANZE ZAHL
CHARACTER(20) VARCHAR(255) VERSCHIEDENER CHARAKTER (255) NCHAR(55) NATIVER CHARAKTER (70) NVARCHAR(100) TEXT CLOB	TEXT
BLOB Kein Datentyp angegeben	KEINER
REAL DOUBLE DOPPELTE GENAUIGKEIT FLOAT	ECHT
NUMERIC DECIMAL(10,5) BOOLEAN DATE DATETIME	NUMERISCH

Boolescher Datentyp

SQLite verfügt nicht über eine separate boolesche Speicherklasse. Stattdessen werden Boolesche Werte als Ganzzahlen 0 (falsch) und 1 (wahr) gespeichert.

Datums- und Uhrzeitdatentyp

SQLite verfügt nicht über eine separate Speicherklasse zum Speichern von Datums- und / oder Uhrzeitangaben. SQLite kann jedoch Datums- und Uhrzeitangaben als TEXT-, REAL- oder INTEGER-Werte speichern.

Sr.Nr.	Speicherklasse & Datumsformat
1	TEXT Ein Datum in einem Format wie "JJJJ-MM-TT HH: MM: SS.SSS"
2	REAL Die Anzahl der Tage seit Mittag in Greenwich am 24. November 4714 v
3	INTEGER Die Anzahl der Sekunden seit 1970-01-01 00:00:00 UTC

Sie können Datums- und Uhrzeitangaben in einem dieser Formate speichern und mithilfe der integrierten Datums- und Uhrzeitfunktionen frei zwischen Formaten konvertieren.

In SQLite sqlite3Mit dem Befehl wird eine neue SQLite-Datenbank erstellt. Sie benötigen keine besonderen Berechtigungen, um eine Datenbank zu erstellen.

Syntax

Im Folgenden finden Sie die grundlegende Syntax des Befehls sqlite3 zum Erstellen einer Datenbank: -

$sqlite3 DatabaseName.db

Der Datenbankname sollte innerhalb des RDBMS immer eindeutig sein.

Beispiel

Wenn Sie eine neue Datenbank <testDB.db> erstellen möchten, lautet die SQLITE3-Anweisung wie folgt:

$sqlite3 testDB.db
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

Mit dem obigen Befehl wird eine Datei erstellt testDB.dbim aktuellen Verzeichnis. Diese Datei wird von der SQLite-Engine als Datenbank verwendet. Wenn Sie beim Erstellen der Datenbank bemerkt haben, dass der Befehl sqlite3 a bereitstelltsqlite> Eingabeaufforderung nach erfolgreicher Erstellung einer Datenbankdatei.

Sobald eine Datenbank erstellt wurde, können Sie sie in der Liste der Datenbanken mit der folgenden SQLite überprüfen .databases Befehl.

sqlite>.databases
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db

Sie werden SQLite verwenden .quit Befehl, um die SQLite-Eingabeaufforderung wie folgt zu verlassen:

sqlite>.quit
$

Der Befehl .dump

Sie können verwenden .dump dot-Befehl zum Exportieren der vollständigen Datenbank in eine Textdatei mit dem folgenden SQLite-Befehl an der Eingabeaufforderung.

$sqlite3 testDB.db .dump > testDB.sql

Der obige Befehl konvertiert den gesamten Inhalt von testDB.db Datenbank in SQLite-Anweisungen und sichern Sie sie in der ASCII-Textdatei testDB.sql. Sie können die Wiederherstellung aus der generierten testDB.sql auf einfache Weise wie folgt durchführen:

$sqlite3 testDB.db < testDB.sql

In diesem Moment ist Ihre Datenbank leer, sodass Sie die beiden oben beschriebenen Verfahren ausprobieren können, sobald Sie nur wenige Tabellen und Daten in Ihrer Datenbank haben. Fahren wir zunächst mit dem nächsten Kapitel fort.

Stellen Sie sich einen Fall vor, in dem mehrere Datenbanken verfügbar sind und Sie jeweils eine davon verwenden möchten. SQLiteATTACH DATABASE Die Anweisung wird verwendet, um eine bestimmte Datenbank auszuwählen. Nach diesem Befehl werden alle SQLite-Anweisungen unter der angehängten Datenbank ausgeführt.

Syntax

Im Folgenden finden Sie die grundlegende Syntax der SQLite ATTACH DATABASE-Anweisung.

ATTACH DATABASE 'DatabaseName' As 'Alias-Name';

Mit dem obigen Befehl wird auch eine Datenbank erstellt, falls die Datenbank bereits nicht erstellt wurde. Andernfalls wird nur der Name der Datenbankdatei mit der logischen Datenbank 'Alias-Name' verknüpft.

Beispiel

Wenn Sie eine vorhandene Datenbank anhängen möchten testDB.db, dann wäre die ATTACH DATABASE-Anweisung wie folgt:

sqlite> ATTACH DATABASE 'testDB.db' as 'TEST';

Verwenden Sie SQLite .database Befehl zum Anzeigen der angehängten Datenbank.

sqlite> .database
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db
2    test             /home/sqlite/testDB.db

Die Datenbanknamen main und tempsind für die Primärdatenbank und die Datenbank reserviert, um temporäre Tabellen und andere temporäre Datenobjekte zu speichern. Diese beiden Datenbanknamen sind für jede Datenbankverbindung vorhanden und sollten nicht für Anhänge verwendet werden. Andernfalls wird die folgende Warnmeldung angezeigt.

sqlite> ATTACH DATABASE 'testDB.db' as 'TEMP';
Error: database TEMP is already in use
sqlite> ATTACH DATABASE 'testDB.db' as 'main';
Error: database TEMP is already in use

SQLite DETACH DATABASEDie Anweisung wird verwendet, um eine benannte Datenbank von einer Datenbankverbindung zu trennen und zu trennen, die zuvor mit der ATTACH-Anweisung angehängt wurde. Wenn dieselbe Datenbankdatei mit mehreren Aliasnamen angehängt wurde, trennt der Befehl DETACH nur den angegebenen Namen und der Rest des Anhangs wird weiterhin fortgesetzt. Sie können das nicht abnehmenmain oder temp Datenbanken.

Wenn es sich bei der Datenbank um eine speicherinterne oder temporäre Datenbank handelt, wird die Datenbank zerstört und der Inhalt geht verloren.

Syntax

Im Folgenden finden Sie die grundlegende Syntax der SQLite DETACH DATABASE-Anweisung 'Alias-Name'.

DETACH DATABASE 'Alias-Name';

Hier ist 'Alias-Name' derselbe Alias, den Sie beim Anhängen der Datenbank mit der ATTACH-Anweisung verwendet haben.

Beispiel

Angenommen, Sie haben eine Datenbank, die Sie im vorherigen Kapitel erstellt und mit 'test' und 'currentDB' angehängt haben, wie wir sehen können .database Befehl.

sqlite>.databases
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db
2    test             /home/sqlite/testDB.db
3    currentDB        /home/sqlite/testDB.db

Versuchen wir, 'currentDB' mit dem folgenden Befehl von testDB.db zu trennen.

sqlite> DETACH DATABASE 'currentDB';

Wenn Sie nun den aktuellen Anhang überprüfen, werden Sie feststellen, dass testDB.db immer noch mit 'test' und 'main' verbunden ist.

sqlite>.databases
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db
2    test             /home/sqlite/testDB.db

SQLite CREATE TABLEDie Anweisung wird verwendet, um eine neue Tabelle in einer der angegebenen Datenbanken zu erstellen. Das Erstellen einer Basistabelle umfasst das Benennen der Tabelle und das Definieren ihrer Spalten und des Datentyps jeder Spalte.

Syntax

Es folgt die grundlegende Syntax der Anweisung CREATE TABLE.

CREATE TABLE database_name.table_name(
   column1 datatype PRIMARY KEY(one or more columns),
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype
);

CREATE TABLE ist das Schlüsselwort, das das Datenbanksystem anweist, eine neue Tabelle zu erstellen. Der eindeutige Name oder Bezeichner für die Tabelle folgt der Anweisung CREATE TABLE. Optional können Sie den Datenbanknamen zusammen mit dem Tabellennamen angeben .

Beispiel

Das folgende Beispiel zeigt eine COMPANY-Tabelle mit der ID als Primärschlüssel und NOT NULL. Dies sind die Einschränkungen, die zeigen, dass diese Felder beim Erstellen von Datensätzen in dieser Tabelle nicht NULL sein dürfen.

sqlite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Lassen Sie uns eine weitere Tabelle erstellen, die wir in unseren Übungen in den folgenden Kapiteln verwenden werden.

sqlite> CREATE TABLE DEPARTMENT(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      NOT NULL
);

Sie können mit dem SQLite-Befehl überprüfen, ob Ihre Tabelle erfolgreich erstellt wurde .tables Befehl, mit dem alle Tabellen in einer angehängten Datenbank aufgelistet werden.

sqlite>.tables
COMPANY     DEPARTMENT

Hier können Sie die COMPANY-Tabelle zweimal sehen, da sie die COMPANY-Tabelle für die Hauptdatenbank und die test.COMPANY-Tabelle für den für Ihre testDB.db erstellten 'test'-Alias ​​anzeigt. Mit der folgenden SQLite können Sie vollständige Informationen zu einer Tabelle abrufen.schema Befehl.

sqlite>.schema COMPANY
CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

SQLite DROP TABLE Die Anweisung wird verwendet, um eine Tabellendefinition und alle zugehörigen Daten, Indizes, Trigger, Einschränkungen und Berechtigungsspezifikationen für diese Tabelle zu entfernen.

Bei der Verwendung dieses Befehls müssen Sie vorsichtig sein, da nach dem Löschen einer Tabelle alle in der Tabelle verfügbaren Informationen für immer verloren gehen.

Syntax

Es folgt die grundlegende Syntax der DROP TABLE-Anweisung. Optional können Sie den Datenbanknamen zusammen mit dem Tabellennamen wie folgt angeben:

DROP TABLE database_name.table_name;

Beispiel

Lassen Sie uns zuerst die COMPANY-Tabelle überprüfen und sie dann aus der Datenbank löschen.

sqlite>.tables
COMPANY       test.COMPANY

Dies bedeutet, dass die COMPANY-Tabelle in der Datenbank verfügbar ist. Lassen Sie uns sie also wie folgt löschen:

sqlite>DROP TABLE COMPANY;
sqlite>

Wenn Sie nun den Befehl .TABLES versuchen, finden Sie die Tabelle COMPANY nicht mehr.

sqlite>.tables
sqlite>

Es wird nichts angezeigt, was bedeutet, dass die Tabelle aus Ihrer Datenbank erfolgreich gelöscht wurde.

SQLite INSERT INTO Die Anweisung wird verwendet, um einer Tabelle in der Datenbank neue Datenzeilen hinzuzufügen.

Syntax

Es folgen die beiden grundlegenden Syntaxen der INSERT INTO-Anweisung.

INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)]  
VALUES (value1, value2, value3,...valueN);

Hier sind Spalte1, Spalte2, ... SpalteN die Namen der Spalten in der Tabelle, in die Sie Daten einfügen möchten.

Möglicherweise müssen Sie den Spaltennamen nicht in der SQLite-Abfrage angeben, wenn Sie Werte für alle Spalten der Tabelle hinzufügen. Stellen Sie jedoch sicher, dass die Reihenfolge der Werte in derselben Reihenfolge wie die Spalten in der Tabelle liegt. Die SQLite INSERT INTO-Syntax lautet wie folgt:

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

Beispiel

Angenommen, Sie haben bereits eine COMPANY-Tabelle in Ihrer testDB.db wie folgt erstellt:

sqlite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Mit den folgenden Anweisungen werden nun sechs Datensätze in der COMPANY-Tabelle erstellt.

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (2, 'Allen', 25, 'Texas', 15000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (5, 'David', 27, 'Texas', 85000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (6, 'Kim', 22, 'South-Hall', 45000.00 );

Sie können einen Datensatz in der COMPANY-Tabelle mit der zweiten Syntax wie folgt erstellen:

INSERT INTO COMPANY VALUES (7, 'James', 24, 'Houston', 10000.00 );

Alle obigen Anweisungen würden die folgenden Datensätze in der COMPANY-Tabelle erstellen. Im nächsten Kapitel erfahren Sie, wie Sie alle diese Datensätze aus einer Tabelle anzeigen.

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

Füllen Sie eine Tabelle mit einer anderen Tabelle

Sie können Daten über eine select-Anweisung über eine andere Tabelle in eine Tabelle einfügen, vorausgesetzt, eine andere Tabelle verfügt über eine Reihe von Feldern, die zum Auffüllen der ersten Tabelle erforderlich sind. Hier ist die Syntax -

INSERT INTO first_table_name [(column1, column2, ... columnN)] 
   SELECT column1, column2, ...columnN 
   FROM second_table_name
   [WHERE condition];

Im Moment können Sie die obige Anweisung überspringen. Lassen Sie uns zunächst die SELECT- und WHERE-Klauseln lernen, die in den folgenden Kapiteln behandelt werden.

SQLite SELECTDie Anweisung wird verwendet, um die Daten aus einer SQLite-Datenbanktabelle abzurufen, die Daten in Form einer Ergebnistabelle zurückgibt. Diese Ergebnistabellen werden auch aufgerufenresult sets.

Syntax

Im Folgenden finden Sie die grundlegende Syntax der SQLite SELECT-Anweisung.

SELECT column1, column2, columnN FROM table_name;

Hier sind Spalte1, Spalte2 ... die Felder einer Tabelle, deren Werte Sie abrufen möchten. Wenn Sie alle im Feld verfügbaren Felder abrufen möchten, können Sie die folgende Syntax verwenden:

SELECT * FROM table_name;

Beispiel

Betrachten Sie die COMPANY-Tabelle mit den folgenden Datensätzen:

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

Im Folgenden finden Sie ein Beispiel zum Abrufen und Anzeigen aller dieser Datensätze mithilfe der SELECT-Anweisung. Hier wurden die ersten drei Befehle verwendet, um eine ordnungsgemäß formatierte Ausgabe festzulegen.

sqlite>.header on
sqlite>.mode column
sqlite> SELECT * FROM COMPANY;

Schließlich erhalten Sie das folgende Ergebnis.

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

Wenn Sie nur ausgewählte Felder der COMPANY-Tabelle abrufen möchten, verwenden Sie die folgende Abfrage:

sqlite> SELECT ID, NAME, SALARY FROM COMPANY;

Die obige Abfrage führt zu folgendem Ergebnis.

ID          NAME        SALARY
----------  ----------  ----------
1           Paul        20000.0
2           Allen       15000.0
3           Teddy       20000.0
4           Mark        65000.0
5           David       85000.0
6           Kim         45000.0
7           James       10000.0

Einstellen der Breite der Ausgabespalte

Manchmal treten im Fall von ein Problem im Zusammenhang mit der abgeschnittenen Ausgabe auf .mode columnDies geschieht aufgrund der Standardbreite der anzuzeigenden Spalte. Was Sie tun können, ist, dass Sie die spaltenanzeigbare Spaltenbreite mit festlegen können.width num, num.... Befehl wie folgt -

sqlite>.width 10, 20, 10
sqlite>SELECT * FROM COMPANY;

Obenstehendes .width Der Befehl setzt die erste Spaltenbreite auf 10, die zweite Spaltenbreite auf 20 und die dritte Spaltenbreite auf 10. Schließlich liefert die obige SELECT-Anweisung das folgende Ergebnis.

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

Schemainformationen

Wie alle dot commands sind an der SQLite-Eingabeaufforderung verfügbar. Daher verwenden Sie beim Programmieren mit SQLite die folgende SELECT-Anweisung mit sqlite_master Tabelle, um alle in Ihrer Datenbank erstellten Tabellen aufzulisten.

sqlite> SELECT tbl_name FROM sqlite_master WHERE type = 'table';

Angenommen, Sie haben nur die Tabelle COMPANY in Ihrer testDB.db, führt dies zu folgendem Ergebnis.

tbl_name
----------
COMPANY

Sie können die vollständigen Informationen zur COMPANY-Tabelle wie folgt auflisten:

sqlite> SELECT sql FROM sqlite_master WHERE type = 'table' AND tbl_name = 'COMPANY';

Angenommen, Sie haben nur die Tabelle COMPANY in Ihrer testDB.db, führt dies zu folgendem Ergebnis.

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
)

Was ist ein Operator in SQLite?

Ein Operator ist ein reserviertes Wort oder ein Zeichen, das hauptsächlich in der WHERE-Klausel einer SQLite-Anweisung verwendet wird, um Operationen auszuführen, z. B. Vergleiche und arithmetische Operationen.

Operatoren werden verwendet, um Bedingungen in einer SQLite-Anweisung anzugeben und als Konjunktionen für mehrere Bedingungen in einer Anweisung zu dienen.

• Rechenzeichen
• Vergleichsoperatoren
• Logische Operatoren
• Bitweise Operatoren

SQLite-Arithmetikoperatoren

Variable annehmen a hält 10 und variabel b hält 20, dann werden SQLite-Arithmetikoperatoren wie folgt verwendet:

Beispiele anzeigen

Operator	Beschreibung	Beispiel
+ (Ergänzung)	Fügt Werte auf beiden Seiten des Operators hinzu	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
/ (Teilung)	Teilt den linken Operanden durch den rechten Operanden	b / a ergibt 2
% (Modul)	Dividiert den linken Operanden durch den rechten Operanden und gibt den Rest zurück	b% a ergibt 0

SQLite-Vergleichsoperatoren

Variable annehmen a hält 10 und variabel b hält 20, dann werden SQLite-Vergleichsoperatoren wie folgt verwendet

Beispiele anzeigen

Operator	Beschreibung	Beispiel
==	Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn ja, wird die Bedingung erfüllt.	(a == b) ist nicht wahr.
=	Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn ja, wird die Bedingung erfüllt.	(a = b) ist nicht wahr.
! =	Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr.	(a! = b) ist wahr.
<>	Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr.	(a <> b) ist wahr.
>	Überprüft, ob die Werte des linken Operanden größer als der Wert des rechten Operanden sind. Wenn ja, wird die Bedingung erfüllt.	(a> b) ist nicht wahr.
<	Überprüft, ob die Werte des linken Operanden kleiner als der Wert des rechten Operanden sind. Wenn ja, wird die Bedingung erfüllt.	(a <b) ist wahr.
> =	Überprüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung erfüllt.	(a> = b) ist nicht wahr.
<=	Überprüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung erfüllt.	(a <= b) ist wahr.
! <	Überprüft, ob der Wert des linken Operanden nicht kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung erfüllt.	(a! <b) ist falsch.
!>	Überprüft, ob der Wert des linken Operanden nicht größer als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung erfüllt.	(a!> b) ist wahr.

Logische SQLite-Operatoren

Hier ist eine Liste aller in SQLite verfügbaren logischen Operatoren.

Beispiele anzeigen

Sr.Nr.	Betreiber & Beschreibung
1	AND Der AND-Operator ermöglicht das Vorhandensein mehrerer Bedingungen in der WHERE-Klausel einer SQL-Anweisung.
2	BETWEEN Der Operator BETWEEN wird verwendet, um nach Werten zu suchen, die innerhalb eines Satzes von Werten liegen, wobei der Minimalwert und der Maximalwert angegeben werden.
3	EXISTS Der EXISTS-Operator wird verwendet, um nach dem Vorhandensein einer Zeile in einer angegebenen Tabelle zu suchen, die bestimmte Kriterien erfüllt.
4	IN Der IN-Operator wird verwendet, um einen Wert mit einer Liste der angegebenen Literalwerte zu vergleichen.
5	NOT IN Die Negation des IN-Operators, mit der ein Wert mit einer Liste der angegebenen Literalwerte verglichen wird.
6	LIKE Der LIKE-Operator wird verwendet, um einen Wert mit Platzhalteroperatoren mit ähnlichen Werten zu vergleichen.
7	GLOB Der GLOB-Operator wird verwendet, um einen Wert mit Platzhalteroperatoren mit ähnlichen Werten zu vergleichen. Außerdem unterscheidet GLOB im Gegensatz zu LIKE zwischen Groß- und Kleinschreibung.
8	NOT Der NOT-Operator kehrt die Bedeutung des logischen Operators um, mit dem er verwendet wird. Z.B. NICHT EXISTIERT, NICHT ZWISCHEN, NICHT IN usw.This is negate operator.
9	OR Der OR-Operator wird verwendet, um mehrere Bedingungen in der WHERE-Klausel einer SQL-Anweisung zu kombinieren.
10	IS NULL Der NULL-Operator wird verwendet, um einen Wert mit einem NULL-Wert zu vergleichen.
11	IS Der IS-Operator arbeitet wie =
12	IS NOT Der IS-Operator arbeitet wie! =
13	|| Fügt zwei verschiedene Zeichenfolgen hinzu und erstellt eine neue.
14	UNIQUE Der UNIQUE-Operator durchsucht jede Zeile einer angegebenen Tabelle nach Eindeutigkeit (keine Duplikate).

Bitweise SQLite-Operatoren

Der bitweise Operator arbeitet mit Bits und führt eine bitweise Operation durch. Es folgt die Wahrheitstabelle für& und |.

p	q	p & q	p | q
0	0	0	0
0	1	0	1
1	1	1	1
1	0	0	1

Angenommen, wenn A= 60; undB = 13, dann sind sie im Binärformat wie folgt:

A = 0011 1100

B = 0000 1101

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

A & B = 0000 1100

A | B = 0011 1101

~ A = 1100 0011

Die von der SQLite-Sprache unterstützten bitweisen Operatoren sind in der folgenden Tabelle aufgeführt. Variable annehmenA hält 60 und variabel B hält 13, dann -

Beispiele anzeigen

Operator	Beschreibung	Beispiel
&	Der binäre UND-Operator kopiert ein wenig in das Ergebnis, wenn es in beiden Operanden vorhanden ist.	(A & B) ergibt 12, was 0000 1100 ist
|	Der binäre ODER-Operator kopiert ein Bit, wenn es in einem der Operanden vorhanden ist.	(A | B) ergibt 61, was 0011 1101 ist
~	Der Komplementoperator für binäre Einsen ist unär und bewirkt das Umdrehen von Bits.	(~ A) ergibt -61, was aufgrund einer vorzeichenbehafteten Binärzahl 1100 0011 in 2er-Komplementform ist
<<	Binärer Linksschaltoperator. Der Wert der linken Operanden wird um die Anzahl der vom rechten Operanden angegebenen Bits nach links verschoben.	Ein << 2 ergibt 240, was 1111 0000 ist
>>	Binärer Rechtsschieber. Der Wert der linken Operanden wird um die Anzahl der vom rechten Operanden angegebenen Bits nach rechts verschoben.	Eine >> 2 ergibt 15, was 0000 1111 ist

Ein Ausdruck ist eine Kombination aus einem oder mehreren Werten, Operatoren und SQL-Funktionen, die zu einem Wert ausgewertet werden.

SQL-Ausdrücke sind wie Formeln und in Abfragesprache geschrieben. Sie können die Datenbank auch nach einem bestimmten Datensatz abfragen.

Syntax

Betrachten Sie die grundlegende Syntax der SELECT-Anweisung wie folgt:

SELECT column1, column2, columnN 
FROM table_name 
WHERE [CONDITION | EXPRESSION];

Im Folgenden sind die verschiedenen Arten von SQLite-Ausdrücken aufgeführt.

SQLite - Boolesche Ausdrücke

SQLite Boolean Expressions rufen die Daten auf der Basis eines übereinstimmenden Einzelwerts ab. Es folgt die Syntax -

SELECT column1, column2, columnN 
FROM table_name 
WHERE SINGLE VALUE MATCHTING EXPRESSION;

Betrachten Sie die COMPANY-Tabelle mit den folgenden Datensätzen:

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

Im Folgenden finden Sie einfache Beispiele für die Verwendung von booleschen SQLite-Ausdrücken.

sqlite> SELECT * FROM COMPANY WHERE SALARY = 10000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           James        24          Houston   10000.0

SQLite - Numerischer Ausdruck

Diese Ausdrücke werden verwendet, um eine beliebige mathematische Operation in einer Abfrage auszuführen. Es folgt die Syntax -

SELECT numerical_expression as OPERATION_NAME
[FROM table_name WHERE CONDITION] ;

Hier wird numerischer Ausdruck für mathematische Ausdrücke oder beliebige Formeln verwendet. Das folgende Beispiel zeigt die Verwendung von numerischen SQLite-Ausdrücken.

sqlite> SELECT (15 + 6) AS ADDITION
ADDITION = 21

Es gibt mehrere integrierte Funktionen wie avg(), sum(), count(), usw., um das durchzuführen, was als bekannt ist aggregate data calculations gegen eine Tabelle oder eine bestimmte Tabellenspalte.

sqlite> SELECT COUNT(*) AS "RECORDS" FROM COMPANY; 
RECORDS = 7

SQLite - Datumsausdrücke

Datumsausdrücke geben die aktuellen Systemdatum- und -zeitwerte zurück. Diese Ausdrücke werden bei verschiedenen Datenmanipulationen verwendet.

sqlite> SELECT CURRENT_TIMESTAMP;
CURRENT_TIMESTAMP = 2013-03-17 10:43:35

SQLite WHERE Klausel wird verwendet, um eine Bedingung anzugeben, während die Daten aus einer Tabelle oder mehreren Tabellen abgerufen werden.

Wenn die gegebene Bedingung erfüllt ist, bedeutet wahr, dann gibt es den spezifischen Wert aus der Tabelle zurück. Sie müssen die WHERE-Klausel verwenden, um die Datensätze zu filtern und nur die erforderlichen Datensätze abzurufen.

Die WHERE-Klausel wird nicht nur in der SELECT-Anweisung verwendet, sondern auch in der UPDATE-, DELETE-Anweisung usw., die in den folgenden Kapiteln behandelt wird.

Syntax

Es folgt die grundlegende Syntax der SQLite SELECT-Anweisung mit der WHERE-Klausel.

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition]

Beispiel

Sie können eine Bedingung mithilfe von Vergleichs- oder logischen Operatoren wie>, <, =, LIKE, NOT usw. angeben . Betrachten Sie die Tabelle COMPANY mit den folgenden Datensätzen:

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

Im Folgenden finden Sie einfache Beispiele für die Verwendung von SQLite Logical Operators. Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen AGE größer oder gleich 25 istAND Das Gehalt ist größer oder gleich 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

Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen AGE größer oder gleich 25 ist OR Das Gehalt ist größer oder gleich 65000,00.

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. Dies bedeutet, dass alle Datensätze vorhanden sind, da keiner der Datensätze 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, in denen NAME mit 'Ki' beginnt, unabhängig davon, was nach 'Ki' kommt.

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, in denen NAME mit 'Ki' beginnt, unabhängig davon, was nach 'Ki' kommt.

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 der AGE-Wert entweder 25 oder 27 beträgt.

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 der AGE-Wert weder 25 noch 27 beträgt.

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, in denen sich der AGE-Wert zwischen 25 und 27 befindet.

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 die SQL-Unterabfrage, wobei die Unterabfrage alle Datensätze mit dem AGE-Feld mit SALARY> 65000 und höher findet. Die WHERE-Klausel wird zusammen mit dem EXISTS-Operator verwendet, um alle Datensätze aufzulisten, in denen AGE von der externen Abfrage vorhanden ist in dem von der Unterabfrage zurückgegebenen Ergebnis -

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, bei der die Unterabfrage alle Datensätze mit dem AGE-Feld mit SALARY> 65000 und höher findet. Die WHERE-Klausel wird zusammen mit dem Operator> verwendet, um alle Datensätze aufzulisten, bei denen AGE von der externen Abfrage größer ist als das Alter im Ergebnis, das von der Unterabfrage zurückgegeben wird.

sqlite> SELECT * FROM COMPANY 
   WHERE AGE > (SELECT AGE FROM COMPANY WHERE SALARY > 65000);

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0

SQLite AND & OROperatoren werden verwendet, um mehrere Bedingungen zu kompilieren, um die ausgewählten Daten in einer SQLite-Anweisung einzugrenzen. Diese beiden Operatoren werden aufgerufenconjunctive operators.

Diese Operatoren bieten die Möglichkeit, mehrere Vergleiche mit verschiedenen Operatoren in derselben SQLite-Anweisung durchzuführen.

Der AND-Operator

Das ANDDer Operator ermöglicht das Vorhandensein mehrerer Bedingungen in der WHERE-Klausel einer SQLite-Anweisung. Bei Verwendung des AND-Operators wird die vollständige Bedingung als wahr angenommen, wenn alle Bedingungen erfüllt sind. Zum Beispiel sind [Bedingung1] UND [Bedingung2] nur dann wahr, wenn sowohl Bedingung1 als auch Bedingung2 wahr sind.

Syntax

Es folgt die grundlegende Syntax des AND-Operators mit der WHERE-Klausel.

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];

Sie können kombinieren NAnzahl der Bedingungen mit dem Operator AND. Damit eine Aktion von der SQLite-Anweisung ausgeführt werden kann, unabhängig davon, ob es sich um eine Transaktion oder eine Abfrage handelt, müssen alle durch das UND getrennten Bedingungen TRUE sein.

Beispiel

Betrachten Sie die COMPANY-Tabelle mit den folgenden Datensätzen:

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 AGE größer oder gleich 25 ist AND Das Gehalt ist größer oder gleich 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

Der OP-Operator

Der OR-Operator wird auch verwendet, um mehrere Bedingungen in der WHERE-Klausel einer SQLite-Anweisung zu kombinieren. Bei Verwendung des ODER-Operators wird die vollständige Bedingung als wahr angenommen, wenn mindestens eine der Bedingungen wahr ist. Zum Beispiel ist [Bedingung1] ODER [Bedingung2] wahr, wenn entweder Bedingung1 oder Bedingung2 wahr ist.

Syntax

Es folgt die grundlegende Syntax des Operators OR mit der WHERE-Klausel.

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]

Sie können kombinieren NAnzahl der Bedingungen mit dem Operator OR. Damit eine Aktion von der SQLite-Anweisung ausgeführt werden kann, unabhängig davon, ob es sich um eine Transaktion oder eine Abfrage handelt, muss nur EINE der durch das ODER getrennten Bedingungen TRUE sein.

Beispiel

Betrachten Sie die COMPANY-Tabelle mit den folgenden Datensätzen.

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 AGE größer oder gleich 25 ist OR Das Gehalt ist größer oder gleich 65000,00.

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

SQLite UPDATEDie Abfrage wird verwendet, um die vorhandenen Datensätze in einer Tabelle zu ändern. Sie können die WHERE-Klausel mit der UPDATE-Abfrage verwenden, um ausgewählte Zeilen zu aktualisieren. Andernfalls werden alle Zeilen aktualisiert.

Syntax

Im Folgenden finden Sie die grundlegende Syntax der UPDATE-Abfrage mit der WHERE-Klausel.

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

Sie können kombinieren N Anzahl der Bedingungen mit UND- oder ODER-Operatoren.

Beispiel

Betrachten Sie die COMPANY-Tabelle mit den folgenden Datensätzen:

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

Im Folgenden finden Sie ein Beispiel, mit dem ADRESSE für einen Kunden mit der ID 6 aktualisiert wird.

sqlite> UPDATE COMPANY SET ADDRESS = 'Texas' WHERE ID = 6;

Die COMPANY-Tabelle enthält nun 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          Texas       45000.0
7           James       24          Houston     10000.0

Wenn Sie alle Spaltenwerte ADDRESS und SALARY in der Tabelle COMPANY ändern möchten, müssen Sie die WHERE-Klausel nicht verwenden. Die UPDATE-Abfrage lautet wie folgt:

sqlite> UPDATE COMPANY SET ADDRESS = 'Texas', SALARY = 20000.00;

Die Tabelle COMPANY enthält nun die folgenden Datensätze:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          Texas       20000.0
2           Allen       25          Texas       20000.0
3           Teddy       23          Texas       20000.0
4           Mark        25          Texas       20000.0
5           David       27          Texas       20000.0
6           Kim         22          Texas       20000.0
7           James       24          Texas       20000.0

SQLite DELETEDie Abfrage wird verwendet, um die vorhandenen Datensätze aus einer Tabelle zu löschen. Sie können die WHERE-Klausel mit der DELETE-Abfrage verwenden, um die ausgewählten Zeilen zu löschen, da sonst alle Datensätze gelöscht würden.

Syntax

Es folgt die grundlegende Syntax der DELETE-Abfrage mit der WHERE-Klausel.

DELETE FROM table_name
WHERE [condition];

Sie können kombinieren N Anzahl der Bedingungen mit UND- oder ODER-Operatoren.

Beispiel

Betrachten Sie die COMPANY-Tabelle mit den folgenden Datensätzen.

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

Das folgende Beispiel löscht einen Kunden mit der ID 7.

sqlite> DELETE FROM COMPANY WHERE ID = 7;

Jetzt enthält die COMPANY-Tabelle 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

Wenn Sie alle Datensätze aus der COMPANY-Tabelle LÖSCHEN möchten, müssen Sie die WHERE-Klausel nicht mit der DELETE-Abfrage verwenden.

sqlite> DELETE FROM COMPANY;

Die COMPANY-Tabelle enthält jetzt keinen Datensatz, da alle Datensätze mit der DELETE-Anweisung gelöscht wurden.

SQLite LIKEDer Operator wird verwendet, um Textwerte mithilfe von Platzhaltern mit einem Muster abzugleichen. Wenn der Suchausdruck mit dem Musterausdruck abgeglichen werden kann, gibt der LIKE-Operator true zurück (1). In Verbindung mit dem LIKE-Operator werden zwei Platzhalter verwendet.

• Das Prozentzeichen (%)
• Der Unterstrich (_)

Das Prozentzeichen steht für null, eins oder mehrere Zahlen oder Zeichen. Der Unterstrich steht für eine einzelne Zahl oder ein einzelnes Zeichen. Diese Symbole können in Kombinationen verwendet werden.

Syntax

Es folgt die grundlegende Syntax von% und _.

SELECT FROM table_name
WHERE column LIKE 'XXXX%'
or 
SELECT FROM table_name
WHERE column LIKE '%XXXX%'
or
SELECT FROM table_name
WHERE column LIKE 'XXXX_'
or
SELECT FROM table_name
WHERE column LIKE '_XXXX'
or
SELECT FROM table_name
WHERE column LIKE '_XXXX_'

Sie können kombinieren NAnzahl der Bedingungen mit UND- oder ODER-Operatoren. Hier kann XXXX ein beliebiger numerischer Wert oder ein Zeichenfolgenwert sein.

Beispiel

In der folgenden Tabelle sind einige Beispiele aufgeführt, die zeigen, wo der WHERE-Teil eine andere LIKE-Klausel mit den Operatoren '%' und '_' hat.

Sr.Nr.	Aussage & Beschreibung
1	WHERE SALARY LIKE '200%' Findet alle Werte, die mit 200 beginnen
2	WHERE SALARY LIKE '%200%' Findet alle Werte mit 200 an einer beliebigen Position
3	WHERE SALARY LIKE '_00%' Findet alle Werte mit 00 an der zweiten und dritten Position
4	WHERE SALARY LIKE '2_%_%' Findet alle Werte, die mit 2 beginnen und mindestens 3 Zeichen lang sind
5	WHERE SALARY LIKE '%2' Findet alle Werte, die mit 2 enden
6	WHERE SALARY LIKE '_2%3' Findet alle Werte, die an zweiter Stelle eine 2 haben und mit einer 3 enden
7	WHERE SALARY LIKE '2___3' Findet alle Werte in einer fünfstelligen Zahl, die mit 2 beginnt und mit 3 endet

Nehmen wir ein reales Beispiel, betrachten wir die COMPANY-Tabelle mit den folgenden Datensätzen.

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

Im Folgenden finden Sie ein Beispiel, in dem alle Datensätze aus der COMPANY-Tabelle angezeigt werden, in der AGE mit 2 beginnt.

sqlite> SELECT * FROM COMPANY WHERE AGE LIKE '2%';

Dies führt zu folgendem Ergebnis.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
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

Im Folgenden finden Sie ein Beispiel, in dem alle Datensätze aus der Tabelle COMPANY angezeigt werden, in der ADDRESS einen Bindestrich (-) im Text enthält.

sqlite> SELECT * FROM COMPANY WHERE ADDRESS  LIKE '%-%';

Dies führt zu folgendem Ergebnis.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
6           Kim         22          South-Hall  45000.0

SQLite GLOBDer Operator wird verwendet, um nur Textwerte mithilfe von Platzhaltern mit einem Muster abzugleichen. Wenn der Suchausdruck mit dem Musterausdruck abgeglichen werden kann, gibt der GLOB-Operator true zurück (1). Im Gegensatz zum LIKE-Operator unterscheidet GLOB zwischen Groß- und Kleinschreibung und folgt der UNIX-Syntax zur Angabe der folgenden Platzhalter.

• Das Sternchen (*)
• Das Fragezeichen (?)

Das Sternchen (*) steht für null oder mehrere Zahlen oder Zeichen. Das Fragezeichen (?) Steht für eine einzelne Zahl oder ein einzelnes Zeichen.

Syntax

Es folgt die grundlegende Syntax von * und ?.

SELECT FROM table_name
WHERE column GLOB 'XXXX*'
or 
SELECT FROM table_name
WHERE column GLOB '*XXXX*'
or
SELECT FROM table_name
WHERE column GLOB 'XXXX?'
or
SELECT FROM table_name
WHERE column GLOB '?XXXX'
or
SELECT FROM table_name
WHERE column GLOB '?XXXX?'
or
SELECT FROM table_name
WHERE column GLOB '????'

Sie können kombinieren NAnzahl der Bedingungen mit UND- oder ODER-Operatoren. Hier kann XXXX ein beliebiger numerischer Wert oder ein Zeichenfolgenwert sein.

Beispiel

In der folgenden Tabelle sind einige Beispiele aufgeführt, die zeigen, wo der WHERE-Teil eine andere LIKE-Klausel mit '*' und '?' Betreiber.

Sr.Nr.	Aussage & Beschreibung
1	WHERE SALARY GLOB '200*' Findet alle Werte, die mit 200 beginnen
2	WHERE SALARY GLOB '*200*' Findet alle Werte mit 200 an einer beliebigen Position
3	WHERE SALARY GLOB '?00*' Findet alle Werte mit 00 an der zweiten und dritten Position
4	WHERE SALARY GLOB '2??' Findet alle Werte, die mit 2 beginnen und mindestens 3 Zeichen lang sind
5	WHERE SALARY GLOB '*2' Findet alle Werte, die mit 2 enden
6	WHERE SALARY GLOB '?2*3' Findet alle Werte, die eine 2 an zweiter Stelle haben und mit einer 3 enden
7	WHERE SALARY GLOB '2???3' Findet alle Werte in einer fünfstelligen Zahl, die mit 2 beginnen und mit 3 enden

Nehmen wir ein reales Beispiel, betrachten wir die COMPANY-Tabelle mit den folgenden Datensätzen:

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

Im Folgenden finden Sie ein Beispiel, in dem alle Datensätze aus der COMPANY-Tabelle angezeigt werden, wobei AGE mit 2 beginnt.

sqlite> SELECT * FROM COMPANY WHERE AGE  GLOB '2*';

Dies führt zu folgendem Ergebnis.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
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

Im Folgenden finden Sie ein Beispiel, in dem alle Datensätze aus der Tabelle COMPANY angezeigt werden, in der ADDRESS einen Bindestrich (-) im Text enthält.

sqlite> SELECT * FROM COMPANY WHERE ADDRESS  GLOB '*-*';

Dies führt zu folgendem Ergebnis.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
6           Kim         22          South-Hall  45000.0

SQLite LIMIT Klausel wird verwendet, um die von der SELECT-Anweisung zurückgegebene Datenmenge zu begrenzen.

Syntax

Es folgt die grundlegende Syntax der SELECT-Anweisung mit der LIMIT-Klausel.

SELECT column1, column2, columnN 
FROM table_name
LIMIT [no of rows]

Es folgt die Syntax der LIMIT-Klausel, wenn sie zusammen mit der OFFSET-Klausel verwendet wird.

SELECT column1, column2, columnN 
FROM table_name
LIMIT [no of rows] OFFSET [row num]

Die SQLite-Engine gibt Zeilen ab der nächsten Zeile an das angegebene OFFSET zurück, wie im letzten Beispiel unten gezeigt.

Beispiel

Betrachten Sie die COMPANY-Tabelle mit den folgenden Datensätzen:

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

Im Folgenden finden Sie ein Beispiel, das die Zeile in der Tabelle entsprechend der Anzahl der Zeilen begrenzt, die Sie aus der Tabelle abrufen möchten.

sqlite> SELECT * FROM COMPANY LIMIT 6;

Dies führt zu folgendem Ergebnis.

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

In bestimmten Situationen müssen Sie jedoch möglicherweise eine Reihe von Datensätzen von einem bestimmten Versatz abholen. Hier ist ein Beispiel, das picks up 3 Datensätze aus der 3 Ausgang ^rd Position.

sqlite> SELECT * FROM COMPANY LIMIT 3 OFFSET 2;

Dies führt zu folgendem Ergebnis.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

SQLite ORDER BY Klausel wird verwendet, um die Daten in aufsteigender oder absteigender Reihenfolge basierend auf einer oder mehreren Spalten zu sortieren.

Syntax

Es folgt die grundlegende Syntax der ORDER BY-Klausel.

SELECT column-list 
FROM table_name 
[WHERE condition] 
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

Sie können mehr als eine Spalte in der ORDER BY-Klausel verwenden. Stellen Sie sicher, dass jede Spalte, die Sie zum Sortieren verwenden, in der Spaltenliste verfügbar sein sollte.

Beispiel

Betrachten Sie die COMPANY-Tabelle mit den folgenden Datensätzen.

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

Es folgt ein Beispiel, in dem das Ergebnis in absteigender Reihenfolge nach GEHALT sortiert wird.

sqlite> SELECT * FROM COMPANY ORDER BY SALARY ASC;

Dies führt zu folgendem Ergebnis.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
7           James       24          Houston     10000.0
2           Allen       25          Texas       15000.0
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
6           Kim         22          South-Hall  45000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

Im Folgenden finden Sie ein Beispiel, in dem das Ergebnis in absteigender Reihenfolge nach NAME und SALARY sortiert wird.

sqlite> SELECT * FROM COMPANY ORDER BY NAME, SALARY ASC;

Dies führt zu folgendem Ergebnis.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
5           David       27          Texas       85000.0
7           James       24          Houston     10000.0
6           Kim         22          South-Hall  45000.0
4           Mark        25          Rich-Mond   65000.0
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0

Es folgt ein Beispiel, in dem das Ergebnis in absteigender Reihenfolge nach NAME sortiert wird.

sqlite> SELECT * FROM COMPANY ORDER BY NAME DESC;

Dies führt zu folgendem Ergebnis.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
3           Teddy       23          Norway      20000.0
1           Paul        32          California  20000.0
4           Mark        25          Rich-Mond   65000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
5           David       27          Texas       85000.0
2           Allen       25          Texas       15000.0

SQLite GROUP BY Die Klausel wird in Zusammenarbeit mit der SELECT-Anweisung verwendet, um identische Daten in Gruppen anzuordnen.

Die GROUP BY-Klausel folgt der WHERE-Klausel in einer SELECT-Anweisung und steht vor der ORDER BY-Klausel.

Syntax

Es folgt die grundlegende Syntax der GROUP BY-Klausel. Die GROUP BY-Klausel muss den Bedingungen in der WHERE-Klausel entsprechen und der ORDER BY-Klausel vorangehen, falls eine verwendet wird.

SELECT column-list
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2....columnN
ORDER BY column1, column2....columnN

Sie können mehr als eine Spalte in der GROUP BY-Klausel verwenden. Stellen Sie sicher, dass die Spalte, die Sie zum Gruppieren verwenden, in der Spaltenliste verfügbar sein sollte.

Beispiel

Betrachten Sie die COMPANY-Tabelle mit den folgenden Datensätzen.

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

Wenn Sie den Gesamtlohn für jeden Kunden wissen möchten, lautet die GROUP BY-Abfrage wie folgt:

sqlite> SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME;

Dies führt zu folgendem Ergebnis:

NAME        SUM(SALARY)
----------  -----------
Allen       15000.0
David       85000.0
James       10000.0
Kim         45000.0
Mark        65000.0
Paul        20000.0
Teddy       20000.0

Lassen Sie uns nun drei weitere Datensätze in der COMPANY-Tabelle mit den folgenden INSERT-Anweisungen erstellen.

INSERT INTO COMPANY VALUES (8, 'Paul', 24, 'Houston', 20000.00 );
INSERT INTO COMPANY VALUES (9, 'James', 44, 'Norway', 5000.00 );
INSERT INTO COMPANY VALUES (10, 'James', 45, 'Texas', 5000.00 );

Unsere Tabelle enthält jetzt die folgenden Datensätze mit doppelten Namen.

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
8           Paul        24          Houston     20000.0
9           James       44          Norway      5000.0
10          James       45          Texas       5000.0

Verwenden wir wieder dieselbe Anweisung, um alle Datensätze mithilfe der NAME-Spalte wie folgt zu gruppieren:

sqlite> SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME ORDER BY NAME;

Dies führt zu folgendem Ergebnis.

NAME        SUM(SALARY)
----------  -----------
Allen       15000
David       85000
James       20000
Kim         45000
Mark        65000
Paul        40000
Teddy       20000

Verwenden wir die ORDER BY-Klausel zusammen mit der GROUP BY-Klausel wie folgt:

sqlite>  SELECT NAME, SUM(SALARY) 
   FROM COMPANY GROUP BY NAME ORDER BY NAME DESC;

Dies führt zu folgendem Ergebnis.

NAME        SUM(SALARY)
----------  -----------
Teddy       20000
Paul        40000
Mark        65000
Kim         45000
James       20000
David       85000
Allen       15000

Mit der HAVING-Klausel können Sie Bedingungen angeben, die filtern, welche Gruppenergebnisse in den Endergebnissen angezeigt werden.

Mit der WHERE-Klausel werden Bedingungen für die ausgewählten Spalten festgelegt, während mit der HAVING-Klausel Bedingungen für Gruppen festgelegt werden, die mit der GROUP BY-Klausel erstellt wurden.

Syntax

Es folgt die Position der HAVING-Klausel in einer SELECT-Abfrage.

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

Die HAVING-Klausel muss in einer Abfrage der GROUP BY-Klausel folgen und bei Verwendung auch der ORDER BY-Klausel vorangehen. Es folgt die Syntax der SELECT-Anweisung, einschließlich der HAVING-Klausel.

SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2

Beispiel

Betrachten Sie die COMPANY-Tabelle mit den folgenden Datensätzen.

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
8           Paul        24          Houston     20000.0
9           James       44          Norway      5000.0
10          James       45          Texas       5000.0

Das folgende Beispiel zeigt den Datensatz an, für den die Anzahl der Namen weniger als 2 beträgt.

sqlite > SELECT * FROM COMPANY GROUP BY name HAVING count(name) < 2;

Dies führt zu folgendem Ergebnis.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000
5           David       27          Texas       85000
6           Kim         22          South-Hall  45000
4           Mark        25          Rich-Mond   65000
3           Teddy       23          Norway      20000

Das folgende Beispiel zeigt den Datensatz an, für den die Anzahl der Namen größer als 2 ist.

sqlite > SELECT * FROM COMPANY GROUP BY name HAVING count(name) > 2;

Dies führt zu folgendem Ergebnis.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
10          James       45          Texas       5000

SQLite DISTINCT Das Schlüsselwort wird in Verbindung mit der SELECT-Anweisung verwendet, um alle doppelten Datensätze zu entfernen und nur die eindeutigen Datensätze abzurufen.

Es kann vorkommen, dass eine Tabelle mehrere doppelte Datensätze enthält. Beim Abrufen solcher Datensätze ist es sinnvoller, nur eindeutige Datensätze abzurufen, anstatt doppelte Datensätze abzurufen.

Syntax

Im Folgenden finden Sie die grundlegende Syntax des Schlüsselworts DISTINCT, um doppelte Datensätze zu entfernen.

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

Beispiel

Betrachten Sie die COMPANY-Tabelle mit den folgenden Datensätzen.

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
8           Paul        24          Houston     20000.0
9           James       44          Norway      5000.0
10          James       45          Texas       5000.0

Lassen Sie uns zunächst sehen, wie die folgende SELECT-Abfrage doppelte Gehaltsdatensätze zurückgibt.

sqlite> SELECT name FROM COMPANY;

Dies führt zu folgendem Ergebnis.

NAME
----------
Paul
Allen
Teddy
Mark
David
Kim
James
Paul
James
James

Lassen Sie uns jetzt verwenden DISTINCT Schlüsselwort mit der obigen SELECT-Abfrage und sehen Sie das Ergebnis.

sqlite> SELECT DISTINCT name FROM COMPANY;

Dies führt zu folgendem Ergebnis, wenn kein doppelter Eintrag vorhanden ist.

NAME
----------
Paul
Allen
Teddy
Mark
David
Kim
James

SQLite PRAGMADer Befehl ist ein spezieller Befehl zur Steuerung verschiedener Umgebungsvariablen und Statusflags in der SQLite-Umgebung. Ein PRAGMA-Wert kann gelesen und basierend auf den Anforderungen festgelegt werden.

Syntax

Um den aktuellen PRAGMA-Wert abzufragen, geben Sie einfach den Namen des Pragmas an.

PRAGMA pragma_name;

Verwenden Sie die folgende Syntax, um einen neuen Wert für PRAGMA festzulegen.

PRAGMA pragma_name = value;

Der Set-Modus kann entweder der Name oder das Ganzzahläquivalent sein, aber der zurückgegebene Wert ist immer eine Ganzzahl.

auto_vacuum Pragma

Das auto_vacuumPragma ruft den automatischen Vakuummodus ab oder stellt ihn ein. Es folgt die einfache Syntax.

PRAGMA [database.]auto_vacuum;
PRAGMA [database.]auto_vacuum = mode;

Wo mode kann eine der folgenden sein -

Sr.Nr.	Pragma Wert & Beschreibung
1	0 or NONE Das automatische Vakuum ist deaktiviert. Dies ist der Standardmodus. Dies bedeutet, dass eine Datenbankdatei niemals kleiner wird, wenn sie nicht manuell mit dem Befehl VACUUM gesaugt wird.
2	1 or FULL Das automatische Vakuum ist aktiviert und vollautomatisch, sodass eine Datenbankdatei verkleinert werden kann, wenn Daten aus der Datenbank entfernt werden.
3	2 or INCREMENTAL Das automatische Vakuum ist aktiviert, muss jedoch manuell aktiviert werden. In diesem Modus bleiben die Referenzdaten erhalten, aber freie Seiten werden einfach auf die freie Liste gesetzt. Diese Seiten können mit dem wiederhergestellt werdenincremental_vacuum pragma Jederzeit.

cache_size Pragma

Das cache_sizePragma kann die maximale Größe des speicherinternen Seitencaches abrufen oder vorübergehend festlegen. Es folgt die einfache Syntax.

PRAGMA [database.]cache_size;
PRAGMA [database.]cache_size = pages;

Das pagesvalue gibt die Anzahl der Seiten im Cache an. Der integrierte Seitencache hat eine Standardgröße von 2.000 Seiten und eine Mindestgröße von 10 Seiten.

case_sensitive_like Pragma

Das case_sensitive_likePragma steuert die Groß- und Kleinschreibung des integrierten LIKE-Ausdrucks. Standardmäßig ist dieses Pragma falsch, was bedeutet, dass der integrierte LIKE-Operator die Groß- und Kleinschreibung ignoriert. Es folgt die einfache Syntax.

PRAGMA case_sensitive_like = [true|false];

Es gibt keine Möglichkeit, den aktuellen Status dieses Pragmas abzufragen.

count_changes Pragma

count_changesPragma ruft den Rückgabewert von Datenmanipulationsanweisungen wie INSERT, UPDATE und DELETE ab oder legt diesen fest. Es folgt die einfache Syntax.

PRAGMA count_changes;
PRAGMA count_changes = [true|false];

Standardmäßig ist dieses Pragma falsch und diese Anweisungen geben nichts zurück. Wenn true festgelegt ist, gibt jede der genannten Anweisungen eine einspaltige, einzeilige Tabelle zurück, die aus einem einzelnen ganzzahligen Wert besteht, der die von der Operation betroffenen Zeilen angibt.

database_list Pragma

Das database_listPragma wird verwendet, um alle angehängten Datenbanken aufzulisten. Es folgt die einfache Syntax.

PRAGMA database_list;

Dieses Pragma gibt eine dreispaltige Tabelle mit einer Zeile pro geöffneter oder angehängter Datenbank zurück, in der die Datenbanksequenznummer, der Name und die zugehörige Datei angegeben sind.

Kodma codieren

Das encodingPragma steuert, wie Zeichenfolgen codiert und in einer Datenbankdatei gespeichert werden. Es folgt die einfache Syntax.

PRAGMA encoding;
PRAGMA encoding = format;

Der Formatwert kann einer von sein UTF-8, UTF-16le, oder UTF-16be.

freelist_count Pragma

Das freelist_countPragma gibt eine einzelne Ganzzahl zurück, die angibt, wie viele Datenbankseiten derzeit als frei und verfügbar markiert sind. Es folgt die einfache Syntax.

PRAGMA [database.]freelist_count;

Der Formatwert kann einer von sein UTF-8, UTF-16le, oder UTF-16be.

index_info Pragma

Das index_infoPragma gibt Informationen zu einem Datenbankindex zurück. Es folgt die einfache Syntax.

PRAGMA [database.]index_info( index_name );

Die Ergebnismenge enthält eine Zeile für jede im Index enthaltene Spalte mit der Spaltenfolge, dem Spaltenindex mit In-Tabelle und dem Spaltennamen.

index_list Pragma

index_listPragma listet alle einer Tabelle zugeordneten Indizes auf. Es folgt die einfache Syntax.

PRAGMA [database.]index_list( table_name );

Die Ergebnismenge enthält eine Zeile für jeden Index mit Indexsequenz, Indexname und Flag, die angibt, ob der Index eindeutig ist oder nicht.

journal_mode Pragma

Das journal_modepragma ruft den Journalmodus ab oder legt diesen fest, der steuert, wie die Journaldatei gespeichert und verarbeitet wird. Es folgt die einfache Syntax.

PRAGMA journal_mode;
PRAGMA journal_mode = mode;
PRAGMA database.journal_mode;
PRAGMA database.journal_mode = mode;

Es gibt fünf unterstützte Journalmodi, wie in der folgenden Tabelle aufgeführt.

Sr.Nr.	Pragma Wert & Beschreibung
1	DELETE Dies ist der Standardmodus. Hier wird nach Abschluss einer Transaktion die Journaldatei gelöscht.
2	TRUNCATE Die Journaldatei wird auf eine Länge von null Byte abgeschnitten.
3	PERSIST Die Journaldatei bleibt an Ort und Stelle, aber der Header wird überschrieben, um anzuzeigen, dass das Journal nicht mehr gültig ist.
4	MEMORY Der Journaldatensatz wird im Speicher und nicht auf der Festplatte gespeichert.
5	OFF Es werden keine Tagebuchaufzeichnungen geführt.

max_page_count Pragma

Das max_page_countPragma ruft die maximal zulässige Seitenzahl für eine Datenbank ab oder legt diese fest. Es folgt die einfache Syntax.

PRAGMA [database.]max_page_count;
PRAGMA [database.]max_page_count = max_page;

Der Standardwert ist 1.073.741.823, was einer Gigaseite entspricht. Wenn also die Standardseitengröße 1 KB beträgt, können Datenbanken auf ein Terabyte anwachsen.

page_count Pragma

Das page_countPragma gibt die aktuelle Anzahl der Seiten in der Datenbank zurück. Es folgt die einfache Syntax:

PRAGMA [database.]page_count;

Die Größe der Datenbankdatei sollte page_count * page_size sein.

page_size Pragma

Das page_sizePragma ruft die Größe der Datenbankseiten ab oder legt diese fest. Es folgt die einfache Syntax.

PRAGMA [database.]page_size;
PRAGMA [database.]page_size = bytes;

Standardmäßig sind die zulässigen Größen 512, 1024, 2048, 4096, 8192, 16384 und 32768 Byte. Die einzige Möglichkeit, die Seitengröße in einer vorhandenen Datenbank zu ändern, besteht darin, die Seitengröße festzulegen und die Datenbank sofort mit VACUUM zu versehen.

parser_trace Pragma

Das parser_tracePragma steuert das Drucken des Debugging-Status beim Parsen von SQL-Befehlen. Es folgt die einfache Syntax.

PRAGMA parser_trace = [true|false];

Standardmäßig ist es auf false gesetzt. Wenn es jedoch durch Setzen auf true aktiviert wird, druckt der SQL-Parser seinen Status beim Parsen von SQL-Befehlen.

recursive_triggers Pragma

Das recursive_triggersPragma ruft die rekursive Triggerfunktion ab oder setzt sie. Wenn rekursive Trigger nicht aktiviert sind, wird durch eine Triggeraktion kein weiterer Trigger ausgelöst. Es folgt die einfache Syntax.

PRAGMA recursive_triggers;
PRAGMA recursive_triggers = [true|false];

schema_version Pragma

Das schema_versionpragma ruft den im Datenbankheader gespeicherten Schemaversionswert ab oder legt diesen fest. Es folgt die einfache Syntax.

PRAGMA [database.]schema_version;
PRAGMA [database.]schema_version = number;

Dies ist ein 32-Bit-Ganzzahlwert mit Vorzeichen, der Schemaänderungen verfolgt. Immer wenn ein Befehl zum Ändern des Schemas ausgeführt wird (z. B. CREATE ... oder DROP ...), wird dieser Wert erhöht.

secure_delete Pragma

Das secure_deletePragma wird verwendet, um zu steuern, wie der Inhalt aus der Datenbank gelöscht wird. Es folgt die einfache Syntax.

PRAGMA secure_delete;
PRAGMA secure_delete = [true|false];
PRAGMA database.secure_delete;
PRAGMA database.secure_delete = [true|false];

Der Standardwert für das sichere Löschflag ist normalerweise deaktiviert. Dies kann jedoch mit der Buildoption SQLITE_SECURE_DELETE geändert werden.

sql_trace Pragma

Das sql_tracePragma wird verwendet, um SQL-Trace-Ergebnisse auf dem Bildschirm abzulegen. Es folgt die einfache Syntax.

PRAGMA sql_trace;
PRAGMA sql_trace = [true|false];

SQLite muss mit der Anweisung SQLITE_DEBUG kompiliert werden, damit dieses Pragma enthalten ist.

synchrones Pragma

Das synchronouspragma ruft den aktuellen Datenträgersynchronisierungsmodus ab oder legt diesen fest, der steuert, wie aggressiv SQLite Daten bis zum physischen Speicher schreibt. Es folgt die einfache Syntax.

PRAGMA [database.]synchronous;
PRAGMA [database.]synchronous = mode;

SQLite unterstützt die folgenden in der Tabelle aufgeführten Synchronisationsmodi.

Sr.Nr.	Pragma Wert & Beschreibung
1	0 or OFF Überhaupt keine Synchronisierungen
2	1 or NORMAL Synchronisieren Sie nach jeder Sequenz kritischer Festplattenvorgänge
3	2 or FULL Synchronisieren Sie nach jedem kritischen Festplattenvorgang

temp_store Pragma

Das temp_storepragma ruft den von temporären Datenbankdateien verwendeten Speichermodus ab oder legt diesen fest. Es folgt die einfache Syntax.

PRAGMA temp_store;
PRAGMA temp_store = mode;

SQLite unterstützt die folgenden Speichermodi.

Sr.Nr.	Pragma Wert & Beschreibung
1	0 or DEFAULT Verwenden Sie die Standardeinstellung für die Kompilierungszeit. Normalerweise DATEI.
2	1 or FILE Verwenden Sie dateibasierten Speicher.
3	2 or MEMORY Verwenden Sie speicherbasierten Speicher.

temp_store_directory Pragma

Das temp_store_directorypragma ruft den für temporäre Datenbankdateien verwendeten Speicherort ab oder legt diesen fest. Es folgt die einfache Syntax.

PRAGMA temp_store_directory;
PRAGMA temp_store_directory = 'directory_path';

user_version Pragma

Das user_versionpragma ruft den benutzerdefinierten Versionswert ab, der im Datenbankheader gespeichert ist, oder legt diesen fest. Es folgt die einfache Syntax.

PRAGMA [database.]user_version;
PRAGMA [database.]user_version = number;

Dies ist ein 32-Bit-Ganzzahlwert mit Vorzeichen, der vom Entwickler zur Versionsverfolgung festgelegt werden kann.

writable_schema Pragma

Das writable_schemaPragma erhält oder legt die Möglichkeit fest, Systemtabellen zu ändern. Es folgt die einfache Syntax.

PRAGMA writable_schema;
PRAGMA writable_schema = [true|false];

Wenn dieses Pragma festgelegt ist, können Tabellen, die mit sqlite_ beginnen, erstellt und geändert werden, einschließlich der Tabelle sqlite_master. Seien Sie vorsichtig, wenn Sie Pragma verwenden, da dies zu einer vollständigen Beschädigung der Datenbank führen kann.

Einschränkungen sind die Regeln, die für Datenspalten in der Tabelle gelten. Diese werden verwendet, um den Datentyp zu begrenzen, der in eine Tabelle aufgenommen werden kann. Dies stellt die Genauigkeit und Zuverlässigkeit der Daten in der Datenbank sicher.

Einschränkungen können Spalten- oder Tabellenebene sein. Einschränkungen auf Spaltenebene werden nur auf eine Spalte angewendet, während Einschränkungen auf Tabellenebene auf die gesamte Tabelle angewendet werden.

Im Folgenden werden häufig verwendete Einschränkungen aufgeführt, die in SQLite verfügbar sind.

• NOT NULL Constraint - Stellt sicher, dass eine Spalte keinen NULL-Wert haben kann.

• DEFAULT Constraint - Stellt einen Standardwert für eine Spalte bereit, wenn keiner angegeben ist.

• UNIQUE Constraint - Stellt sicher, dass alle Werte in einer Spalte unterschiedlich sind.

• PRIMARY Key - Identifiziert jede Zeile / jeden Datensatz in einer Datenbanktabelle eindeutig.

• CHECK Constraint - Stellt sicher, dass alle Werte in einer Spalte bestimmte Bedingungen erfüllen.

NICHT NULL Einschränkung

Standardmäßig kann eine Spalte NULL-Werte enthalten. Wenn Sie nicht möchten, dass eine Spalte einen NULL-Wert hat, müssen Sie eine solche Einschränkung für diese Spalte definieren und angeben, dass NULL für diese Spalte jetzt nicht zulässig ist.

Ein NULL ist nicht dasselbe wie keine Daten, sondern repräsentiert unbekannte Daten.

Beispiel

Mit der folgenden SQLite-Anweisung wird beispielsweise eine neue Tabelle mit dem Namen COMPANY erstellt und fünf Spalten hinzugefügt, von denen drei, ID und NAME und AGE, angeben, dass NULL-Werte nicht akzeptiert werden sollen.

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

STANDARD-Einschränkung

Die DEFAULT-Einschränkung stellt einen Standardwert für eine Spalte bereit, wenn die INSERT INTO-Anweisung keinen bestimmten Wert bereitstellt.

Beispiel

Mit der folgenden SQLite-Anweisung wird beispielsweise eine neue Tabelle mit dem Namen COMPANY erstellt und fünf Spalten hinzugefügt. Hier ist die Spalte SALARY standardmäßig auf 5000,00 festgelegt. Wenn die Anweisung INSERT INTO keinen Wert für diese Spalte bereitstellt, wird diese Spalte standardmäßig auf 5000,00 festgelegt.

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL    DEFAULT 50000.00
);

Einzigartige Beschränkung

Die UNIQUE-Einschränkung verhindert, dass zwei Datensätze in einer bestimmten Spalte identische Werte haben. In der Tabelle UNTERNEHMEN möchten Sie beispielsweise möglicherweise verhindern, dass zwei oder mehr Personen das gleiche Alter haben.

Beispiel

Mit der folgenden SQLite-Anweisung wird beispielsweise eine neue Tabelle mit dem Namen COMPANY erstellt und fünf Spalten hinzugefügt. Hier ist die Spalte AGE auf EINZIGARTIG gesetzt, sodass Sie nicht zwei Datensätze mit demselben Alter haben können -

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL UNIQUE,
   ADDRESS        CHAR(50),
   SALARY         REAL    DEFAULT 50000.00
);

PRIMARY KEY-Einschränkung

Die PRIMARY KEY-Einschränkung identifiziert jeden Datensatz in einer Datenbanktabelle eindeutig. Es können mehrere EINZIGARTIGE Spalten vorhanden sein, jedoch nur ein Primärschlüssel in einer Tabelle. Primärschlüssel sind beim Entwerfen der Datenbanktabellen wichtig. Primärschlüssel sind eindeutige IDs.

Wir verwenden sie, um auf Tabellenzeilen zu verweisen. Primärschlüssel werden beim Erstellen von Beziehungen zwischen Tabellen zu Fremdschlüsseln in anderen Tabellen. Aufgrund einer langjährigen Codierungsüberwachung können Primärschlüssel in SQLite NULL sein. Dies ist bei anderen Datenbanken nicht der Fall.

Ein Primärschlüssel ist ein Feld in einer Tabelle, das alle Zeilen / Datensätze in einer Datenbanktabelle eindeutig identifiziert. Primärschlüssel müssen eindeutige Werte enthalten. Eine Primärschlüsselspalte darf keine NULL-Werte haben.

Eine Tabelle kann nur einen Primärschlüssel haben, der aus einzelnen oder mehreren Feldern bestehen kann. Wenn mehrere Felder als Primärschlüssel verwendet werden, werden sie als a bezeichnetcomposite key.

Wenn für eine Tabelle in einem oder mehreren Feldern ein Primärschlüssel definiert ist, können nicht zwei Datensätze mit demselben Wert für diese Felder vorhanden sein.

Beispiel

Sie haben oben bereits verschiedene Beispiele gesehen, in denen wir eine COMPANY-Tabelle mit der ID als Primärschlüssel erstellt haben.

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Einschränkung prüfen

Mit CHECK Constraint kann eine Bedingung den Wert überprüfen, der in einen Datensatz eingegeben wird. Wenn die Bedingung als falsch ausgewertet wird, verletzt der Datensatz die Einschränkung und wird nicht in die Tabelle eingetragen.

Beispiel

Die folgende SQLite erstellt beispielsweise eine neue Tabelle mit dem Namen COMPANY und fügt fünf Spalten hinzu. Hier fügen wir eine Spalte CHECK with SALARY hinzu, damit Sie keine SALARY Zero haben können.

CREATE TABLE COMPANY3(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL    CHECK(SALARY > 0)
);

Einschränkung fallen lassen

SQLite unterstützt eine begrenzte Teilmenge von ALTER TABLE. Mit dem Befehl ALTER TABLE in SQLite kann der Benutzer eine Tabelle umbenennen oder einer vorhandenen Tabelle eine neue Spalte hinzufügen. Es ist nicht möglich, eine Spalte umzubenennen, eine Spalte zu entfernen oder Einschränkungen zu einer Tabelle hinzuzufügen oder daraus zu entfernen.

SQLite JoinsKlausel wird verwendet, um Datensätze aus zwei oder mehr Tabellen in einer Datenbank zu kombinieren. Ein JOIN ist ein Mittel zum Kombinieren von Feldern aus zwei Tabellen unter Verwendung gemeinsamer Werte.

SQL definiert drei Haupttypen von Verknüpfungen:

• Das CROSS JOIN
• Der INNERE JOIN
• Der OUTER JOIN

Bevor wir fortfahren, betrachten wir zwei Tabellen COMPANY und DEPARTMENT. Wir haben bereits INSERT-Anweisungen zum Auffüllen der COMPANY-Tabelle gesehen. Nehmen wir also einfach die Liste der in der COMPANY-Tabelle verfügbaren Datensätze an -

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

Eine andere Tabelle ist DEPARTMENT mit der folgenden Definition:

CREATE TABLE DEPARTMENT(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      NOT NULL
);

Hier ist die Liste der INSERT-Anweisungen zum Auffüllen der DEPARTMENT-Tabelle:

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (1, 'IT Billing', 1 );

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (2, 'Engineering', 2 );

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (3, 'Finance', 7 );

Schließlich haben wir die folgende Liste von Datensätzen in der Tabelle DEPARTMENT -

ID          DEPT        EMP_ID
----------  ----------  ----------
1           IT Billing  1
2           Engineering 2
3           Finance     7

Das CROSS JOIN

CROSS JOIN vergleicht jede Zeile der ersten Tabelle mit jeder Zeile der zweiten Tabelle. Wenn die Eingabetabellen eine x- bzw. eine y-Zeile haben, hat die resultierende Tabelle eine x * y-Zeile. Da CROSS JOINs das Potenzial haben, extrem große Tabellen zu generieren, muss darauf geachtet werden, diese nur bei Bedarf zu verwenden.

Es folgt die Syntax von CROSS JOIN -

SELECT ... FROM table1 CROSS JOIN table2 ...

Basierend auf den obigen Tabellen können Sie einen CROSS JOIN wie folgt schreiben:

sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;

Die obige Abfrage führt zu folgendem Ergebnis:

EMP_ID      NAME        DEPT
----------  ----------  ----------
1           Paul        IT Billing
2           Paul        Engineering
7           Paul        Finance
1           Allen       IT Billing
2           Allen       Engineering
7           Allen       Finance
1           Teddy       IT Billing
2           Teddy       Engineering
7           Teddy       Finance
1           Mark        IT Billing
2           Mark        Engineering
7           Mark        Finance
1           David       IT Billing
2           David       Engineering
7           David       Finance
1           Kim         IT Billing
2           Kim         Engineering
7           Kim         Finance
1           James       IT Billing
2           James       Engineering
7           James       Finance

Der INNERE JOIN

INNER JOIN erstellt eine neue Ergebnistabelle, indem die Spaltenwerte zweier Tabellen (Tabelle1 und Tabelle2) basierend auf dem Join-Prädikat kombiniert werden. Die Abfrage vergleicht jede Zeile von Tabelle1 mit jeder Zeile von Tabelle2, um alle Zeilenpaare zu finden, die das Join-Prädikat erfüllen. Wenn das Join-Prädikat erfüllt ist, werden die Spaltenwerte für jedes übereinstimmende Zeilenpaar von A und B zu einer Ergebniszeile kombiniert.

Ein INNER JOIN ist der häufigste und standardmäßigste Join-Typ. Sie können das Schlüsselwort INNER optional verwenden.

Es folgt die Syntax von INNER JOIN -

SELECT ... FROM table1 [INNER] JOIN table2 ON conditional_expression ...

Um Redundanz zu vermeiden und die Phrasierung kürzer zu halten, können INNER JOIN-Bedingungen mit a deklariert werden USINGAusdruck. Dieser Ausdruck gibt eine Liste mit einer oder mehreren Spalten an.

SELECT ... FROM table1 JOIN table2 USING ( column1 ,... ) ...

Ein NATURAL JOIN ähnelt einem JOIN...USINGEs wird nur automatisch geprüft, ob die Werte jeder Spalte in beiden Tabellen gleich sind.

SELECT ... FROM table1 NATURAL JOIN table2...

Basierend auf den obigen Tabellen können Sie einen INNER JOIN wie folgt schreiben:

sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID;

Die obige Abfrage führt zu folgendem Ergebnis:

EMP_ID      NAME        DEPT
----------  ----------  ----------
1           Paul        IT Billing
2           Allen       Engineering
7           James       Finance

Der OUTER JOIN

OUTER JOIN ist eine Erweiterung von INNER JOIN. Obwohl der SQL-Standard drei Arten von OUTER JOINs definiert: LEFT, RIGHT und FULL, unterstützt SQLite nur dieLEFT OUTER JOIN.

OUTER JOINs haben eine Bedingung, die mit INNER JOINs identisch ist und mit einem Schlüsselwort ON, USING oder NATURAL ausgedrückt wird. Die anfängliche Ergebnistabelle wird auf die gleiche Weise berechnet. Sobald der primäre JOIN berechnet ist, nimmt ein OUTER JOIN alle nicht verbundenen Zeilen aus einer oder beiden Tabellen, füllt sie mit NULL-Werten auf und hängt sie an die resultierende Tabelle an.

Es folgt die Syntax von LEFT OUTER JOIN -

SELECT ... FROM table1 LEFT OUTER JOIN table2 ON conditional_expression ...

Um Redundanz zu vermeiden und die Phrasierung kürzer zu halten, können OUTER JOIN-Bedingungen mit einem USING-Ausdruck deklariert werden. Dieser Ausdruck gibt eine Liste mit einer oder mehreren Spalten an.

SELECT ... FROM table1 LEFT OUTER JOIN table2 USING ( column1 ,... ) ...

Basierend auf den obigen Tabellen können Sie einen inneren Join wie folgt schreiben:

sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID;

Die obige Abfrage führt zu folgendem Ergebnis:

EMP_ID      NAME        DEPT
----------  ----------  ----------
1           Paul        IT Billing
2           Allen       Engineering
            Teddy
            Mark
            David
            Kim
7           James       Finance

SQLite UNION Klausel / Operator wird verwendet, um die Ergebnisse von zwei oder mehr SELECT-Anweisungen zu kombinieren, ohne doppelte Zeilen zurückzugeben.

Um UNION verwenden zu können, muss für jedes SELECT die gleiche Anzahl von Spalten ausgewählt, die gleiche Anzahl von Spaltenausdrücken, der gleiche Datentyp und die gleiche Reihenfolge angegeben werden, sie müssen jedoch nicht dieselbe Länge haben.

Syntax

Es folgt die grundlegende Syntax von UNION.

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Hier kann die angegebene Bedingung ein beliebiger Ausdruck sein, der auf Ihrer Anforderung basiert.

Beispiel

Betrachten Sie die folgenden zwei Tabellen: (a) COMPANY- Tabelle wie folgt:

sqlite> select * from COMPANY;
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

(b) Eine andere Tabelle ist ABTEILUNG wie folgt -

ID          DEPT                  EMP_ID
----------  --------------------  ----------
1           IT Billing            1
2           Engineering           2
3           Finance               7
4           Engineering           3
5           Finance               4
6           Engineering           5
7           Finance               6

Lassen Sie uns nun diese beiden Tabellen mit der SELECT-Anweisung zusammen mit der UNION-Klausel wie folgt verbinden:

sqlite>  SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID
         
         UNION
         
         SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID;

Dies führt zu folgendem Ergebnis.

EMP_ID      NAME                  DEPT
----------  --------------------  ----------
1           Paul                  IT Billing
2           Allen                 Engineering
3           Teddy                 Engineering
4           Mark                  Finance
5           David                 Engineering
6           Kim                   Finance
7           James                 Finance

Die UNION ALL-Klausel

Der Operator UNION ALL wird verwendet, um die Ergebnisse von zwei SELECT-Anweisungen einschließlich doppelter Zeilen zu kombinieren.

Die gleichen Regeln, die für UNION gelten, gelten auch für den Operator UNION ALL.

Syntax

Es folgt die grundlegende Syntax von UNION ALL.

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION ALL

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Hier kann die angegebene Bedingung ein beliebiger Ausdruck sein, der auf Ihrer Anforderung basiert.

Beispiel

Lassen Sie uns nun die beiden oben genannten Tabellen in unserer SELECT-Anweisung wie folgt verbinden:

sqlite>  SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID
         
         UNION ALL

         SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID;

Dies führt zu folgendem Ergebnis.

EMP_ID      NAME                  DEPT
----------  --------------------  ----------
1           Paul                  IT Billing
2           Allen                 Engineering
3           Teddy                 Engineering
4           Mark                  Finance
5           David                 Engineering
6           Kim                   Finance
7           James                 Finance
1           Paul                  IT Billing
2           Allen                 Engineering
3           Teddy                 Engineering
4           Mark                  Finance
5           David                 Engineering
6           Kim                   Finance
7           James                 Finance

SQLite NULList der Begriff, der verwendet wird, um einen fehlenden Wert darzustellen. Ein NULL-Wert in einer Tabelle ist ein Wert in einem Feld, der leer zu sein scheint.

Ein Feld mit einem NULL-Wert ist ein Feld ohne Wert. Es ist sehr wichtig zu verstehen, dass sich ein NULL-Wert von einem Nullwert oder einem Feld mit Leerzeichen unterscheidet.

Syntax

Im Folgenden finden Sie die grundlegende Syntax der Verwendung NULL beim Erstellen einer Tabelle.

SQLite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Hier, NOT NULLbedeutet, dass die Spalte immer einen expliziten Wert des angegebenen Datentyps akzeptieren sollte. Es gibt zwei Spalten, in denen wir NICHT NULL verwendet haben, was bedeutet, dass diese Spalten NULL sein können.

Ein Feld mit einem NULL-Wert wurde während der Datensatzerstellung leer gelassen.

Beispiel

Der NULL-Wert kann Probleme bei der Auswahl von Daten verursachen, da beim Vergleich eines unbekannten Werts mit einem anderen Wert das Ergebnis immer unbekannt ist und nicht in den Endergebnissen enthalten ist. Betrachten Sie die folgende Tabelle, UNTERNEHMEN mit den folgenden Datensätzen -

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

Verwenden wir die UPDATE-Anweisung, um einige nullwertfähige Werte wie folgt auf NULL zu setzen:

sqlite> UPDATE COMPANY SET ADDRESS = NULL, SALARY = NULL where ID IN(6,7);

Die COMPANY-Tabelle enthält nun 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
7           James       24

Lassen Sie uns als nächstes die Verwendung von sehen IS NOT NULL Operator, um alle Datensätze aufzulisten, bei denen SALARY nicht NULL ist.

sqlite> SELECT  ID, NAME, AGE, ADDRESS, SALARY
        FROM COMPANY
        WHERE SALARY IS NOT NULL;

Die obige SQLite-Anweisung führt zu folgendem Ergebnis:

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

Es folgt die Verwendung von IS NULL Operator, der alle Datensätze auflistet, bei denen SALARY NULL ist.

sqlite> SELECT  ID, NAME, AGE, ADDRESS, SALARY
        FROM COMPANY
        WHERE SALARY IS NULL;

Die obige SQLite-Anweisung führt zu folgendem Ergebnis.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
6           Kim         22
7           James       24

Sie können eine Tabelle oder eine Spalte vorübergehend umbenennen, indem Sie einen anderen Namen angeben, der als bezeichnet wird ALIAS. Die Verwendung von Tabellenaliasnamen bedeutet, dass eine Tabelle in einer bestimmten SQLite-Anweisung umbenannt wird. Das Umbenennen ist eine vorübergehende Änderung, und der tatsächliche Tabellenname ändert sich in der Datenbank nicht.

Die Spaltenaliasnamen werden verwendet, um die Spalten einer Tabelle für den Zweck einer bestimmten SQLite-Abfrage umzubenennen.

Syntax

Es folgt die grundlegende Syntax von table alias.

SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];

Es folgt die grundlegende Syntax von column alias.

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];

Beispiel

Betrachten Sie die folgenden zwei Tabellen: (a) Die Tabelle COMPANY lautet wie folgt:

sqlite> select * from COMPANY;
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

(b) Eine andere Tabelle ist ABTEILUNG wie folgt -

ID          DEPT                  EMP_ID
----------  --------------------  ----------
1           IT Billing            1
2           Engineering           2
3           Finance               7
4           Engineering           3
5           Finance               4
6           Engineering           5
7           Finance               6

Im Folgenden wird die Verwendung von beschrieben TABLE ALIAS wo wir C und D als Aliase für COMPANY- bzw. DEPARTMENT-Tabellen verwenden -

sqlite> SELECT C.ID, C.NAME, C.AGE, D.DEPT
        FROM COMPANY AS C, DEPARTMENT AS D
        WHERE  C.ID = D.EMP_ID;

Die obige SQLite-Anweisung führt zu folgendem Ergebnis:

ID          NAME        AGE         DEPT
----------  ----------  ----------  ----------
1           Paul        32          IT Billing
2           Allen       25          Engineering
3           Teddy       23          Engineering
4           Mark        25          Finance
5           David       27          Engineering
6           Kim         22          Finance
7           James       24          Finance

Betrachten Sie ein Beispiel für die Verwendung von COLUMN ALIAS Dabei ist COMPANY_ID ein Alias ​​der ID-Spalte und COMPANY_NAME ein Alias ​​der Namensspalte.

sqlite> SELECT C.ID AS COMPANY_ID, C.NAME AS COMPANY_NAME, C.AGE, D.DEPT
        FROM COMPANY AS C, DEPARTMENT AS D
        WHERE  C.ID = D.EMP_ID;

Die obige SQLite-Anweisung führt zu folgendem Ergebnis:

COMPANY_ID  COMPANY_NAME  AGE         DEPT
----------  ------------  ----------  ----------
1           Paul          32          IT Billing
2           Allen         25          Engineering
3           Teddy         23          Engineering
4           Mark          25          Finance
5           David         27          Engineering
6           Kim           22          Finance
7           James         24          Finance

SQLite Triggerssind Datenbank-Rückruffunktionen, die automatisch ausgeführt / aufgerufen werden, wenn ein bestimmtes Datenbankereignis auftritt. Im Folgenden sind die wichtigen Punkte zu SQLite-Triggern aufgeführt:

• Der SQLite-Trigger kann so festgelegt werden, dass er immer dann ausgelöst wird, wenn ein DELETE, INSERT oder UPDATE einer bestimmten Datenbanktabelle auftritt oder wenn ein UPDATE in einer oder mehreren angegebenen Spalten einer Tabelle auftritt.

• Derzeit unterstützt SQLite nur FOR EACH ROW-Trigger, nicht FOR EACH STATEMENT-Trigger. Daher ist die explizite Angabe von FOR EACH ROW optional.

• Sowohl die WHEN-Klausel als auch die Triggeraktionen können mithilfe von Verweisen auf das Formular auf Elemente der Zeile zugreifen, die eingefügt, gelöscht oder aktualisiert werden NEW.column-name und OLD.column-nameDabei ist Spaltenname der Name einer Spalte aus der Tabelle, der der Trigger zugeordnet ist.

• Wenn eine WHEN-Klausel angegeben wird, werden die angegebenen SQL-Anweisungen nur für Zeilen ausgeführt, für die die WHEN-Klausel wahr ist. Wenn keine WHEN-Klausel angegeben wird, werden die SQL-Anweisungen für alle Zeilen ausgeführt.

• Das Schlüsselwort BEFORE oder AFTER bestimmt, wann die Triggeraktionen in Bezug auf das Einfügen, Ändern oder Entfernen der zugehörigen Zeile ausgeführt werden.

• Trigger werden automatisch gelöscht, wenn die Tabelle, der sie zugeordnet sind, gelöscht wird.

• Die zu ändernde Tabelle muss in derselben Datenbank vorhanden sein wie die Tabelle oder Ansicht, an die der Trigger angehängt ist, und muss nur verwendet werden tablename nicht database.tablename.

• Eine spezielle SQL-Funktion RAISE () kann innerhalb eines Triggerprogramms verwendet werden, um eine Ausnahme auszulösen.

Syntax

Im Folgenden finden Sie die grundlegende Syntax zum Erstellen von a trigger.

CREATE TRIGGER trigger_name [BEFORE|AFTER] event_name 
ON table_name
BEGIN
 -- Trigger logic goes here....
END;

Hier, event_namekönnte INSERT, DELETE, und UPDATE Datenbankoperation auf der genannten Tabelletable_name. Sie können optional FÜR JEDE REIHE nach dem Tabellennamen angeben.

Im Folgenden finden Sie die Syntax zum Erstellen eines Triggers für eine UPDATE-Operation für eine oder mehrere angegebene Spalten einer Tabelle.

CREATE TRIGGER trigger_name [BEFORE|AFTER] UPDATE OF column_name 
ON table_name
BEGIN
   -- Trigger logic goes here....
END;

Beispiel

Betrachten wir einen Fall, in dem wir den Audit-Test für jeden Datensatz, der in die COMPANY-Tabelle eingefügt wird, fortsetzen möchten, den wir wie folgt neu erstellen (Drop COMPANY-Tabelle, falls Sie sie bereits haben).

sqlite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Um den Audit-Test fortzusetzen, erstellen wir eine neue Tabelle mit dem Namen AUDIT, in die die Protokollnachrichten eingefügt werden, wenn in der COMPANY-Tabelle ein Eintrag für einen neuen Datensatz vorhanden ist.

sqlite> CREATE TABLE AUDIT(
   EMP_ID INT NOT NULL,
   ENTRY_DATE TEXT NOT NULL
);

Hier ist ID die AUDIT-Datensatz-ID und EMP_ID ist die ID, die aus der COMPANY-Tabelle stammt, und DATE behält den Zeitstempel bei, wenn der Datensatz in der COMPANY-Tabelle erstellt wird. Erstellen wir nun einen Trigger für die COMPANY-Tabelle wie folgt:

sqlite> CREATE TRIGGER audit_log AFTER INSERT 
ON COMPANY
BEGIN
   INSERT INTO AUDIT(EMP_ID, ENTRY_DATE) VALUES (new.ID, datetime('now'));
END;

Jetzt beginnen wir mit der eigentlichen Arbeit. Beginnen wir mit dem Einfügen eines Datensatzes in die COMPANY-Tabelle, der zur Erstellung eines Überwachungsprotokolldatensatzes in der AUDIT-Tabelle führen soll. Erstellen Sie einen Datensatz in der COMPANY-Tabelle wie folgt:

sqlite> INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );

Dadurch wird ein Datensatz in der COMPANY-Tabelle erstellt, der wie folgt lautet:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0

Gleichzeitig wird ein Datensatz in der AUDIT-Tabelle erstellt. Dieser Datensatz ist das Ergebnis eines Triggers, den wir bei der INSERT-Operation in der COMPANY-Tabelle erstellt haben. Ebenso können Sie Ihre Trigger für UPDATE- und DELETE-Vorgänge basierend auf Ihren Anforderungen erstellen.

EMP_ID      ENTRY_DATE
----------  -------------------
1           2013-04-05 06:26:00

Trigger auflisten

Sie können alle Trigger von auflisten sqlite_master Tabelle wie folgt -

sqlite> SELECT name FROM sqlite_master
WHERE type = 'trigger';

Die obige SQLite-Anweisung listet nur einen Eintrag wie folgt auf:

name
----------
audit_log

Wenn Sie Trigger für eine bestimmte Tabelle auflisten möchten, verwenden Sie die AND-Klausel mit dem Tabellennamen wie folgt:

sqlite> SELECT name FROM sqlite_master
WHERE type = 'trigger' AND tbl_name = 'COMPANY';

Die obige SQLite-Anweisung listet auch nur einen Eintrag wie folgt auf:

name
----------
audit_log

Trigger fallen lassen

Es folgt der Befehl DROP, mit dem ein vorhandener Trigger gelöscht werden kann.

sqlite> DROP TRIGGER trigger_name;

Indizes sind spezielle Nachschlagetabellen, mit denen die Datenbanksuchmaschine den Datenabruf beschleunigen kann. Einfach gesagt, einindexist ein Zeiger auf Daten in einer Tabelle. Ein Index in einer Datenbank ist einem Index auf der Rückseite eines Buches sehr ähnlich.

Wenn Sie beispielsweise auf alle Seiten in einem Buch verweisen möchten, die ein bestimmtes Thema behandeln, verweisen Sie zunächst auf den Index, in dem alle Themen alphabetisch aufgelistet sind, und verweisen dann auf eine oder mehrere bestimmte Seitenzahlen.

Ein Index beschleunigt SELECT-Abfragen und WHERE-Klauseln, verlangsamt jedoch die Dateneingabe mit den Anweisungen UPDATE und INSERT. Indizes können ohne Auswirkung auf die Daten erstellt oder gelöscht werden.

Das Erstellen eines Index umfasst die Anweisung CREATE INDEX, mit der Sie den Index benennen, die Tabelle und die zu indizierenden Spalten angeben und angeben können, ob der Index in aufsteigender oder absteigender Reihenfolge vorliegt.

Indizes können auch eindeutig sein, ähnlich wie bei der UNIQUE-Einschränkung, da der Index doppelte Einträge in der Spalte oder einer Kombination von Spalten verhindert, für die ein Index vorhanden ist.

Der Befehl CREATE INDEX

Es folgt die grundlegende Syntax von CREATE INDEX.

CREATE INDEX index_name ON table_name;

Einspaltige Indizes

Ein einspaltiger Index wird basierend auf nur einer Tabellenspalte erstellt. Die grundlegende Syntax lautet wie folgt:

CREATE INDEX index_name
ON table_name (column_name);

Einzigartige Indizes

Eindeutige Indizes werden nicht nur für die Leistung, sondern auch für die Datenintegrität verwendet. Mit einem eindeutigen Index können keine doppelten Werte in die Tabelle eingefügt werden. Die grundlegende Syntax lautet wie folgt:

CREATE UNIQUE INDEX index_name
on table_name (column_name);

Zusammengesetzte Indizes

Ein zusammengesetzter Index ist ein Index für zwei oder mehr Spalten einer Tabelle. Die grundlegende Syntax lautet wie folgt:

CREATE INDEX index_name
on table_name (column1, column2);

Berücksichtigen Sie beim Erstellen eines einspaltigen Index oder eines zusammengesetzten Index die Spalte (n), die Sie möglicherweise sehr häufig in der WHERE-Klausel einer Abfrage als Filterbedingungen verwenden.

Sollte nur eine Spalte verwendet werden, sollte ein einspaltiger Index die Wahl sein. Sollten zwei oder mehr Spalten in der WHERE-Klausel häufig als Filter verwendet werden, ist der zusammengesetzte Index die beste Wahl.

Implizite Indizes

Implizite Indizes sind Indizes, die vom Datenbankserver automatisch erstellt werden, wenn ein Objekt erstellt wird. Indizes werden automatisch für Primärschlüsseleinschränkungen und eindeutige Einschränkungen erstellt.

Example

Im Folgenden finden Sie ein Beispiel, in dem wir einen Index in der COMPANY- Tabelle für die Gehaltsspalte erstellen.

sqlite> CREATE INDEX salary_index ON COMPANY (salary);

Lassen Sie uns nun alle in der COMPANY-Tabelle verfügbaren Indizes mit auflisten .indices Befehl wie folgt -

sqlite> .indices COMPANY

Dies führt zu folgendem Ergebnis, wobei sqlite_autoindex_COMPANY_1 ein impliziter Index ist, der beim Erstellen der Tabelle selbst erstellt wurde.

salary_index
sqlite_autoindex_COMPANY_1

Sie können alle Indizes datenbankweit wie folgt auflisten:

sqlite> SELECT * FROM sqlite_master WHERE type = 'index';

Der Befehl DROP INDEX

Ein Index kann mit SQLite gelöscht werden DROPBefehl. Beim Löschen eines Index ist Vorsicht geboten, da die Leistung möglicherweise verlangsamt oder verbessert wird.

Das Folgende ist die grundlegende Syntax wie folgt:

DROP INDEX index_name;

Mit der folgenden Anweisung können Sie zuvor erstellte Indizes löschen.

sqlite> DROP INDEX salary_index;

Wann sollten Indizes vermieden werden?

Obwohl Indizes die Leistung einer Datenbank verbessern sollen, sollten sie manchmal vermieden werden. Die folgenden Richtlinien geben an, wann die Verwendung eines Index überdacht werden sollte.

Indizes sollten nicht verwendet werden in -

• Kleine Tische.
• Tabellen mit häufigen Aktualisierungs- oder Einfügevorgängen für große Stapel.
• Spalten, die eine hohe Anzahl von NULL-Werten enthalten.
• Spalten, die häufig bearbeitet werden.

Die Klausel "INDEXED BY Indexname" gibt an, dass der benannte Index verwendet werden muss, um Werte in der vorhergehenden Tabelle nachzuschlagen.

Wenn der Indexname nicht vorhanden ist oder nicht für die Abfrage verwendet werden kann, schlägt die Vorbereitung der SQLite-Anweisung fehl.

Die Klausel "NOT INDEXED" gibt an, dass beim Zugriff auf die vorhergehende Tabelle kein Index verwendet werden darf, einschließlich impliziter Indizes, die durch Einschränkungen von UNIQUE und PRIMARY KEY erstellt wurden.

Der INTEGER PRIMARY KEY kann jedoch weiterhin zum Nachschlagen von Einträgen verwendet werden, selbst wenn "NOT INDEXED" angegeben ist.

Syntax

Es folgt die Syntax für die INDEXED BY-Klausel, die mit der Anweisung DELETE, UPDATE oder SELECT verwendet werden kann.

SELECT|DELETE|UPDATE column1, column2...
INDEXED BY (index_name)
table_name
WHERE (CONDITION);

Beispiel

Betrachten Sie die Tabelle UNTERNEHMEN. Wir erstellen einen Index und verwenden ihn zur Durchführung der INDEXED BY-Operation.

sqlite> CREATE INDEX salary_index ON COMPANY(salary);
sqlite>

Wenn Sie nun die Daten aus der Tabelle COMPANY auswählen, können Sie die INDEXED BY-Klausel wie folgt verwenden:

sqlite> SELECT * FROM COMPANY INDEXED BY salary_index WHERE salary > 5000;

Dies führt zu folgendem Ergebnis.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
7           James       24          Houston     10000.0
2           Allen       25          Texas       15000.0
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
6           Kim         22          South-Hall  45000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

SQLite ALTER TABLEDer Befehl ändert eine vorhandene Tabelle, ohne einen vollständigen Speicherauszug durchzuführen und die Daten neu zu laden. Sie können eine Tabelle mit der Anweisung ALTER TABLE umbenennen und mit der Anweisung ALTER TABLE zusätzliche Spalten in eine vorhandene Tabelle einfügen.

Es gibt keine andere Operation, die vom Befehl ALTER TABLE in SQLite unterstützt wird, außer das Umbenennen einer Tabelle und das Hinzufügen einer Spalte in einer vorhandenen Tabelle.

Syntax

Es folgt die grundlegende Syntax von ALTER TABLE eine vorhandene Tabelle umbenennen.

ALTER TABLE database_name.table_name RENAME TO new_table_name;

Es folgt die grundlegende Syntax von ALTER TABLE um eine neue Spalte in eine vorhandene Tabelle einzufügen.

ALTER TABLE database_name.table_name ADD COLUMN column_def...;

Beispiel

Betrachten Sie die COMPANY- Tabelle mit den folgenden Datensätzen:

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

Versuchen wir nun, diese Tabelle mit der Anweisung ALTER TABLE wie folgt umzubenennen:

sqlite> ALTER TABLE COMPANY RENAME TO OLD_COMPANY;

Die obige SQLite-Anweisung benennt die COMPANY-Tabelle in OLD_COMPANY um. Versuchen wir nun, eine neue Spalte in der Tabelle OLD_COMPANY wie folgt hinzuzufügen:

sqlite> ALTER TABLE OLD_COMPANY ADD COLUMN SEX char(1);

Die COMPANY-Tabelle wurde jetzt geändert und es folgt die Ausgabe der SELECT-Anweisung.

ID          NAME        AGE         ADDRESS     SALARY      SEX
----------  ----------  ----------  ----------  ----------  ---
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

Es ist zu beachten, dass die neu hinzugefügte Spalte mit NULL-Werten gefüllt ist.

Leider haben wir in SQLite keinen Befehl TRUNCATE TABLE, aber Sie können SQLite verwenden DELETE Befehl zum Löschen vollständiger Daten aus einer vorhandenen Tabelle. Es wird jedoch empfohlen, den Befehl DROP TABLE zu verwenden, um die vollständige Tabelle zu löschen und erneut zu erstellen.

Syntax

Es folgt die grundlegende Syntax des Befehls DELETE.

sqlite> DELETE FROM table_name;

Es folgt die grundlegende Syntax von DROP TABLE.

sqlite> DROP TABLE table_name;

Wenn Sie den Befehl DELETE TABLE verwenden, um alle Datensätze zu löschen, wird die Verwendung empfohlen VACUUM Befehl zum Löschen nicht genutzten Speicherplatzes.

Beispiel

Betrachten Sie die COMPANY- Tabelle mit den folgenden Datensätzen.

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

Es folgt das Beispiel zum Abschneiden der obigen Tabelle:

SQLite> DELETE FROM COMPANY;
SQLite> VACUUM;

Jetzt wird die COMPANY-Tabelle vollständig abgeschnitten und es wird nichts von der SELECT-Anweisung ausgegeben.

Eine Ansicht ist nichts anderes als eine SQLite-Anweisung, die in der Datenbank mit einem zugeordneten Namen gespeichert ist. Es ist eigentlich eine Zusammensetzung einer Tabelle in Form einer vordefinierten SQLite-Abfrage.

Eine Ansicht kann alle Zeilen einer Tabelle oder ausgewählte Zeilen aus einer oder mehreren Tabellen enthalten. Eine Ansicht kann aus einer oder mehreren Tabellen erstellt werden. Dies hängt von der geschriebenen SQLite-Abfrage ab, um eine Ansicht zu erstellen.

Ansichten, bei denen es sich um virtuelle Tabellen handelt, ermöglichen den Benutzern Folgendes:

• Strukturieren Sie Daten so, dass Benutzer oder Benutzerklassen sie natürlich oder intuitiv finden.

• Beschränken Sie den Zugriff auf die Daten so, dass ein Benutzer nur begrenzte Daten anstelle einer vollständigen Tabelle sehen kann.

• Fassen Sie Daten aus verschiedenen Tabellen zusammen, mit denen Berichte erstellt werden können.

SQLite-Ansichten sind schreibgeschützt und daher können Sie möglicherweise keine DELETE-, INSERT- oder UPDATE-Anweisung für eine Ansicht ausführen. Sie können jedoch einen Auslöser für eine Ansicht erstellen, die beim Versuch ausgelöst wird, eine Ansicht zu LÖSCHEN, EINFÜGEN oder AKTUALISIEREN, und im Hauptteil des Auslösers das zu tun, was Sie benötigen.

Ansichten erstellen

SQLite-Ansichten werden mit dem erstellt CREATE VIEWErklärung. SQLite-Ansichten können aus einer einzelnen Tabelle, mehreren Tabellen oder einer anderen Ansicht erstellt werden.

Im Folgenden finden Sie die grundlegende Syntax von CREATE VIEW.

CREATE [TEMP | TEMPORARY] VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];

Sie können mehrere Tabellen in Ihre SELECT-Anweisung aufnehmen, ähnlich wie Sie sie in einer normalen SQL SELECT-Abfrage verwenden. Wenn das optionale Schlüsselwort TEMP oder TEMPORARY vorhanden ist, wird die Ansicht in der temporären Datenbank erstellt.

Beispiel

Betrachten Sie die COMPANY- Tabelle mit den folgenden Datensätzen:

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

Im Folgenden finden Sie ein Beispiel zum Erstellen einer Ansicht aus der COMPANY-Tabelle. In dieser Ansicht werden nur wenige Spalten aus der COMPANY-Tabelle angezeigt.

sqlite> CREATE VIEW COMPANY_VIEW AS
SELECT ID, NAME, AGE
FROM  COMPANY;

Sie können jetzt COMPANY_VIEW auf ähnliche Weise abfragen wie eine tatsächliche Tabelle. Das Folgende ist ein Beispiel -

sqlite> SELECT * FROM COMPANY_VIEW;

Dies führt zu folgendem Ergebnis.

ID          NAME        AGE
----------  ----------  ----------
1           Paul        32
2           Allen       25
3           Teddy       23
4           Mark        25
5           David       27
6           Kim         22
7           James       24

Ansichten löschen

Verwenden Sie zum Löschen einer Ansicht einfach die Anweisung DROP VIEW mit der view_name. Die grundlegende DROP VIEW-Syntax lautet wie folgt:

sqlite> DROP VIEW view_name;

Mit dem folgenden Befehl wird die Ansicht COMPANY_VIEW gelöscht, die wir im letzten Abschnitt erstellt haben.

sqlite> DROP VIEW COMPANY_VIEW;

Eine Transaktion ist eine Arbeitseinheit, die für eine Datenbank ausgeführt wird. Transaktionen sind Einheiten oder Abfolgen von Arbeiten, die in einer logischen Reihenfolge ausgeführt werden, entweder manuell von einem Benutzer oder automatisch von einer Art Datenbankprogramm.

Eine Transaktion ist die Weitergabe einer oder mehrerer Änderungen an der Datenbank. Wenn Sie beispielsweise einen Datensatz erstellen, aktualisieren oder aus der Tabelle löschen, führen Sie eine Transaktion für die Tabelle aus. Es ist wichtig, Transaktionen zu steuern, um die Datenintegrität sicherzustellen und Datenbankfehler zu behandeln.

In der Praxis werden Sie viele SQLite-Abfragen zu einer Gruppe zusammenfassen und alle zusammen als Teil einer Transaktion ausführen.

Eigenschaften von Transaktionen

Transaktionen haben die folgenden vier Standardeigenschaften, die normalerweise mit dem Akronym ACID bezeichnet werden.

• Atomicity- stellt sicher, dass alle Vorgänge innerhalb der Arbeitseinheit erfolgreich abgeschlossen wurden; Andernfalls wird die Transaktion zum Zeitpunkt des Ausfalls abgebrochen und frühere Vorgänge werden auf ihren vorherigen Status zurückgesetzt.

• Consistency - Stellt sicher, dass die Datenbank bei einer erfolgreich festgeschriebenen Transaktion den Status ordnungsgemäß ändert.

• Isolation - Ermöglicht den unabhängigen und transparenten Betrieb von Transaktionen.

• Durability - Stellt sicher, dass das Ergebnis oder die Wirkung einer festgeschriebenen Transaktion bei einem Systemausfall bestehen bleibt.

Transaktionskontrolle

Die folgenden Befehle werden zur Steuerung von Transaktionen verwendet:

• BEGIN TRANSACTION - Um eine Transaktion zu starten.

• COMMIT - Um die Änderungen zu speichern, können Sie sie alternativ verwenden END TRANSACTION Befehl.

• ROLLBACK - Um die Änderungen rückgängig zu machen.

Transaktionssteuerungsbefehle werden nur mit den DML-Befehlen INSERT, UPDATE und DELETE verwendet. Sie können beim Erstellen oder Löschen von Tabellen nicht verwendet werden, da diese Vorgänge automatisch in der Datenbank festgeschrieben werden.

Befehl TRANSACTION BEGINNEN

Transaktionen können mit BEGIN TRANSACTION oder einfach mit dem Befehl BEGIN gestartet werden. Solche Transaktionen bleiben normalerweise bestehen, bis der nächste Befehl COMMIT oder ROLLBACK auftritt. Eine Transaktion wird jedoch auch zurückgesetzt, wenn die Datenbank geschlossen wird oder ein Fehler auftritt. Es folgt die einfache Syntax zum Starten einer Transaktion.

BEGIN;
or 
BEGIN TRANSACTION;

Befehl COMMIT

Der Befehl COMMIT ist der Transaktionsbefehl, mit dem Änderungen, die von einer Transaktion aufgerufen werden, in der Datenbank gespeichert werden.

Der Befehl COMMIT speichert alle Transaktionen in der Datenbank seit dem letzten Befehl COMMIT oder ROLLBACK.

Es folgt die Syntax für den Befehl COMMIT.

COMMIT;
or
END TRANSACTION;

ROLLBACK-Befehl

Der Befehl ROLLBACK ist der Transaktionsbefehl, mit dem Transaktionen rückgängig gemacht werden, die noch nicht in der Datenbank gespeichert wurden.

Der Befehl ROLLBACK kann nur zum Rückgängigmachen von Transaktionen verwendet werden, seit der letzte Befehl COMMIT oder ROLLBACK ausgegeben wurde.

Es folgt die Syntax für den Befehl ROLLBACK.

ROLLBACK;

Example

Betrachten Sie die COMPANY- Tabelle mit den folgenden Datensätzen.

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

Starten Sie nun eine Transaktion und löschen Sie Datensätze aus der Tabelle mit dem Alter = 25. Verwenden Sie dann den Befehl ROLLBACK, um alle Änderungen rückgängig zu machen.

sqlite> BEGIN;
sqlite> DELETE FROM COMPANY WHERE AGE = 25;
sqlite> ROLLBACK;

Wenn Sie nun die COMPANY-Tabelle überprüfen, enthält sie weiterhin 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

Beginnen wir eine weitere Transaktion und löschen Datensätze aus der Tabelle mit dem Alter = 25. Schließlich verwenden wir den Befehl COMMIT, um alle Änderungen festzuschreiben.

sqlite> BEGIN;
sqlite> DELETE FROM COMPANY WHERE AGE = 25;
sqlite> COMMIT;

Wenn Sie jetzt überprüfen, dass die COMPANY-Tabelle noch die folgenden Datensätze enthält:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Eine Unterabfrage oder innere Abfrage oder verschachtelte Abfrage ist eine Abfrage in einer anderen SQLite-Abfrage und in die WHERE-Klausel eingebettet.

Eine Unterabfrage wird verwendet, um Daten zurückzugeben, die in der Hauptabfrage als Bedingung verwendet werden, um die abzurufenden Daten weiter einzuschränken.

Unterabfragen können mit den Anweisungen SELECT, INSERT, UPDATE und DELETE zusammen mit den Operatoren wie =, <,>,> =, <=, IN, ZWISCHEN usw. verwendet werden.

Es gibt einige Regeln, denen Unterabfragen folgen müssen -

• Unterabfragen müssen in Klammern stehen.

• Eine Unterabfrage kann nur eine Spalte in der SELECT-Klausel enthalten, es sei denn, die Hauptabfrage enthält mehrere Spalten, damit die Unterabfrage ihre ausgewählten Spalten vergleicht.

• Ein ORDER BY kann nicht in einer Unterabfrage verwendet werden, obwohl die Hauptabfrage ein ORDER BY verwenden kann. Mit GROUP BY kann dieselbe Funktion wie mit ORDER BY in einer Unterabfrage ausgeführt werden.

• Unterabfragen, die mehr als eine Zeile zurückgeben, können nur mit mehreren Wertoperatoren verwendet werden, z. B. dem IN-Operator.

• Der Operator ZWISCHEN kann nicht mit einer Unterabfrage verwendet werden. ZWISCHEN kann jedoch innerhalb der Unterabfrage verwendet werden.

Unterabfragen mit SELECT-Anweisung

Unterabfragen werden am häufigsten mit der SELECT-Anweisung verwendet. Die grundlegende Syntax lautet wie folgt:

SELECT column_name [, column_name ]
FROM table1 [, table2 ]
WHERE column_name OPERATOR
   (SELECT column_name [, column_name ]
      FROM table1 [, table2 ]
      [WHERE])

Beispiel

Betrachten Sie die COMPANY- Tabelle mit den folgenden Datensätzen.

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

Lassen Sie uns nun die folgende Unterabfrage mit der SELECT-Anweisung überprüfen.

sqlite> SELECT * 
   FROM COMPANY 
   WHERE ID IN (SELECT ID 
      FROM COMPANY 
      WHERE SALARY > 45000) ;

Dies führt zu folgendem Ergebnis.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

Unterabfragen mit INSERT-Anweisung

Unterabfragen können auch mit INSERT-Anweisungen verwendet werden. Die INSERT-Anweisung verwendet die von der Unterabfrage zurückgegebenen Daten, um sie in eine andere Tabelle einzufügen. Die ausgewählten Daten in der Unterabfrage können mit einer beliebigen Zeichen-, Datums- oder Zahlenfunktion geändert werden.

Das Folgende ist die grundlegende Syntax wie folgt:

INSERT INTO table_name [ (column1 [, column2 ]) ]
   SELECT [ *|column1 [, column2 ]
   FROM table1 [, table2 ]
   [ WHERE VALUE OPERATOR ]

Beispiel

Stellen Sie sich eine Tabelle COMPANY_BKP mit einer ähnlichen Struktur wie die Tabelle COMPANY vor, die mit COMPANY_BKP als Tabellenname mit derselben CREATE TABLE erstellt werden kann. Um die vollständige COMPANY-Tabelle in COMPANY_BKP zu kopieren, folgt die folgende Syntax:

sqlite> INSERT INTO COMPANY_BKP
   SELECT * FROM COMPANY 
   WHERE ID IN (SELECT ID 
      FROM COMPANY) ;

Unterabfragen mit UPDATE-Anweisung

Die Unterabfrage kann in Verbindung mit der UPDATE-Anweisung verwendet werden. Bei Verwendung einer Unterabfrage mit der UPDATE-Anweisung können entweder einzelne oder mehrere Spalten in einer Tabelle aktualisiert werden.

Das Folgende ist die grundlegende Syntax wie folgt:

UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
      FROM TABLE_NAME)
   [ WHERE) ]

Beispiel

Angenommen, wir haben die Tabelle COMPANY_BKP zur Verfügung, die eine Sicherung der Tabelle COMPANY darstellt.

Das folgende Beispiel aktualisiert das Gehalt in der COMPANY-Tabelle für alle Kunden, deren ALTER größer oder gleich 27 ist, um das 0,50-fache.

sqlite> UPDATE COMPANY
   SET SALARY = SALARY * 0.50
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
      WHERE AGE >= 27 );

Dies würde sich auf zwei Zeilen auswirken und schließlich würde die COMPANY-Tabelle die folgenden Datensätze enthalten:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  10000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       42500.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Unterabfragen mit DELETE-Anweisung

Die Unterabfrage kann in Verbindung mit der DELETE-Anweisung wie bei allen anderen oben genannten Anweisungen verwendet werden.

Das Folgende ist die grundlegende Syntax wie folgt:

DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
      FROM TABLE_NAME)
   [ WHERE) ]

Beispiel

Angenommen, wir haben die Tabelle COMPANY_BKP zur Verfügung, die eine Sicherung der Tabelle COMPANY darstellt.

Das folgende Beispiel löscht Datensätze aus der COMPANY-Tabelle für alle Kunden, deren AGE größer oder gleich 27 ist.

sqlite> DELETE FROM COMPANY
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
   WHERE AGE > 27 );

Dies wirkt sich auf zwei Zeilen aus und schließlich enthält die COMPANY-Tabelle die folgenden Datensätze:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       42500.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

SQLite AUTOINCREMENTist ein Schlüsselwort, das zum automatischen Inkrementieren eines Feldwerts in der Tabelle verwendet wird. Wir können einen Feldwert mithilfe von automatisch erhöhenAUTOINCREMENT Schlüsselwort beim Erstellen einer Tabelle mit einem bestimmten Spaltennamen zum automatischen Inkrementieren.

Das Schlüsselwort AUTOINCREMENT kann nur mit dem Feld INTEGER verwendet werden.

Syntax

Die grundlegende Verwendung von AUTOINCREMENT Schlüsselwort ist wie folgt -

CREATE TABLE table_name(
   column1 INTEGER AUTOINCREMENT,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
);

Beispiel

Betrachten Sie die zu erstellende COMPANY-Tabelle wie folgt:

sqlite> CREATE TABLE COMPANY(
   ID INTEGER PRIMARY KEY AUTOINCREMENT,
   NAME           TEXT      NOT NULL,
   AGE            INT       NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Fügen Sie nun die folgenden Datensätze in die Tabelle COMPANY ein -

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Paul', 32, 'California', 20000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ('Allen', 25, 'Texas', 15000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ('Teddy', 23, 'Norway', 20000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Mark', 25, 'Rich-Mond ', 65000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'David', 27, 'Texas', 85000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Kim', 22, 'South-Hall', 45000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'James', 24, 'Houston', 10000.00 );

Dadurch werden 7 Tupel in die Tabelle COMPANY eingefügt, und COMPANY verfügt über 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

Wenn Sie Benutzereingaben über eine Webseite in eine SQLite-Datenbank einfügen, besteht die Möglichkeit, dass Sie sich für ein Sicherheitsproblem, das als SQL Injection bezeichnet wird, offen gelassen haben. In diesem Kapitel erfahren Sie, wie Sie dies verhindern und Ihre Skripte und SQLite-Anweisungen sichern können.

Die Injektion erfolgt normalerweise, wenn Sie einen Benutzer wie seinen Namen um Eingabe bitten und anstelle eines Namens eine SQLite-Anweisung erhalten, die Sie unwissentlich in Ihrer Datenbank ausführen.

Vertrauen Sie niemals vom Benutzer bereitgestellten Daten. Verarbeiten Sie diese Daten erst nach der Validierung. Dies erfolgt in der Regel durch Pattern Matching. Im folgenden Beispiel ist der Benutzername auf alphanumerische Zeichen plus Unterstrich und auf eine Länge zwischen 8 und 20 Zeichen beschränkt. Ändern Sie diese Regeln nach Bedarf.

if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches)){ $db = new SQLiteDatabase('filename');
   $result = @$db->query("SELECT * FROM users WHERE username = $matches[0]");
} else {
   echo "username not accepted";
}

Betrachten Sie diesen Auszug, um das Problem zu demonstrieren -

$name = "Qadir'; DELETE FROM users;";
@$db->query("SELECT * FROM users WHERE username = '{$name}'");

Der Funktionsaufruf soll einen Datensatz aus der Benutzertabelle abrufen, wobei die Namensspalte mit dem vom Benutzer angegebenen Namen übereinstimmt. Unter normalen Umständen,$namewürde nur alphanumerische Zeichen und möglicherweise Leerzeichen enthalten, wie z. B. die Zeichenfolge ilia. In diesem Fall wird der Aufruf der Datenbank durch Anhängen einer völlig neuen Abfrage an $ name zu einer Katastrophe: Die injizierte DELETE-Abfrage entfernt alle Datensätze von Benutzern.

Es gibt Datenbankschnittstellen, die das Stapeln von Abfragen oder das Ausführen mehrerer Abfragen in einem einzigen Funktionsaufruf nicht zulassen. Wenn Sie versuchen, Abfragen zu stapeln, schlägt der Aufruf fehl, aber SQLite und PostgreSQL führen problemlos gestapelte Abfragen aus, führen alle in einer Zeichenfolge bereitgestellten Abfragen aus und verursachen ein ernstes Sicherheitsproblem.

Verhindern von SQL Injection

Sie können alle Escape-Zeichen in Skriptsprachen wie PERL und PHP intelligent verarbeiten. Die Programmiersprache PHP bietet die Funktionstring sqlite_escape_string() um Eingabezeichen zu umgehen, die speziell für SQLite sind.

if (get_magic_quotes_gpc()) {
   $name = sqlite_escape_string($name);
}
$result = @$db->query("SELECT * FROM users WHERE username = '{$name}'");

Obwohl die Codierung das Einfügen der Daten sicher macht, werden einfache Textvergleiche und gerendert LIKE Klauseln in Ihren Abfragen, die für die Spalten, die die Binärdaten enthalten, unbrauchbar sind.

Note - - addslashes()sollte NICHT verwendet werden, um Ihre Zeichenfolgen für SQLite-Abfragen in Anführungszeichen zu setzen. Dies führt zu seltsamen Ergebnissen beim Abrufen Ihrer Daten.

Der SQLite-Anweisung kann das Schlüsselwort "EXPLAIN" oder der Ausdruck "EXPLAIN QUERY PLAN" vorangestellt werden, mit dem die Details einer Tabelle beschrieben werden.

Bei beiden Änderungen verhält sich die SQLite-Anweisung wie eine Abfrage und gibt Informationen darüber zurück, wie die SQLite-Anweisung funktioniert hätte, wenn das Schlüsselwort oder die Phrase EXPLAIN weggelassen worden wäre.

• Die Ausgabe von EXPLAIN und EXPLAIN QUERY PLAN dient nur zur interaktiven Analyse und Fehlerbehebung.

• Die Details des Ausgabeformats können sich von einer Version von SQLite zur nächsten ändern.

• Anwendungen sollten EXPLAIN oder EXPLAIN QUERY PLAN nicht verwenden, da ihr genaues Verhalten variabel und nur teilweise dokumentiert ist.

Syntax

Syntax für EXPLAIN ist wie folgt -

EXPLAIN [SQLite Query]

Syntax für EXPLAIN QUERY PLAN ist wie folgt -

EXPLAIN  QUERY PLAN [SQLite Query]

Beispiel

Betrachten Sie die COMPANY- Tabelle mit den folgenden Datensätzen:

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

Lassen Sie uns nun die folgende Unterabfrage mit der SELECT-Anweisung überprüfen:

sqlite> EXPLAIN SELECT * FROM COMPANY WHERE Salary >= 20000;

Dies führt zu folgendem Ergebnis.

addr        opcode      p1          p2          p3
----------  ----------  ----------  ----------  ----------
0           Goto        0           19
1           Integer     0           0
2           OpenRead    0           8
3           SetNumColu  0           5
4           Rewind      0           17
5           Column      0           4
6           RealAffini  0           0
7           Integer     20000       0
8           Lt          357         16          collseq(BI
9           Rowid       0           0
10          Column      0           1
11          Column      0           2
12          Column      0           3
13          Column      0           4
14          RealAffini  0           0
15          Callback    5           0
16          Next        0           5
17          Close       0           0
18          Halt        0           0
19          Transactio  0           0
20          VerifyCook  0           38
21          Goto        0           1
22          Noop        0           0

Lassen Sie uns nun Folgendes überprüfen Explain Query Plan mit SELECT Anweisung -

SQLite> EXPLAIN QUERY PLAN SELECT * FROM COMPANY WHERE Salary >= 20000;

order       from        detail
----------  ----------  -------------
0           0           TABLE COMPANY

Der Befehl VACUUM bereinigt die Hauptdatenbank, indem der Inhalt in eine temporäre Datenbankdatei kopiert und die ursprüngliche Datenbankdatei von der Kopie neu geladen wird. Dies eliminiert freie Seiten, richtet Tabellendaten so aus, dass sie zusammenhängend sind, und bereinigt ansonsten die Datenbankdateistruktur.

Der Befehl VACUUM kann die ROWID von Einträgen in Tabellen ändern, die keinen expliziten INTEGER PRIMARY KEY haben. Der Befehl VACUUM funktioniert nur in der Hauptdatenbank. Es ist nicht möglich, eine angehängte Datenbankdatei VACUUM.

Der Befehl VACUUM schlägt fehl, wenn eine Transaktion aktiv ist. Der Befehl VACUUM ist ein No-Op für In-Memory-Datenbanken. Da der Befehl VACUUM die Datenbankdatei von Grund auf neu erstellt, kann VACUUM auch zum Ändern vieler datenbankspezifischer Konfigurationsparameter verwendet werden.

Handbuch VAKUUM

Im Folgenden finden Sie eine einfache Syntax zum Ausgeben eines VACUUM-Befehls für die gesamte Datenbank an der Eingabeaufforderung:

$sqlite3 database_name "VACUUM;"

Sie können VACUUM über die SQLite-Eingabeaufforderung wie folgt ausführen:

sqlite> VACUUM;

Sie können VACUUM auch für eine bestimmte Tabelle wie folgt ausführen:

sqlite> VACUUM table_name;

Auto-VACCUM

SQLite Auto-VACUUM macht nicht dasselbe wie VACUUM, sondern verschiebt nur freie Seiten an das Ende der Datenbank, wodurch die Datenbankgröße verringert wird. Auf diese Weise kann die Datenbank erheblich fragmentiert werden, während VACUUM die Defragmentierung sicherstellt. Daher hält Auto-VACUUM die Datenbank nur klein.

Sie können das automatische Staubsaugen von SQLite mithilfe der folgenden Pragmas aktivieren / deaktivieren, die an der SQLite-Eingabeaufforderung ausgeführt werden:

sqlite> PRAGMA auto_vacuum = NONE; -- 0 means disable auto vacuum
sqlite> PRAGMA auto_vacuum = FULL; -- 1 means enable full auto vacuum
sqlite> PRAGMA auto_vacuum = INCREMENTAL; -- 2 means enable incremental vacuum

Sie können den folgenden Befehl an der Eingabeaufforderung ausführen, um die automatische Vakuumeinstellung zu überprüfen:

$sqlite3 database_name "PRAGMA auto_vacuum;"

SQLite unterstützt fünf Datums- und Uhrzeitfunktionen wie folgt:

Sr.Nr.	Funktion	Beispiel
1	Datum (Zeitleiste, Modifikatoren ...)	Dies gibt das Datum in diesem Format zurück: JJJJ-MM-TT
2	Zeit (Zeitleiste, Modifikatoren ...)	Dies gibt die Zeit als HH: MM: SS zurück
3	Datum / Uhrzeit (Zeitleiste, Modifikatoren ...)	Dies gibt JJJJ-MM-TT HH: MM: SS zurück
4	julianday (timestring, modifikatoren ...)	Dies gibt die Anzahl der Tage seit Mittag in Greenwich am 24. November 4714 v. Chr. Zurück
5	strftime (Timestring, Modifikatoren ...)	Dies gibt das Datum zurück, das gemäß der Formatzeichenfolge formatiert wurde, die als erstes Argument angegeben wurde, das gemäß den unten erläuterten Formatierern formatiert wurde.

Alle oben genannten fünf Datums- und Zeitfunktionen verwenden eine Zeitzeichenfolge als Argument. Auf die Zeitzeichenfolge folgen null oder mehr Modifikatoren. Die Funktion strftime () verwendet auch eine Formatzeichenfolge als erstes Argument. Im folgenden Abschnitt erfahren Sie mehr über verschiedene Arten von Zeitzeichenfolgen und Modifikatoren.

Zeitstrings

Eine Zeitzeichenfolge kann in einem der folgenden Formate vorliegen:

Sr.Nr.	Zeitzeichenfolge	Beispiel
1	JJJJ-MM-TT	2010-12-30
2	JJJJ-MM-TT HH: MM	2010-12-30 12:10
3	JJJJ-MM-TT HH: MM: SS.SSS	2010-12-30 12: 10: 04.100
4	MM-TT-JJJJ HH: MM	30-12-2010 12:10
5	HH: MM	12:10
6	JJJJ-MM-TTTHH: MM	2010-12-30 12:10
7	HH: MM: SS	12:10:01
8	JJJJMMTT HHMMSS	20101230 121001
9	jetzt	2013-05-07

Sie können das "T" als Literalzeichen zwischen Datum und Uhrzeit verwenden.

Modifikatoren

Auf die Zeitzeichenfolge können null oder mehr Modifikatoren folgen, die Datum und / oder Uhrzeit ändern, die von einer der oben genannten fünf Funktionen zurückgegeben werden. Modifikatoren werden von links nach rechts angewendet.

Folgende Modifikatoren sind in SQLite verfügbar:

• NNN Tage
• NNN Stunden
• NNN Minuten
• NNN.NNNN Sekunden
• NNN Monate
• NNN Jahre
• Anfang des Monats
• Anfang des Jahres
• Tagesanfang
• Wochentag N.
• unixepoch
• localtime
• utc

Formatierer

SQLite bietet eine sehr praktische Funktion strftime()um ein Datum und eine Uhrzeit zu formatieren. Sie können die folgenden Ersetzungen verwenden, um Datum und Uhrzeit zu formatieren.

Auswechslung	Beschreibung
% d	Tag des Monats, 01-31
% f	Sekundenbruchteil, SS.SSS
% H.	Stunde, 00-23
% j	Tag des Jahres, 001-366
% J.	Julianische Tagesnummer, DDDD.DDDD
% m	Monat 00-12
% M.	Minute, 00-59
% s	Sekunden seit dem 01.01.1970
% S.	Sekunden, 00-59
% w	Wochentag 0-6 (0 ist Sonntag)
% W.	Woche des Jahres, 01-53
% Y.	Jahr, JJJJ
%%	% Symbol

Beispiele

Probieren wir jetzt verschiedene Beispiele mit der SQLite-Eingabeaufforderung aus. Der folgende Befehl berechnet das aktuelle Datum.

sqlite> SELECT date('now');
2013-05-07

Der folgende Befehl berechnet den letzten Tag des aktuellen Monats.

sqlite> SELECT date('now','start of month','+1 month','-1 day');
2013-05-31

Der folgende Befehl berechnet Datum und Uhrzeit für einen bestimmten UNIX-Zeitstempel 1092941466.

sqlite> SELECT datetime(1092941466, 'unixepoch');
2004-08-19 18:51:06

Der folgende Befehl berechnet Datum und Uhrzeit für einen bestimmten UNIX-Zeitstempel 1092941466 und kompensiert Ihre lokale Zeitzone.

sqlite> SELECT datetime(1092941466, 'unixepoch', 'localtime');
2004-08-19 13:51:06

Der folgende Befehl berechnet den aktuellen UNIX-Zeitstempel.

sqlite> SELECT strftime('%s','now');
1393348134

Der folgende Befehl berechnet die Anzahl der Tage seit der Unterzeichnung der US-Unabhängigkeitserklärung.

sqlite> SELECT julianday('now') - julianday('1776-07-04');
86798.7094695023

Der folgende Befehl berechnet die Anzahl der Sekunden seit einem bestimmten Moment im Jahr 2004.

sqlite> SELECT strftime('%s','now') - strftime('%s','2004-01-01 02:34:56');
295001572

Der folgende Befehl berechnet das Datum des ersten Dienstags im Oktober für das laufende Jahr.

sqlite> SELECT date('now','start of year','+9 months','weekday 2');
2013-10-01

Der folgende Befehl berechnet die Zeit seit der UNIX-Epoche in Sekunden (wie strftime ('% s', 'now'), außer Bruchteil).

sqlite> SELECT (julianday('now') - 2440587.5)*86400.0;
1367926077.12598

Verwenden Sie zum Konvertieren zwischen UTC- und lokalen Zeitwerten beim Formatieren eines Datums die folgenden Modifikatoren utc oder localtime:

sqlite> SELECT time('12:00', 'localtime');
05:00:00

sqlite> SELECT time('12:00', 'utc');
19:00:00

SQLite verfügt über viele integrierte Funktionen zum Verarbeiten von Zeichenfolgen oder numerischen Daten. Im Folgenden finden Sie eine Liste einiger nützlicher integrierter SQLite-Funktionen, bei denen die Groß- und Kleinschreibung nicht berücksichtigt wird. Dies bedeutet, dass Sie diese Funktionen entweder in Kleinbuchstaben oder in Großbuchstaben oder in gemischter Form verwenden können. Weitere Informationen finden Sie in der offiziellen Dokumentation zu SQLite.

Sr.Nr.	Bedienungsanleitung
1	SQLite COUNT Function Die SQLite COUNT-Aggregatfunktion wird verwendet, um die Anzahl der Zeilen in einer Datenbanktabelle zu zählen.
2	SQLite MAX Function Mit der SQLite MAX-Aggregatfunktion können wir den höchsten (maximalen) Wert für eine bestimmte Spalte auswählen.
3	SQLite MIN Function Mit der SQLite MIN-Aggregatfunktion können wir den niedrigsten (minimalen) Wert für eine bestimmte Spalte auswählen.
4	SQLite AVG Function Die SQLite AVG-Aggregatfunktion wählt den Durchschnittswert für eine bestimmte Tabellenspalte aus.
5	SQLite SUM Function Mit der SQLite SUM-Aggregatfunktion können Sie die Summe für eine numerische Spalte auswählen.
6	SQLite RANDOM Function Die SQLite RANDOM-Funktion gibt eine pseudozufällige Ganzzahl zwischen -9223372036854775808 und +9223372036854775807 zurück.
7	SQLite ABS Function Die SQLite ABS-Funktion gibt den absoluten Wert des numerischen Arguments zurück.
8	SQLite UPPER Function Die SQLite UPPER-Funktion konvertiert eine Zeichenfolge in Großbuchstaben.
9	SQLite LOWER Function Die SQLite LOWER-Funktion konvertiert eine Zeichenfolge in Kleinbuchstaben.
10	SQLite LENGTH Function Die SQLite LENGTH-Funktion gibt die Länge eines Strings zurück.
11	SQLite sqlite_version Function Die SQLite-Funktion sqlite_version gibt die Version der SQLite-Bibliothek zurück.

Bevor wir Beispiele für die oben genannten Funktionen geben, betrachten Sie die Tabelle COMPANY mit den folgenden Datensätzen.

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

SQLite COUNT-Funktion

Die SQLite COUNT-Aggregatfunktion wird verwendet, um die Anzahl der Zeilen in einer Datenbanktabelle zu zählen. Das Folgende ist ein Beispiel -

sqlite> SELECT count(*) FROM COMPANY;

Die obige SQLite SQL-Anweisung erzeugt Folgendes.

count(*)
----------
7

SQLite MAX-Funktion

Mit der SQLite MAX-Aggregatfunktion können wir den höchsten (maximalen) Wert für eine bestimmte Spalte auswählen. Das Folgende ist ein Beispiel -

sqlite> SELECT max(salary) FROM COMPANY;

Die obige SQLite SQL-Anweisung erzeugt Folgendes.

max(salary)
-----------
85000.0

SQLite MIN-Funktion

Mit der SQLite MIN-Aggregatfunktion können wir den niedrigsten (minimalen) Wert für eine bestimmte Spalte auswählen. Das Folgende ist ein Beispiel -

sqlite> SELECT min(salary) FROM COMPANY;

Die obige SQLite SQL-Anweisung erzeugt Folgendes.

min(salary)
-----------
10000.0

SQLite AVG-Funktion

Die SQLite AVG-Aggregatfunktion wählt den Durchschnittswert für eine bestimmte Tabellenspalte aus. Es folgt ein Beispiel -

sqlite> SELECT avg(salary) FROM COMPANY;

Die obige SQLite SQL-Anweisung erzeugt Folgendes.

avg(salary)
----------------
37142.8571428572

SQLite SUM-Funktion

Mit der SQLite SUM-Aggregatfunktion können Sie die Summe für eine numerische Spalte auswählen. Das Folgende ist ein Beispiel -

sqlite> SELECT sum(salary) FROM COMPANY;

Die obige SQLite SQL-Anweisung erzeugt Folgendes.

sum(salary)
-----------
260000.0

SQLite RANDOM-Funktion

Die SQLite RANDOM-Funktion gibt eine pseudozufällige Ganzzahl zwischen -9223372036854775808 und +9223372036854775807 zurück. Das Folgende ist ein Beispiel -

sqlite> SELECT random() AS Random;

Die obige SQLite SQL-Anweisung erzeugt Folgendes.

Random
-------------------
5876796417670984050

SQLite ABS-Funktion

Die SQLite ABS-Funktion gibt den absoluten Wert des numerischen Arguments zurück. Das Folgende ist ein Beispiel -

sqlite> SELECT abs(5), abs(-15), abs(NULL), abs(0), abs("ABC");

Die obige SQLite SQL-Anweisung erzeugt Folgendes.

abs(5)      abs(-15)    abs(NULL)   abs(0)      abs("ABC")
----------  ----------  ----------  ----------  ----------
5           15                      0           0.0

SQLite UPPER-Funktion

Die SQLite UPPER-Funktion konvertiert eine Zeichenfolge in Großbuchstaben. Das Folgende ist ein Beispiel -

sqlite> SELECT upper(name) FROM COMPANY;

Die obige SQLite SQL-Anweisung erzeugt Folgendes.

upper(name)
-----------
PAUL
ALLEN
TEDDY
MARK
DAVID
KIM
JAMES

SQLite LOWER-Funktion

Die SQLite LOWER-Funktion konvertiert eine Zeichenfolge in Kleinbuchstaben. Das Folgende ist ein Beispiel -

sqlite> SELECT lower(name) FROM COMPANY;

Die obige SQLite SQL-Anweisung erzeugt Folgendes.

lower(name)
-----------
paul
allen
teddy
mark
david
kim
james

SQLite LENGTH-Funktion

Die SQLite LENGTH-Funktion gibt die Länge eines Strings zurück. Das Folgende ist ein Beispiel -

sqlite> SELECT name, length(name) FROM COMPANY;

Die obige SQLite SQL-Anweisung erzeugt Folgendes.

NAME        length(name)
----------  ------------
Paul        4
Allen       5
Teddy       5
Mark        4
David       5
Kim         3
James       5

SQLite sqlite_version Funktion

Die SQLite-Funktion sqlite_version gibt die Version der SQLite-Bibliothek zurück. Das Folgende ist ein Beispiel -

sqlite> SELECT sqlite_version() AS 'SQLite Version';

Die obige SQLite SQL-Anweisung erzeugt Folgendes.

SQLite Version
--------------
3.6.20

In diesem Kapitel erfahren Sie, wie Sie SQLite in C / C ++ - Programmen verwenden.

Installation

Bevor Sie SQLite in unseren C / C ++ - Programmen verwenden, müssen Sie sicherstellen, dass auf dem Computer eine SQLite-Bibliothek eingerichtet ist. Sie können das Kapitel SQLite-Installation überprüfen, um den Installationsprozess zu verstehen.

C / C ++ - Schnittstellen-APIs

Im Folgenden finden Sie wichtige C / C ++ - SQLite-Schnittstellenroutinen, die ausreichen können, um mit der SQLite-Datenbank Ihres C / C ++ - Programms zu arbeiten. Wenn Sie nach einer komplexeren Anwendung suchen, können Sie die offizielle SQLite-Dokumentation lesen.

Sr.Nr.	API & Beschreibung
1	sqlite3_open(const char *filename, sqlite3 **ppDb) Diese Routine öffnet eine Verbindung zu einer SQLite-Datenbankdatei und gibt ein Datenbankverbindungsobjekt zurück, das von anderen SQLite-Routinen verwendet werden soll. Wenn das Dateinamenargument NULL oder ': memory:' ist, erstellt sqlite3_open () eine speicherinterne Datenbank im RAM, die nur für die Dauer der Sitzung gültig ist. Wenn der Dateiname nicht NULL ist, versucht sqlite3_open (), die Datenbankdatei mithilfe ihres Werts zu öffnen. Wenn keine Datei mit diesem Namen vorhanden ist, öffnet sqlite3_open () eine neue Datenbankdatei mit diesem Namen.
2	sqlite3_exec(sqlite3*, const char *sql, sqlite_callback, void *data, char **errmsg) Diese Routine bietet eine schnelle und einfache Möglichkeit, SQL-Befehle auszuführen, die von einem SQL-Argument bereitgestellt werden, das aus mehr als einem SQL-Befehl bestehen kann. Hier ist das erste Argument sqlite3 ein offenes Datenbankobjekt, sqlite_callback ist ein Rückruf, für den Daten das erste Argument sind, und errmsg wird zurückgegeben, um alle von der Routine ausgelösten Fehler zu erfassen. Die Routine SQLite3_exec () analysiert und führt jeden in der sql Argument, bis es das Ende der Zeichenfolge erreicht oder auf einen Fehler stößt.
3	sqlite3_close(sqlite3*) Diese Routine schließt eine Datenbankverbindung, die zuvor durch einen Aufruf von sqlite3_open () geöffnet wurde. Alle mit der Verbindung verbundenen vorbereiteten Anweisungen sollten vor dem Schließen der Verbindung abgeschlossen werden. Wenn noch Fragen bestehen, die noch nicht abgeschlossen wurden, gibt sqlite3_close () SQLITE_BUSY mit der Fehlermeldung zurück, dass aufgrund nicht finalisierter Anweisungen nicht geschlossen werden kann.

Verbindung zur Datenbank herstellen

Das folgende C-Codesegment zeigt, wie eine Verbindung zu einer vorhandenen Datenbank hergestellt wird. Wenn die Datenbank nicht vorhanden ist, wird sie erstellt und schließlich wird ein Datenbankobjekt zurückgegeben.

#include <stdio.h>
#include <sqlite3.h> 

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;

   rc = sqlite3_open("test.db", &db);

   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }
   sqlite3_close(db);
}

Lassen Sie uns nun das obige Programm kompilieren und ausführen, um unsere Datenbank zu erstellen test.dbim aktuellen Verzeichnis. Sie können Ihren Pfad gemäß Ihren Anforderungen ändern.

$gcc test.c -l sqlite3
$./a.out
Opened database successfully

Wenn Sie C ++ - Quellcode verwenden möchten, können Sie Ihren Code wie folgt kompilieren:

$g++ test.c -l sqlite3

Hier verknüpfen wir unser Programm mit der sqlite3-Bibliothek, um dem C-Programm die erforderlichen Funktionen bereitzustellen. Dadurch wird eine Datenbankdatei test.db in Ihrem Verzeichnis erstellt und Sie erhalten das folgende Ergebnis.

-rwxr-xr-x. 1 root root 7383 May 8 02:06 a.out
-rw-r--r--. 1 root root  323 May 8 02:05 test.c
-rw-r--r--. 1 root root    0 May 8 02:06 test.db

Erstellen Sie eine Tabelle

Das folgende C-Codesegment wird verwendet, um eine Tabelle in der zuvor erstellten Datenbank zu erstellen -

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *NotUsed, int argc, char **argv, char **azColName) {
   int i;
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stdout, "Opened database successfully\n");
   }

   /* Create SQL statement */
   sql = "CREATE TABLE COMPANY("  \
      "ID INT PRIMARY KEY     NOT NULL," \
      "NAME           TEXT    NOT NULL," \
      "AGE            INT     NOT NULL," \
      "ADDRESS        CHAR(50)," \
      "SALARY         REAL );";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
   
   if( rc != SQLITE_OK ){
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Table created successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

Wenn das obige Programm kompiliert und ausgeführt wird, erstellt es eine COMPANY-Tabelle in Ihrer test.db und die endgültige Auflistung der Datei lautet wie folgt:

-rwxr-xr-x. 1 root root 9567 May 8 02:31 a.out
-rw-r--r--. 1 root root 1207 May 8 02:31 test.c
-rw-r--r--. 1 root root 3072 May 8 02:31 test.db

INSERT-Betrieb

Das folgende C-Codesegment zeigt, wie Sie Datensätze in der im obigen Beispiel erstellten COMPANY-Tabelle erstellen können:

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *NotUsed, int argc, char **argv, char **azColName) {
   int i;
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create SQL statement */
   sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "  \
         "VALUES (1, 'Paul', 32, 'California', 20000.00 ); " \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "  \
         "VALUES (2, 'Allen', 25, 'Texas', 15000.00 ); "     \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
         "VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );" \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
         "VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
   
   if( rc != SQLITE_OK ){
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Records created successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

Wenn das obige Programm kompiliert und ausgeführt wird, werden die angegebenen Datensätze in der COMPANY-Tabelle erstellt und die folgenden zwei Zeilen angezeigt:

Opened database successfully
Records created successfully

SELECT-Betrieb

Bevor wir mit dem eigentlichen Beispiel zum Abrufen von Datensätzen fortfahren, wollen wir uns einige Details zur Rückruffunktion ansehen, die wir in unseren Beispielen verwenden. Dieser Rückruf bietet eine Möglichkeit, Ergebnisse aus SELECT-Anweisungen zu erhalten. Es hat die folgende Erklärung -

typedef int (*sqlite3_callback)(
   void*,    /* Data provided in the 4th argument of sqlite3_exec() */
   int,      /* The number of columns in row */
   char**,   /* An array of strings representing fields in the row */
   char**    /* An array of strings representing column names */
);

Wenn der obige Rückruf in der Routine sqlite_exec () als drittes Argument bereitgestellt wird, ruft SQLite diese Rückruffunktion für jeden Datensatz auf, der in jeder innerhalb des SQL-Arguments ausgeführten SELECT-Anweisung verarbeitet wird.

Das folgende C-Codesegment zeigt, wie Sie Datensätze aus der im obigen Beispiel erstellten COMPANY-Tabelle abrufen und anzeigen können.

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *data, int argc, char **argv, char **azColName){
   int i;
   fprintf(stderr, "%s: ", (const char*)data);
   
   for(i = 0; i<argc; i++){
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;
   const char* data = "Callback function called";

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create SQL statement */
   sql = "SELECT * from COMPANY";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
   
   if( rc != SQLITE_OK ) {
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Operation done successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

Wenn das obige Programm kompiliert und ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0

Callback function called: ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

UPDATE-Betrieb

Das folgende C-Codesegment zeigt, wie wir die UPDATE-Anweisung verwenden können, um einen Datensatz zu aktualisieren und dann aktualisierte Datensätze aus der COMPANY-Tabelle abzurufen und anzuzeigen.

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *data, int argc, char **argv, char **azColName){
   int i;
   fprintf(stderr, "%s: ", (const char*)data);
   
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;
   const char* data = "Callback function called";

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create merged SQL statement */
   sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1; " \
         "SELECT * from COMPANY";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
   
   if( rc != SQLITE_OK ) {
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Operation done successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

Wenn das obige Programm kompiliert und ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0

Callback function called: ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

DELETE-Betrieb

Das folgende C-Codesegment zeigt, wie Sie mit der DELETE-Anweisung einen beliebigen Datensatz löschen und dann die verbleibenden Datensätze aus der COMPANY-Tabelle abrufen und anzeigen können.

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *data, int argc, char **argv, char **azColName) {
   int i;
   fprintf(stderr, "%s: ", (const char*)data);
   
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;
   const char* data = "Callback function called";

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create merged SQL statement */
   sql = "DELETE from COMPANY where ID=2; " \
         "SELECT * from COMPANY";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
   
   if( rc != SQLITE_OK ) {
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Operation done successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

Wenn das obige Programm kompiliert und ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0

Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

In diesem Kapitel erfahren Sie, wie Sie SQLite in Java-Programmen verwenden.

Installation

Bevor Sie SQLite in unseren Java-Programmen verwenden, müssen Sie sicherstellen, dass SQLite JDBC-Treiber und Java auf dem Computer eingerichtet sind. Sie können das Java-Tutorial für die Java-Installation auf Ihrem Computer überprüfen. Lassen Sie uns nun überprüfen, wie der SQLite JDBC-Treiber eingerichtet wird.

• Laden Sie die neueste Version von sqlite-jdbc- (VERSION) .jar aus dem sqlite-jdbc- Repository herunter .

• Fügen Sie die heruntergeladene JAR-Datei sqlite-jdbc- (VERSION) .jar in Ihren Klassenpfad ein, oder verwenden Sie sie zusammen mit der Option -classpath, wie in den folgenden Beispielen erläutert.

Im folgenden Abschnitt wird davon ausgegangen, dass Sie nur wenig über Java JDBC-Konzepte wissen. Wenn Sie dies nicht tun, wird empfohlen, eine halbe Stunde mit JDBC Tutorial zu verbringen , um sich mit den unten erläuterten Konzepten vertraut zu machen.

Verbindung zur Datenbank herstellen

Das folgende Java-Programm zeigt, wie Sie eine Verbindung zu einer vorhandenen Datenbank herstellen. Wenn die Datenbank nicht vorhanden ist, wird sie erstellt und schließlich wird ein Datenbankobjekt zurückgegeben.

import java.sql.*;

public class SQLiteJDBC {
  public static void main( String args[] ) {
      Connection c = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Opened database successfully");
   }
}

Lassen Sie uns nun das obige Programm kompilieren und ausführen, um unsere Datenbank zu erstellen test.dbim aktuellen Verzeichnis. Sie können Ihren Pfad gemäß Ihren Anforderungen ändern. Wir gehen davon aus, dass die aktuelle Version des JDBC-Treibers sqlite-jdbc-3.7.2.jar im aktuellen Pfad verfügbar ist.

$javac SQLiteJDBC.java $java -classpath ".:sqlite-jdbc-3.7.2.jar" SQLiteJDBC
Open database successfully

Wenn Sie einen Windows-Computer verwenden, können Sie Ihren Code wie folgt kompilieren und ausführen:

$javac SQLiteJDBC.java $java -classpath ".;sqlite-jdbc-3.7.2.jar" SQLiteJDBC
Opened database successfully

Erstellen Sie eine Tabelle

Das folgende Java-Programm wird verwendet, um eine Tabelle in der zuvor erstellten Datenbank zu erstellen.

import java.sql.*;

public class SQLiteJDBC {

   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "CREATE TABLE COMPANY " +
                        "(ID INT PRIMARY KEY     NOT NULL," +
                        " NAME           TEXT    NOT NULL, " + 
                        " AGE            INT     NOT NULL, " + 
                        " ADDRESS        CHAR(50), " + 
                        " SALARY         REAL)"; 
         stmt.executeUpdate(sql);
         stmt.close();
         c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Table created successfully");
   }
}

Wenn das obige Programm kompiliert und ausgeführt wird, erstellt es eine COMPANY-Tabelle in Ihrem test.db und die endgültige Auflistung der Datei lautet wie folgt:

-rw-r--r--. 1 root root 3201128 Jan 22 19:04 sqlite-jdbc-3.7.2.jar
-rw-r--r--. 1 root root    1506 May  8 05:43 SQLiteJDBC.class
-rw-r--r--. 1 root root     832 May  8 05:42 SQLiteJDBC.java
-rw-r--r--. 1 root root    3072 May  8 05:43 test.db

INSERT-Betrieb

Das folgende Java-Programm zeigt, wie Datensätze in der im obigen Beispiel erstellten COMPANY-Tabelle erstellt werden.

import java.sql.*;

public class SQLiteJDBC {

   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
         c.setAutoCommit(false);
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                        "VALUES (1, 'Paul', 32, 'California', 20000.00 );"; 
         stmt.executeUpdate(sql);

         sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                  "VALUES (2, 'Allen', 25, 'Texas', 15000.00 );"; 
         stmt.executeUpdate(sql);

         sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                  "VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );"; 
         stmt.executeUpdate(sql);

         sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                  "VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );"; 
         stmt.executeUpdate(sql);

         stmt.close();
         c.commit();
         c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Records created successfully");
   }
}

Wenn das obige Programm kompiliert und ausgeführt wird, werden die angegebenen Datensätze in der COMPANY-Tabelle erstellt und die folgenden zwei Zeilen angezeigt:

Opened database successfully
Records created successfully

SELECT-Betrieb

Das folgende Java-Programm zeigt, wie Datensätze aus der im obigen Beispiel erstellten COMPANY-Tabelle abgerufen und angezeigt werden.

import java.sql.*;

public class SQLiteJDBC {

  public static void main( String args[] ) {

   Connection c = null;
   Statement stmt = null;
   try {
      Class.forName("org.sqlite.JDBC");
      c = DriverManager.getConnection("jdbc:sqlite:test.db");
      c.setAutoCommit(false);
      System.out.println("Opened database successfully");

      stmt = c.createStatement();
      ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
      
      while ( rs.next() ) {
         int id = rs.getInt("id");
         String  name = rs.getString("name");
         int age  = rs.getInt("age");
         String  address = rs.getString("address");
         float salary = rs.getFloat("salary");
         
         System.out.println( "ID = " + id );
         System.out.println( "NAME = " + name );
         System.out.println( "AGE = " + age );
         System.out.println( "ADDRESS = " + address );
         System.out.println( "SALARY = " + salary );
         System.out.println();
      }
      rs.close();
      stmt.close();
      c.close();
   } catch ( Exception e ) {
      System.err.println( e.getClass().getName() + ": " + e.getMessage() );
      System.exit(0);
   }
   System.out.println("Operation done successfully");
  }
}

Wenn das obige Programm kompiliert und ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0

ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

UPDATE-Betrieb

Der folgende Java-Code zeigt, wie Sie mit der UPDATE-Anweisung einen Datensatz aktualisieren und anschließend die aktualisierten Datensätze aus der COMPANY-Tabelle abrufen und anzeigen.

import java.sql.*;

public class SQLiteJDBC {

  public static void main( String args[] ) {
  
   Connection c = null;
   Statement stmt = null;
   
   try {
      Class.forName("org.sqlite.JDBC");
      c = DriverManager.getConnection("jdbc:sqlite:test.db");
      c.setAutoCommit(false);
      System.out.println("Opened database successfully");

      stmt = c.createStatement();
      String sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1;";
      stmt.executeUpdate(sql);
      c.commit();

      ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
      
      while ( rs.next() ) {
         int id = rs.getInt("id");
         String  name = rs.getString("name");
         int age  = rs.getInt("age");
         String  address = rs.getString("address");
         float salary = rs.getFloat("salary");
         
         System.out.println( "ID = " + id );
         System.out.println( "NAME = " + name );
         System.out.println( "AGE = " + age );
         System.out.println( "ADDRESS = " + address );
         System.out.println( "SALARY = " + salary );
         System.out.println();
      }
      rs.close();
      stmt.close();
      c.close();
   } catch ( Exception e ) {
      System.err.println( e.getClass().getName() + ": " + e.getMessage() );
      System.exit(0);
   }
    System.out.println("Operation done successfully");
   }
}

Wenn das obige Programm kompiliert und ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0

ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

DELETE-Betrieb

Der folgende Java-Code zeigt, wie Sie mit der DELETE-Anweisung einen Datensatz löschen und dann die verbleibenden Datensätze aus unserer COMPANY-Tabelle abrufen und anzeigen.

import java.sql.*;

public class SQLiteJDBC {

   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
         c.setAutoCommit(false);
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "DELETE from COMPANY where ID=2;";
         stmt.executeUpdate(sql);
         c.commit();

         ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
         
         while ( rs.next() ) {
         int id = rs.getInt("id");
         String  name = rs.getString("name");
         int age  = rs.getInt("age");
         String  address = rs.getString("address");
         float salary = rs.getFloat("salary");
         
         System.out.println( "ID = " + id );
         System.out.println( "NAME = " + name );
         System.out.println( "AGE = " + age );
         System.out.println( "ADDRESS = " + address );
         System.out.println( "SALARY = " + salary );
         System.out.println();
      }
      rs.close();
      stmt.close();
      c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Operation done successfully");
   }
}

Wenn das obige Programm kompiliert und ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0

ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

In diesem Kapitel erfahren Sie, wie Sie SQLite in PHP-Programmen verwenden.

Installation

Die SQLite3-Erweiterung ist ab PHP 5.3.0 standardmäßig aktiviert. Es ist möglich, es mit zu deaktivieren--without-sqlite3 zur Kompilierungszeit.

Windows-Benutzer müssen php_sqlite3.dll aktivieren, um diese Erweiterung verwenden zu können. Diese DLL ist in Windows-Distributionen von PHP ab PHP 5.3.0 enthalten.

Detaillierte Anweisungen zur Installation finden Sie in unserem PHP-Tutorial und auf der offiziellen Website.

PHP-Schnittstellen-APIs

Im Folgenden finden Sie wichtige PHP-Routinen, die für die Arbeit mit der SQLite-Datenbank Ihres PHP-Programms ausreichen können. Wenn Sie nach einer anspruchsvolleren Anwendung suchen, können Sie die offizielle Dokumentation zu PHP einsehen.

Sr.Nr.	API & Beschreibung
1	public void SQLite3::open ( filename, flags, encryption_key ) Öffnet die SQLite 3-Datenbank. Wenn der Build eine Verschlüsselung enthält, wird versucht, den Schlüssel zu verwenden. Wenn der Dateiname als angegeben ist':memory:'SQLite3 :: open () erstellt eine speicherinterne Datenbank im RAM, die nur für die Dauer der Sitzung gültig ist. Wenn der Dateiname der tatsächliche Name der Gerätedatei ist, versucht SQLite3 :: open (), die Datenbankdatei mithilfe ihres Werts zu öffnen. Wenn keine Datei mit diesem Namen vorhanden ist, wird eine neue Datenbankdatei mit diesem Namen erstellt. Optionale Flags, mit denen festgelegt wird, wie die SQLite-Datenbank geöffnet werden soll. Standardmäßig verwendet open SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE.
2	public bool SQLite3::exec ( string $query ) Diese Routine bietet eine schnelle und einfache Möglichkeit, SQL-Befehle auszuführen, die vom SQL-Argument bereitgestellt werden und aus mehr als einem SQL-Befehl bestehen können. Diese Routine wird verwendet, um eine ergebnislose Abfrage für eine bestimmte Datenbank auszuführen.
3	public SQLite3Result SQLite3::query ( string $query ) Diese Routine führt eine SQL-Abfrage aus und gibt eine zurück SQLite3Result Objekt, wenn die Abfrage Ergebnisse zurückgibt.
4	public int SQLite3::lastErrorCode ( void ) Diese Routine gibt den numerischen Ergebniscode der letzten fehlgeschlagenen SQLite-Anforderung zurück.
5	public string SQLite3::lastErrorMsg ( void ) Diese Routine gibt englischen Text zurück, der die letzte fehlgeschlagene SQLite-Anforderung beschreibt.
6	public int SQLite3::changes ( void ) Diese Routine gibt die Anzahl der Datenbankzeilen zurück, die von der letzten SQL-Anweisung aktualisiert, eingefügt oder gelöscht wurden.
7	public bool SQLite3::close ( void ) Diese Routine schließt eine Datenbankverbindung, die zuvor durch einen Aufruf von SQLite3 :: open () geöffnet wurde.
8	public string SQLite3::escapeString ( string $value ) Diese Routine gibt eine Zeichenfolge zurück, die zur sicheren Aufnahme in eine SQL-Anweisung ordnungsgemäß maskiert wurde.

Verbindung zur Datenbank herstellen

Der folgende PHP-Code zeigt, wie eine Verbindung zu einer vorhandenen Datenbank hergestellt wird. Wenn die Datenbank nicht vorhanden ist, wird sie erstellt und schließlich wird ein Datenbankobjekt zurückgegeben.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db');
      }
   }
   $db = new MyDB(); if(!$db) {
      echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }
?>

Lassen Sie uns nun das obige Programm ausführen, um unsere Datenbank zu erstellen test.dbim aktuellen Verzeichnis. Sie können Ihren Pfad gemäß Ihren Anforderungen ändern. Wenn die Datenbank erfolgreich erstellt wurde, wird die folgende Meldung angezeigt:

Open database successfully

Erstellen Sie eine Tabelle

Das folgende PHP-Programm wird verwendet, um eine Tabelle in der zuvor erstellten Datenbank zu erstellen.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db');
      }
   }
   $db = new MyDB(); if(!$db) {
      echo $db->lastErrorMsg(); } else { echo "Opened database successfully\n"; } $sql =<<<EOF
      CREATE TABLE COMPANY
      (ID INT PRIMARY KEY     NOT NULL,
      NAME           TEXT    NOT NULL,
      AGE            INT     NOT NULL,
      ADDRESS        CHAR(50),
      SALARY         REAL);
EOF;

   $ret = $db->exec($sql); if(!$ret){
      echo $db->lastErrorMsg(); } else { echo "Table created successfully\n"; } $db->close();
?>

Wenn das obige Programm ausgeführt wird, wird die COMPANY-Tabelle in Ihrem erstellt test.db und es werden die folgenden Meldungen angezeigt -

Opened database successfully
Table created successfully

INSERT-Betrieb

Das folgende PHP-Programm zeigt, wie Datensätze in der im obigen Beispiel erstellten COMPANY-Tabelle erstellt werden.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db'); } } $db = new MyDB();
   if(!$db){ echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }

   $sql =<<<EOF INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (1, 'Paul', 32, 'California', 20000.00 ); INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (2, 'Allen', 25, 'Texas', 15000.00 ); INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (3, 'Teddy', 23, 'Norway', 20000.00 ); INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 ); EOF; $ret = $db->exec($sql);
   if(!$ret) { echo $db->lastErrorMsg();
   } else {
      echo "Records created successfully\n";
   }
   $db->close();
?>

Wenn das obige Programm ausgeführt wird, werden die angegebenen Datensätze in der COMPANY-Tabelle erstellt und die folgenden zwei Zeilen angezeigt.

Opened database successfully
Records created successfully

SELECT-Betrieb

Das folgende PHP-Programm zeigt, wie Datensätze aus der im obigen Beispiel erstellten COMPANY-Tabelle abgerufen und angezeigt werden:

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db');
      }
   }
   
   $db = new MyDB(); if(!$db) {
      echo $db->lastErrorMsg(); } else { echo "Opened database successfully\n"; } $sql =<<<EOF
      SELECT * from COMPANY;
EOF;

   $ret = $db->query($sql); while($row = $ret->fetchArray(SQLITE3_ASSOC) ) { echo "ID = ". $row['ID'] . "\n";
      echo "NAME = ". $row['NAME'] ."\n"; echo "ADDRESS = ". $row['ADDRESS'] ."\n";
      echo "SALARY = ".$row['SALARY'] ."\n\n"; } echo "Operation done successfully\n"; $db->close();
?>

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

UPDATE-Betrieb

Der folgende PHP-Code zeigt, wie Sie mit der UPDATE-Anweisung einen Datensatz aktualisieren und anschließend die aktualisierten Datensätze aus der COMPANY-Tabelle abrufen und anzeigen.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db'); } } $db = new MyDB();
   if(!$db) { echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }
   $sql =<<<EOF UPDATE COMPANY set SALARY = 25000.00 where ID=1; EOF; $ret = $db->exec($sql);
   if(!$ret) { echo $db->lastErrorMsg();
   } else {
      echo $db->changes(), " Record updated successfully\n"; } $sql =<<<EOF
      SELECT * from COMPANY;
EOF;
   
   $ret = $db->query($sql); while($row = $ret->fetchArray(SQLITE3_ASSOC) ) { echo "ID = ". $row['ID'] . "\n";
      echo "NAME = ". $row['NAME'] ."\n"; echo "ADDRESS = ". $row['ADDRESS'] ."\n";
      echo "SALARY = ".$row['SALARY'] ."\n\n"; } echo "Operation done successfully\n"; $db->close();
?>

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
1 Record updated successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

DELETE-Betrieb

Der folgende PHP-Code zeigt, wie Sie mit der DELETE-Anweisung einen Datensatz löschen und dann die verbleibenden Datensätze aus der COMPANY-Tabelle abrufen und anzeigen.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db'); } } $db = new MyDB();
   if(!$db) { echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }
   $sql =<<<EOF DELETE from COMPANY where ID = 2; EOF; $ret = $db->exec($sql);
   if(!$ret){ echo $db->lastErrorMsg();
   } else {
      echo $db->changes(), " Record deleted successfully\n"; } $sql =<<<EOF
      SELECT * from COMPANY;
EOF;
   $ret = $db->query($sql); while($row = $ret->fetchArray(SQLITE3_ASSOC) ) { echo "ID = ". $row['ID'] . "\n";
      echo "NAME = ". $row['NAME'] ."\n"; echo "ADDRESS = ". $row['ADDRESS'] ."\n";
      echo "SALARY = ".$row['SALARY'] ."\n\n"; } echo "Operation done successfully\n"; $db->close();
?>

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
1 Record deleted successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

In diesem Kapitel erfahren Sie, wie Sie SQLite in Perl-Programmen verwenden.

Installation

SQLite3 kann mithilfe des Perl-DBI-Moduls, einem Datenbankzugriffsmodul für die Programmiersprache Perl, in Perl integriert werden. Es definiert eine Reihe von Methoden, Variablen und Konventionen, die eine Standarddatenbankschnittstelle bereitstellen.

Im Folgenden finden Sie einfache Schritte zum Installieren des DBI-Moduls auf Ihrem Linux / UNIX-Computer:

$ wget http://search.cpan.org/CPAN/authors/id/T/TI/TIMB/DBI-1.625.tar.gz $ tar xvfz DBI-1.625.tar.gz
$ cd DBI-1.625 $ perl Makefile.PL
$ make $ make install

Wenn Sie den SQLite-Treiber für DBI installieren müssen, kann er wie folgt installiert werden:

$ wget http://search.cpan.org/CPAN/authors/id/M/MS/MSERGEANT/DBD-SQLite-1.11.tar.gz $ tar xvfz DBD-SQLite-1.11.tar.gz
$ cd DBD-SQLite-1.11 $ perl Makefile.PL
$ make $ make install

DBI-Schnittstellen-APIs

Im Folgenden finden Sie wichtige DBI-Routinen, die ausreichen können, um mit der SQLite-Datenbank Ihres Perl-Programms zu arbeiten. Wenn Sie nach einer anspruchsvolleren Anwendung suchen, können Sie die offizielle Dokumentation von Perl DBI einsehen.

Sr.Nr.	API & Beschreibung
1	DBI->connect($data_source, "", "", \%attr) Stellt eine Datenbankverbindung oder Sitzung zur angeforderten $ data_source her. Gibt ein Datenbankhandle-Objekt zurück, wenn die Verbindung erfolgreich ist. Datenquelle hat die Form wie - DBI:SQLite:dbname = 'test.db'Dabei ist SQLite der Name des SQLite-Treibers und test.db der Name der SQLite-Datenbankdatei. Wenn der Dateiname als angegeben ist':memory:'Es wird eine speicherinterne Datenbank im RAM erstellt, die nur für die Dauer der Sitzung gültig ist. Wenn der Dateiname der tatsächliche Name der Gerätedatei ist, wird versucht, die Datenbankdatei mithilfe ihres Werts zu öffnen. Wenn keine Datei mit diesem Namen vorhanden ist, wird eine neue Datenbankdatei mit diesem Namen erstellt. Sie behalten den zweiten und dritten Parameter als leere Zeichenfolgen bei, und der letzte Parameter besteht darin, verschiedene Attribute zu übergeben, wie im folgenden Beispiel gezeigt.
2	$dbh->do($sql) Diese Routine bereitet eine einzelne SQL-Anweisung vor und führt sie aus. Gibt die Anzahl der betroffenen oder bei einem Fehler nicht definierten Zeilen zurück. Ein Rückgabewert von -1 bedeutet, dass die Anzahl der Zeilen nicht bekannt, nicht zutreffend oder nicht verfügbar ist. Hier ist $ dbh ein Handle, das vom Aufruf DBI-> connect () zurückgegeben wird.
3	$dbh->prepare($sql) Diese Routine bereitet eine Anweisung für die spätere Ausführung durch das Datenbankmodul vor und gibt einen Verweis auf ein Anweisungshandle-Objekt zurück.
4	$sth->execute() Diese Routine führt die erforderliche Verarbeitung aus, um die vorbereitete Anweisung auszuführen. Ein undef wird zurückgegeben, wenn ein Fehler auftritt. Eine erfolgreiche Ausführung gibt unabhängig von der Anzahl der betroffenen Zeilen immer true zurück. Hier,$sth is a statement handle returned by $dbh-> bereite ($ sql) Aufruf vor.
5	$sth->fetchrow_array() Diese Routine ruft die nächste Datenzeile ab und gibt sie als Liste mit den Feldwerten zurück. Nullfelder werden als undef-Werte in der Liste zurückgegeben.
6	$DBI::err Dies entspricht $ h-> err, wobei $h is any of the handle types like $dbh, $sth, or $drh. Dies gibt den Fehlercode des nativen Datenbankmoduls von der zuletzt aufgerufenen Treibermethode zurück.
7	$DBI::errstr Dies entspricht $ h-> errstr, wobei $h is any of the handle types like $dbh, $sth, or $drh. Dies gibt die native Datenbankmodul-Fehlermeldung der zuletzt aufgerufenen DBI-Methode zurück.
8	$dbh->disconnect() Diese Routine schließt eine Datenbankverbindung, die zuvor durch einen Aufruf von DBI-> connect () geöffnet wurde.

Verbindung zur Datenbank herstellen

Der folgende Perl-Code zeigt, wie Sie eine Verbindung zu einer vorhandenen Datenbank herstellen. Wenn die Datenbank nicht vorhanden ist, wird sie erstellt und schließlich wird ein Datenbankobjekt zurückgegeben.

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "SQLite"; 
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) 
   or die $DBI::errstr;

print "Opened database successfully\n";

Führen Sie nun das obige Programm aus, um unsere Datenbank test.db im aktuellen Verzeichnis zu erstellen. Sie können Ihren Pfad gemäß Ihren Anforderungen ändern. Behalten Sie den obigen Code in der Datei sqlite.pl bei und führen Sie ihn wie unten gezeigt aus. Wenn die Datenbank erfolgreich erstellt wurde, wird die folgende Meldung angezeigt:

$ chmod +x sqlite.pl
$ ./sqlite.pl
Open database successfully

Erstellen Sie eine Tabelle

Das folgende Perl-Programm wird verwendet, um eine Tabelle in der zuvor erstellten Datenbank zu erstellen.

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
   or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(CREATE TABLE COMPANY
   (ID INT PRIMARY KEY     NOT NULL,
      NAME           TEXT    NOT NULL,
      AGE            INT     NOT NULL,
      ADDRESS        CHAR(50),
      SALARY         REAL););

my $rv = $dbh->do($stmt); if($rv < 0) {
   print $DBI::errstr; } else { print "Table created successfully\n"; } $dbh->disconnect();

Wenn das obige Programm ausgeführt wird, erstellt es eine COMPANY-Tabelle in Ihrer test.db und zeigt die folgenden Meldungen an:

Opened database successfully
Table created successfully

NOTE - Falls Sie den folgenden Fehler in einer der Operationen sehen -

DBD::SQLite::st execute failed: not an error(21) at dbdimp.c line 398

In diesem Fall öffnen dbdimp.c file verfügbar in der DBD-SQLite-Installation und finden Sie es heraus sqlite3_prepare() Funktion und ändern Sie das dritte Argument in -1 statt 0. Installieren Sie abschließend DBD :: SQLite mit make und TU make install um das Problem zu lösen.

INSERT-Betrieb

Das folgende Perl-Programm zeigt, wie Datensätze in der im obigen Beispiel erstellten COMPANY-Tabelle erstellt werden.

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "SQLite"; my $database = "test.db";
my $dsn = "DBI:$driver:dbname=$database"; my $userid = "";
my $password = ""; my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) or die $DBI::errstr;
print "Opened database successfully\n";

my $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (1, 'Paul', 32, 'California', 20000.00 )); my $rv = $dbh->do($stmt) or die $DBI::errstr; $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
               VALUES (2, 'Allen', 25, 'Texas', 15000.00 ));
$rv = $dbh->do($stmt) or die $DBI::errstr;

$stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (3, 'Teddy', 23, 'Norway', 20000.00 )); $rv = $dbh->do($stmt) or die $DBI::errstr; $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
               VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 ););

$rv = $dbh->do($stmt) or die $DBI::errstr;

print "Records created successfully\n";
$dbh->disconnect();

Wenn das obige Programm ausgeführt wird, werden die angegebenen Datensätze in der COMPANY-Tabelle erstellt und die folgenden zwei Zeilen angezeigt:

Opened database successfully
Records created successfully

SELECT-Betrieb

Das folgende Perl-Programm zeigt, wie Datensätze aus der im obigen Beispiel erstellten COMPANY-Tabelle abgerufen und angezeigt werden.

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
   or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(SELECT id, name, address, salary from COMPANY;);
my $sth = $dbh->prepare( $stmt ); my $rv = $sth->execute() or die $DBI::errstr;

if($rv < 0) { print $DBI::errstr;
}

while(my @row = $sth->fetchrow_array()) { print "ID = ". $row[0] . "\n";
      print "NAME = ". $row[1] ."\n"; print "ADDRESS = ". $row[2] ."\n";
      print "SALARY =  ". $row[3] ."\n\n"; } print "Operation done successfully\n"; $dbh->disconnect();

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY =  20000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY =  15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY =  65000

Operation done successfully

UPDATE-Betrieb

Der folgende Perl-Code zeigt, wie die UPDATE-Anweisung zum Aktualisieren eines Datensatzes und zum Abrufen und Anzeigen der aktualisierten Datensätze aus der COMPANY-Tabelle ausgeführt wird.

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "SQLite"; my $database = "test.db";
my $dsn = "DBI:$driver:dbname=$database"; my $userid = "";
my $password = ""; my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) or die $DBI::errstr;
print "Opened database successfully\n";

my $stmt = qq(UPDATE COMPANY set SALARY = 25000.00 where ID=1;); my $rv = $dbh->do($stmt) or die $DBI::errstr; if( $rv < 0 ) {
   print $DBI::errstr; } else { print "Total number of rows updated : $rv\n";
}
$stmt = qq(SELECT id, name, address, salary from COMPANY;); my $sth = $dbh->prepare( $stmt );
$rv = $sth->execute() or die $DBI::errstr; if($rv < 0) {
   print $DBI::errstr; } while(my @row = $sth->fetchrow_array()) {
      print "ID = ". $row[0] . "\n"; print "NAME = ". $row[1] ."\n";
      print "ADDRESS = ". $row[2] ."\n"; print "SALARY = ". $row[3] ."\n\n";
}
print "Operation done successfully\n";
$dbh->disconnect();

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
Total number of rows updated : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY =  25000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY =  15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY =  65000

Operation done successfully

DELETE-Betrieb

Der folgende Perl-Code zeigt, wie Sie mit der DELETE-Anweisung einen Datensatz löschen und dann die verbleibenden Datensätze aus der COMPANY-Tabelle abrufen und anzeigen.

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
   or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(DELETE from COMPANY where ID = 2;);
my $rv = $dbh->do($stmt) or die $DBI::errstr;

if( $rv < 0 ) { print $DBI::errstr;
} else {
   print "Total number of rows deleted : $rv\n"; } $stmt = qq(SELECT id, name, address, salary from COMPANY;);
my $sth = $dbh->prepare( $stmt ); $rv = $sth->execute() or die $DBI::errstr;

if($rv < 0) { print $DBI::errstr;
}

while(my @row = $sth->fetchrow_array()) { print "ID = ". $row[0] . "\n";
      print "NAME = ". $row[1] ."\n"; print "ADDRESS = ". $row[2] ."\n";
      print "SALARY =  ". $row[3] ."\n\n"; } print "Operation done successfully\n"; $dbh->disconnect();

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
Total number of rows deleted : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

In diesem Kapitel erfahren Sie, wie Sie SQLite in Python-Programmen verwenden.

Installation

SQLite3 kann mit dem von Gerhard Haring geschriebenen sqlite3-Modul in Python integriert werden. Es bietet eine SQL-Schnittstelle, die der in PEP 249 beschriebenen DB-API 2.0-Spezifikation entspricht. Sie müssen dieses Modul nicht separat installieren, da es standardmäßig zusammen mit Python ab Version 2.5.x ausgeliefert wird.

Um das sqlite3-Modul verwenden zu können, müssen Sie zuerst ein Verbindungsobjekt erstellen, das die Datenbank darstellt. Anschließend können Sie optional ein Cursorobjekt erstellen, das Sie bei der Ausführung aller SQL-Anweisungen unterstützt.

Python-SQLite3-Modul-APIs

Im Folgenden finden Sie wichtige Routinen für sqlite3-Module, die für die Arbeit mit der SQLite-Datenbank Ihres Python-Programms ausreichen können. Wenn Sie nach einer anspruchsvolleren Anwendung suchen, können Sie die offizielle Dokumentation des Python sqlite3-Moduls lesen.

Sr.Nr.	API & Beschreibung
1	sqlite3.connect(database [,timeout ,other optional arguments]) Diese API öffnet eine Verbindung zur SQLite-Datenbankdatei. Sie können ": memory:" verwenden, um eine Datenbankverbindung zu einer Datenbank zu öffnen, die sich im RAM statt auf der Festplatte befindet. Wenn die Datenbank erfolgreich geöffnet wurde, wird ein Verbindungsobjekt zurückgegeben. Wenn auf eine Datenbank über mehrere Verbindungen zugegriffen wird und einer der Prozesse die Datenbank ändert, wird die SQLite-Datenbank gesperrt, bis diese Transaktion festgeschrieben wird. Der Parameter timeout gibt an, wie lange die Verbindung warten soll, bis die Sperre aufgehoben wird, bis eine Ausnahme ausgelöst wird. Der Standardwert für den Timeout-Parameter ist 5,0 (fünf Sekunden). Wenn der angegebene Datenbankname nicht vorhanden ist, wird durch diesen Aufruf die Datenbank erstellt. Sie können den Dateinamen auch mit dem erforderlichen Pfad angeben, wenn Sie eine Datenbank an einer anderen Stelle als im aktuellen Verzeichnis erstellen möchten.
2	connection.cursor([cursorClass]) Diese Routine erstellt eine cursorDies wird während Ihrer gesamten Datenbankprogrammierung mit Python verwendet. Diese Methode akzeptiert einen einzelnen optionalen Parameter cursorClass. Wenn angegeben, muss dies eine benutzerdefinierte Cursorklasse sein, die sqlite3.Cursor erweitert.
3	cursor.execute(sql [, optional parameters]) Diese Routine führt eine SQL-Anweisung aus. Die SQL-Anweisung kann parametrisiert werden (dh Platzhalter anstelle von SQL-Literalen). Das sqlite3-Modul unterstützt zwei Arten von Platzhaltern: Fragezeichen und benannte Platzhalter (benannter Stil). For example - cursor.execute ("In Personenwerte einfügen (?,?)", (Wer, Alter))
4	connection.execute(sql [, optional parameters]) Diese Routine ist eine Verknüpfung der obigen Ausführungsmethode, die vom Cursorobjekt bereitgestellt wird. Sie erstellt ein Zwischencursorobjekt, indem sie die Cursormethode aufruft, und ruft dann die Ausführungsmethode des Cursors mit den angegebenen Parametern auf.
5	cursor.executemany(sql, seq_of_parameters) Diese Routine führt einen SQL-Befehl für alle Parametersequenzen oder Zuordnungen aus, die in der Sequenz sql gefunden werden.
6	connection.executemany(sql[, parameters]) Diese Routine ist eine Verknüpfung, die durch Aufrufen der Cursormethode ein Zwischencursorobjekt erstellt und dann die ausführbare Methode cursor.s mit den angegebenen Parametern aufruft.
7	cursor.executescript(sql_script) Diese Routine führt mehrere SQL-Anweisungen gleichzeitig aus, die in Form eines Skripts bereitgestellt werden. Es gibt zuerst eine COMMIT-Anweisung aus und führt dann das SQL-Skript aus, das es als Parameter erhält. Alle SQL-Anweisungen sollten durch ein Semikolon (;) getrennt werden.
8	connection.executescript(sql_script) Diese Routine ist eine Verknüpfung, die durch Aufrufen der Cursormethode ein Zwischencursorobjekt erstellt und dann die Executescript-Methode des Cursors mit den angegebenen Parametern aufruft.
9	connection.total_changes() Diese Routine gibt die Gesamtzahl der Datenbankzeilen zurück, die seit dem Öffnen der Datenbankverbindung geändert, eingefügt oder gelöscht wurden.
10	connection.commit() Diese Methode schreibt die aktuelle Transaktion fest. Wenn Sie diese Methode nicht aufrufen, ist alles, was Sie seit dem letzten Aufruf von commit () getan haben, für andere Datenbankverbindungen nicht sichtbar.
11	connection.rollback() Diese Methode setzt alle Änderungen an der Datenbank seit dem letzten Aufruf von commit () zurück.
12	connection.close() Diese Methode schließt die Datenbankverbindung. Beachten Sie, dass dies nicht automatisch commit () aufruft. Wenn Sie nur Ihre Datenbankverbindung schließen, ohne zuerst commit () aufzurufen, gehen Ihre Änderungen verloren!
13	cursor.fetchone() Diese Methode ruft die nächste Zeile einer Abfrageergebnismenge ab und gibt eine einzelne Sequenz zurück oder Keine, wenn keine weiteren Daten verfügbar sind.
14	cursor.fetchmany([size = cursor.arraysize]) Diese Routine ruft den nächsten Satz von Zeilen eines Abfrageergebnisses ab und gibt eine Liste zurück. Eine leere Liste wird zurückgegeben, wenn keine Zeilen mehr verfügbar sind. Die Methode versucht, so viele Zeilen abzurufen, wie durch den Größenparameter angegeben.
15	cursor.fetchall() Diese Routine ruft alle (verbleibenden) Zeilen eines Abfrageergebnisses ab und gibt eine Liste zurück. Eine leere Liste wird zurückgegeben, wenn keine Zeilen verfügbar sind.

Verbindung zur Datenbank herstellen

Der folgende Python-Code zeigt, wie eine Verbindung zu einer vorhandenen Datenbank hergestellt wird. Wenn die Datenbank nicht vorhanden ist, wird sie erstellt und schließlich wird ein Datenbankobjekt zurückgegeben.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')

print "Opened database successfully";

Hier können Sie auch den Datenbanknamen als speziellen Namen angeben :memory:um eine Datenbank im RAM zu erstellen. Lassen Sie uns nun das obige Programm ausführen, um unsere Datenbank zu erstellentest.dbim aktuellen Verzeichnis. Sie können Ihren Pfad gemäß Ihren Anforderungen ändern. Behalten Sie den obigen Code in der Datei sqlite.py und führen Sie ihn wie unten gezeigt aus. Wenn die Datenbank erfolgreich erstellt wurde, wird die folgende Meldung angezeigt.

$chmod +x sqlite.py $./sqlite.py
Open database successfully

Erstellen Sie eine Tabelle

Das folgende Python-Programm wird verwendet, um eine Tabelle in der zuvor erstellten Datenbank zu erstellen.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute('''CREATE TABLE COMPANY
         (ID INT PRIMARY KEY     NOT NULL,
         NAME           TEXT    NOT NULL,
         AGE            INT     NOT NULL,
         ADDRESS        CHAR(50),
         SALARY         REAL);''')
print "Table created successfully";

conn.close()

Wenn das obige Programm ausgeführt wird, wird die COMPANY-Tabelle in Ihrem erstellt test.db und es werden die folgenden Meldungen angezeigt -

Opened database successfully
Table created successfully

INSERT-Betrieb

Das folgende Python-Programm zeigt, wie Datensätze in der im obigen Beispiel erstellten COMPANY-Tabelle erstellt werden.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (1, 'Paul', 32, 'California', 20000.00 )");

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (2, 'Allen', 25, 'Texas', 15000.00 )");

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (3, 'Teddy', 23, 'Norway', 20000.00 )");

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 )");

conn.commit()
print "Records created successfully";
conn.close()

Wenn das obige Programm ausgeführt wird, werden die angegebenen Datensätze in der COMPANY-Tabelle erstellt und die folgenden zwei Zeilen angezeigt:

Opened database successfully
Records created successfully

SELECT-Betrieb

Das folgende Python-Programm zeigt, wie Datensätze aus der im obigen Beispiel erstellten COMPANY-Tabelle abgerufen und angezeigt werden.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

cursor = conn.execute("SELECT id, name, address, salary from COMPANY")
for row in cursor:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000.0

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

UPDATE-Betrieb

Der folgende Python-Code zeigt, wie Sie mit der UPDATE-Anweisung einen Datensatz aktualisieren und anschließend die aktualisierten Datensätze aus der COMPANY-Tabelle abrufen und anzeigen.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute("UPDATE COMPANY set SALARY = 25000.00 where ID = 1")
conn.commit()
print "Total number of rows updated :", conn.total_changes

cursor = conn.execute("SELECT id, name, address, salary from COMPANY")
for row in cursor:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
Total number of rows updated : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000.0

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

DELETE-Betrieb

Der folgende Python-Code zeigt, wie Sie mit der DELETE-Anweisung einen Datensatz löschen und dann die verbleibenden Datensätze aus der COMPANY-Tabelle abrufen und anzeigen.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute("DELETE from COMPANY where ID = 2;")
conn.commit()
print "Total number of rows deleted :", conn.total_changes

cursor = conn.execute("SELECT id, name, address, salary from COMPANY")
for row in cursor:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
Total number of rows deleted : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000.0

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully