mitmario.dev

Warum eine Datenbank?

Node.js Sandbox 3 Min Lesezeit 3 BeispieleLektion 1 von 9

Eine JSON-Datei als Speicher funktioniert, solange ein einziges Programm sie liest und schreibt, ein Lauf nach dem anderen. Auf einem Server läuft derselbe Code aber gleichzeitig für jeden, der gerade etwas will. Dann gehen Einträge verloren.

Zwei Anfragen, ein verlorener Eintrag

Zwei Anfragen, ein verlorener Eintrag
import { mkdir, writeFile, readFile, rename } from "node:fs/promises";

await mkdir("daten", { recursive: true });
await writeFile("daten/liste.json", JSON.stringify(["Bestellung 1"]));

const lies = async () => JSON.parse(await readFile("daten/liste.json", "utf8"));

// So sauber, wie es mit einer Datei ueberhaupt geht: geschrieben wird in
// eine Zwischendatei, danach umbenannt. Ein halb geschriebenes
// liste.json kann es damit nicht geben.
const schreibe = async (liste, wer) => {
  await writeFile(`daten/${wer}.tmp`, JSON.stringify(liste));
  await rename(`daten/${wer}.tmp`, "daten/liste.json");
};

// Zwei Anfragen treffen gleichzeitig ein. Beide lesen denselben Stand.
const [standAnna, standBert] = await Promise.all([lies(), lies()]);

standAnna.push("Bestellung von Anna");
standBert.push("Bestellung von Bert");

// Und beide schreiben ihn zurueck.
await schreibe(standAnna, "anna");
await schreibe(standBert, "bert");

console.log("abgeschickt:  Anna, Bert");
console.log("in der Datei:", (await lies()).join(" | "));

Anna und Bert schicken im selben Moment eine Bestellung ab. Danach steht Bert in der Datei und Anna nicht. Kein Absturz, keine Meldung, kein Eintrag im Protokoll. Die Bestellung ist einfach weg.

Dabei wird im Beispiel sauber geschrieben, erst in eine Zwischendatei und dann per Umbenennen. Ein rename innerhalb desselben Dateisystems ist unteilbar. Wer liest, sieht also immer entweder den alten oder den neuen Stand und nie etwas dazwischen. Sauberer geht es mit einer Datei kaum.

Schuld ist die Reihenfolge. Wer eine Datei als Speicher benutzt, macht immer drei Schritte, nämlich lesen, ändern und zurückschreiben. Zwischen dem Lesen und dem Zurückschreiben liegt eine Lücke. In dieser Lücke arbeitet die andere Anfrage mit einem Stand, der schon veraltet ist. Schreibt sie zurück, ist alles weg, was in der Zwischenzeit passiert ist.

Auf dem eigenen Rechner triffst du das fast nie. Du klickst einmal, wartest, klickst wieder. Sobald zwei Leute gleichzeitig auf derselben Seite sind, kann es bei jeder Bestellung passieren.

Dieselbe Sache mit einer Tabelle

Dieselbe Sache mit einer Tabelle
import { DatabaseSync } from "node:sqlite";
import { mkdirSync, rmSync } from "node:fs";

// Jeder Lauf faengt mit einer frischen Datenbank an.
mkdirSync("daten", { recursive: true });
rmSync("daten/bestellungen.db", { force: true });

// Einmal aufsetzen, danach zwei getrennte Verbindungen auf dieselbe
// Datei. Genau das tun zwei gleichzeitige Anfragen auf einem Server auch.
const aufbau = new DatabaseSync("daten/bestellungen.db");
aufbau.exec(`CREATE TABLE IF NOT EXISTS bestellungen (
  id INTEGER PRIMARY KEY,
  text TEXT NOT NULL
)`);
aufbau.prepare("INSERT INTO bestellungen (text) VALUES (?)").run("Bestellung 1");
aufbau.close();

const anna = new DatabaseSync("daten/bestellungen.db");
const bert = new DatabaseSync("daten/bestellungen.db");

// Niemand liest den Bestand, niemand schreibt ihn zurueck. Jeder haengt
// eine Zeile an, und mehr passiert nicht.
anna.prepare("INSERT INTO bestellungen (text) VALUES (?)").run("Bestellung von Anna");
bert.prepare("INSERT INTO bestellungen (text) VALUES (?)").run("Bestellung von Bert");

anna.close();
bert.close();

const db = new DatabaseSync("daten/bestellungen.db");
const zeilen = db.prepare("SELECT text FROM bestellungen ORDER BY id").all();
db.close();

console.log("abgeschickt:  Anna, Bert");
console.log("in der Tabelle:", zeilen.map((zeile) => zeile.text).join(" | "));

Beide Bestellungen sind da. Die drei Schritte sind auf einen zusammengeschrumpft. Gelesen und zurückgeschrieben wird nichts mehr, jede Verbindung hängt einfach eine Zeile an. Ohne Lücke gibt es nichts, in das die andere Anfrage hineinfallen könnte.

Dazu ordnet die Datenbank gleichzeitige Zugriffe selbst. Zwei Schreibvorgänge auf dieselbe Datei laufen nacheinander ab, auch wenn sie gleichzeitig ankommen. Darum musst du dich in deinem Programm nicht kümmern.

Suchen, ohne alles zu lesen

Eine Bestellung finden
import { DatabaseSync } from "node:sqlite";
import { mkdirSync, rmSync, writeFileSync, statSync, readFileSync } from "node:fs";

// Jeder Lauf faengt mit einer frischen Datenbank an.
mkdirSync("daten", { recursive: true });
rmSync("daten/bestellungen.db", { force: true });

// Fuenftausend Bestellungen, einmal als JSON-Datei und einmal als Tabelle.
const bestellungen = Array.from({ length: 5000 }, (_, i) => ({
  id: i + 1,
  kunde: `Kunde ${i + 1}`,
  betrag: (i % 90) + 10,
}));

writeFileSync("daten/bestellungen.json", JSON.stringify(bestellungen));

const db = new DatabaseSync("daten/bestellungen.db");
db.exec("CREATE TABLE IF NOT EXISTS bestellungen (id INTEGER PRIMARY KEY, kunde TEXT NOT NULL, betrag INTEGER NOT NULL)");
db.exec("BEGIN");
const einfuegen = db.prepare("INSERT INTO bestellungen (id, kunde, betrag) VALUES (?, ?, ?)");
for (const eintrag of bestellungen) einfuegen.run(eintrag.id, eintrag.kunde, eintrag.betrag);
db.exec("COMMIT");

// Weg 1: die ganze Datei lesen, die ganze Liste zerlegen, dann suchen.
const liste = JSON.parse(readFileSync("daten/bestellungen.json", "utf8"));
let angesehen = 0;
const ausJson = liste.find((eintrag) => {
  angesehen += 1;
  return eintrag.id === 4711;
});

const kb = Math.round(statSync("daten/bestellungen.json").size / 1024);
console.log(`JSON:   ${kb} KB gelesen, ${liste.length} Einträge zerlegt, ${angesehen} angesehen`);
console.log(`        gefunden: ${ausJson.kunde}`);

// Weg 2: die Datenbank fragen.
const ausDb = db.prepare("SELECT kunde FROM bestellungen WHERE id = ?").get(4711);
db.close();

console.log(`SQLite: eine Abfrage, eine Zeile zurück`);
console.log(`        gefunden: ${ausDb.kunde}`);

Um eine einzige Bestellung aus der JSON-Datei zu holen, liest dein Programm 218 KB von der Platte, baut daraus 5000 Objekte im Arbeitsspeicher auf und sieht sich 4711 davon an. Bei fünftausend Einträgen merkt man das kaum. Bei fünfhunderttausend ist es der Unterschied zwischen einer Seite, die sofort da ist, und einer, bei der der Ventilator angeht.

Die Datenbank fragt man in SQL, einer eigenen kleinen Sprache nur für Tabellen. Die Zeile mit SELECT im Beispiel fragt nach dem Kunden der Bestellung 4711, und die Datenbank gibt in einem Schritt eine Zeile zurück. Sie weiß, wo die Zeile liegt, und muss sie nicht erst suchen. Wie das funktioniert, ist eine eigene Geschichte. Für heute reicht, dass das Filtern in die Datenbank gehört und nicht nach JavaScript.

Alles oder nichts

Eine Datenbank kann außerdem mehrere Änderungen zu einem Paket zusammenfassen, das entweder ganz oder gar nicht passiert. Wie das geht, kommt in Lektion 12.3. Bei einer Überweisung willst du das unbedingt, denn dort wird von einem Konto abgebucht und dem anderen gutgeschrieben. Mit zwei Schreibvorgängen auf eine Datei bekommst du es nicht.

Warum SQLite und wo ihre Grenze liegt

SQLite ist eine Datei. Kein Serverprozess, den man startet, keine Zugangsdaten, kein Port. Gibst du einen Dateinamen an, den es noch nicht gibt, wird die Datei angelegt. Eine Sicherung ist eine Kopie dieser Datei.

In Node braucht es dafür keine Installation. node:sqlite ist eingebaut, also kein Paket und nichts, was man wie in Abschnitt 5 erst bewerten müsste. Ganz so fest wie node:fs steht es aber noch nicht. In der Dokumentation von Node 24 steht es als Release Candidate, und Node 22 schreibt beim Laden eine Warnung auf den Fehlerkanal.

Die Grenze liegt beim gleichzeitigen Schreiben. Lesen können beliebig viele Prozesse zugleich, geschrieben wird nacheinander. Für eine Anwendung mit ein paar hundert oder tausend Nutzern reicht das mit großem Abstand. Sollen irgendwann mehrere Server gleichzeitig in dieselben Daten schreiben, wechselt man zu PostgreSQL, mit einem anderen Verbindungsaufbau und fast demselben SQL.

Bevor die Datenbank kommt, misst du in der Aufgabe nach, wie viele Bestellungen beim gleichzeitigen Schreiben in eine JSON-Datei verschwinden.

Zum Mitnehmen

Eine JSON-Datei verliert Einträge, sobald zwei Anfragen gleichzeitig lesen und zurückschreiben, und um eine Zeile zu finden, muss sie ganz gelesen werden. SQLite hängt Zeilen an, ordnet gleichzeitige Zugriffe und findet eine Zeile, ohne alles zu lesen.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.

Was in dieser Lektion steckt

  • Artikel mit 3 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.