std.db

Datenbank-Units für die direkte Kommunikation mit relationalen Datenbanken und Key-Value-Stores. Lyx implementiert alle Datenbankprotokolle nativ über TCP — ohne externe Treiber, Middleware-Schichten oder ORMs. Ausnahme: std.db.sqlite bindet libsqlite3 per FFI ein.

Unit	Protokoll / Port	Beschreibung
std.db.mysql	MySQL Prot. 41 / 3306	MySQL/MariaDB-Client: Verbindung, Abfragen, Prepared Statements, Transaktionen
std.db.postgres	Wire Protocol v3 / 5432	PostgreSQL-Client ohne libpq: vollständige Frontend/Backend-Kommunikation, Binding, Connection Pool
std.db.sqlite	FFI libsqlite3	SQLite3-Bindings: Verbindung, Prepared Statements, Binding (1-basiert), Column-Accessoren (0-basiert)
std.db.redis	RESP / 6379	Redis-Vollclient: Strings, Lists, Hashes, Sets, Sorted Sets, Pub/Sub, Pipelining, TTL
std.db.redis_simple	RESP / 6379	Redis-Minimal-Client: nur GET/SET/DEL/EXPIRE — ohne std.string-Abhängigkeit

Designprinzipien

Kein Treiber-Layer — Lyx spricht das native Datenbankprotokoll direkt; kein libmysql, kein libpq, kein ODBC, kein Redis-Wrapper
Keine Abstraktionsschicht — jede Unit ist auf ihr Protokoll spezialisiert und gibt dessen volle Funktionalität frei
Explizite Verbindungsverwaltung — Verbindungen, Abfragen und Ressourcen werden manuell verwaltet
Fehler per Rückgabewert — kein throw/catch; Fehler werden als int64 < 0 oder 0-Pointer signalisiert

Verfügbare Units

std.db.mysql

MySQL-Client über MySQL-Protokoll 41 (TCP-Port 3306). Unterstützt Verbindungsaufbau mit Authentifizierung, einfache Abfragen, Ergebnis-Sets, Prepared Statements und Transaktionen.

import std.db.mysql;

var conn := MySQLConnect("127.0.0.1", 3306, "user", "pass", "mydb");
var res  := MySQLQuery(conn, "SELECT id, name FROM users WHERE active = 1");
while (MySQLFetchRow(res) != 0) {
    Print(MySQLGetRowStr(res, 0, 1));
}
MySQLFreeResult(res);
MySQLClose(conn);

→ Vollständige Dokumentation: std.db.mysql

std.db.postgres

PostgreSQL-Client über das native Frontend/Backend Wire Protocol v3 (TCP-Port 5432) — ohne libpq. Unterstützt SimpleQuery, Prepared Statements, Parameter-Binding (0-basiert), Transaktionen mit Savepoints, Connection Pool, LISTEN/NOTIFY und COPY. MD5-Auth über std.crypto.md5.

import std.db.postgres;

var conn := PGConnect("127.0.0.1", 5432, "mydb", "user", "pass");
if (PGIsConnected(conn) == 0) { return; }

var res := PGQuery(conn, "SELECT id, email FROM users LIMIT 10");
var i: int64 := 0;
while (i < PGNumRows(res)) {
    PGFetchRow(res, i);
    PrintLn(PGGetStr(res, 1));   // email
    i := i + 1;
}
PGFreeResult(res);
PGClose(conn);

→ Vollständige Dokumentation: std.db.postgres

std.db.sqlite

SQLite3-Bindings via FFI (libsqlite3.so.0). Prepared-Statement-Muster: SQLiteStmtPrepare → Bind → SQLiteStmtStep → Column-Accessoren → SQLiteStmtFinalize. Parameter-Binding ist 1-basiert, Column-Zugriff 0-basiert.

import std.db.sqlite;

var db   := SQLiteOpen("/data/app.db");
var stmt := SQLiteStmtPrepare(db, "SELECT name FROM users WHERE id = ?");
SQLiteBindInt(stmt, 1, 42);

if (SQLiteStmtStep(stmt) == SQLITE_ROW) {
    Print(SQLiteColumnText(stmt, 0));
}

SQLiteStmtFinalize(stmt);
SQLiteClose(db);

→ Vollständige Dokumentation: std.db.sqlite

std.db.redis

Redis-Vollclient über das RESP-Protokoll (TCP-Port 6379). Unterstützt alle Redis-Datenstrukturen: Strings, Lists, Hashes, Sets, Sorted Sets, Streams sowie Pub/Sub, Pipelining und TTL-Verwaltung.

import std.db.redis;

var conn := RedisConnect("127.0.0.1", 6379);
RedisSet(conn, "session:42", "user_data_json");
RedisExpire(conn, "session:42", 3600);
var val := RedisGet(conn, "session:42");
Print(val);
RedisClose(conn);

→ Vollständige Dokumentation: std.db.redis

std.db.redis_simple

Minimaler Redis-Client ohne std.string-Abhängigkeit. Stellt nur die vier grundlegenden Operationen bereit: GET, SET, DEL, EXPIRE. Geeignet für eingeschränkte Umgebungen oder als Laufzeit-Dependency-freie Alternative.

→ Vollständige Dokumentation: std.db.redis_simple

Unit wählen

Szenario	Empfehlung
Bestehende MySQL/MariaDB-Infrastruktur	`std.db.mysql`
PostgreSQL, Prepared Statements, Connection Pool	`std.db.postgres`
Embedded / Mobile / Single-File	`std.db.sqlite`
Caching, Sessions, Pub/Sub	`std.db.redis`
Minimale Binärgröße, nur GET/SET	`std.db.redis_simple`
Dokumente (JSON), flexible Schemata	`std.net.mongo`