Tabellen in SQLite anzeigen

Einleitung

SQLite ist eine beliebte Datenbank-Engine, die für ihre Einfachheit und Effizienz bei der Verwaltung relationaler Datenbanken bekannt ist. Als eingebettete SQL-Datenbank-Engine wird sie oft direkt in Anwendungen genutzt und bietet eine schlanke Datenbanklösung ohne separaten Serverprozess. In diesem Tutorial schauen wir uns an, wie du eine Liste der Tabellen in einer SQLite-Datenbank anzeigst – eine typische Aufgabe, wenn du dich mit der Struktur einer bestehenden Datenbank vertraut machst oder Fehler suchst.

Voraussetzungen

Du brauchst eine installierte und erreichbare SQLite-Installation. Mit SQLite-Datenbanken kannst du auf verschiedene Weise arbeiten, etwa über die Kommandozeile, ein Python-Skript oder GUI-Tools wie Beekeeper Studio. Diese Anleitung nutzt das SQLite-Kommandozeilentool, da es überall verfügbar ist.

Auf die SQLite-Datenbank zugreifen

Öffne zuerst dein Terminal oder deine Eingabeaufforderung und greife mit dem SQLite-Kommandozeilentool auf deine SQLite-Datenbank zu. Der allgemeine Befehl, um mit deiner Datenbank zu arbeiten, lautet:

sqlite3 your_database_file.db

Ersetze ‘your_database_file.db’ durch den Pfad zu deiner SQLite-Datenbankdatei.

Tabellen mit dem Befehl .tables auflisten

SQLite bietet mit dem Befehl .tables eine einfache Möglichkeit, alle verfügbaren Tabellen deiner aktiven Datenbank aufzulisten.

Gib in deiner SQLite-Kommandozeile Folgendes ein:

.tables

Wenn du diesen Befehl ausführst, gibt SQLite eine Liste aller Tabellennamen in deiner aktuellen Datenbank zurück.

Erwartete Ausgabe: (mit der Beispieldatenbank ‘sakila.db’)

actor                   experiments             payment
address                 film                    rental
category                film_actor              sales_by_film_category
city                    film_category           sales_by_store
country                 film_list               staff
customer                film_text               staff_list
customer_list           inventory               store
events                  language

Wie funktioniert der Befehl .tables?

SQLite weist die Datenbank an, die Namen aller Tabellen und Views in der Haupt- und den angehängten Datenbanken zurückzugeben. Dazu führt es im Hintergrund einen SELECT-Befehl auf der Tabelle sqlite_master aus.

Die Tabelle sqlite_master abfragen

Für mehr Kontrolle kannst du die Tabelle ‘sqlite_master’ direkt abfragen. Sie speichert die Metadaten der Datenbank, einschließlich der Tabellendefinitionen.

Zum Beispiel:

SELECT name FROM sqlite_master WHERE type='table';

Dieser SQL-Befehl wählt alle Einträge der Spalte name aus der Tabelle sqlite_master aus, bei denen type gleich ‘table’ ist.

Erwartete Ausgabe: (mit der Beispieldatenbank ‘sakila.db’)

---------------
actor
sqlite_sequence
country
city
address
language
category
customer
film
film_actor
film_category
film_text
inventory
staff
store
payment
rental
experiments
events

Tabellenschema mit dem Befehl .schema anzeigen

Um die Struktur bzw. das ‘Schema’ deiner Tabelle zu untersuchen (also die Spalten und ihre Datentypen), bietet SQLite den Befehl .schema:

.schema your_table_name

Erwartete Ausgabe: (mit der Tabelle ‘actor’ aus der Beispieldatenbank ‘sakila.db’)

CREATE TABLE actor (
  actor_id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
  first_name VARCHAR(45) NOT NULL,
  last_name VARCHAR(45) NOT NULL,
  last_update TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
  , "email_address" VARCHAR(255) NULL);
CREATE INDEX idx_actor_last_name ON actor(last_name)
;
CREATE TRIGGER actor_trigger_ai AFTER INSERT ON actor
 BEGIN
  UPDATE actor SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
 END;
CREATE TRIGGER actor_trigger_au AFTER UPDATE ON actor
 BEGIN
  UPDATE actor SET last_update = DATETIME('NOW')  WHERE rowid = new.rowid;
 END;

Ersetze ‘your_table_name’ durch den Namen deiner Tabelle.

Dieser Befehl gibt die CREATE TABLE-Anweisung zurück, mit der die Tabelle in deiner Datenbank erstellt wurde.

Eine SELECT-SQL-Anweisung verwenden

Alternativ kannst du das Schema mit einer SELECT-Anweisung auf der Tabelle sqlite_master abrufen:

SELECT sql FROM sqlite_master WHERE name = 'your_table_name';

Dieser Befehl gibt dieselbe CREATE TABLE-Anweisung zurück wie der Befehl .schema, allerdings ohne die ‘INDEX’- und ‘TRIGGER’-Anweisungen.

Tabelleninfos mit dem Befehl PRAGMA abrufen

Eine weitere Möglichkeit in SQLite ist der Befehl PRAGMA, der verschiedene Eigenschaften der SQLite-Datenbank liefert. Ein nützlicher PRAGMA-Befehl ist ‘table_info’, mit dem du Informationen über die Spalten einer Tabelle abrufen kannst.

‘table_info’ listet zwar nicht alle Tabellen auf, lässt sich aber mit den Befehlen zum Auflisten kombinieren, um die Struktur einer Tabelle direkt nach dem Finden ihres Namens zu verstehen.

Beispiel:

PRAGMA table_info('actor');

Erwartete Ausgabe: (mit der Tabelle ‘actor’ aus der Beispieldatenbank ‘sakila.db’)

cid  name           type          notnull  dflt_value         pk
---  -------------  ------------  -------  -----------------  --
0    actor_id       INTEGER       1                           1
1    first_name     VARCHAR(45)   1                           0
2    last_name      VARCHAR(45)   1                           0
3    last_update    TIMESTAMP     1        CURRENT_TIMESTAMP  0
4    email_address  VARCHAR(255)  0                           0

Jede Zeile steht für eine Spalte der Tabelle ‘actor’. Die Felder zeigen jeweils ‘cid’, ‘name’, ‘type’ der Spalte, ihren ‘not null’-Status, ihren ‘default value’ und die ‘primary key’-Information.

Fazit

Tabellen in SQLite aufzulisten ist eine grundlegende Fähigkeit für die Verwaltung und Analyse von Datenbanken. Ob du den Befehl .tables für eine schnelle Liste nutzt, die Tabelle sqlite_master für einen programmatischeren Ansatz abfragst oder PRAGMA-Anweisungen verwendest, um detaillierte Informationen über Tabellenstrukturen zu sammeln: SQLite bietet dir viele Werkzeuge, um deine Datenbank zu verstehen und effektiv mit ihr zu arbeiten.

SQL-Befehle zum Anzeigen deiner SQLite-Tabellen zu verstehen und zu schreiben, kann sich lohnen, ist aber auch zeitaufwendig und komplex – besonders bei großen Datenbanken.

Beekeeper Studio bietet eine benutzerfreundliche Oberfläche für die Tabellen deiner Datenbank, mit der du bequem durch zahlreiche Tabellen navigierst.

Und um das Schema einer beliebigen Tabelle abzurufen, klickst du einfach auf den Tabellennamen – schon erscheint das Schema übersichtlich strukturiert.