Datenbanken & SQL

Daten dauerhaft ablegen, abfragen und ändern: std.db spricht SQLite über die C-Bibliothek, PostgreSQL, MySQL und Redis dagegen nativ über das jeweilige Netzprotokoll — ohne Client-Bibliothek. Diese Seite zeigt den Arbeitsweg je Backend, die gemeinsamen Muster (Prepared Statements, Transaktionen, Ressourcen) und benennt, was heute trägt.

→ std.db — Unit-Referenz · Netzwerk-Guide · Capabilities

Faustregel: SQLite, solange es geht. Eine Datei, kein Server, kein Netz, keine Zugangsdaten — und für die allermeisten Anwendungen schnell genug. Ein Server-Backend lohnt, wenn mehrere Prozesse gleichzeitig schreiben oder die Daten getrennt vom Programm leben sollen.

import std.io;
import std.db.sqlite;

fn main(): int64 {
    var db: int64 := SQLiteOpen("kunden.db"c);       // ":memory:" für flüchtige DB
    if (db == 0) { PrintLn("Öffnen fehlgeschlagen"); return 1; }

    if (!SQLiteExec(db, "CREATE TABLE IF NOT EXISTS kunden (id INTEGER PRIMARY KEY, name TEXT, umsatz_cent INTEGER)"c)) {
        PrintLn(SQLiteErrmsg(db));
        SQLiteClose(db);
        return 1;
    }

    // Einfügen mit Prepared Statement
    var stmt: int64 := SQLiteStmtPrepare(db, "INSERT INTO kunden (name, umsatz_cent) VALUES (?, ?)"c);
    if (stmt == 0) { PrintLn(SQLiteErrmsg(db)); SQLiteClose(db); return 1; }

    SQLiteBindStr(stmt, 1, "Meier GmbH"c);
    SQLiteBindInt(stmt, 2, 125050);
    SQLiteStmtStep(stmt);

    SQLiteStmtReset(stmt);           // dasselbe Statement erneut verwenden
    SQLiteClearBindings(stmt);
    SQLiteBindStr(stmt, 1, "Schulze AG"c);
    SQLiteBindInt(stmt, 2, 89000);
    SQLiteStmtStep(stmt);
    SQLiteStmtFinalize(stmt);

    Print("letzte ID: ");  PrintLn(IntToStr(SQLiteLastInsertId(db)));
    Print("geaendert: ");  PrintLn(IntToStr(SQLiteChanges(db)));

    // Abfragen
    var q: int64 := SQLiteStmtPrepare(db, "SELECT id, name FROM kunden WHERE umsatz_cent > ? ORDER BY umsatz_cent DESC"c);
    SQLiteBindInt(q, 1, 50000);
    while (SQLiteStmtStep(q) == SQLITE_ROW) {
        var name: pchar := SQLiteColumnText(q, 1);
        Print(IntToStr(SQLiteColumnInt(q, 0))); Print(" | "); PrintLn(name);
    }
    SQLiteStmtFinalize(q);

    SQLiteClose(db);
    return 0;
}

Ausgabe:

letzte ID: 2
geaendert: 1
1 | Meier GmbH
2 | Schulze AG

1. SQLiteStmtPrepare übersetzt das SQL einmal. Rückgabe 0 heißt Fehler — SQLiteErrmsg nennt den Grund.
2. SQLiteBind… setzt die Werte. Die Parameter sind 1-basiert.
3. SQLiteStmtStep führt aus. SQLITE_ROW (100) heißt „eine Zeile liegt bereit„, SQLITE_DONE (101) „fertig“.
4. SQLiteStmtFinalize gibt das Statement frei. Ohne diesen Aufruf bleibt es am Verbindungsobjekt hängen.

Die Spalten in SQLiteColumn… sind dagegen 0-basiert. Diese Asymmetrie stammt aus SQLite selbst und ist die häufigste Fehlerquelle beim Einstieg.

SQLiteExec(db, sql) führt ein Statement in einem Schritt aus — richtig für CREATE TABLE, PRAGMA, DELETE ohne Parameter. Niemals mit selbst zusammengesetztem SQL aus fremden Daten (Abschnitt 4).

Für jeden Dienst, der nebenläufig liest, gehört SQLiteSetJournalMode(db, „WAL“c) direkt hinter das SQLiteOpen.

if (!SQLiteBegin(db)) { PrintLn(SQLiteErrmsg(db)); return 1; }

var ok: bool := SQLiteExec(db, "UPDATE konto SET stand = stand - 100 WHERE id = 1"c);
if (ok) { ok := SQLiteExec(db, "UPDATE konto SET stand = stand + 100 WHERE id = 2"c); }

if (ok) { SQLiteCommit(db); }
else    { SQLiteRollback(db); PrintLn(SQLiteErrmsg(db)); }

• SQLiteBegin beginnt verzögert (die Sperre entsteht erst beim ersten Schreiben). SQLiteBeginImmediate nimmt die Schreibsperre sofort — richtig, wenn zwei Prozesse um dieselbe Datei konkurrieren, sonst droht SQLITE_BUSY mitten in der Transaktion. SQLiteBeginExclusive sperrt die ganze Datei.
• SQLiteInTransaction beantwortet, ob eine läuft.
• Jeder Fehlerpfad braucht sein Rollback. Ein früher return zwischen Begin und Commit hinterlässt eine offene Transaktion und damit eine gesperrte Datei.
• Ein Massenimport gehört in eine Transaktion. Ohne sie schreibt SQLite jede einzelne Zeile mit eigener Synchronisierung auf die Platte — der Unterschied liegt bei Faktor Hundert.

PostgreSQL kennt zusätzlich Sicherungspunkte: PGSavepoint, PGRollbackTo, PGReleaseSavepoint, dazu PGBeginReadOnly und PGBeginSerializable.

Falsch — und zwar unabhängig davon, wie sicher die Quelle wirkt:

// NIEMALS so:
var sql: int64 := alloc(512);
StrReplace(sql as pchar, "SELECT * FROM kunden WHERE name = 'X'"c, "X"c, eingabe);
SQLiteExec(db, sql as pchar);

Richtig:

var q: int64 := SQLiteStmtPrepare(db, "SELECT id FROM kunden WHERE name = ?"c);
SQLiteBindStr(q, 1, eingabe);
while (SQLiteStmtStep(q) == SQLITE_ROW) { … }
SQLiteStmtFinalize(q);

Der Unterschied ist nicht Bequemlichkeit, sondern die Grenze zwischen Code und Daten: Ein gebundener Wert kann das Statement nicht mehr verändern, egal was darin steht. Ein zusammengesetzter String kann es immer.

Dieselbe Regel bei PostgreSQL: PGStmtPrepare + PGBind… + PGStmtExecute. Bei Redis sind Schlüssel und Werte ohnehin getrennte Protokollfelder — dort entsteht das Problem nicht. Bei MySQL/MariaDB steht dieser Schutz derzeit nicht zur Verfügung, siehe Abschnitt 8.

Ausnahme, die keine ist: Tabellen- und Spaltennamen lassen sich nicht binden. Wo sie variabel sein müssen, gehören sie gegen eine feste Liste erlaubter Namen geprüft, nicht maskiert.

// statt umsatz REAL:
CREATE TABLE kunden (id INTEGER PRIMARY KEY, name TEXT, umsatz_cent INTEGER)

// Anzeige: 125050 -> "1250,50"
var euro: int64 := cent / 100;
var rest: int64 := cent % 100;

Für die Netz-Backends:

@capabilities([system.exit, system.memory.heap, network.tcp.connect])
import std.io          grant [system.write];
import std.db.postgres grant [network.tcp.connect, system.memory.heap];

→ Die vollständige Capability-Matrix steht im Netzwerk-Guide.

std.db.postgres spricht das Frontend/Backend-Protokoll v3 selbst — inklusive MD5-Authentifizierung, Prepared Statements und Transaktionssteuerung.

import std.io;
import std.db.postgres;

fn main(): int64 {
    var conn: int64 := PGConnect("127.0.0.1"c, 5432, "app"c, "geheim"c, "kundendb"c);
    if (conn == 0 || PGIsConnected(conn) == 0) {
        PrintLn(PGError(conn));
        return 1;
    }
    var v: pchar := PGServerVersion(conn);
    Print("Server: "); PrintLn(v);

    var res: int64 := PGQuery(conn, "SELECT id, name FROM kunden ORDER BY id"c);
    if (res == 0) { PrintLn(PGError(conn)); PGClose(conn); return 1; }

    Print("Zeilen: "); PrintLn(IntToStr(PGNumRows(res)));
    while (PGFetchRow(res) != 0) {
        var name: pchar := PGGetStr(res, 1);
        Print(IntToStr(PGGetInt(res, 0))); Print(" | "); PrintLn(name);
    }
    PGFreeResult(res);
    PGClose(conn);
    return 0;
}

Ein Prepared Statement bekommt hier einen Namen und lebt auf dem Server: PGStmtPrepare(conn, „kunde_nach_id“c, „SELECT name FROM kunden WHERE id = $1“c). PostgreSQL nummeriert die Platzhalter ($1, $2) statt sie mit ? zu schreiben.

Geprüft gegen MariaDB 10.11 über TCP.

import std.io;
import std.db.mysql;

fn main(): int64 {
    var conn: MySQLConn := MySQLConnect("127.0.0.1"c, 3306, "maria"c, "geheim"c, "maria"c);
    if (conn.fd < 0) { PrintLn(MySQLError(conn)); return 1; }

    var res: MySQLResult := MySQLQuery(conn, "SELECT id, name, umsatz_cent FROM kunden ORDER BY id"c);
    Print("Zeilen: "); PrintLn(IntToStr(MySQLNumRows(res)));

    var row: int64 := MySQLFetchRow(res);
    while (row != 0) {
        Print(IntToStr(MySQLGetRowInt(res, row, 0))); Print(" | ");
        var name: pchar := MySQLGetRowStr(res, row, 1);
        Print(name); Print(" | ");
        PrintLn(IntToStr(MySQLGetRowInt(res, row, 2)));
        row := MySQLFetchRow(res);
    }
    MySQLFreeResult(res);
    MySQLClose(conn);
    return 0;
}

Ausgabe:

Zeilen: 2
1 | Meier GmbH | 125050
2 | Schulze AG | 89000

Die Ergebnismenge liegt vollständig im Speicher — bei großen Abfragen also LIMIT setzen.

Kein SQL, sondern Schlüssel-Wert-Speicher: Cache, Warteschlange, Zähler, Sitzungsdaten.

import std.io;
import std.db.redis;

fn main(): int64 {
    var conn: RedisConn := RedisConnect("db.example.com"c, 6379);
    if (conn.fd < 0) { PrintLn("Redis nicht erreichbar"); return 1; }

    RedisSet(conn, "kunde:1"c, "Meier GmbH"c);
    var r: RedisReply := RedisGet(conn, "kunde:1"c);
    if (r.kind == REDIS_REPLY_BULK) {
        var s: pchar := r.str_val;
        PrintLn(s);
    }

    RedisLPush(conn, "queue"c, "job1"c);
    Print("Laenge: "); PrintLn(IntToStr(RedisLLen(conn, "queue"c)));

    RedisClose(conn);
    return 0;
}

Die Antwort kommt als RedisReply mit kind (REDIS_REPLY_NIL, …_BULK, …_INTEGER, …_ARRAY, …_ERROR, …_STATUS), int_val, str_val und str_len. kind zuerst prüfen — ein fehlender Schlüssel liefert REDIS_REPLY_NIL, nicht etwa eine leere Zeichenkette.

std.db.redis_simple ist die Sparversion mit RedisConnect, RedisClose, RedisPing, RedisSet, RedisGet — nützlich, wenn nur ein Wert abgelegt werden soll.

Ein Dienst, der pro Anfrage eine Verbindung öffnet und nicht schließt, läuft nach einigen tausend Anfragen in das Deskriptorlimit — und zwar erst im Betrieb, nicht im Test.

Die dritte Ebene ist kein Fehler. Wer „keine Zeile„ wie „Fehler“ behandelt, meldet Störungen, wo nur nichts zu finden war.

Lyx bringt kein Migrationswerkzeug mit. Bewährt hat sich eine Versionsnummer in der Datenbank selbst:

SQLiteExec(db, "CREATE TABLE IF NOT EXISTS schema_version (v INTEGER)"c);
// beim Start lesen, mit der erwarteten Version vergleichen, gezielt nachziehen

Die SQLite- und MySQL-Beispiele dieser Seite sind übersetzt und gegen eine echte Datenbank ausgeführt worden (SQLite-Datei bzw. MariaDB 10.11); der PostgreSQL-Abschnitt folgt dem Quelltext der Unit, ohne laufenden Server geprüft zu sein.

• std.db — Unit-Referenz · sqlite · postgres · mysql · redis
• std.graphdb — Knoten und Kanten statt Tabellen
• std.net.mongo — MongoDB Wire Protocol
• Netzwerk-Guide — Namensauflösung, Capabilities, Timeouts
• Daten & Serialisierung — was aus der Datenbank herausfällt, weiterverarbeiten
• Capabilities · FFI (SQLite bindet libsqlite3 ein)