Tabellen in SQLite erstellen

Einführung

In diesem Lab lernen Sie die grundlegenden Fähigkeiten zum Erstellen und Verwalten von Tabellen in SQLite, einer schlanken und serverlosen Datenbank-Engine, die sich perfekt für kleine Anwendungen eignet. Sie werden SQLite-Datentypen erkunden, Tabellen mit Primärschlüsseln erstellen, Einschränkungen wie NOT NULL und UNIQUE anwenden, Tabellenstrukturen mit dem Befehl .schema inspizieren und Tabellen sicher löschen (drop). Durch schrittweise Übungen in der LabEx VM-Umgebung sammeln Sie praktische Erfahrungen mit dem sqlite3-Befehlszeilentool zum Erstellen und Verwalten von Datenbanktabellen. Dieses Lab ist für Anfänger konzipiert und bietet einen klaren Weg zum Verständnis der SQLite-Tabellenverwaltung.

Verbinden Sie sich mit SQLite und erstellen Sie eine contacts Tabelle

In diesem ersten Schritt verbinden Sie sich mit einer SQLite-Datenbank und erstellen Ihre erste Tabelle namens contacts (Kontakte). SQLite ist eine schlanke Datenbank-Engine, die Daten in einer einzigen Datei speichert. Sie verwenden das sqlite3-Befehlszeilentool, um mit der Datenbank zu interagieren.

Öffnen Sie ein Terminal in der LabEx VM-Umgebung. Stellen Sie sicher, dass Sie sich im Standardarbeitsverzeichnis /home/labex/project befinden.
Verbinden Sie sich mit einer SQLite-Datenbank namens test.db mit dem sqlite3-Tool. Dieser Befehl erstellt die Datenbankdatei, falls sie noch nicht vorhanden ist.
```
sqlite3 test.db
```
Dieser Befehl öffnet die SQLite-Shell, und Sie sehen eine Eingabeaufforderung wie sqlite>, die anzeigt, dass Sie sich in der SQLite-Umgebung befinden.
Erstellen Sie eine Tabelle namens contacts mit Spalten für id, name (Name) und phone (Telefonnummer). Geben Sie den folgenden SQL-Befehl an der sqlite>-Eingabeaufforderung ein:
```
CREATE TABLE contacts (
    id INTEGER PRIMARY KEY,
    name TEXT,
    phone TEXT
);
```
Dieser Befehl erstellt eine Tabelle namens contacts. Die Spalte id ist eine Ganzzahl (Integer) und wird als PRIMARY KEY (Primärschlüssel) festgelegt, was bedeutet, dass sie jede Zeile in der Tabelle eindeutig identifiziert. Die Spalten name und phone sind beide vom Typ TEXT, der beliebige Zeichenkettendaten speichern kann.

Lassen Sie uns den Befehl aufschlüsseln:
- CREATE TABLE contacts: Dies weist SQLite an, eine neue Tabelle namens contacts zu erstellen.
- id INTEGER PRIMARY KEY: Dies definiert eine Spalte namens id mit dem Datentyp INTEGER (Ganzzahl). Die PRIMARY KEY-Einschränkung (Primärschlüssel-Einschränkung) stellt sicher, dass jeder Wert in dieser Spalte eindeutig ist und als primäre Kennung für jede Zeile dient.
- name TEXT: Dies definiert eine Spalte namens name mit dem Datentyp TEXT, der beliebige Zeichenkettendaten speichern kann.
- phone TEXT: Dies definiert eine Spalte namens phone mit dem Datentyp TEXT, der beliebige Zeichenkettendaten speichern kann.

Daten in die contacts Tabelle einfügen

Nachdem Sie die contacts-Tabelle erstellt haben, fügen wir einige Daten ein. Sie verwenden die INSERT INTO-Anweisung, um neue Zeilen zur Tabelle hinzuzufügen.

Fügen Sie einen neuen Kontakt in die contacts-Tabelle ein. Führen Sie diesen Befehl an der sqlite>-Eingabeaufforderung aus:
```
INSERT INTO contacts (name, phone) VALUES ('John Doe', '123-456-7890');
```
Dieser Befehl fügt eine neue Zeile in die contacts-Tabelle mit dem Namen 'John Doe' und der Telefonnummer '123-456-7890' ein. Der Spalte id wird automatisch ein eindeutiger Wert zugewiesen, da sie der Primärschlüssel (primary key) ist.

Lassen Sie uns den Befehl aufschlüsseln:
- INSERT INTO contacts: Dies weist SQLite an, Daten in die contacts-Tabelle einzufügen.
- (name, phone): Dies gibt die Spalten an, in die Sie Daten einfügen möchten.
- VALUES ('John Doe', '123-456-7890'): Dies gibt die Werte an, die in die entsprechenden Spalten eingefügt werden sollen.
Fügen Sie einen weiteren Kontakt in die contacts-Tabelle ein:
```
INSERT INTO contacts (name, phone) VALUES ('Jane Smith', '987-654-3210');
```
Dieser Befehl fügt eine weitere Zeile in die contacts-Tabelle mit dem Namen 'Jane Smith' und der Telefonnummer '987-654-3210' ein.

Daten aus der contacts Tabelle abrufen

Nachdem Sie Daten in die contacts-Tabelle eingefügt haben, rufen wir sie ab. Sie verwenden die SELECT-Anweisung, um die Tabelle abzufragen und die Daten anzuzeigen.

Rufen Sie alle Daten aus der contacts-Tabelle ab. Führen Sie diesen Befehl an der sqlite>-Eingabeaufforderung aus:
```
SELECT * FROM contacts;
```
Dieser Befehl wählt alle Spalten (*) aus der contacts-Tabelle aus und zeigt die Ergebnisse an.

Erwartete Ausgabe:
```
1|John Doe|123-456-7890
2|Jane Smith|987-654-3210
```
Die Ausgabe zeigt die beiden Kontakte, die Sie eingefügt haben, zusammen mit ihren automatisch zugewiesenen id-Werten.

Lassen Sie uns den Befehl aufschlüsseln:
- SELECT *: Dies weist SQLite an, alle Spalten aus der Tabelle auszuwählen.
- FROM contacts: Dies gibt die Tabelle an, aus der Sie Daten abrufen möchten.
Rufen Sie nur die Spalten name (Name) und phone (Telefonnummer) aus der contacts-Tabelle ab:
```
SELECT name, phone FROM contacts;
```
Dieser Befehl wählt nur die Spalten name und phone aus der contacts-Tabelle aus und zeigt die Ergebnisse an.

Erwartete Ausgabe:
```
John Doe|123-456-7890
Jane Smith|987-654-3210
```

Erstellen einer users Tabelle mit Constraints

Constraints (Bedingungen) sind Regeln, die die Datenintegrität in einer Tabelle erzwingen. Fügen wir NOT NULL- und UNIQUE-Constraints zu einer neuen Tabelle namens users hinzu.

Erstellen Sie eine Tabelle namens users mit Constraints. Führen Sie diesen Befehl an der sqlite>-Eingabeaufforderung aus:
```
CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    username TEXT NOT NULL UNIQUE,
    email TEXT NOT NULL,
    age INTEGER
);
```
Dieser Befehl erstellt eine Tabelle namens users mit den folgenden Constraints:
- username darf nicht NULL sein und muss UNIQUE sein.
- email darf nicht NULL sein.
Lassen Sie uns den Befehl aufschlüsseln:
- CREATE TABLE users: Dies weist SQLite an, eine neue Tabelle namens users zu erstellen.
- id INTEGER PRIMARY KEY: Dies definiert eine Spalte namens id mit dem Datentyp INTEGER. Der PRIMARY KEY-Constraint (Primärschlüssel-Bedingung) stellt sicher, dass jeder Wert in dieser Spalte eindeutig ist und als primärer Identifikator für jede Zeile dient.
- username TEXT NOT NULL UNIQUE: Dies definiert eine Spalte namens username mit dem Datentyp TEXT. Der NOT NULL-Constraint (Nicht-Null-Bedingung) stellt sicher, dass diese Spalte nicht leer sein darf, und der UNIQUE-Constraint (Eindeutigkeitsbedingung) stellt sicher, dass alle Werte in dieser Spalte unterschiedlich sind.
- email TEXT NOT NULL: Dies definiert eine Spalte namens email mit dem Datentyp TEXT. Der NOT NULL-Constraint stellt sicher, dass diese Spalte nicht leer sein darf.
- age INTEGER: Dies definiert eine Spalte namens age mit dem Datentyp INTEGER.
Versuchen wir nun, einige Daten einzufügen, die gegen diese Constraints verstoßen, um zu sehen, wie sie funktionieren. Versuchen Sie zunächst, einen Benutzer ohne Benutzernamen einzufügen:
```
INSERT INTO users (email, age) VALUES ('test@example.com', 25);
```
Sie sehen einen Fehler, da die Spalte username als NOT NULL definiert ist.

Erwartete Ausgabe:
```
Error: NOT NULL constraint failed: users.username
```
Dieser Fehler zeigt, dass SQLite den NOT NULL-Constraint für username erzwingt und das Einfügen verhindert.
Versuchen Sie als Nächstes, einen Benutzer mit einem doppelten Benutzernamen einzufügen. Fügen Sie zuerst einen gültigen Benutzer ein:
```
INSERT INTO users (username, email, age) VALUES ('johndoe', 'john.doe@example.com', 30);
```
Versuchen Sie dann, einen anderen Benutzer mit demselben Benutzernamen einzufügen:
```
INSERT INTO users (username, email, age) VALUES ('johndoe', 'jane.doe@example.com', 25);
```
Sie sehen einen Fehler, da die Spalte username als UNIQUE definiert ist.

Erwartete Ausgabe:
```
Error: UNIQUE constraint failed: users.username
```
Dieser Fehler zeigt, dass SQLite den UNIQUE-Constraint für username erzwingt und doppelte Werte verhindert.

Tabellenstruktur mit .schema inspizieren

Sie können die Struktur einer Tabelle mit dem Befehl .schema inspizieren. Dieser Befehl zeigt die SQL-Anweisung an, die zum Erstellen der Tabelle verwendet wurde, einschließlich Spaltennamen, Datentypen und Constraints (Bedingungen).

Inspizieren Sie die Struktur der users-Tabelle. Führen Sie diesen Befehl an der sqlite>-Eingabeaufforderung aus:
```
.schema users
```
Erwartete Ausgabe:
```
CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    username TEXT NOT NULL UNIQUE,
    email TEXT NOT NULL,
    age INTEGER
);
```
Die Ausgabe zeigt die CREATE TABLE-Anweisung für die users-Tabelle, einschließlich der NOT NULL- und UNIQUE-Constraints für die Spalte username.

Der Befehl .schema ist ein nützliches Werkzeug, um die Struktur Ihrer Tabellen zu verstehen und zu überprüfen, ob die Constraints korrekt definiert sind.
Beenden Sie die SQLite-Shell:
```
.quit
```
Dieser Befehl beendet die SQLite-Shell und bringt Sie zum Linux-Terminal zurück.

WICHTIG: Stellen Sie sicher, dass Sie .exit ausführen, bevor Sie auf die Schaltfläche "Continue" (Weiter) klicken. Andernfalls kann der Schritt nicht überprüft werden, da der SQLite-Verlauf nicht aufgezeichnet wird.

Die contacts Tabelle löschen

Sie können eine Tabelle mit dem Befehl DROP TABLE aus der Datenbank löschen. Dieser Befehl löscht die Tabelle und alle ihre Daten dauerhaft. Verwenden Sie ihn daher mit Vorsicht.

Verbinden Sie sich mit der test.db-Datenbank:
```
sqlite3 test.db
```
Löschen Sie die contacts-Tabelle. Führen Sie diesen Befehl an der sqlite>-Eingabeaufforderung aus:
```
DROP TABLE contacts;
```
Dieser Befehl löscht die contacts-Tabelle und alle ihre Daten aus der Datenbank.

Warnung: Diese Aktion ist irreversibel. Sobald Sie eine Tabelle gelöscht haben, können Sie sie oder ihre Daten nicht mehr wiederherstellen.
Überprüfen Sie, ob die contacts-Tabelle gelöscht wurde, indem Sie versuchen, Daten daraus auszuwählen:
```
SELECT * FROM contacts;
```
Sie sehen einen Fehler, da die contacts-Tabelle nicht mehr existiert.
Beenden Sie die SQLite-Shell:
```
.quit
```

Zusammenfassung

In diesem Lab haben Sie die grundlegenden Fähigkeiten zum Erstellen und Verwalten von Tabellen in SQLite erlernt. Sie haben SQLite-Datentypen erkundet, Tabellen mit Primärschlüsseln (primary keys) erstellt, Constraints (Bedingungen) wie NOT NULL und UNIQUE angewendet, Tabellenstrukturen mit dem Befehl .schema inspiziert und Tabellen sicher gelöscht. Diese Fähigkeiten sind unerlässlich für die Arbeit mit SQLite-Datenbanken und die Entwicklung datengesteuerter Anwendungen (data-driven applications).