SQLite SELECT: Spalten, Ausdrücke und Aliase

SELECT liest Zeilen aus einer Tabelle

Jede Abfrage an eine SQLite-Datenbank beginnt mit SELECT. Damit sagst du der Datenbank: gib mir diese Spalten, aus dieser Tabelle, für die Zeilen, die folgenden Bedingungen entsprechen. Heute schauen wir uns die ersten beiden Teile an — Spalten und Tabelle. Das Filtern kommt im nächsten Dokument.

Die einfachste denkbare SQLite-Abfrage:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL,
    stock INTEGER
);

INSERT INTO products (name, price, stock) VALUES
    ('Notizbuch', 4.50, 120),
    ('Stift', 1.20, 500),
    ('Rucksack', 39.99, 25),
    ('Radiergummi', 0.80, 300);

SELECT * FROM products;

SELECT * heißt "alle Spalten". FROM products gibt die Tabelle an. Das Ergebnis: pro Datensatz eine Zeile mit allen vier Spalten. Das Semikolon schließt die Anweisung ab.

Mehr steckt nicht dahinter: SELECT <Spalten> FROM <Tabelle>;.

Bestimmte Spalten in SQLite auswählen

* ist praktisch, wenn man sich erst einmal umschauen will. In echtem Code willst du aber fast immer genau die Spalten benennen, die du tatsächlich brauchst:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL,
    stock INTEGER
);

INSERT INTO products (name, price, stock) VALUES
    ('Notizbuch', 4.50, 120),
    ('Stift', 1.20, 500),
    ('Rucksack', 39.99, 25);

SELECT name, price FROM products;

Du bekommst zwei Spalten zurück – und zwar in genau der Reihenfolge, in der du sie angefordert hast. Die Reihenfolge in der SELECT-Liste bestimmt also die Reihenfolge im Ergebnis und muss nicht mit der Spaltenreihenfolge in der Tabelle übereinstimmen.

Warum ist das besser als SELECT *? Aus zwei Gründen. Erstens werden weniger Daten übertragen (bzw. aus der Datei gelesen), was bei breiten Tabellen schnell ins Gewicht fällt. Zweitens bleibt deine Abfrage stabil, wenn jemand nächsten Monat eine neue Spalte hinzufügt. SELECT * liefert dann klammheimlich mehr Daten zurück – und das kann Anwendungscode kaputtmachen, der Zeilen über die Position auspackt.

SELECT kann nicht nur abfragen, sondern auch berechnen

Die Einträge in der SELECT-Liste müssen keine reinen Spaltennamen sein. Erlaubt ist jeder beliebige Ausdruck – Arithmetik, Funktionsaufrufe, String-Verkettung, Konstanten. SQLite wertet den Ausdruck für jede Zeile aus.

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL,
    stock INTEGER
);

INSERT INTO products (name, price, stock) VALUES
    ('Notizbuch', 4.50, 120),
    ('Stift', 1.20, 500),
    ('Rucksack', 39.99, 25);

SELECT name, price, stock, price * stock FROM products;

Die vierte Spalte existiert in der Tabelle gar nicht – SQLite berechnet sie Zeile für Zeile. Genauso kannst du mit String-Funktionen, Datumswerten oder bedingten Ausdrücken arbeiten – im Grunde mit allem, was SQL hergibt. Die SELECT-Liste ist also nicht nur dazu da, Daten abzurufen, sondern auch, um sie passend zu formen.

Du kannst SELECT sogar ganz ohne FROM-Klausel verwenden und SQLite damit wie einen Taschenrechner einsetzen:

SELECT 2 + 2, upper('hello'), length('SQLite');

Eine Zeile, drei Spalten. Praktisch, wenn du erst mal ausprobieren willst, was ein Ausdruck eigentlich tut, bevor du ihn in eine echte Abfrage einbaust.

Spalten umbenennen mit AS

Sobald du eine Spalte berechnest, vergibt SQLite automatisch einen Namen dafür – meistens den Ausdruck selbst, also so etwas wie price * stock. Das sieht nicht nur unschön aus, sondern ist auch unzuverlässig. Mit dem Schlüsselwort AS gibst du der Spalte einen sauberen Namen:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL,
    stock INTEGER
);

INSERT INTO products (name, price, stock) VALUES
    ('Notizbuch', 4.50, 120),
    ('Rucksack', 39.99, 25);

SELECT
    name AS product,
    price * stock AS inventory_value
FROM products;

Der Alias bestimmt den Spaltennamen im Ergebnis. Das verbessert nicht nur die Lesbarkeit beim Durchschauen der Ausgabe, sondern ist vor allem im Anwendungscode entscheidend, wenn du Werte über den Spaltennamen abgreifst (row["inventory_value"] statt row[1]).

Das Schlüsselwort AS ist optional — price * stock inventory_value funktioniert genauso. Trotzdem: Schreib es aus. Die Absicht wird dadurch klarer, und du vermeidest, dass jemand ein fehlendes Komma versehentlich für einen Alias hält.

Auch die Tabelle mit einem Alias versehen

Du kannst genauso gut der Tabelle selbst einen kurzen Alias geben. Bei einer einzelnen Tabelle bringt das wenig, aber sobald JOINs ins Spiel kommen, zahlt sich diese Gewohnheit sofort aus:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL
);

INSERT INTO products (name, price) VALUES ('Notizbuch', 4.50);

SELECT p.name, p.price FROM products AS p;

p steht hier stellvertretend für products. Die Punktnotation p.name macht klar, aus welcher Tabelle eine Spalte stammt. Bei einer einzelnen Tabelle ist das nur Ballast – sobald aber drei Tabellen per Join zusammenkommen, hält genau diese Schreibweise die Abfrage überhaupt erst lesbar.

Literale und Konstanten im Ergebnis

In einem SQLite SELECT kannst du echte Spalten mit festen Werten kombinieren. Das ist praktisch, wenn du Zeilen markieren oder einen Platzhalter einsetzen willst:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL
);

INSERT INTO products (name, price) VALUES
    ('Notizbuch', 4.50),
    ('Stift', 1.20);

SELECT
    name,
    price,
    'USD' AS currency,
    1 AS active
FROM products;

Jede Zeile bekommt dasselbe 'USD' und 1. Dieses Muster taucht typischerweise dann auf, wenn du Ergebnisse aus mehreren Abfragen mit UNION zusammenführst und eine Markierungsspalte brauchst, um die Quellen voneinander unterscheiden zu können.

Kurz zu NULL

Manche Spalten sind leer — entweder wurde kein Wert eingefügt, oder die Spalte hat keinen Standardwert. SQLite stellt "kein Wert" als NULL dar, und NULL erscheint in den SELECT-Ergebnissen je nach Tool entweder als leeres Feld oder als das Wort NULL.

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL
);

INSERT INTO products (name, price) VALUES
    ('Notizbuch', 4.50),
    ('Geheimnisvoller Artikel', NULL);

SELECT name, price, price * 2 AS doubled FROM products;

Schau dir die zweite Zeile an. price ist NULL, und price * 2 ist ebenfalls NULL — jede Rechenoperation mit NULL ergibt wieder NULL. Das ist eine der häufigsten Stolperfallen bei SQL-Ergebnissen und bekommt später eine eigene Seite. Merk dir vorerst nur: NULL steckt sich durch Ausdrücke hindurch an.

Was du mitnimmst

• SELECT <Spalten> FROM <Tabelle>; ist die Grundform jeder Abfrage.
• In echtem Code immer die Spalten explizit auflisten; SELECT * ist nur zum Erkunden gedacht.
• In der SELECT-Liste darf jeder beliebige Ausdruck stehen, nicht nur Spaltennamen.
• Mit AS gibst du berechneten Spalten und Tabellen-Aliassen sprechende Namen.
• NULL zieht sich durch jede Rechnung — denk daran, wenn die Ergebnisse seltsam aussehen.

Als Nächstes: Zeilen filtern mit WHERE

Bisher liefert jede Abfrage sämtliche Zeilen der Tabelle zurück. Mit der WHERE-Klausel grenzt du das Ergebnis ein — nach Preis, nach Name, nach Datum oder nach jedem Ausdruck, der wahr oder falsch ergibt. Genau darum geht es im nächsten Kapitel.