Abschnitt 12 · Lektion 8
Synthese: die API mit Datenbank
Wer die Bücher-API benutzt, soll nicht merken, dass ihre Daten jetzt in einer Datenbank liegen. Dieselben Pfade, dieselben Statuscodes, dieselben Rümpfe, und trotzdem übersteht der Bestand einen Neustart. Wie viel Arbeit das macht, hängt daran, wie viel Code den Speicher kennt.
Der Speicher hinter vier Funktionen
// Wie in Lektion 11.7 liegen die Daten in einem Array.
const buecher = [
{ id: 1, titel: "Node in der Praxis", jahr: 2020 },
{ id: 2, titel: "JavaScript von vorn", jahr: 2019 },
{ id: 3, titel: "HTTP verstehen", jahr: 2017 },
];
let naechsteId = 4;
export const laden = {
alle: () => buecher,
eines: (id) => buecher.find((buch) => buch.id === id),
anlegen: (titel, jahr) => {
const buch = { id: naechsteId++, titel, jahr };
buecher.push(buch);
return buch;
},
loeschen: (id) => {
const platz = buecher.findIndex((buch) => buch.id === id);
if (platz === -1) return false;
buecher.splice(platz, 1);
return true;
},
}; import { DatabaseSync } from "node:sqlite";
const db = new DatabaseSync(":memory:");
db.exec(`CREATE TABLE buecher (id INTEGER PRIMARY KEY, titel TEXT NOT NULL, jahr INTEGER);
INSERT INTO buecher (titel, jahr) VALUES
('Node in der Praxis', 2020), ('JavaScript von vorn', 2019), ('HTTP verstehen', 2017);`);
// Dieselben vier Funktionen, dieselben Rueckgaben, andere Innereien.
export const laden = {
alle: () => db.prepare("SELECT id, titel, jahr FROM buecher ORDER BY id").all(),
eines: (id) => db.prepare("SELECT id, titel, jahr FROM buecher WHERE id = ?").get(id),
anlegen: (titel, jahr) => {
const kennung = db.prepare("INSERT INTO buecher (titel, jahr) VALUES (?, ?)").run(titel, jahr).lastInsertRowid;
return db.prepare("SELECT id, titel, jahr FROM buecher WHERE id = ?").get(kennung);
},
loeschen: (id) => db.prepare("DELETE FROM buecher WHERE id = ?").run(id).changes > 0,
}; import { laden as imSpeicher } from "./imspeicher.js";
import { laden as mitTabelle } from "./mittabelle.js";
// Derselbe Ablauf gegen beide Umsetzungen. Wenn die vier Funktionen
// wirklich gleich geblieben sind, muss zweimal dasselbe herauskommen.
function ablauf(laden) {
const zeilen = [];
zeilen.push(`alle: ${laden.alle().length}`);
zeilen.push(`eines(2): ${laden.eines(2).titel}`);
zeilen.push(`eines(99): ${laden.eines(99)}`);
const neu = laden.anlegen("Nachtschicht mit Node", 2023);
zeilen.push(`anlegen: id ${neu.id}`);
zeilen.push(`loeschen(1): ${laden.loeschen(1)}`);
zeilen.push(`loeschen(99): ${laden.loeschen(99)}`);
zeilen.push(`alle danach: ${laden.alle().length}`);
return zeilen;
}
const links = ablauf(imSpeicher);
const rechts = ablauf(mitTabelle);
for (let i = 0; i < links.length; i++) {
const gleich = links[i] === rechts[i] ? "gleich" : "ABWEICHUNG";
console.log(`${links[i].padEnd(24)} | ${rechts[i].padEnd(24)} | ${gleich}`);
} In der ersten Spalte der Ausgabe steht ein Array wie in Lektion 11.7, in der zweiten dieselben vier Funktionen mit SQLite darunter. Derselbe Ablauf gegen beide, und siebenmal steht „gleich“ in der letzten Spalte.
Im Beispiel liegt der Datenzugriff in vier eigenen Funktionen, und für einen anderen Speicher tauschst du nur diese vier aus, statt die ganze Anwendung umzubauen. Die Bücher-API aus Abschnitt 11 greift dagegen in ihren Routen direkt auf das Array zu. Sie wird deshalb Route für Route umgestellt, und von außen darf sich dabei nichts ändern.
Das undefined bei eines(99) kommt bei beiden heraus, weil find und get sich zufällig gleich
verhalten. Und anlegen gibt bei SQLite den Eintrag zurück, den es danach noch einmal liest. Das
sieht nach einem überflüssigen Schritt aus. Er ist aber der ehrlichere. Was der Aufrufer bekommt,
steht dann wirklich so in der Tabelle, samt allen Spalten mit Vorgabewerten, die er gar nicht
mitgeschickt hat.
Wo die Verbindung hingehört
Einmal beim Start, nicht je Anfrage. Eine Verbindung ist bei SQLite eine geöffnete Datei, und sie je Anfrage neu aufzumachen und wieder zu schließen kostet nur Zeit.
Praktisch ist das ein eigenes Modul, das die Datenbank öffnet und exportiert. Node wertet ein Modul nur einmal aus, egal wie oft es importiert wird, und deshalb bekommen alle Teile der Anwendung dieselbe Verbindung. Im Beispiel „Eine Datei läuft nur einmal“ aus Abschnitt 2 war es ein Zähler, hier ist es die Verbindung.
Die Tabellen entstehen an derselben Stelle, mit CREATE TABLE IF NOT EXISTS. Die Anwendung soll auf
einer leeren Festplatte hochfahren können, ohne dass vorher jemand von Hand etwas anlegt, und beim
zweiten Start genauso.
Der Wert aus der Adresszeile
import { DatabaseSync } from "node:sqlite";
const db = new DatabaseSync(":memory:");
db.exec(`CREATE TABLE buecher (id INTEGER PRIMARY KEY, titel TEXT NOT NULL, jahr INTEGER, gelesen INTEGER);
INSERT INTO buecher (titel, jahr, gelesen) VALUES ('Node in der Praxis', 2020, 0);`);
const zeig = (was, tu) => {
try {
console.log(`${was} ${tu()}`);
} catch (fehler) {
console.log(`${was} ${fehler.constructor.name}: ${fehler.message}`);
}
};
// Eine Kennung aus der Adresszeile ist Text, kein Zahlenwert.
const suche = db.prepare("SELECT titel FROM buecher WHERE id = ?");
zeig('id als Text "1": ', () => JSON.stringify(suche.get("1")));
zeig("id als Zahl 1: ", () => JSON.stringify(suche.get(1)));
// Ein Wahrheitswert aus einem JSON-Rumpf.
const setze = db.prepare("UPDATE buecher SET gelesen = ? WHERE id = 1");
zeig("gelesen = true: ", () => `changes ${setze.run(true).changes}`);
zeig("in der Spalte: ", () => JSON.stringify(db.prepare("SELECT gelesen FROM buecher").get()));
zeig("gelesen = 1: ", () => `changes ${setze.run(1).changes}`);
// Und ein Feld, das gar nicht mitgeschickt wurde.
const jahr = db.prepare("UPDATE buecher SET jahr = ? WHERE id = 1");
zeig("jahr = undefined: ", () => `changes ${jahr.run(undefined).changes}`);
zeig("jahr = null: ", () => `changes ${jahr.run(null).changes}`); Was aus der Adresszeile kommt, ist Text. req.params.id ist also "1" und nicht die Zahl 1.
Trotzdem findet WHERE id = ? im ersten Teil des Beispiels die Zeile auch mit dem Text "1".
SQLite rechnet den Wert nämlich in den Typ der Spalte um, wenn die Spalte einen hat, und
INTEGER PRIMARY KEY hat einen. Für eine Spalte ohne Typ gilt das nicht, aber die kommt in einer
selbst angelegten Tabelle nicht vor.
Ein Number(req.params.id) gehört trotzdem in den Code, aus einem anderen Grund. Sobald du mit dem
Wert rechnest oder vergleichst oder er in eine Antwort kommt, brauchst du eine Zahl. Ein id === 1
gegen den Text "1" ist falsch, und dieser Fehler zeigt sich später und weiter weg.
undefined lässt sich in Node 24, das in der Sandbox läuft, nicht binden. Der Versuch wirft
TypeError: Provided value cannot be bound to SQLite parameter 1., und das Feld bleibt, wie es war.
Bis Node 24.20 galt das auch für einen Wahrheitswert. Ein JSON-Rumpf mit "gelesen": true ist dabei
das Natürlichste der Welt. Reicht man ihn auf so einer Version ungeprüft an die Datenbank durch,
stürzt die Route ab und antwortet mit 500 statt mit 400.
Seit Node 24.21 nimmt node:sqlite true und false an und schreibt 1 und 0. Node 26 schreibt für
undefined ein NULL. Die Route stürzt dann nicht mehr ab. Schickt aber jemand "jahr": true,
steht danach eine 1 als Jahreszahl im Bestand, und das merkt niemand.
Ein Wahrheitswert für eine Ja-Nein-Spalte wie gelesen wird vor dem Binden in 0 oder 1 übersetzt,
denn SQLite hat keinen eigenen Typ dafür. Ein Feld, das nicht mitgeschickt wurde, ist undefined
und kommt gar nicht erst in die Anweisung. Wie das geht, steht im nächsten Abschnitt.
Nur die geschickten Felder ändern
import { DatabaseSync } from "node:sqlite";
const db = new DatabaseSync(":memory:");
db.exec(`CREATE TABLE buecher (id INTEGER PRIMARY KEY, titel TEXT NOT NULL, jahr INTEGER);
INSERT INTO buecher (titel, jahr) VALUES ('Node in der Praxis', 2020);`);
// Die Spaltennamen kommen aus dieser Liste und nie aus dem Rumpf.
const AENDERBAR = ["titel", "jahr"];
function aendere(id, rumpf) {
const felder = AENDERBAR.filter((feld) => rumpf[feld] !== undefined);
if (felder.length === 0) return "nichts zu tun";
const satz = felder.map((feld) => `${feld} = ?`).join(", ");
const werte = felder.map((feld) => rumpf[feld]);
console.log(` SQL: UPDATE buecher SET ${satz} WHERE id = ?`);
db.prepare(`UPDATE buecher SET ${satz} WHERE id = ?`).run(...werte, id);
return JSON.stringify(db.prepare("SELECT id, titel, jahr FROM buecher WHERE id = ?").get(id));
}
console.log("nur das Jahr:");
console.log(` ${aendere(1, { jahr: 1999 })}`);
console.log("nur der Titel:");
console.log(` ${aendere(1, { titel: "Node in der Praxis, 2. Auflage" })}`);
console.log("ein Feld, das nicht in der Liste steht:");
console.log(` ${aendere(1, { id: 42, geheim: "weg damit" })}`); Das ist PATCH, jetzt in SQL. Die SET-Liste entsteht aus den Feldern, die wirklich da sind, und
die Werte gehen als Parameter mit.
Die Anweisung heißt einmal SET jahr = ?, einmal SET titel = ?, und nie stehen beide da, wenn nur
eines geschickt wurde. Würde man immer beide Spalten setzen, müsste man den fehlenden Wert vorher
lesen. Zwischen dem Lesen und dem Schreiben liegt dann wieder die Lücke, durch die am Anfang des
Abschnitts Bestellungen verloren gingen.
Die Spaltennamen kommen aus der Zeile const AENDERBAR = ["titel", "jahr"] und nie aus den
Schlüsseln des empfangenen Objekts. Ein Spaltenname ist kein Wert und lässt sich nicht als
Platzhalter übergeben. Er landet also als Text in der Anweisung. Das war die Warnung in Lektion
12.5, und die Liste ist die Antwort darauf.
Im letzten Aufruf kommen id und geheim mit, und beide fallen einfach heraus. Der Aufrufer kann
sich also weder eine neue Kennung geben noch eine Spalte erfinden.
Die Routen der Bücher-API ziehen in der Aufgabe in die Datenbank um, und von außen bleibt alles, wie es war.
Zum Mitnehmen
Nach dem Umzug in SQLite antwortet die Bücher-API wie vorher, und die Verbindung entsteht einmal beim Start. Was an eine Anweisung gebunden wird, ist vorher geprüft, und gesetzt werden nur die geschickten Felder aus einer festen Liste.
Jetzt du
Basis Konto, kostenlosZu 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.