7. Datenbankzugriff

Die folgenden Kapitel runden den Kurs ab und behandeln den Datenbankzugriff aus TypeScript-Skripten; sie orientieren sich an den Kapiteln „Verwendung des DBMS MySQL“ und „Verwendung des ORM SQLAlchemy“ im Kurs „Einführung in Python 3 und das Framework Flask“ (2019). Nacheinander werden drei Ansätze vorgestellt: der direkte Zugriff auf das DBMS mit dem nativen Treiber mysql2, gefolgt von zwei ORM-Ansätzen (Object-Relational Mapping) – TypeORM und Prisma.
7.1. Direkter Zugriff auf die Datenbank
Zwei SQL-Skripte, die diesem Kapitel beiliegen, ermöglichen es, die Testdatenbanken zu erstellen: dbpersons (eine einzige Tabelle, die im Kapitel zum nativen Treiber verwendet wird) und dbschool (vier miteinander verknüpfte Tabellen, die in den beiden Kapiteln zu ORM verwendet werden).

7.1.1. Vorbereitung der Datenbank [dbpersons]
Die Datenbank dbpersons enthält nur eine Tabelle, persons, die dasselbe Schema wie im Python-Kurs verwendet (Spalten id, first\_name, last\_name, age, mit einer Eindeutigkeitsbedingung für das Paar (last\_name, first\_name)). Das SQL-Skript sql/create_dbpersons.sql unten erstellt die Datenbank, den Anwendungsbenutzer und die Tabelle und fügt anschließend fünf beliebige Personen ein:
| -- create_dbpersons.sql
-- Erstellt die Datenbank [dbpersons] neu, die im Kapitel „Zugriff auf MySQL mit dem
-- nativen Treiber [mysql2]“ verwendet wird, mit beliebigen Daten (die Originale des
-- Python/Flask-Kurses von 2020 sind nicht mehr verfügbar).
--
-- Verwendung:
-- mysql -u root -p < create_dbpersons.sql
--
-- Erstellt die Datenbank, den Anwendungsbenutzer [admpersons/nobody] (dieselben
-- Zugangsdaten wie im Originalkurs) und die Tabelle [persons].
DROP DATABASE IF EXISTS dbpersons;
CREATE DATABASE dbpersons CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER IF NOT EXISTS 'admpersons'@'localhost' IDENTIFIED BY 'nobody';
GRANT ALL PRIVILEGES ON dbpersons.* TO 'admpersons'@'localhost';
FLUSH PRIVILEGES;
USE dbpersons;
CREATE TABLE persons (
id INT PRIMARY KEY,
first_name VARCHAR(30) NOT NULL,
last_name VARCHAR(30) NOT NULL,
age INTEGER NOT NULL,
UNIQUE (last_name, first_name)
);
-- beliebige Daten (dieselben Personen wie in den Beispielen des Originalkurses)
INSERT INTO persons (id, first_name, last_name, age) VALUES
(1, 'Paul', 'Langevin', 48),
(2, 'Sylvie', 'Lefur', 70),
(3, 'Pierre', 'Nicazou', 35),
(4, 'Geraldine','Colou', 26),
(5, 'Paulette', 'Girond', 56);
|
Um diese Datenbank (MySQL) zu erstellen, können Sie das Werkzeug [HeidiSQL] von Laragon verwenden. Wir haben es bereits eingesetzt.
- In [1] starten Sie alle Laragon-Dienste. Dadurch wird das DBMS MySQL gestartet;
- in [2] rufen Sie das Datenbankverwaltungswerkzeug [HeidiSQL] auf;
- In [1-2] melden Sie sich bei MySQL an;
Mit [1-2] führen Sie die beiden SQL-Dateien des Projekts nacheinander aus:

Drücken Sie, während Sie noch in [HeidiSQL] sind, F5, um die Anzeige zu aktualisieren:
Wir sind nun bereit, diese beiden Datenbanken zu verwenden.
7.1.2. Skript [mysql-01]
Erster Blick auf den Treiber mysql2 (Modul mysql2/promise, das eine API auf Basis von Promises statt Callbacks bereitstellt): Es wird eine Verbindung zu dbpersons geöffnet und anschließend wieder geschlossen. Dies folgt demselben Ansatz wie das Python-Skript [mysql_01] (Kapitel 16).
| // databases/mysql/mysql-01.ts
// Erster Schritt: Verbindung zur MySQL-Datenbank [dbpersons] herstellen und dann
// trennen. Portiert das Python-Skript [mysql_01] des Python/Flask-Kurses.
import mysql from 'mysql2/promise';
// Verbindung zur MySQL-Datenbank [dbpersons]
// die Identität des Benutzers ist (admpersons, nobody)
const USER = 'admpersons';
const PWD = 'nobody';
const HOST = 'localhost';
const DATABASE = 'dbpersons';
// los geht's
let connection: mysql.Connection | undefined;
try {
console.log('Connecting to the MySQL DBMS...');
// Verbindung
connection = await mysql.createConnection({ host: HOST, user: USER, password: PWD, database: DATABASE });
// Fortsetzung
console.log(
`Successful MySQL connection to database=${DATABASE}, host=${HOST} as user=${USER}, passwd=${PWD}`,
);
} catch (error) {
// den Fehler anzeigen
console.log(`The following error occurred: ${error}`);
} finally {
// die Verbindung schließen, falls sie geöffnet wurde
if (connection) {
await connection.end();
}
}
|
Kommentieren wir diesen Code:
- Zeile 16: [mysql.createConnection({ host: HOST, user: USER, password: PWD, database: DATABASE })] – öffnet eine einzelne, asynchrone Verbindung – createConnection gibt ein Promise<Connection> zurück, daher das
await; dies ist das TypeScript-Äquivalent zu mysql.connector.connect(...) auf der Python-Seite;
- Zeile 29: [connection.end()] – schließt die Verbindung im
finally-Block ordnungsgemäß, unabhängig davon, ob ein Fehler aufgetreten ist – die Verbindung wird außerhalb des try -Blocks deklariert (Typ mysql.Connection | undefined), damit sie auf dieser Ebene zugänglich bleibt.
Führen wir dieses Skript aus:
npx tsx databases/mysql/mysql-01.ts
Ergebnis der Ausführung:
| Connecting to the MySQL DBMS...
Successful MySQL connection to database=dbpersons, host=localhost as user=admpersons, passwd=nobody
|
7.1.3. Skript [mysql-02]
Dieses Mal ist die Verbindung in einer wiederverwendbaren Funktion connect(host, database, login, pwd) gekapselt, die zuerst mit gültigen und dann ein zweites Mal mit ungültigen Zugangsdaten aufgerufen wird, um den vom Treiber zurückgegebenen Fehler zu beobachten. Das Python-Skript heißt **[mysql\_02]**.
| // databases/mysql/mysql-02.ts
// In diesem neuen Skript ist die Datenbankverbindung in einer Funktion isoliert.
// Portiert das Python-Skript [mysql_02].
import mysql from 'mysql2/promise';
// verbindet sich mit der Datenbank [database] auf dem Server [host] (login, pwd) und trennt sich dann wieder
// wirft eine Exception, wenn es ein Problem gibt
async function connect(host: string, database: string, login: string, pwd: string): Promise<void> {
let cnx: mysql.Connection | undefined;
try {
// Verbindung
cnx = await mysql.createConnection({ host, user: login, password: pwd, database });
console.log(
`Successful connection to database=${database}, host=${host} as user=${login}, passwd=${pwd}`,
);
} finally {
// die Verbindung schließen, falls sie geöffnet wurde
if (cnx) {
await cnx.end();
console.log('Successful disconnection\n');
}
}
}
// main
// Verbindungsdaten
const USER = 'admpersons';
const PASSWD = 'nobody';
const HOST = 'localhost';
const DATABASE = 'dbpersons';
// Verbindung eines vorhandenen Benutzers
try {
await connect(HOST, DATABASE, USER, PASSWD);
} catch (error) {
// den Fehler anzeigen
console.log(String(error));
}
// Verbindung eines nicht vorhandenen Benutzers
try {
await connect(HOST, DATABASE, 'xx', 'xx');
} catch (error) {
// den Fehler anzeigen
console.log(String(error));
}
|
Kommentieren wir diesen Code:
- Zeile 9: [async function connect(host, database, login, pwd): Promise<void>] – eine async-Funktion, die nichts zurückgibt, aber eine Ausnahme auslösen kann – sie fängt Verbindungsfehler nicht selbst ab, sondern lässt sie an den Aufrufer weiterlaufen;
- Zeile 40: [await connect(HOST, DATABASE, 'xx', 'xx')] – der zweite Aufruf mit einem Benutzer „xx“ , der auf der MySQL-Seite nicht existiert, löst eine Ausnahme aus, die der umschließende
catch-Block anzeigt.
Führen wir dieses Skript aus:
npx tsx databases/mysql/mysql-02.ts
Ergebnis der Ausführung:
| Successful connection to database=dbpersons, host=localhost as user=admpersons, passwd=nobody
Successful disconnection
Error: Access denied for user 'xx'@'localhost' (using password: YES)
|
Versionsspezifisches Problem: Bei einem aktuellen MySQL-Server (ab Version 8.4) kann dieser zweite Aufruf eine andere Meldung erzeugen: „Error: Plugin 'mysql_native_password' is not loaded“ statt „Access denied for user 'xx'@'localhost'.“ Die Ursache hat nichts mit dem Skript zu tun: Um nicht preiszugeben, ob ein Konto existiert oder nicht (Schutz vor Enumeration), simuliert MySQL bei der Anmeldung mit einem unbekannten Benutzer einen Authentifizierungsaustausch – und diese Simulation ist fest auf das veraltete Plugin mysql_native_password verdrahtet, das seit MySQL 8.4 standardmäßig deaktiviert ist. Das von diesem Skript demonstrierte Prinzip (eine bei ungültigen Zugangsdaten ausgelöste und abgefangene Ausnahme) bleibt davon unberührt; um die genau angezeigte Meldung wiederherzustellen, fügen Sie mysql\_native\_password=ON unterhalb von [mysqld] in der Datei my.ini des Servers hinzu und starten den Server anschließend neu.
7.1.4. Skript [mysql-03]
Wir wissen, wie man sich verbindet; nun setzen wir über die Verbindung einen SQL-Befehl ab, um die Tabelle „persons“ mit einem leicht abweichenden Schema (ohne die Spalte „id“, mit zusammengesetztem Primärschlüssel) (neu) zu erstellen. Das übernimmt das Python-Skript [mysql_03].
| // databases/mysql/mysql-03.ts
// Da wir nun wissen, wie man sich verbindet, senden wir SQL-Anweisungen über die Verbindung:
// wir erstellen die Tabelle [persons] der Datenbank [dbpersons] (neu).
// Portiert das Python-Skript [mysql_03].
import mysql from 'mysql2/promise';
// führt eine Update-Abfrage über die Verbindung aus
async function executeSql(connection: mysql.Connection, query: string): Promise<void> {
await connection.query(query);
}
// main
// Verbindungsdaten
const ID = 'admpersons';
const PWD = 'nobody';
const HOST = 'localhost';
const DATABASE = 'dbpersons';
// wir gehen Schritt für Schritt vor
let connection: mysql.Connection;
try {
// Verbindung - mysql2 führt jede Abfrage in einer eigenen Transaktion aus,
// die standardmäßig automatisch committet wird (Entsprechung von AUTOCOMMIT=True auf der Python-Seite)
connection = await mysql.createConnection({ host: HOST, user: ID, password: PWD, database: DATABASE });
} catch (error) {
console.log(`The following error occurred: ${error}`);
process.exit(1);
}
// Löschen der Tabelle persons, falls sie existiert
// falls sie nicht existiert, tritt ein Fehler auf - wir ignorieren ihn
try {
await executeSql(connection, 'drop table persons');
} catch {
// ignoriert
}
// Erstellen der Tabelle persons
const query =
'create table persons (id int PRIMARY KEY, first_name varchar(30) NOT NULL, last_name varchar(30) NOT NULL, ' +
'age integer NOT NULL, unique(last_name,first_name))';
try {
await executeSql(connection, query);
console.log(`${query}: query succeeded`);
} catch (error) {
console.log(`The following error occurred: ${error}`);
} finally {
await connection.end();
}
|
Kommentieren wir diesen Code:
- Zeile 9: [await connection.query(query)] — connection.query() führt einen SQL-String direkt ohne Parameter aus – die sicherere, parametrisierte Variante mit execute() sehen wir im Skript [mysql-05];
- Zeile 28: [await executeSql(connection, 'drop table persons')] – es wird versucht, die Tabelle innerhalb eines leeren try/catch-Blocks zu löschen: Existiert die Tabelle noch nicht, wird der MySQL-Fehler einfach ignoriert.
Führen wir dieses Skript aus:
npx tsx databases/mysql/mysql-03.ts
Ergebnis der Ausführung:
| create table persons (id int PRIMARY KEY, first_name varchar(30) NOT NULL, last_name varchar(30) NOT NULL, age integer NOT NULL, unique(last_name,first_name)): query succeeded
|
7.1.5. Ein wiederverwendbares Modul: [mysql-module.ts]
Bevor wir das Hauptskript [mysql-04] schreiben, das eine ganze Datei mit SQL-Befehlen ausführt, lagern wir die Ausführungslogik für eine Liste von Befehlen – mit oder ohne Transaktion – in ein Modul aus, zusammen mit der Anzeige des Ergebnisses jedes Befehls (Zeilen bei einem SELECT bzw. die Anzahl der geänderten Zeilen bei INSERT/UPDATE/DELETE). Das Python-Modul heißt [mysql_module].
| // databases/mysql/mysql-module.ts
// Wiederverwendbare Funktionen zum Ausführen einer Liste (oder einer Datei) von SQL-Befehlen
// über eine offene MySQL-Verbindung. Portiert das Python-Modul [mysql_module].
import type { Connection, FieldPacket, ResultSetHeader, RowDataPacket } from 'mysql2/promise';
import { readFile } from 'node:fs/promises';
// zeigt das Ergebnis eines SQL-Befehls an (Ergebnis eines mysql2-query())
// - gibt es ein Array [fields], war es ein SELECT: wir zeigen die Spalten
// und dann die Zeilen an;
// - andernfalls war es eine Änderungsanweisung (INSERT/UPDATE/DELETE/DDL): wir
// zeigen die Anzahl der geänderten Zeilen an (Entsprechung von cursor.rowcount).
function displayInfo(rows: RowDataPacket[] | ResultSetHeader, fields: FieldPacket[] | undefined): void {
if (fields && fields.length > 0) {
// es war ein SELECT — fields beschreibt die angeforderten Spalten
const titles = fields.map((f) => f.name);
console.log(titles.join(', '));
console.log('*'.repeat(titles.join(', ').length));
for (const row of rows as RowDataPacket[]) {
console.log(titles.map((t) => row[t]));
}
console.log('*'.repeat(titles.join(', ').length));
} else {
// keine Spalten beschrieben — Änderungsanweisung
const header = rows as ResultSetHeader;
console.log(`number of modified rows: ${header.affectedRows}`);
}
}
// verwendet die offene Verbindung [connection]
// führt über diese Verbindung die SQL-Befehle aus der Liste [sqlCommands] aus
// (ein Befehl pro Element; leere Zeilen oder Zeilen, die mit # beginnen, werden ignoriert)
// - bei verbose=true folgt auf jede Ausführung einer SQL-Anweisung eine Anzeige,
// die ihren Erfolg oder Misserfolg angibt;
// - bei stop=true stoppt die Funktion beim 1. aufgetretenen Fehler, andernfalls
// führt sie alle Befehle aus;
// - bei withTransaction=true macht jeder Fehler alle zuvor ausgeführten SQL-Anweisungen
// rückgängig (Rollback); andernfalls wird jeder Befehl
// unabhängig committet (Standardverhalten von mysql2);
// die Funktion gibt ein Array [error1, error2, ...] zurück
export async function executeListOfCommands(
connection: Connection,
sqlCommands: string[],
verbose = false,
stop = true,
withTransaction = true,
): Promise<string[]> {
const errors: string[] = [];
if (withTransaction) {
await connection.beginTransaction();
}
try {
for (const rawCommand of sqlCommands) {
// Leerzeichen am Anfang und Ende des aktuellen Befehls entfernen
const command = rawCommand.trim();
// leerer Befehl oder Kommentar? weiter zum nächsten
if (command === '' || command[0] === '#') {
continue;
}
// Ausführung des aktuellen Befehls
try {
const [rows, fields] = await connection.query(command);
// kein Fehler
if (verbose) {
console.log(`[${command}]: Successful execution`);
}
displayInfo(rows as RowDataPacket[], fields);
} catch (error) {
const msg = `${command}: Error (${error})`;
errors.push(msg);
if (verbose) {
console.log(msg);
}
// halten wir an?
if (withTransaction || stop) {
return errors;
}
}
}
return errors;
} finally {
// die Transaktion committen / zurückrollen, falls es eine gibt
if (withTransaction) {
if (errors.length > 0) {
await connection.rollback();
} else {
await connection.commit();
}
}
}
}
// verwendet die offene Verbindung [connection]
// führt über diese Verbindung die SQL-Befehle aus der
// Textdatei [sqlFilename] aus (ein Befehl pro Zeile)
export async function executeFileOfCommands(
connection: Connection,
sqlFilename: string,
verbose = false,
stop = true,
withTransaction = true,
): Promise<string[]> {
try {
const content = await readFile(sqlFilename, 'utf-8');
return await executeListOfCommands(connection, content.split('\n'), verbose, stop, withTransaction);
} catch (error) {
return [`The file ${sqlFilename} could not be processed: ${error}`];
}
}
|
Kommentieren wir diesen Code:
- Zeile 45: [if (withTransaction) { await connection.beginTransaction(); }] – mysql2 befindet sich standardmäßig im AUTOCOMMIT-Modus (jede Abfrage wird einzeln bestätigt) – beginTransaction() schaltet die Verbindung explizit in den Transaktionsmodus, genau wie es connexion.start_transaction() auf der Python-Seite täte;
- Zeile 76: [if (withTransaction || stop) { return errors; }] – im Transaktionsmodus beendet der erste Fehler die Schleife sofort – weiterzumachen wäre sinnlos, da die gesamte Transaktion ohnehin zurückgerollt wird;
- Zeile 82: [if (errors.length > 0) { await connection.rollback(); } else { await connection.commit(); }] – globaler Commit oder Rollback, je nachdem, ob ein Fehler aufgetreten ist oder nicht – siehe jedoch die Falle, auf die im folgenden Skript [mysql-04] hingewiesen wird.
Das Skript verwendet außerdem ein kleines Konfigurationsmodul, config-04.ts, das den Pfad zur Datei mit den SQL-Befehlen und die Zugangsdaten zentralisiert:
| // databases/mysql/config-04.ts
// Konfiguration des Skripts [mysql-04]: Pfad der Datei mit SQL-Befehlen und
// Verbindungsdaten für die Datenbank [dbpersons].
import { fileURLToPath } from 'node:url';
import { dirname, join } from 'node:path';
const scriptDir = dirname(fileURLToPath(import.meta.url));
export function configure() {
return {
// Datei mit SQL-Befehlen
commandsFilename: join(scriptDir, 'data', 'commands.sql'),
// Verbindungsdaten der Datenbank
host: 'localhost',
database: 'dbpersons',
user: 'admpersons',
password: 'nobody',
};
}
|
Hinweis: import.meta.url gefolgt von fileURLToPath/dirname ist die Standardmethode, wie sie im ECMAScript-Modul ("type": "module" in package.json) definiert ist, um das Verzeichnis der aktuellen Datei zu ermitteln – das Äquivalent zur magischen Variable __dirname, die in CommonJS nativ verfügbar ist, in ESM aber nicht.
Das Skript selbst, data/commands.sql, folgt dem im Python-Kurs verwendeten Format (ein Befehl pro Zeile; leere Zeilen oder Zeilen, die mit # beginnen, werden ignoriert):

| # Löschen der Tabelle [persons]
drop table persons
# Erstellen der Tabelle persons
create table persons (first_name varchar(30) not null, last_name varchar(30) not null, age integer not null, primary key (last_name,first_name))
# Einfügen von zwei Personen
insert into persons(first_name, last_name, age) values('Paul','Langevin',48)
insert into persons(first_name, last_name, age) values ('Sylvie','Lefur',70)
# Anzeige der Tabelle
select first_name, last_name, age from persons
# absichtlicher Fehler
xx
# Einfügen von drei Personen
insert into persons(first_name, last_name, age) values ('Pierre','Nicazou',35)
insert into persons(first_name, last_name, age) values ('Geraldine','Colou',26)
insert into persons(first_name, last_name, age) values ('Paulette','Girond',56)
# Anzeige der Tabelle
select first_name, last_name, age from persons
# Liste der Personen in alphabetischer Reihenfolge der Nachnamen und bei gleichen Nachnamen in alphabetischer Reihenfolge der Vornamen
select last_name,first_name from persons order by last_name asc, first_name desc
# Liste der Personen mit einem Alter im Intervall [20,40] in absteigender Reihenfolge des Alters
# dann bei gleichem Alter in alphabetischer Reihenfolge der Nachnamen und bei gleichen Nachnamen in alphabetischer Reihenfolge der Vornamen
select last_name,first_name,age from persons where age between 20 and 40 order by age desc, last_name asc, first_name asc
# Einfügen von Frau Bruneau
insert into persons(first_name, last_name, age) values('Josette','Bruneau',46)
# Aktualisierung ihres Alters
update persons set age=47 where last_name='Bruneau'
# Liste der Personen mit dem Nachnamen Bruneau
select last_name,first_name,age from persons where last_name='Bruneau'
# Löschen von Frau Bruneau
delete from persons where last_name='Bruneau'
# Liste der Personen mit dem Nachnamen Bruneau
select last_name,first_name,age from persons where last_name='Bruneau'
|
7.1.6. Skript [mysql-04]
Das Hauptskript: Es führt die Datei data/commands.sql mit dem vorherigen Modul aus, mit oder ohne Transaktion, je nach Kommandozeilenparameter. Es entspricht dem Python-Skript [mysql_04].
| // databases/mysql/mysql-04.ts
// Hauptskript: führt die SQL-Befehlsdatei [data/commands.sql] aus,
// mit oder ohne Transaktion je nach Kommandozeilenparameter.
// Portiert das Python-Skript [mysql_04].
// npx tsx databases/mysql/mysql-04.ts true (mit Transaktion)
// npx tsx databases/mysql/mysql-04.ts false (ohne Transaktion)
import mysql from 'mysql2/promise';
import { configure } from './config-04.js';
import { executeFileOfCommands } from './mysql-module.js';
const config = configure();
// main
// Prüfung der Aufrufsyntax
const args = process.argv.slice(2);
let error = args.length !== 1;
let withTransactionText = '';
if (!error) {
withTransactionText = args[0].toLowerCase();
error = withTransactionText !== 'true' && withTransactionText !== 'false';
}
if (error) {
console.log('syntax: mysql-04.ts true / false');
process.exit(1);
}
// einen Text berechnen
const withTransaction = withTransactionText === 'true';
const text = withTransaction ? 'with transaction' : 'without transaction';
// Bildschirmlogs
console.log('--------------------------------------------------------------------');
console.log(`Executing the SQL file ${config.commandsFilename} ${text}`);
console.log('--------------------------------------------------------------------');
// Ausführung der SQL-Anweisungen der Datei
let connection: mysql.Connection | undefined;
let errors: string[] = [];
try {
// Verbindung zur Datenbank
connection = await mysql.createConnection({
host: config.host,
user: config.user,
password: config.password,
database: config.database,
});
// Ausführung der Datei mit SQL-Befehlen
errors = await executeFileOfCommands(connection, config.commandsFilename, true, false, withTransaction);
} catch (fatalError) {
console.log(`The following fatal error occurred: ${fatalError}`);
process.exit(1);
} finally {
if (connection) {
await connection.end();
}
}
// Anzeige der Anzahl der Fehler
console.log('--------------------------------------------------------------------');
console.log('Execution completed');
console.log('--------------------------------------------------------------------');
console.log(`There were ${errors.length} error(s)`);
for (const currentError of errors) {
console.log(currentError);
}
|
Führen wir es zunächst ohne Transaktion aus:
npx tsx databases/mysql/mysql-04.ts false
Ergebnis der Ausführung:
| --------------------------------------------------------------------
Executing the SQL file .../databases/mysql/data/commands.sql without transaction
--------------------------------------------------------------------
[drop table persons]: Successful execution
number of modified rows: 0
[create table persons (...)]: Successful execution
number of modified rows: 0
[insert into persons(first_name, last_name, age) values('Paul','Langevin',48)]: Successful execution
number of modified rows: 1
[insert into persons(first_name, last_name, age) values ('Sylvie','Lefur',70)]: Successful execution
number of modified rows: 1
[select first_name, last_name, age from persons]: Successful execution
first_name, last_name, age
**************************
[ 'Paul', 'Langevin', 48 ]
[ 'Sylvie', 'Lefur', 70 ]
**************************
xx: Error (Error: You have an error in your SQL syntax; ... near 'xx' at line 1)
[insert into persons(first_name, last_name, age) values ('Pierre','Nicazou',35)]: Successful execution
[insert into persons(first_name, last_name, age) values ('Geraldine','Colou',26)]: Successful execution
[insert into persons(first_name, last_name, age) values ('Paulette','Girond',56)]: Successful execution
[select first_name, last_name, age from persons]: Successful execution
first_name, last_name, age
**************************
[ 'Geraldine', 'Colou', 26 ]
[ 'Paulette', 'Girond', 56 ]
[ 'Paul', 'Langevin', 48 ]
[ 'Sylvie', 'Lefur', 70 ]
[ 'Pierre', 'Nicazou', 35 ]
**************************
(... rest of the SELECT/UPDATE/DELETE commands of the commands file, all executed despite the error ...)
--------------------------------------------------------------------
Execution completed
--------------------------------------------------------------------
There were 1 error(s)
xx: Error (Error: You have an error in your SQL syntax; ... near 'xx' at line 1)
|
Ohne Transaktion wird jeder Befehl unabhängig bestätigt: Der einzige absichtliche Fehler (Befehl xx) verhindert nicht, dass die nachfolgenden Befehle ausgeführt werden.
Führen wir es nun mit einer Transaktion aus (auf einer zurückgesetzten, leeren Tabelle):
npx tsx databases/mysql/mysql-04.ts true
Ergebnis der Ausführung:
| --------------------------------------------------------------------
Executing the SQL file .../databases/mysql/data/commands.sql with transaction
--------------------------------------------------------------------
[drop table persons]: Successful execution
number of modified rows: 0
[create table persons (...)]: Successful execution
number of modified rows: 0
[insert into persons(first_name, last_name, age) values('Paul','Langevin',48)]: Successful execution
number of modified rows: 1
[insert into persons(first_name, last_name, age) values ('Sylvie','Lefur',70)]: Successful execution
number of modified rows: 1
[select first_name, last_name, age from persons]: Successful execution
first_name, last_name, age
**************************
[ 'Paul', 'Langevin', 48 ]
[ 'Sylvie', 'Lefur', 70 ]
**************************
xx: Error (Error: You have an error in your SQL syntax; ... near 'xx' at line 1)
--------------------------------------------------------------------
Execution completed
--------------------------------------------------------------------
There were 1 error(s)
xx: Error (Error: You have an error in your SQL syntax; ... near 'xx' at line 1)
|
Dieses Mal beendet der Fehler die Schleife, sobald er auftritt (siehe mysql-module.ts, Zeile 76): Die auf den Fehler folgenden Befehle (Updates, Deletes usw.) werden nie ausgeführt. Der Code ruft dann connection.rollback() auf, um die Transaktion zurückzurollen.
Achtung: Man könnte erwarten, dass die Tabelle persons nach diesem rollback() leer ist – das behauptet der ursprüngliche Python-Kurs zu SQLAlchemy fälschlicherweise. Tatsächlich bestätigen bei MySQL/MariaDB (wie bei den meisten DBMS) die Datendefinitionsanweisungen (DDL: CREATE TABLE, DROP TABLE ...) vor ihrer Ausführung implizit alle laufenden Transaktionen per Commit (bzw. Rollback). Hier haben CREATE und TABLE des zweiten Befehls daher bereits (unsichtbar) alles Vorhergehende bestätigt, einschließlich – da davor nichts lag – ihrer selbst; die beiden darauf folgenden INSERT-Befehle eröffnen dann gewissermaßen eine neue implizite Transaktion, die tatsächlich zurückgerollt wird ... außer dass die Überprüfung der Datenbank in der Praxis zeigt, dass die beiden eingefügten Zeilen nach dem rollback() weiterhin vorhanden sind: Das CREATE TABLE hat die Transaktion bestätigt, während die Schleife noch lief, noch bevor die nachfolgenden INSERT-Anweisungen ausgeführt wurden – auch diese sind daher, sobald sie ausgeführt werden, außerhalb jeder expliziten Transaktion endgültig bestätigt. Merken Sie sich die allgemeine Regel: Ein DDL-Befehl kann nicht durch ein ROLLBACK zurückgerollt werden und bestätigt stillschweigend jede zuvor geöffnete Transaktion.
7.1.7. Skript [mysql-05]
Letztes Skript dieses Kapitels: parametrisierte Abfragen. Wir erstellen die Tabelle persons mit dem Schema samt Spalte id neu (wie im Skript **[mysql-03]), fügen dann Personen einzeln mit einer vorbereiteten Anweisung ein (connection.execute(), Parameter ?) und fügen eine ganze Liste von Personen in einer einzigen mehrzeiligen Abfrage ein (connection.query() mit values ?). Dies ist das Python-Skript [mysql_05]**.
| // databases/mysql/mysql-05.ts
// Parametrisierte Abfragen: einzelnes vorbereitetes Einfügen, dann Masseneinfügung.
// Portiert das Python-Skript [mysql_05]. Hier erstellen wir die Tabelle [persons] neu mit
// dem Schema mit einer Spalte [id] (wie im Skript mysql-03), damit dieses Skript
// unabhängig von dem Zustand ist, den mysql-04 hinterlässt.
import mysql from 'mysql2/promise';
// die Identität des Benutzers
const ID = 'admpersons';
const PWD = 'nobody';
// der Rechner des DBMS
const HOST = 'localhost';
// Identität der Datenbank
const DATABASE = 'dbpersons';
type Person = [id: number, lastName: string, firstName: string, age: number];
// Liste von Personen (id, lastName, firstName, age)
const persons: Person[] = [];
for (let i = 0; i < 5; i++) {
persons.push([i, `l0${i}`, `f0${i}`, i + 10]);
}
persons.push([40, "d'Aboot", "Y'éna", 18]);
// eine weitere Liste von Personen
const otherPersons: Person[] = [];
for (let i = 0; i < 5; i++) {
otherPersons.push([i + 100, `l1${i}`, `f1${i}`, i + 20]);
}
otherPersons.push([200, "d'Aboot", "F'ilhem", 34]);
// Zugriff auf das DBMS
let connection: mysql.Connection | undefined;
try {
// Verbindung
connection = await mysql.createConnection({ host: HOST, user: ID, password: PWD, database: DATABASE });
// (Neu-)Erstellung der Tabelle mit dem Schema mit [id]-Spalte (siehe mysql-03.ts)
await connection.query('drop table if exists persons');
await connection.query(
'create table persons (id int PRIMARY KEY, first_name varchar(30) NOT NULL, last_name varchar(30) NOT NULL, ' +
'age integer NOT NULL, unique(last_name,first_name))',
);
// Löschen der vorhandenen Datensätze
await connection.query('delete from persons');
// Einfügen Person für Person mit einem vorbereiteten Statement
for (const person of persons) {
const [id, lastName, firstName, age] = person;
await connection.execute('insert into persons(id,last_name,first_name,age) values(?,?,?,?)', [id, lastName, firstName, age]);
}
// Masseneinfügung einer Liste von Personen — Entsprechung von executemany:
// mysql2 bietet connection.query('insert ... values ?', [[...],[...],...])
// das eine einzige mehrzeilige Abfrage erzeugt
const values = otherPersons.map(([id, lastName, firstName, age]) => [id, lastName, firstName, age]);
await connection.query('insert into persons(id,last_name,first_name,age) values ?', [values]);
// Committen der Transaktion — hier wurde jede Abfrage bereits automatisch committet
// (mysql2 befindet sich standardmäßig im AUTOCOMMIT-Modus, wie der im
// Skript mysql-03 erwähnte Standardmodus; es gibt also nichts explizit zu committen)
console.log(`${persons.length + otherPersons.length} persons inserted.`);
} catch (error) {
console.log(`The following error occurred: ${error}`);
} finally {
if (connection) {
await connection.end();
}
}
|
Kommentieren wir diesen Code:
- Zeile 23: [persons.push([40, "d'Aboot", "Y'éna", 18])] – ein Vor- und Nachname mit Apostroph – absichtlich eingefügt, um zu überprüfen, dass parametrisierte Abfragen die Werte korrekt maskieren (anders als die Verkettung von SQL-Strings, die anfällig für Injection ist);
- Zeile 50: [await connection.execute('insert into persons(id,last_name,first_name,age) values(?,?,?,?)', [id, lastName, firstName, age])] –
execute() bereitet die parametrisierte Abfrage vor und führt sie dann mit dem übergebenen Array von Werten aus – die ? -Platzhalter werden sicher ersetzt, auch bei Apostrophen;
- Zeile 56: [await connection.query('insert into persons(id,last_name,first_name,age) values ?', [values])] – mysql2 bietet damit das Äquivalent zu Pythons
executemany(): eine einzige mehrzeilige SQL-Abfrage, die aus einem Array von Arrays aufgebaut wird und effizienter ist als eine Schleife einzelner Inserts.
Führen wir dieses Skript aus:
npx tsx databases/mysql/mysql-05.ts
Ergebnis der Ausführung:
Überprüfung der Datenbank (mit HeidiSQL):
7.1.8. Fazit
Der native Treiber mysql2 bietet einen direkten, unkomplizierten Zugriff auf das DBMS: Sie schreiben das SQL selbst, verwalten Transaktionen selbst, und das Ergebnis einer Abfrage ist einfach ein JavaScript-Array von Zeilen. Dies ist derselbe Ansatz wie beim Python-Modul mysql.connector aus Kapitel 16 des Python/Flask-Kurses. Die nächsten beiden Kapitel zeigen, wie ein ORM (TypeORM, dann Prisma) es ermöglicht, dieselben Operationen ohne SQL zu schreiben, indem typisierte TypeScript-Objekte manipuliert werden.
7.2. Verwendung des ORM TypeORM
Wir behandeln nun ORM, angelehnt an das Kapitel „Verwendung des ORM SQLAlchemy“ (Kapitel 19) des Python/Flask-Kurses. Das Prinzip hinter ORM (Object-Relational Mapping) besteht darin, Objekte der Sprache zu manipulieren, statt SQL zu schreiben: Eine Klasse entspricht einer Tabelle, eine Instanz einer Zeile, ein Attribut einer Spalte und eine Beziehung zwischen Klassen (Assoziation, Komposition) einem Fremdschlüssel.
Anhand desselben Beispiels werden nacheinander zwei ORM-Implementierungen vorgestellt, damit sie verglichen werden können: TypeORM in diesem Kapitel, Prisma im nächsten. Von beiden ähnelt TypeORM im Stil am stärksten SQLAlchemy (dekorierte Klassen, per Methoden abgefragte Repositorys); Prisma hingegen erzeugt aus einer separaten, deklarativen Schemadatei einen vollständig typisierten Client.
7.2.1. Vorbereitung der Datenbank [dbschool]
Die beiden ORM-Kapitel verwenden eine umfangreichere Datenbank als dbpersons, nämlich die Datenbank dbschool, bestehend aus vier miteinander verknüpften Tabellen – basierend auf demselben „vollständigen Beispiel“ aus Kapitel 19 des Python-Kurses: Eine Klasse enthält Schüler, jeder Schüler hat Noten in Fächern, und jedes Fach hat eine Gewichtung:
| -- create_dbschool.sql
-- Erstellt die Datenbank [dbschool] neu, die in den ORM-Kapiteln (TypeORM und Prisma) verwendet wird,
-- eine Portierung des Schemas [Class / Student / Subject / Grade] aus Kapitel 19 des
-- Python/Flask-Kurses („Verwendung des ORM SQLALCHEMY“, Skripte 05 — vollständiges
-- Beispiel), mit beliebigen Daten (die Originaldatenbank ist nicht mehr
-- verfügbar). Tabellen-/Spaltennamen sind bewusst ohne Akzente gehalten
-- (ASCII-Bezeichner), sicherer mit MySQL/TypeORM/Prisma.
--
-- Verwendung:
-- mysql -u root -p < create_dbschool.sql
DROP DATABASE IF EXISTS dbschool;
CREATE DATABASE dbschool CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER IF NOT EXISTS 'admschool'@'localhost' IDENTIFIED BY 'pwdschool';
GRANT ALL PRIVILEGES ON dbschool.* TO 'admschool'@'localhost';
FLUSH PRIVILEGES;
USE dbschool;
-- eine Klasse (z. B. [class1], [class2])
CREATE TABLE classes (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(30) NOT NULL UNIQUE
);
-- ein Schüler gehört zu einer Klasse (N-1-Beziehung)
CREATE TABLE students (
id INT PRIMARY KEY,
last_name VARCHAR(30) NOT NULL,
first_name VARCHAR(30) NOT NULL,
class_id INT NOT NULL,
CONSTRAINT fk_students_class FOREIGN KEY (class_id) REFERENCES classes(id)
);
-- ein Fach (z. B. [subject1], Koeffizient 1)
CREATE TABLE subjects (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(30) NOT NULL UNIQUE,
coefficient DECIMAL(4,2) NOT NULL
);
-- eine Note ist die Note eines Schülers in einem Fach (N-1-, N-1-Beziehungen)
CREATE TABLE grades (
id INT AUTO_INCREMENT PRIMARY KEY,
value DECIMAL(4,2) NOT NULL,
student_id INT NOT NULL,
subject_id INT NOT NULL,
CONSTRAINT fk_grades_student FOREIGN KEY (student_id) REFERENCES students(id),
CONSTRAINT fk_grades_subject FOREIGN KEY (subject_id) REFERENCES subjects(id)
);
-- beliebige Daten (dieselben Werte wie in den Beispielen des Originalkurses,
-- die für Schüler 11 ergaben: grades=[10, 6], gewichteter Durchschnitt = 7.33)
INSERT INTO classes (id, name) VALUES (1, 'class1'), (2, 'class2');
INSERT INTO students (id, last_name, first_name, class_id) VALUES
(11, 'lastname1', 'firstname1', 1),
(21, 'lastname2', 'firstname2', 1),
(32, 'lastname3', 'firstname3', 2),
(42, 'lastname4', 'firstname4', 2);
INSERT INTO subjects (id, name, coefficient) VALUES
(1, 'subject1', 1.0),
(2, 'subject2', 2.0);
INSERT INTO grades (value, student_id, subject_id) VALUES
(10, 11, 1),
(12, 21, 1),
(14, 32, 1),
(16, 42, 1),
(6, 11, 2),
(8, 21, 2),
(10, 32, 2),
(12, 42, 2);
|
Kommentieren wir dieses Skript:
- Zeile 33: [CONSTRAINT fk_students_class FOREIGN KEY (class_id) REFERENCES classes(id)] – ein Fremdschlüssel pro Beziehung – students.class_id (ein Schüler gehört zu einer Klasse) und zwei für grades (student_id, subject_id) bei der N:N-Beziehung „Schüler hat Noten in Fächern“;
- Zeile 53: [INSERT INTO grades (value, student_id, subject_id) VALUES (10, 11, 1), ...] – willkürlich gewählte Noten, die das Beispiel des Python-Kurses exakt nachbilden (Schüler 11: Noten 10 und 6, Gewichtungsfaktoren 1 und 2, woraus sich ein gewichteter Durchschnitt von (10×1 + 6×2) / (1+2) = 7.33 ergibt – ein Wert, den man im Skript [typeorm-04-stats] wiederfindet).
mysql -u root -p < sql/create_dbschool.sql
7.2.2. Installation und Mapping der Entitäten
TypeORM wird mit typeorm und, für die Ausführung dieses Kurses im Modus tsx, mit reflect-metadata (für Dekoratoren erforderlich) installiert. Zwei Optionen aus tsconfig.json sind unverzichtbar:
| "experimentalDecorators": true,
"emitDecoratorMetadata": true
|
Achtung: tsx (wie esbuild, das es verwendet) transpiliert TypeScript zu JavaScript, ohne den vollständigen Typprüfer auszuführen – die Dekorator-Metadaten, die emitDecoratorMetadata automatisch einfügen soll (der Typ jeder Spalte, abgeleitet aus dem TypeScript-Typ der Eigenschaft), stehen daher zur Laufzeit nicht immer zur Verfügung, was einen Fehler ColumnTypeUndefinedError auslöst. Die sicherste Lösung – die in allen untenstehenden Entitäten verwendet wird – besteht darin, den Typ jeder Spalte explizit als erstes Argument des Dekorators anzugeben: @Column('varchar', { length: 30 }) statt einfach @Column().
Jede Tabelle wird durch eine mit @Entity annotierte Klasse dargestellt. Hier die Entität Person (die Tabelle persons aus der Datenbank dbpersons, die aus dem vorherigen Kapitel für das erste TypeORM-Skript übernommen wurde):
| // databases/typeorm/entities/person.entity.ts
// TypeORM-Entität, die der Tabelle [persons] der Datenbank
// [dbpersons] entspricht (siehe Kapitel "nativer MySQL-Treiber").
// Portiert den Geist des Mappings des Python-Skripts [demo] (Kapitel 19) in einer
// modernen "deklarativen" Version (Dekoratoren), näher an dem, was Spring
// Data JPA tut, als am alten klassischen [mapper()] von sqlalchemy 1.3.
import { Column, Entity, PrimaryColumn, Unique } from 'typeorm';
// Die Spaltentypen werden explizit angegeben (statt per Reflection aus den
// TypeScript-Typen abgeleitet): portabler zwischen den Build-Werkzeugen
// (tsx/esbuild, ts-node, SWC...) als die Abhängigkeit von
// "emitDecoratorMetadata".
@Entity({ name: 'persons' })
@Unique(['lastName', 'firstName'])
export class Person {
@PrimaryColumn('int')
id!: number;
@Column('varchar', { name: 'first_name', length: 30 })
firstName!: string;
@Column('varchar', { name: 'last_name', length: 30 })
lastName!: string;
@Column('int')
age!: number;
}
|
Dazu kommen die vier Entitäten aus dbschool – SchoolClass, Student, Subject und Grade –, in denen Beziehungen mit @ManyToOne/@OneToMany deklariert werden (das Äquivalent zu relationship() in SQLAlchemy):
| // databases/typeorm/entities/school-class.entity.ts
// Portiert die Python-Klasse [Class] (Kapitel 19, Skripte 05).
import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from 'typeorm';
import { Student } from './student.entity.js';
@Entity({ name: 'classes' })
export class SchoolClass {
@PrimaryGeneratedColumn()
id!: number;
@Column('varchar', { length: 30, unique: true })
name!: string;
// inverse Eigenschaft (backref) von Student.schoolClass — bei Bedarf geladen
@OneToMany(() => Student, (student) => student.schoolClass)
students!: Student[];
}
|
| // databases/typeorm/entities/student.entity.ts
// Portiert die Python-Klasse [Student] (Kapitel 19, Skripte 05).
import { Column, Entity, JoinColumn, ManyToOne, OneToMany, PrimaryColumn } from 'typeorm';
import { SchoolClass } from './school-class.entity.js';
import { Grade } from './grade.entity.js';
@Entity({ name: 'students' })
export class Student {
@PrimaryColumn('int')
id!: number;
@Column('varchar', { name: 'last_name', length: 30 })
lastName!: string;
@Column('varchar', { name: 'first_name', length: 30 })
firstName!: string;
// ein Student gehört zu einer Klasse (N-1-Beziehung, Spalte [class_id])
@ManyToOne(() => SchoolClass, (schoolClass) => schoolClass.students)
@JoinColumn({ name: 'class_id' })
schoolClass!: SchoolClass;
// inverse Eigenschaft (backref) von Grade.student
@OneToMany(() => Grade, (grade) => grade.student)
grades!: Grade[];
}
|
| // databases/typeorm/entities/subject.entity.ts
// Portiert die Python-Klasse [Subject] (Kapitel 19, Skripte 05).
import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from 'typeorm';
import { Grade } from './grade.entity.js';
@Entity({ name: 'subjects' })
export class Subject {
@PrimaryGeneratedColumn()
id!: number;
@Column('varchar', { length: 30, unique: true })
name!: string;
@Column('decimal', { precision: 4, scale: 2 })
coefficient!: number;
// inverse Eigenschaft (backref) von Grade.subject
@OneToMany(() => Grade, (grade) => grade.subject)
grades!: Grade[];
}
|
| // databases/typeorm/entities/grade.entity.ts
// Portiert die Python-Klasse [Grade] (Kapitel 19, Skripte 05): die Note eines
// Studenten in einem Fach.
import { Column, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
import { Student } from './student.entity.js';
import { Subject } from './subject.entity.js';
@Entity({ name: 'grades' })
export class Grade {
@PrimaryGeneratedColumn()
id!: number;
@Column('decimal', { precision: 4, scale: 2 })
value!: number;
@ManyToOne(() => Student, (student) => student.grades)
@JoinColumn({ name: 'student_id' })
student!: Student;
@ManyToOne(() => Subject, (subject) => subject.grades)
@JoinColumn({ name: 'subject_id' })
subject!: Subject;
}
|
Schauen wir uns diese Entitäten genauer an:
- Zeile 19: [@ManyToOne(() => SchoolClass, (schoolClass) => schoolClass.students) @JoinColumn({ name: 'class_id' })] – @ManyToOne deklariert die „viele“-Seite der Beziehung (ein Schüler, eine Klasse); das erste Argument ist eine Funktion, die die Zielklasse zurückgibt (statt der Klasse selbst), um Probleme mit zirkulären Abhängigkeiten zwischen Modulen zu vermeiden; das zweite Argument verknüpft mit der inversen Eigenschaft auf der Seite von SchoolClass;
- Zeile 24: [@OneToMany(() => Grade, (grade) => grade.student) grades!: Grade[]] – die „Spiegel“-Eigenschaft auf der „eins“-Seite – ein Schüler hat mehrere Noten; sie dient lediglich der Lesbarkeit; dafür wird in der Datenbank keine zusätzliche Spalte angelegt (der Fremdschlüssel liegt bei Grade);
Schließlich eine DataSource (das Äquivalent zur engine von SQLAlchemy) pro Datenbank, die die Verbindung und die Liste der von ihr verwalteten Entitäten enthält:
| // databases/typeorm/data-source-persons.ts
// TypeORM-Datenquelle für die Datenbank [dbpersons].
import 'reflect-metadata';
import { DataSource } from 'typeorm';
import { Person } from './entities/person.entity.js';
export const AppDataSource = new DataSource({
type: 'mysql',
host: 'localhost',
port: 3306,
username: 'admpersons',
password: 'nobody',
database: 'dbpersons',
entities: [Person],
synchronize: false,
});
|
| // databases/typeorm/data-source-school.ts
// TypeORM-Datenquelle für die Datenbank [dbschool] (Schema Class / Student /
// Subject / Grade aus Kapitel 19, Skripte 05).
import 'reflect-metadata';
import { DataSource } from 'typeorm';
import { SchoolClass } from './entities/school-class.entity.js';
import { Student } from './entities/student.entity.js';
import { Subject } from './entities/subject.entity.js';
import { Grade } from './entities/grade.entity.js';
export const AppDataSource = new DataSource({
type: 'mysql',
host: 'localhost',
port: 3306,
username: 'admschool',
password: 'pwdschool',
database: 'dbschool',
entities: [SchoolClass, Student, Subject, Grade],
synchronize: false,
});
|
Hinweis: synchronize: false weist TypeORM an, das Datenbankschema niemals anhand der Entitäten zu ändern (was synchronize: true täte – nützlich in der Entwicklung, aber gefährlich in der Produktion): Das Schema wird hier vollständig durch die SQL-Skripte am Anfang dieses Kapitels definiert.
7.2.3. Skript [typeorm-01]
Erste Verwendung von TypeORM: DataSource öffnen, dann die Tabelle persons über das Repository der Entität Person lesen und beschreiben, ohne eine einzige Zeile SQL zu schreiben. Dies folgt demselben Ansatz wie das Python-Skript [main] (Kapitel 19, Skripte 01).
| // databases/typeorm/typeorm-01.ts
// Erste Verwendung von TypeORM: die Datenquelle öffnen, dann in der Tabelle [persons]
// über das Repository der Entität [Person] lesen und schreiben, ohne
// eine einzige Zeile SQL zu schreiben.
// Portiert den Geist des Python-Skripts [main] (Kapitel 19, Skripte 01).
import { AppDataSource } from './data-source-persons.js';
import { Person } from './entities/person.entity.js';
await AppDataSource.initialize();
console.log('TypeORM connection to [dbpersons] established.');
try {
const repo = AppDataSource.getRepository(Person);
// alle Personen, nach Nachnamen sortiert
const all = await repo.find({ order: { lastName: 'ASC' } });
console.log('Persons in the database:');
for (const p of all) {
console.log(` ${p.id} ${p.firstName} ${p.lastName} (${p.age} years old)`);
}
// eine Person anhand ihres Primärschlüssels
const paul = await repo.findOneBy({ id: 1 });
console.log(`Person id=1: ${paul ? `${paul.firstName} ${paul.lastName}` : 'not found'}`);
// Einfügen einer neuen Person (die Entität ist eine einfache Klasse: `new`
// genügt, keine spezielle Factory nötig)
const newPerson = new Person();
newPerson.id = 99;
newPerson.firstName = 'Ada';
newPerson.lastName = 'Lovelace';
newPerson.age = 36;
await repo.save(newPerson);
console.log('Person 99 inserted.');
// Aktualisierung
newPerson.age = 37;
await repo.save(newPerson);
console.log(`After update, age=${(await repo.findOneBy({ id: 99 }))?.age}`);
// Löschung — die Datenbank wird in den Zustand zurückversetzt, in dem wir sie vorgefunden haben
await repo.delete({ id: 99 });
console.log('Person 99 deleted.');
} finally {
await AppDataSource.destroy();
}
|
Kommentieren wir diesen Code:
- Zeile 15: [await repo.find({ order: { lastName: 'ASC' } })] – Repository.find() ist die allgemeine Lesemethode; die Option
order erzeugt die Klausel ORDER BY – es ist kein SQL nötig;
- Zeile 28: [const newPerson = new Person(); newPerson.id = 99; ... await repo.save(newPerson);] – eine TypeORM-Entität ist eine gewöhnliche Klasse:
new genügt, um eine Instanz zu erzeugen, und save() entscheidet selbst – je nachdem, ob der Primärschlüssel in der Datenbank bereits existiert –, ob ein INSERT oder ein UPDATE erzeugt wird – das entspricht session.add() + session.commit() in SQLAlchemy, jedoch ohne eine explizite Session, die bestätigt werden müsste.
Führen wir dieses Skript aus (nachdem die Datenbank [dbpersons] mit ihrem Erstellungsskript zurückgesetzt wurde):
npx tsx databases/typeorm/typeorm-01.ts
Ergebnis der Ausführung:
| TypeORM connection to [dbpersons] established.
Persons in the database:
4 Geraldine Colou (26 years old)
5 Paulette Girond (56 years old)
1 Paul Langevin (48 years old)
2 Sylvie Lefur (70 years old)
3 Pierre Nicazou (35 years old)
Person id=1: Paul Langevin
Person 99 inserted.
After update, age=37
Person 99 deleted.
|
7.2.4. Skript [typeorm-02]
Als Nächstes wechseln wir zu dbschool: Wir lesen die Tabellen classes und subjects , fügen dann einen Schüler hinzu, lesen ihn erneut und löschen ihn. Dies folgt dem Ansatz der Python-Skripte [02] und [03] (Kapitel 19): Entitäten abbilden und dann manipulieren.
| // databases/typeorm/typeorm-02.ts
// Mapping von vier verknüpften Entitäten (Class, Student, Subject, Grade)
// und grundlegende Operationen (CRUD) auf der Datenbank [dbschool].
// Überträgt den Ansatz der Python-Skripte [02] und [03] (Kapitel 19): sqlalchemy-
// Mappings, dann Bearbeitung der Entitäten der Session.
import { AppDataSource } from './data-source-school.js';
import { SchoolClass } from './entities/school-class.entity.js';
import { Student } from './entities/student.entity.js';
import { Subject } from './entities/subject.entity.js';
await AppDataSource.initialize();
console.log('TypeORM connection to [dbschool] established.');
try {
const classRepo = AppDataSource.getRepository(SchoolClass);
const studentRepo = AppDataSource.getRepository(Student);
const subjectRepo = AppDataSource.getRepository(Subject);
// alle Klassen
console.log('Classes:');
for (const c of await classRepo.find({ order: { name: 'ASC' } })) {
console.log(` ${c.id} ${c.name}`);
}
// alle Fächer mit ihrem Koeffizienten
console.log('Subjects:');
for (const s of await subjectRepo.find({ order: { name: 'ASC' } })) {
console.log(` ${s.id} ${s.name} (coefficient ${s.coefficient})`);
}
// Hinzufügen eines neuen Schülers in [class1]
const class1 = await classRepo.findOneByOrFail({ name: 'class1' });
const newStudent = new Student();
newStudent.id = 999;
newStudent.lastName = 'Curie';
newStudent.firstName = 'Marie';
newStudent.schoolClass = class1;
await studentRepo.save(newStudent);
console.log(`Student ${newStudent.firstName} ${newStudent.lastName} added to ${class1.name}.`);
// erneutes Lesen — wir geben `relations` an, um die zugehörige Klasse zu laden
// (andernfalls bliebe die Eigenschaft [schoolClass] leer, da TypeORM bei
// Entitäten mit "eager: false" standardmäßig kein Lazy Loading durchführt)
const reread = await studentRepo.findOne({ where: { id: 999 }, relations: { schoolClass: true } });
console.log(`Re-read: ${reread?.firstName} ${reread?.lastName}, class=${reread?.schoolClass.name}`);
// Löschung — die Datenbank wird in den Zustand zurückversetzt, in dem wir sie vorgefunden haben
await studentRepo.delete({ id: 999 });
console.log('Student 999 deleted.');
} finally {
await AppDataSource.destroy();
}
|
Kommentieren wir diesen Code:
- Zeile 37: [newStudent.schoolClass = class1; await studentRepo.save(newStudent);] – wir verknüpfen den Schüler mit seiner Klasse, indem wir direkt das zuvor geladene Objekt
class1 zuweisen – TypeORM übersetzt diese Zuweisung beim INSERT in class_id;
- Zeile 44: [await studentRepo.findOne({ where: { id: 999 }, relations: { schoolClass: true } })] – wichtiger Punkt: Anders als SQLAlchemy, das Beziehungen standardmäßig bei Bedarf lädt (Lazy Loading), lädt TypeORM keine Beziehungen, bevor sie über die Option
relations ausdrücklich angefordert werden – ohne sie wäre reread.schoolClass undefined.
Hinweis: Diese Entscheidung in TypeORM (kein implizites Lazy Loading) ist bewusst getroffen: Eine geladene Beziehung erfordert immer einen zusätzlichen Join oder eine zusätzliche Abfrage (SQL), einen Aufwand, den wir lieber im Code sichtbar machen, als ihn beim ersten Zugriff auf die Eigenschaft stillschweigend anfallen zu lassen, wie es SQLAlchemy täte.
Führen wir dieses Skript aus:
npx tsx databases/typeorm/typeorm-02.ts
Ergebnis der Ausführung:
| TypeORM connection to [dbschool] established.
Classes:
1 class1
2 class2
Subjects:
1 subject1 (coefficient 1.00)
2 subject2 (coefficient 2.00)
Student Marie Curie added to class1.
Re-read: Marie Curie, class=class1
Student 999 deleted.
|
7.2.5. Skript [typeorm-03-joined-queries]
Dieses Skript hebt die Abfragen hervor, die TypeORM auslöst, um auf mehrere Tabellen verteilte Informationen abzurufen, wobei systematisch die im vorherigen Skript gesehene Option „relations“ verwendet wird. Es basiert auf dem Python-Skript [main_joined_queries] (Kapitel 19, Skripte 05).
| // databases/typeorm/typeorm-03-joined-queries.ts
// Zeigt die Abfragen, die TypeORM absetzt, um Informationen aus mehreren
// Tabellen zu holen, wenn eine Beziehung (@ManyToOne / @OneToMany)
// angefordert wird. Überträgt das Python-Skript
// [main_joined_queries] (Kapitel 19, Skripte 05).
//
// Anders als sqlalchemy (im Python-Kurs verwendet) führt TypeORM
// bei "classic"-Entitäten (Repository) standardmäßig KEIN Lazy Loading durch:
// Die zu ladenden Beziehungen müssen explizit angefordert werden, mit der Option
// `relations` oder mit einer Abfrage über `createQueryBuilder` /
// `leftJoinAndSelect`. Diese Entscheidung ist bewusst und explizit: Anders als beim
// "hidden" Lazy Loading von sqlalchemy sieht man hier beim Lesen immer,
// welche zusätzlichen SQL-Abfragen (Joins) ein Lesevorgang auslöst.
import { AppDataSource } from './data-source-school.js';
import { SchoolClass } from './entities/school-class.entity.js';
import { Student } from './entities/student.entity.js';
import { Subject } from './entities/subject.entity.js';
await AppDataSource.initialize();
try {
const studentRepo = AppDataSource.getRepository(Student);
const classRepo = AppDataSource.getRepository(SchoolClass);
const subjectRepo = AppDataSource.getRepository(Subject);
// Schüler nach ID, mit seiner Klasse (expliziter Join über `relations`)
console.log('student id=11 -----------');
const student11 = await studentRepo.findOneOrFail({ where: { id: 11 }, relations: { schoolClass: true } });
console.log(`student={"id":${student11.id},"lastName":"${student11.lastName}","firstName":"${student11.firstName}"}`);
console.log(`student's class: {"id":${student11.schoolClass.id},"name":"${student11.schoolClass.name}"}`);
// die Schüler derselben Klasse (neue Abfrage, mit eigenem Join)
console.log('students in the same class:');
const studentsClass = await classRepo.findOneOrFail({
where: { id: student11.schoolClass.id },
relations: { students: true },
});
for (const s of studentsClass.students) {
console.log(`student={"id":${s.id},"lastName":"${s.lastName}","firstName":"${s.firstName}"}`);
}
// ein Schüler nach seinem Nachnamen
console.log("student lastName='lastname2' -----------");
const byName = await studentRepo.findOneOrFail({ where: { lastName: 'lastname2' }, relations: { schoolClass: true } });
console.log(`student={"id":${byName.id},"lastName":"${byName.lastName}","firstName":"${byName.firstName}"}`);
console.log(`student's class: {"id":${byName.schoolClass.id},"name":"${byName.schoolClass.name}"}`);
// die Noten eines Schülers, mit dem Fach jeder Note
console.log('grades of student id=11 -----------');
const studentWithGrades = await studentRepo.findOneOrFail({
where: { id: 11 },
relations: { grades: { subject: true } },
});
for (const grade of studentWithGrades.grades) {
console.log(`grade={"id":${grade.id},"value":${grade.value}}, subject={"name":"${grade.subject.name}"}`);
}
// die Schüler einer Klasse, nach Klassenname
for (const className of ['class1', 'class2']) {
console.log(`students of class name='${className}' -----------`);
const schoolClass = await classRepo.findOneOrFail({ where: { name: className }, relations: { students: true } });
for (const s of schoolClass.students) {
console.log(`{"id":${s.id},"lastName":"${s.lastName}","firstName":"${s.firstName}"}`);
}
}
// die Noten in einem Fach, nach Fachname
for (const subjectName of ['subject1', 'subject2']) {
console.log(`subject with name='${subjectName}' -----------`);
const subject = await subjectRepo.findOneOrFail({ where: { name: subjectName }, relations: { grades: true } });
console.log(`subject={"name":"${subject.name}","coefficient":${subject.coefficient}}`);
console.log('Grades in the subject: ');
for (const grade of subject.grades) {
console.log(`{"id":${grade.id},"value":${grade.value}}`);
}
}
} finally {
await AppDataSource.destroy();
}
|
Kommentieren wir diesen Code:
- Zeile 28: [await studentRepo.findOneOrFail({ where: { id: 11 }, relations: { schoolClass: true } })] – findOneOrFail (wie get_or_404 aus dem Flask-Kurs) löst eine Ausnahme aus, statt null zurückzugeben, wenn keine Zeile passt – nützlich, wenn das Fehlen von Ergebnissen eine Anomalie und kein normaler, zu prüfender Fall ist;
- Zeile 52: [relations: { grades: { subject: true } }] – eine verschachtelte relations-Option ruft in einer einzigen Abfrage (TypeORM erzeugt die nötigen SQL-Joins) die Noten des Schülers und zu jeder Note das Fach ab – ohne diese Verschachtelung würde grade.subject fehlen.
Führen wir dieses Skript aus:
npx tsx databases/typeorm/typeorm-03-joined-queries.ts
Ergebnis der Ausführung:
| student id=11 -----------
student={"id":11,"lastName":"lastname1","firstName":"firstname1"}
student's class: {"id":1,"name":"class1"}
students in the same class:
student={"id":11,"lastName":"lastname1","firstName":"firstname1"}
student={"id":21,"lastName":"lastname2","firstName":"firstname2"}
student lastName='lastname2' -----------
student={"id":21,"lastName":"lastname2","firstName":"firstname2"}
student's class: {"id":1,"name":"class1"}
grades of student id=11 -----------
grade={"id":1,"value":10.00}, subject={"name":"subject1"}
grade={"id":5,"value":6.00}, subject={"name":"subject2"}
students of class name='class1' -----------
{"id":11,"lastName":"lastname1","firstName":"firstname1"}
{"id":21,"lastName":"lastname2","firstName":"firstname2"}
students of class name='class2' -----------
{"id":32,"lastName":"lastname3","firstName":"firstname3"}
{"id":42,"lastName":"lastname4","firstName":"firstname4"}
subject with name='subject1' -----------
subject={"name":"subject1","coefficient":1.00}
Grades in the subject:
{"id":1,"value":10.00}
{"id":2,"value":12.00}
{"id":3,"value":14.00}
{"id":4,"value":16.00}
subject with name='subject2' -----------
subject={"name":"subject2","coefficient":2.00}
Grades in the subject:
{"id":5,"value":6.00}
{"id":6,"value":8.00}
{"id":7,"value":10.00}
{"id":8,"value":12.00}
|
7.2.6. Skript [typeorm-04-stats]
Letztes Skript des Kapitels: Es berechnet für einen gegebenen Schüler seinen nach den Fachkoeffizienten gewichteten Durchschnitt sowie seine minimale und maximale Note. Das Python-Skript heißt [main_stats_for_student] (Kapitel 19, Skripte 05).
| // databases/typeorm/typeorm-04-stats.ts
// Berechnet für einen gegebenen Schüler seinen mit den Koeffizienten der
// Fächer gewichteten Durchschnitt sowie seine minimale und maximale Note.
// Überträgt das Python-Skript [main_stats_for_student] (Kapitel 19, Skripte 05).
//
// Fallstrick, den man kennen sollte: Die `decimal`-Spalten (hier `grade.value` und
// `subject.coefficient`) sind in der Entität auf der TypeScript-Seite als `number`
// typisiert, aber der Treiber mysql2 liefert sie tatsächlich als
// *Zeichenketten* zurück (um bei der Umwandlung in eine
// Gleitkomma-`number` keine Genauigkeit zu verlieren). `typeof grade.value` ist zur
// Laufzeit `'string'`, trotz des deklarierten Typs. Eine Berechnung wie
// `sum += grade.value * subject.coefficient` würde dann eine
// Verkettung oder eine riskante implizite Umwandlung durchführen: Man muss
// vor jeder Berechnung explizit mit `Number(...)` umwandeln.
import { AppDataSource } from './data-source-school.js';
import { Student } from './entities/student.entity.js';
// berechnet die Statistiken (gewichteter Durchschnitt, Minimum, Maximum) eines Schülers
async function studentStats(studentId: number): Promise<void> {
const studentRepo = AppDataSource.getRepository(Student);
// wir laden den Schüler mit seinen Noten und für jede Note das zugehörige
// Fach (um den Koeffizienten zu erhalten) — eine einzige Abfrage mit zwei
// Joins, dank der verschachtelten Option `relations`
const student = await studentRepo.findOneOrFail({
where: { id: studentId },
relations: { grades: { subject: true } },
});
console.log(`Statistics of student {"id":${student.id},"lastName":"${student.lastName}","firstName":"${student.firstName}"}`);
if (student.grades.length === 0) {
console.log(' no grades.');
return;
}
let weightedSum = 0;
let coefficientsSum = 0;
let min = Number.POSITIVE_INFINITY;
let max = Number.NEGATIVE_INFINITY;
for (const grade of student.grades) {
// explizite Umwandlung: `grade.value` und `grade.subject.coefficient`
// sind zur Laufzeit Zeichenketten, trotz ihres deklarierten Typs `number`
const value = Number(grade.value);
const coefficient = Number(grade.subject.coefficient);
weightedSum += value * coefficient;
coefficientsSum += coefficient;
min = Math.min(min, value);
max = Math.max(max, value);
console.log(` grade=${value.toFixed(2)} subject="${grade.subject.name}" (coefficient ${coefficient.toFixed(2)})`);
}
const average = weightedSum / coefficientsSum;
console.log(` weighted average=${average.toFixed(2)}, min=${min.toFixed(2)}, max=${max.toFixed(2)}`);
}
await AppDataSource.initialize();
try {
// Schüler id=11: Noten subject1=10 (Koeff. 1.0), subject2=6 (Koeff. 2.0)
// gewichteter Durchschnitt = (10*1.0 + 6*2.0) / (1.0+2.0) = 22/3 = 7.33
await studentStats(11);
console.log();
// Schüler id=21: Noten subject1=12 (Koeff. 1.0), subject2=8 (Koeff. 2.0)
await studentStats(21);
console.log();
// Schüler id=32: Noten subject1=14 (Koeff. 1.0), subject2=10 (Koeff. 2.0)
await studentStats(32);
console.log();
// Schüler id=42: Noten subject1=16 (Koeff. 1.0), subject2=12 (Koeff. 2.0)
await studentStats(42);
} finally {
await AppDataSource.destroy();
}
|
Kommentieren wir diesen Code:
- Zeile 35: [const value = Number(grade.value); const coefficient = Number(grade.subject.coefficient);] – eine Falle, auf die man achten muss: Die SQL-Spalten vom Typ DECIMAL (hier grade.value und subject.coefficient) sind auf der Seite der TypeScript-Entität als
number typisiert, der Treiber mysql2 liefert sie tatsächlich jedoch als Strings , um die Dezimalgenauigkeit zu bewahren – typeof grade.value ergibt zur Laufzeit 'string' , trotz des deklarierten Typs. Eine direkte arithmetische Berechnung würde zu einer Verkettung oder einer riskanten impliziten Umwandlung führen; vor jeder Berechnung müssen Sie daher explizit mit Number(...) umwandeln.
Führen wir dieses Skript aus:
npx tsx databases/typeorm/typeorm-04-stats.ts
Ergebnis der Ausführung:
| Statistics of student {"id":11,"lastName":"lastname1","firstName":"firstname1"}
grade=10.00 subject="subject1" (coefficient 1.00)
grade=6.00 subject="subject2" (coefficient 2.00)
weighted average=7.33, min=6.00, max=10.00
Statistics of student {"id":21,"lastName":"lastname2","firstName":"firstname2"}
grade=12.00 subject="subject1" (coefficient 1.00)
grade=8.00 subject="subject2" (coefficient 2.00)
weighted average=9.33, min=8.00, max=12.00
Statistics of student {"id":32,"lastName":"lastname3","firstName":"firstname3"}
grade=14.00 subject="subject1" (coefficient 1.00)
grade=10.00 subject="subject2" (coefficient 2.00)
weighted average=11.33, min=10.00, max=14.00
Statistics of student {"id":42,"lastName":"lastname4","firstName":"firstname4"}
grade=16.00 subject="subject1" (coefficient 1.00)
grade=12.00 subject="subject2" (coefficient 2.00)
weighted average=13.33, min=12.00, max=16.00
|
Für Schüler 11 sehen wir tatsächlich den gewichteten Durchschnitt von 7.33, den der ursprüngliche Python-Kurs für denselben Datensatz angibt.
7.2.7. Fazit
TypeORM ermöglicht es, Lese-/Schreiboperationen ohne SQL zu schreiben, mit dekorierten Entitäten, die SQLAlchemy im Geiste ähneln – um den Preis eines wesentlichen Designunterschieds, den man kennen sollte (kein implizites Lazy Loading von Beziehungen: alle nicht ausdrücklich angeforderten Beziehungen werden weggelassen) und einer Werkzeugfalle, die speziell bei der Ausführung mit TSX auftritt (Spaltentypen müssen explizit angegeben werden). Das folgende Kapitel verwendet exakt dasselbe Beispiel mit Prisma, um die beiden Ansätze zu vergleichen.
7.3. Verwendung des ORM Prisma
Zweites ORM, mit demselben Beispiel wie im vorherigen Kapitel (die Datenbanken dbpersons und dbschool), um die beiden Ansätze zu vergleichen. Prisma unterscheidet sich von TypeORM in seinem Entwurf: Statt Klassen zu annotieren, wird das Datenbankschema in einer separaten Datei im eigenen deklarativen Format von Prisma beschrieben, aus der der Befehl prisma generate einen vollständig typisierten Client erzeugt.
Wichtig: Zum Zeitpunkt der Erstellung dieses Kapitels liegt Prisma ORM in Version 7 vor, die gegenüber den früheren Versionen (5 und 6) wesentliche interne Änderungen erfahren hat: Die Query Engine, früher ein separat heruntergeladenes, in Rust kompiliertes Binary, ist nun ein WebAssembly-Modul, das direkt im npm-Paket eingebettet ist, kombiniert mit einem Driver-Adapter (hier @prisma/adapter-mariadb), der Abfragen an einen herkömmlichen JavaScript-Treiber weiterleitet. Das allgemeine Prinzip bleibt jedoch dasselbe wie bei früheren Prisma-Versionen, und das Folgende gilt daher auch für diese.
Hinweis zu dieser Umgebung: Der Befehl npx prisma generate , der den TypeScript-Client aus der Datei schema.prisma erzeugt, benötigt eine Prisma-spezifische Netzwerkressource (binaries.prisma.sh), um eine interne Komponente seiner CLI abzurufen – eine Ressource, auf die die Netzwerkrichtlinie der Laufzeitumgebung, in der dieser Kurs vorbereitet wurde, keinen Zugriff erlaubte. Die Skripte dieses Kapitels wurden daher mit derselben Sorgfalt wie die vorherigen geschrieben und geprüft, konnten in dieser Umgebung jedoch nicht ausgeführt oder verifiziert werden – anders als jene der beiden vorherigen Kapitel, die alle ausgeführt und deren Ergebnisse überprüft wurden. Auf einem Rechner mit normalem Internetzugang (dem typischen Fall) läuft npx prisma generate ohne besondere Probleme, und die Skripte sollten die unten gezeigten „erwarteten“ Ausgaben liefern, die aus denselben, im vorherigen Kapitel bereits verifizierten Daten berechnet wurden.
7.3.1. Installation und Konfiguration
Prisma wird mit zwei Paketen installiert: prisma (die CLI, eine Entwicklungsabhängigkeit) und @prisma/client (die Client-Bibliothek, eine Produktionsabhängigkeit); wir fügen @prisma/adapter-mariadb hinzu, den Treiberadapter für MySQL/MariaDB, der intern auf dem Paket mariadb aufbaut. Pro Datenbank gibt es ein Prisma-Schema – genau wie es pro Datenbank eine TypeORM-DataSource gibt:
| // databases/prisma/schema-persons.prisma
// Prisma-Schema der Datenbank [dbpersons] (eine einzige Tabelle [persons]).
// Prisma ORM 7 generiert einen "Rust-free" TypeScript-Client (Provider
// "prisma-client"): Driver Adapter (`driverAdapters`, hier
// @prisma/adapter-mariadb) werden standardmäßig verwendet, es ist nicht mehr nötig,
// `previewFeatures = ["driverAdapters"]` zu deklarieren, wie in den Versionen 5/6.
generator client {
provider = "prisma-client"
// Ausgabepfad des generierten Clients, relativ zu dieser Datei — seit
// Prisma 7 ist er Pflicht (der Client wird nicht mehr standardmäßig in
// node_modules geschrieben)
output = "../../generated/prisma-persons"
}
// seit Prisma ORM 7 enthält die Datasource keine Verbindungs-URL mehr: Mit
// Driver Adaptern wird die Verbindung vollständig zur
// Laufzeit auf der Seite von PrismaClient konfiguriert (siehe prisma-01.ts) — `provider`
// dient nur dazu, dem Generator mitzuteilen, welchen SQL-Dialekt er ansteuern soll
datasource db {
provider = "mysql"
}
// überträgt die Tabelle [persons] aus create_dbpersons.sql
model Person {
id Int @id
firstName String @map("first_name") @db.VarChar(30)
lastName String @map("last_name") @db.VarChar(30)
age Int
@@unique([lastName, firstName])
@@map("persons")
}
|
| // databases/prisma/schema-school.prisma
// Prisma-Schema der Datenbank [dbschool] (Klassen / Schüler / Fächer / Noten).
// Dieselben Tabellen wie in databases/typeorm/entities/*.entity.ts und sql/create_dbschool.sql
// — die beiden ORM-Kapitel (TypeORM, dann Prisma) verwenden bewusst
// dasselbe Beispiel, damit der Leser die beiden Ansätze an einem
// identischen Fall vergleichen kann.
generator client {
provider = "prisma-client"
output = "../../generated/prisma-school"
}
// seit Prisma ORM 7 enthält die Datasource keine Verbindungs-URL mehr: Mit
// Driver Adaptern wird die Verbindung vollständig zur
// Laufzeit auf der Seite von PrismaClient konfiguriert (siehe prisma-02.ts) — `provider`
// dient nur dazu, dem Generator mitzuteilen, welchen SQL-Dialekt er ansteuern soll
datasource db {
provider = "mysql"
}
model SchoolClass {
id Int @id @default(autoincrement())
name String @unique @db.VarChar(30)
students Student[]
@@map("classes")
}
model Student {
id Int @id
lastName String @map("last_name") @db.VarChar(30)
firstName String @map("first_name") @db.VarChar(30)
classId Int @map("class_id")
schoolClass SchoolClass @relation(fields: [classId], references: [id])
grades Grade[]
@@map("students")
}
model Subject {
id Int @id @default(autoincrement())
name String @unique @db.VarChar(30)
coefficient Decimal @db.Decimal(4, 2)
grades Grade[]
@@map("subjects")
}
model Grade {
id Int @id @default(autoincrement())
value Decimal @db.Decimal(4, 2)
studentId Int @map("student_id")
subjectId Int @map("subject_id")
student Student @relation(fields: [studentId], references: [id])
subject Subject @relation(fields: [subjectId], references: [id])
@@map("grades")
}
|
Kommentieren wir diese Schemas:
- Zeile 7: [generator client { provider = "prisma-client" output = "../../generated/prisma-school" }] – seit Prisma 7 ist das Ausgabeverzeichnis output des generierten Clients Pflicht (frühere Versionen schrieben ihn standardmäßig nach node_modules); Treiberadapter werden standardmäßig verwendet; es ist nicht mehr nötig, sie mit previewFeatures zu aktivieren, wie es bei ihrer Einführung (Versionen 5 und 6) der Fall war;
- Zeile 16: [datasource db { provider = "mysql" }] – Wichtige Änderung in Prisma ORM 7: Der Block
datasource enthält keine Verbindungszeichenfolge mehr (url = env(...), das in den Versionen 5 und 6 erlaubt war, wird von der CLI nun abgelehnt – Fehler P1012, The url property of the datasource is no longer supported in schema files); bei Treiberadaptern wird die gesamte Verbindungskonfiguration (Host, Benutzername, Passwort, Datenbank) zur Laufzeit von PrismaClient übernommen –der provider dient nur noch dazu, dem Generator mitzuteilen, welcher SQL-Dialekt anzusteuern ist;
- Zeile 32: [@@map("students") ... classId Int @map("class_id")] – @map/@@map dienen dazu, die Eigenschaften des Prisma-Modells in camelCase zu benennen (classId) und sie dabei auf bestehende, in snake_case benannte SQL-Spalten abzubilden (class_id) – ein Konventionsunterschied zwischen Prisma, das überall camelCase bevorzugt, und dem bestehenden SQL-Schema;
- Zeile 50: [value Decimal @db.Decimal(4, 2)] – der Typ Decimal von Prisma (nicht zu verwechseln mit number) – siehe die zugehörige Falle beim Skript [prisma-04-stats] weiter unten.
Bevor Sie ihn erstmals verwenden, müssen Sie den Client generieren (einmalig oder jedes Mal, wenn das Schema geändert wird):
npx prisma generate --schema=databases/prisma/schema-persons.prisma
npx prisma generate --schema=databases/prisma/schema-school.prisma
Der generierte Client wird dann mit dem Treiberadapter instanziiert, der explizit konfiguriert wird (mit denselben Zugangsdaten wie in den vorherigen Abschnitten, der Konsistenz halber), statt sich auf die von der CLI gelesene Umgebungsvariable zu stützen:
| import { PrismaMariaDb } from '@prisma/adapter-mariadb';
import { PrismaClient } from '../../generated/prisma-school/client.js';
const adapter = new PrismaMariaDb({
host: 'localhost', user: 'admschool', password: 'pwdschool', database: 'dbschool',
});
const prisma = new PrismaClient({ adapter });
|
7.3.2. Skript [prisma-01]
Erste Verwendung von Prisma: Lesen und Schreiben der Tabelle persons über den generierten Client. Verwendet dasselbe Beispiel wie typeorm-01.ts – vergleichen Sie die beiden Dateien; nur die API ändert sich.
| // databases/prisma/prisma-01.ts
// Erste Verwendung von Prisma ORM: Lesen und Schreiben in der Tabelle
// [persons] über den generierten Client, ohne eine einzige Zeile
// SQL zu schreiben. Verwendet dasselbe Beispiel wie databases/typeorm/typeorm-01.ts,
// um die beiden ORMs an einem identischen Fall zu vergleichen.
//
// Wichtig — diese Datei lässt sich erst nach der Generierung des
// Prisma-Clients kompilieren/ausführen (siehe README):
// npx prisma generate --schema=databases/prisma/schema-persons.prisma
// Dieser Befehl schreibt das unten importierte Modul ../../generated/prisma-persons;
// solange er nicht ausgeführt wurde, existiert dieses Modul nicht.
import { PrismaMariaDb } from '@prisma/adapter-mariadb';
import { PrismaClient } from '../../generated/prisma-persons/client.js';
// Prisma ORM 7 verbindet sich nicht mehr selbst mit der Datenbank: Wir übergeben ihm
// einen "driver adapter" (hier @prisma/adapter-mariadb, der auf dem Paket
// `mariadb` aufbaut), der bereits mit den Verbindungsdaten konfiguriert ist — das
// gleiche Prinzip wie beim DataSource von TypeORM.
const adapter = new PrismaMariaDb({
host: 'localhost',
user: 'admpersons',
password: 'nobody',
database: 'dbpersons',
});
const prisma = new PrismaClient({ adapter });
try {
// alle Personen, nach Nachnamen sortiert
const all = await prisma.person.findMany({ orderBy: { lastName: 'asc' } });
console.log('Persons in the database:');
for (const p of all) {
console.log(` ${p.id} ${p.firstName} ${p.lastName} (${p.age} years old)`);
}
// eine Person anhand ihres Primärschlüssels
const paul = await prisma.person.findUnique({ where: { id: 1 } });
console.log(`Person id=1: ${paul ? `${paul.firstName} ${paul.lastName}` : 'not found'}`);
// Einfügen einer neuen Person — `create` gibt den erstellten Datensatz zurück
const newPerson = await prisma.person.create({
data: { id: 99, firstName: 'Ada', lastName: 'Lovelace', age: 36 },
});
console.log(`Person ${newPerson.id} inserted.`);
// Aktualisierung
const updated = await prisma.person.update({
where: { id: 99 },
data: { age: 37 },
});
console.log(`After update, age=${updated.age}`);
// Löschung — die Datenbank wird in den Zustand zurückversetzt, in dem wir sie vorgefunden haben
await prisma.person.delete({ where: { id: 99 } });
console.log('Person 99 deleted.');
} finally {
await prisma.$disconnect();
}
|
Kommentieren wir diesen Code:
- Zeile 22: [await prisma.person.findMany({ orderBy: { lastName: 'asc' } })] – jedes Modell des Schemas wird zu einer Eigenschaft des Clients (prisma.person) mit standardisierten Methoden – findMany, findUnique, create, update, delete ... –, die allen Modellen gemeinsam sind, unabhängig vom DBMS;
- Zeile 39: [const newPerson = await prisma.person.create({ data: {...} });] – anders als bei TypeORM (new gefolgt von save()) trennt Prisma klar zwischen Erstellen (create) und Aktualisieren (update) – zwei getrennte Methoden statt einer einzigen Methode, die die Absicht errät.
Nach der Ausführung (npx tsx databases/prisma/prisma-01.ts) erzeugt dieses Skript:
Ausgabe:
| Persons in the database:
4 Geraldine Colou (26 years old)
5 Paulette Girond (56 years old)
1 Paul Langevin (48 years old)
2 Sylvie Lefur (70 years old)
3 Pierre Nicazou (35 years old)
Person id=1: Paul Langevin
Person 99 inserted.
After update, age=37
Person 99 deleted.
|
7.3.3. Skript [prisma-02]
Liest die Tabellen „classes/subjects“ aus dbschool, fügt dann einen Schüler hinzu, aktualisiert und löscht ihn. Verwendet dasselbe Beispiel wie typeorm-02.ts.
| // databases/prisma/prisma-02.ts
// Lesen der Tabellen [classes]/[subjects] von [dbschool], dann Hinzufügen, erneutes Lesen
// und Löschen eines Schülers. Verwendet dasselbe Beispiel wie
// databases/typeorm/typeorm-02.ts.
//
// Diese Datei setzt den generierten Client voraus: siehe prisma-01.ts für den Hinweis
// zu `npx prisma generate --schema=databases/prisma/schema-school.prisma`.
import { PrismaMariaDb } from '@prisma/adapter-mariadb';
import { PrismaClient } from '../../generated/prisma-school/client.js';
const adapter = new PrismaMariaDb({
host: 'localhost',
user: 'admschool',
password: 'pwdschool',
database: 'dbschool',
});
const prisma = new PrismaClient({ adapter });
console.log('Prisma connection to [dbschool] established.');
try {
// alle Klassen
console.log('Classes:');
for (const c of await prisma.schoolClass.findMany({ orderBy: { name: 'asc' } })) {
console.log(` ${c.id} ${c.name}`);
}
// alle Fächer mit ihrem Koeffizienten — `coefficient` hat den Typ
// `Decimal` (eine von Prisma bereitgestellte Klasse, keine native JavaScript-`number`);
// wir geben ihn hier direkt aus (sein `toString()` tut das Richtige), aber
// jede Berechnung damit erfordert den Umweg über `.toNumber()` (siehe prisma-04-stats.ts)
console.log('Subjects:');
for (const s of await prisma.subject.findMany({ orderBy: { name: 'asc' } })) {
console.log(` ${s.id} ${s.name} (coefficient ${s.coefficient})`);
}
// Hinzufügen eines neuen Schülers in [class1] — `connect` verknüpft den neuen Schüler
// über ihren Schlüssel mit einer bestehenden Klasse, ohne diese Klasse
// vorher laden zu müssen (anders als die Zuweisung `newStudent.schoolClass = class1`
// bei TypeORM)
const class1 = await prisma.schoolClass.findUniqueOrThrow({ where: { name: 'class1' } });
const newStudent = await prisma.student.create({
data: { id: 999, lastName: 'Curie', firstName: 'Marie', schoolClass: { connect: { id: class1.id } } },
});
console.log(`Student ${newStudent.firstName} ${newStudent.lastName} added to ${class1.name}.`);
// erneutes Lesen — `include` lädt die angeforderte Beziehung (Prisma führt, wie
// TypeORM, standardmäßig kein Lazy Loading durch: Eine Beziehung, die nicht in
// `include` steht, fehlt schlicht im zurückgegebenen Objekt)
const reread = await prisma.student.findUnique({ where: { id: 999 }, include: { schoolClass: true } });
console.log(`Re-read: ${reread?.firstName} ${reread?.lastName}, class=${reread?.schoolClass.name}`);
// Löschung — die Datenbank wird in den Zustand zurückversetzt, in dem wir sie vorgefunden haben
await prisma.student.delete({ where: { id: 999 } });
console.log('Student 999 deleted.');
} finally {
await prisma.$disconnect();
}
|
Kommentieren wir diesen Code:
- Zeile 39: [data: { id: 999, lastName: 'Curie', firstName: 'Marie', schoolClass: { connect: { id: class1.id } } }] –
connect verknüpft den neuen Schüler über ihren Schlüssel mit einer bestehenden Klasse – Prisma bildet den Wert für die Spalte class_id automatisch, sodass wir ihn nicht direkt bearbeiten müssen;
- Zeile 44: [await prisma.student.findUnique({ where: { id: 999 }, include: { schoolClass: true } })] – gleiches Prinzip wie bei TypeORM:
include (statt relations) lädt die angeforderte Beziehung ausdrücklich – auch Prisma führt hier kein implizites Lazy Loading durch.
Nach der Ausführung (npx tsx databases/prisma/prisma-02.ts) erzeugt dieses Skript:
| Prisma connection to [dbschool] established.
Classes:
1 class1
2 class2
Subjects:
1 subject1 (coefficient 1)
2 subject2 (coefficient 2)
Student Marie Curie added to class1.
Re-read: Marie Curie, class=class1
Student 999 deleted.
|
7.3.4. Skript [prisma-03-joined-queries]
Abfragen mit Joins auf dbschool. Enthält exakt dasselbe Beispiel wie typeorm-03-joined-queries.ts – vergleichen Sie die beiden Dateien: Die Logik ist identisch, nur die API ändert sich (mit include statt relations und findUniqueOrThrow/findFirstOrThrow statt findOneOrFail).
| // databases/prisma/prisma-03-joined-queries.ts
// Abfragen mit Joins (`include`) auf [dbschool]. Verwendet genau dasselbe
// Beispiel wie databases/typeorm/typeorm-03-joined-queries.ts — vergleichen Sie die
// beiden Dateien: Die Logik ist identisch, nur die API ändert sich (`include`
// statt `relations`, `findUniqueOrThrow`/`findFirstOrThrow` statt
// `findOneOrFail`).
import { PrismaMariaDb } from '@prisma/adapter-mariadb';
import { PrismaClient } from '../../generated/prisma-school/client.js';
const adapter = new PrismaMariaDb({
host: 'localhost',
user: 'admschool',
password: 'pwdschool',
database: 'dbschool',
});
const prisma = new PrismaClient({ adapter });
try {
// Schüler nach ID, mit seiner Klasse (expliziter Join über `include`)
console.log('student id=11 -----------');
const student11 = await prisma.student.findUniqueOrThrow({ where: { id: 11 }, include: { schoolClass: true } });
console.log(`student={"id":${student11.id},"lastName":"${student11.lastName}","firstName":"${student11.firstName}"}`);
console.log(`student's class: {"id":${student11.schoolClass.id},"name":"${student11.schoolClass.name}"}`);
// die Schüler derselben Klasse (neue Abfrage, mit eigenem Join)
console.log('students in the same class:');
const studentsClass = await prisma.schoolClass.findUniqueOrThrow({
where: { id: student11.schoolClass.id },
include: { students: true },
});
for (const s of studentsClass.students) {
console.log(`student={"id":${s.id},"lastName":"${s.lastName}","firstName":"${s.firstName}"}`);
}
// ein Schüler nach seinem Nachnamen
console.log("student lastName='lastname2' -----------");
const byName = await prisma.student.findFirstOrThrow({ where: { lastName: 'lastname2' }, include: { schoolClass: true } });
console.log(`student={"id":${byName.id},"lastName":"${byName.lastName}","firstName":"${byName.firstName}"}`);
console.log(`student's class: {"id":${byName.schoolClass.id},"name":"${byName.schoolClass.name}"}`);
// die Noten eines Schülers, mit dem Fach jeder Note — verschachteltes `include`,
// Äquivalent zu `relations: { grades: { subject: true } }` von TypeORM
console.log('grades of student id=11 -----------');
const studentWithGrades = await prisma.student.findUniqueOrThrow({
where: { id: 11 },
include: { grades: { include: { subject: true } } },
});
for (const grade of studentWithGrades.grades) {
console.log(`grade={"id":${grade.id},"value":${grade.value}}, subject={"name":"${grade.subject.name}"}`);
}
// die Schüler einer Klasse, nach Klassenname
for (const className of ['class1', 'class2']) {
console.log(`students of class name='${className}' -----------`);
const schoolClass = await prisma.schoolClass.findUniqueOrThrow({ where: { name: className }, include: { students: true } });
for (const s of schoolClass.students) {
console.log(`{"id":${s.id},"lastName":"${s.lastName}","firstName":"${s.firstName}"}`);
}
}
// die Noten in einem Fach, nach Fachname
for (const subjectName of ['subject1', 'subject2']) {
console.log(`subject with name='${subjectName}' -----------`);
const subject = await prisma.subject.findUniqueOrThrow({ where: { name: subjectName }, include: { grades: true } });
console.log(`subject={"name":"${subject.name}","coefficient":${subject.coefficient}}`);
console.log('Grades in the subject: ');
for (const grade of subject.grades) {
console.log(`{"id":${grade.id},"value":${grade.value}}`);
}
}
} finally {
await prisma.$disconnect();
}
|
Kommentieren wir diesen Code:
- Zeile 44: [include: { grades: { include: { subject: true } } }] – ein verschachteltes
include, äquivalent zu relations: { grades: { subject: true } } in TypeORM – ruft in einer einzigen Abfrage die Noten des Schülers und zu jeder Note ihr Fach ab.
Nach der Ausführung (npx tsx .\databases\prisma\prisma-03-joined-queries.ts) erzeugt dieses Skript:
| student id=11 -----------
student={"id":11,"lastName":"lastname1","firstName":"firstname1"}
student's class: {"id":1,"name":"class1"}
students in the same class:
student={"id":11,"lastName":"lastname1","firstName":"firstname1"}
student={"id":21,"lastName":"lastname2","firstName":"firstname2"}
student lastName='lastname2' -----------
student={"id":21,"lastName":"lastname2","firstName":"firstname2"}
student's class: {"id":1,"name":"class1"}
grades of student id=11 -----------
grade={"id":1,"value":10}, subject={"name":"subject1"}
grade={"id":5,"value":6}, subject={"name":"subject2"}
students of class name='class1' -----------
{"id":11,"lastName":"lastname1","firstName":"firstname1"}
{"id":21,"lastName":"lastname2","firstName":"firstname2"}
students of class name='class2' -----------
{"id":32,"lastName":"lastname3","firstName":"firstname3"}
{"id":42,"lastName":"lastname4","firstName":"firstname4"}
subject with name='subject1' -----------
subject={"name":"subject1","coefficient":1}
Grades in the subject:
{"id":1,"value":10}
{"id":2,"value":12}
{"id":3,"value":14}
{"id":4,"value":16}
subject with name='subject2' -----------
subject={"name":"subject2","coefficient":2}
Grades in the subject:
{"id":5,"value":6}
{"id":6,"value":8}
{"id":7,"value":10}
{"id":8,"value":12}
|
Hinweis: Die obigen numerischen Werte erscheinen bei der Interpolation in einen String ohne nachgestellte Dezimalnullen (10 statt 10.00), anders als in der Ausgabe des Skripts [typeorm-03] – ein sichtbares Zeichen dafür, dass grade.value kein String mehr ist, wie es bei TypeORM der Fall ist (siehe das folgende Skript).
7.3.5. Skript [prisma-04-stats]
Berechnet für einen gegebenen Schüler seinen nach den Fachkoeffizienten gewichteten Notendurchschnitt sowie seine minimale und maximale Note. Verwendet dasselbe Beispiel wie typeorm-04-stats.ts.
| // databases/prisma/prisma-04-stats.ts
// Berechnet für einen gegebenen Schüler seinen mit den Koeffizienten der
// Fächer gewichteten Durchschnitt sowie seine minimale und maximale Note. Verwendet dasselbe Beispiel wie
// databases/typeorm/typeorm-04-stats.ts.
//
// Fallstrick, der sich von dem bei TypeORM unterscheidet: Prisma liefert die
// `Decimal`-Spalten (hier `grade.value` und `subject.coefficient`) nicht als
// Zeichenketten zurück, sondern als Instanzen der Klasse `Prisma.Decimal`
// (bereitgestellt von der Bibliothek decimal.js), um keine
// Dezimalgenauigkeit zu verlieren. `typeof grade.value` ist `'object'`, weder `'number'`
// noch `'string'`. Eine Berechnung wie `grade.value * subject.coefficient`
// würde fast zufällig funktionieren (`Decimal` überschreibt `valueOf`), aber
// die bewährte Vorgehensweise — und die unten verwendete — ist, vor jeder
// Gleitkommaberechnung explizit `.toNumber()` aufzurufen.
import { PrismaMariaDb } from '@prisma/adapter-mariadb';
import { PrismaClient } from '../../generated/prisma-school/client.js';
const adapter = new PrismaMariaDb({
host: 'localhost',
user: 'admschool',
password: 'pwdschool',
database: 'dbschool',
});
const prisma = new PrismaClient({ adapter });
// berechnet die Statistiken (gewichteter Durchschnitt, Minimum, Maximum) eines Schülers
async function studentStats(studentId: number): Promise<void> {
// eine einzige Abfrage mit zwei Join-Ebenen (Noten, dann das Fach
// jeder Note), um den Koeffizienten jedes Fachs zu erhalten
const student = await prisma.student.findUniqueOrThrow({
where: { id: studentId },
include: { grades: { include: { subject: true } } },
});
console.log(`Statistics of student {"id":${student.id},"lastName":"${student.lastName}","firstName":"${student.firstName}"}`);
if (student.grades.length === 0) {
console.log(' no grades.');
return;
}
let weightedSum = 0;
let coefficientsSum = 0;
let min = Number.POSITIVE_INFINITY;
let max = Number.NEGATIVE_INFINITY;
for (const grade of student.grades) {
// explizite Umwandlung: `grade.value` und `grade.subject.coefficient`
// sind `Prisma.Decimal`-Werte, keine `number`-Werte
const value = grade.value.toNumber();
const coefficient = grade.subject.coefficient.toNumber();
weightedSum += value * coefficient;
coefficientsSum += coefficient;
min = Math.min(min, value);
max = Math.max(max, value);
console.log(` grade=${value.toFixed(2)} subject="${grade.subject.name}" (coefficient ${coefficient.toFixed(2)})`);
}
const average = weightedSum / coefficientsSum;
console.log(` weighted average=${average.toFixed(2)}, min=${min.toFixed(2)}, max=${max.toFixed(2)}`);
}
try {
// Schüler id=11: Noten subject1=10 (Koeff. 1.0), subject2=6 (Koeff. 2.0)
// gewichteter Durchschnitt = (10*1.0 + 6*2.0) / (1.0+2.0) = 22/3 = 7.33
await studentStats(11);
console.log();
await studentStats(21);
console.log();
await studentStats(32);
console.log();
await studentStats(42);
} finally {
await prisma.$disconnect();
}
|
Kommentieren wir diesen Code:
- Zeile 48: [const value = grade.value.toNumber(); const coefficient = grade.subject.coefficient.toNumber();] – eine Falle, die man kennen sollte und die sich von der bei TypeORM unterscheidet: Prisma liefert Decimal-Spalten nicht als Strings, sondern als Instanzen der Klasse Prisma.Decimal (bereitgestellt von der Bibliothek decimal.js), um keine Dezimalgenauigkeit zu verlieren –
typeof grade.value liefert 'object', nicht 'number' oder 'string'. Empfehlenswert ist es, vor jeder Gleitkommaberechnung ausdrücklich .toNumber() aufzurufen – eine direkte Berechnung wie grade.value * subject.coefficient würde fast zufällig funktionieren (Decimal überschreibt valueOf), bleibt aber eine Praxis, die man vermeiden sollte.
Nach der Ausführung (npx tsx .\databases\prisma\prisma-04-stats.ts) erzeugt dieses Skript:
| Statistics of student {"id":11,"lastName":"lastname1","firstName":"firstname1"}
grade=10.00 subject="subject1" (coefficient 1.00)
grade=6.00 subject="subject2" (coefficient 2.00)
weighted average=7.33, min=6.00, max=10.00
Statistics of student {"id":21,"lastName":"lastname2","firstName":"firstname2"}
grade=12.00 subject="subject1" (coefficient 1.00)
grade=8.00 subject="subject2" (coefficient 2.00)
weighted average=9.33, min=8.00, max=12.00
Statistics of student {"id":32,"lastName":"lastname3","firstName":"firstname3"}
grade=14.00 subject="subject1" (coefficient 1.00)
grade=10.00 subject="subject2" (coefficient 2.00)
weighted average=11.33, min=10.00, max=14.00
Statistics of student {"id":42,"lastName":"lastname4","firstName":"firstname4"}
grade=16.00 subject="subject1" (coefficient 1.00)
grade=12.00 subject="subject2" (coefficient 2.00)
weighted average=13.33, min=12.00, max=16.00
|
7.3.6. Fazit
Bei demselben Beispiel erzeugen TypeORM und Prisma Code von vergleichbarer Länge und Lesbarkeit – die Unterschiede sind hauptsächlich stilistischer Art: dekorierte Klassen und ein Repository bei TypeORM (näher an SQLAlchemy und Spring Data JPA) sowie ein separates deklaratives Schema und ein vollständig generierter Client bei Prisma (im Geiste näher an einem Werkzeug wie Alembic in Kombination mit einem Codegenerator). Beide vermeiden es, SQL zu schreiben, und beide teilen dieselbe Designentscheidung – kein implizites Lazy Loading von Beziehungen –, die sie von SQLAlchemy unterscheidet. Die Wahl zwischen beiden hängt in einem realen Projekt vor allem vom Ökosystem (Prisma Studio, Prisma-Migrationen usw.) und von den Präferenzen des Teams ab.