9. Schichtenarchitektur und Datenzugriff
Die bisherigen Beispiele hielten ihre Daten im Speicher. Eine echte Anwendung speichert sie in einer Datenbank und ist in Schichten gegliedert (siehe das Diagramm in der Einführung):
- die Web-Schicht (Controller, Views): liest die Anfrage, ruft die Geschäftsschicht auf und wählt die View aus;
- die Geschäfts-Schicht: die Geschäftsregeln;
- die DAO-Schicht: die Datenbankabfragen.
Jede Schicht kennt nur die unter ihr liegende Schicht und von dieser so wenige Details wie möglich: Die Web-Schicht kennt die SQL-Schicht nicht, und die Geschäftsschicht kennt die HTML-Schicht nicht. Diese Trennung macht jede Schicht leichter verständlich, testbar und weiterentwickelbar. Beispiel 28 wendet dies auf die Verwaltung einer Personenliste an: Es ist, in kleinerem Maßstab, die Verwaltung der Ärzte und Clients aus der Fallstudie.
9.1. Beispiel 28: Ein Drei-Schichten-System zur Verwaltung von Personen
| 28-layers/
├── database/
│ └── dbpersons.sql
├── public/
│ ├── css/
│ │ └── styles.css
│ └── js/
│ └── app.js
├── src/
│ ├── business/
│ │ ├── business.exception.ts
│ │ └── persons.business.ts
│ ├── config/
│ │ └── database.config.ts
│ ├── dao/
│ │ └── persons.dao.ts
│ ├── entities/
│ │ └── person.entity.ts
│ ├── web/
│ │ ├── flash.ts
│ │ ├── person-form.dto.ts
│ │ ├── persons.controller.ts
│ │ └── validation.ts
│ ├── app.module.ts
│ └── main.ts
├── views/
│ ├── partials/
│ │ └── confirmation.hbs
│ ├── form.hbs
│ ├── layout.hbs
│ └── list.hbs
├── nest-cli.json
└── tsconfig.json
|
9.1.1. Die Datenbank
Die Datenbank [dbpersons] wird durch ein SQL-Skript erstellt. Mit [Laragon] kann es zum Beispiel im Werkzeug [HeidiSQL] ausgeführt werden (Menü Datei / SQL-Datei ausführen) oder über die Befehlszeile:
| mysql -u root < database/dbpersons.sql
|
Die Datei [database/dbpersons.sql]:
| -- Datenbank von Beispiel 28: eine einzige Tabelle, [persons]
DROP DATABASE IF EXISTS dbpersons;
CREATE DATABASE dbpersons CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
USE dbpersons;
CREATE TABLE persons (
id INT NOT NULL AUTO_INCREMENT,
version INT NOT NULL DEFAULT 1,
first_name VARCHAR(30) NOT NULL,
last_name VARCHAR(30) NOT NULL,
age INT NOT NULL,
PRIMARY KEY (id),
-- zwei Personen dürfen nicht denselben Vor- und Nachnamen haben
CONSTRAINT unq_persons_first_name_last_name UNIQUE (first_name, last_name)
) ENGINE = InnoDB;
INSERT INTO persons (first_name, last_name, age) VALUES
('Marie', 'Pélissier', 42),
('Jacques', 'Bromard', 35),
('Philippe', 'Jandot', 58);
|
- Zeile 3: Der Zeichensatz [utf8mb4] akzeptiert alle Zeichen (Akzente, Emojis usw.). Die Kollation [utf8mb4_unicode_ci] vergleicht Zeichenfolgen ohne Rücksicht auf Groß- und Kleinschreibung und auf Akzente: Für MySQL sind [pelissier], und [Pélissier] gleich;
- Zeile 8: eine Versionsnummer, die bei jeder Änderung der Zeile erhöht wird (siehe „optimistisches Sperren“ weiter unten);
- Zeile 14: eine benannte Eindeutigkeitsbedingung: Die Datenbank lässt keine zwei Personen mit demselben Vor- und Nachnamen zu. Der Name dient dazu, den Fehler zu identifizieren.
9.1.2. Die Konfiguration von TypeORM
Die Datei [src/config/database.config.ts]:
| import { TypeOrmModuleOptions } from '@nestjs/typeorm';
import { Person } from '../entities/person.entity';
// die Datenbankverbindung; die Standardwerte sind die von Laragon
export function databaseConfig(): TypeOrmModuleOptions {
return {
type: 'mysql',
host: process.env.DB_HOST ?? 'localhost',
port: Number(process.env.DB_PORT ?? 3306),
username: process.env.DB_USERNAME ?? 'root',
password: process.env.DB_PASSWORD ?? '',
database: 'dbpersons',
entities: [Person],
// das Schema wird vom SQL-Skript erstellt und nie von TypeORM geändert
synchronize: false,
// DB_LOGGING=true: zeigt die an die Datenbank gesendeten SQL-Anweisungen an
logging: process.env.DB_LOGGING === 'true',
};
}
|
- Zeilen 8–11: Verbindungsparameter, gelesen aus Umgebungsvariablen, mit den Standardwerten von [Laragon] (Benutzername [root], kein Passwort);
- Zeile 13: die Klassen, die [TypeORM] auf Tabellen abbildet;
- Zeile 15: [TypeORM] könnte die Tabellen anhand der Klassen selbst erstellen oder ändern. Das ist für einen Prototyp praktisch, für eine Datenbank mit Daten aber gefährlich: Das Schema bleibt in der Verantwortung des SQL-Skripts;
- Zeile 17: Mit der Umgebungsvariablen [DB_LOGGING=true] werden die an die Datenbank gesendeten SQL-Befehle in der Konsole angezeigt.
9.1.3. Die Entität Person
Die Datei [src/entities/person.entity.ts]:
| import { Column, Entity, PrimaryGeneratedColumn, VersionColumn } from 'typeorm';
// eine Zeile der Tabelle [persons] <-> ein Person-Objekt
@Entity('persons')
export class Person {
@PrimaryGeneratedColumn()
id: number;
// wird von TypeORM bei jeder Änderung erhöht (optimistisches Sperren)
@VersionColumn()
version: number;
@Column({ name: 'first_name', length: 30 })
firstName: string;
@Column({ name: 'last_name', length: 30 })
lastName: string;
@Column()
age: number;
}
|
- Zeile 4: Die Klasse [Person] entspricht der Tabelle [persons]: Jede Zeile der Tabelle wird ein [Person]-Objekt;
- Zeile 6: der Primärschlüssel, von der Datenbank erzeugt ([AUTO_INCREMENT]);
- Zeile 10: die Versionsspalte, verwaltet von [TypeORM];
- Zeilen 13–20: die übrigen Spalten.
9.1.4. Die DAO-Schicht
Die Datei [src/dao/persons.dao.ts]:
| import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { EntityManager, Not, Repository } from 'typeorm';
import { Person } from '../entities/person.entity';
// die DATENZUGRIFFS-Schicht: Abfragen, keine Geschäftsregeln
@Injectable()
export class PersonsDao {
constructor(@InjectRepository(Person) private readonly repository: Repository<Person>) {}
// innerhalb einer Transaktion müssen wir über den "manager" der Transaktion gehen
private repo(manager?: EntityManager): Repository<Person> {
return manager ? manager.getRepository(Person) : this.repository;
}
list(): Promise<Person[]> {
return this.repository.find({ order: { lastName: 'ASC', firstName: 'ASC' } });
}
read(id: number, manager?: EntityManager): Promise<Person | null> {
return this.repo(manager).findOneBy({ id });
}
// eine ANDERE Person (id verschieden von [exceptId]) mit diesem Vor- und Nachnamen
namesake(firstName: string, lastName: string, exceptId: number, manager?: EntityManager): Promise<Person | null> {
return this.repo(manager).findOneBy({ firstName, lastName, id: Not(exceptId) });
}
// INSERT, wenn die Person keine id hat, sonst UPDATE
save(person: Person, manager?: EntityManager): Promise<Person> {
return this.repo(manager).save(person);
}
async delete(id: number, manager?: EntityManager): Promise<void> {
await this.repo(manager).delete(id);
}
}
|
- Zeile 9: [TypeORM] stellt für jede Entität ein Repository ([Repository<Person>]) bereit, das die Tabelle lesen und beschreiben kann. [@InjectRepository] injiziert es;
- Zeilen 12–14: Innerhalb einer Transaktion müssen alle Abfragen über dasselbe [EntityManager]-Objekt laufen – das der Transaktion zugeordnete. Jede Methode akzeptiert deshalb einen optionalen [manager];
- Zeilen 16–18: [find] mit Sortierung: [SELECT ... ORDER BY last_name, first_name];
- Zeilen 25–27: eine Person mit demselben Vor- und Nachnamen, die nicht [exceptId] ([Not]) ist: nützlich beim Ändern eines Datensatzes, der nicht mit sich selbst in Konflikt geraten darf;
- Zeilen 30–32: [save] wird zu [INSERT] , wenn das Objekt keine Kennung hat, andernfalls zu [UPDATE].
Die DAO-Schicht enthält keine Regeln: nur Abfragen.
9.1.5. Die Geschäftsschicht
Die Datei [src/business/business.exception.ts]:
| // eine Geschäftsregel lehnt die Operation ab: das ist keine Anomalie,
// die Meldung ist für den Benutzer bestimmt
export class BusinessException extends Error {}
|
Eine [BusinessException] zeigt an, dass eine Geschäftsregel eine Operation abgelehnt hat. Das ist kein Programmfehler: Die Meldung ist für den Benutzer bestimmt.
Die Datei [src/business/persons.business.ts]:
| import { Injectable } from '@nestjs/common';
import { DataSource, EntityManager } from 'typeorm';
import { PersonsDao } from '../dao/persons.dao';
import { Person } from '../entities/person.entity';
import { BusinessException } from './business.exception';
export interface PersonData {
firstName: string;
lastName: string;
age: number;
}
// die GESCHÄFTSSCHICHT: die Geschäftsregeln, und nur sie
@Injectable()
export class PersonsBusiness {
constructor(
private readonly dao: PersonsDao,
private readonly dataSource: DataSource,
) {}
list(): Promise<Person[]> {
return this.dao.list();
}
async read(id: number): Promise<Person> {
const person = await this.dao.read(id);
if (!person) {
throw new BusinessException('This person does not exist (anymore).');
}
return person;
}
add(data: PersonData): Promise<Person> {
return this.transaction(async (manager) => {
// Regel 1: keine zwei Personen mit demselben Vor- und Nachnamen
if (await this.dao.namesake(data.firstName, data.lastName, 0, manager)) {
throw new BusinessException('A person already has these first and last names.');
}
const person = new Person();
person.firstName = data.firstName;
person.lastName = data.lastName;
person.age = data.age;
return this.dao.save(person, manager);
});
}
edit(id: number, version: number, data: PersonData): Promise<Person> {
return this.transaction(async (manager) => {
const person = await this.dao.read(id, manager);
if (!person) {
throw new BusinessException('This person does not exist (anymore).');
}
// Regel 2: wir ändern keinen Datensatz, der in der Zwischenzeit von jemand anderem geändert wurde
if (person.version !== version) {
throw new BusinessException('This record has been modified meanwhile: reload it.');
}
if (await this.dao.namesake(data.firstName, data.lastName, id, manager)) {
throw new BusinessException('A person already has these first and last names.');
}
person.firstName = data.firstName;
person.lastName = data.lastName;
person.age = data.age;
return this.dao.save(person, manager);
});
}
async delete(id: number): Promise<Person> {
const person = await this.read(id);
await this.dao.delete(id);
return person;
}
// [work] läuft innerhalb einer Transaktion: COMMIT bei Erfolg, ROLLBACK
// wenn eine Exception geworfen wird. Eine Verletzung der Eindeutigkeitsbedingung (zum Beispiel zwei
// gleichzeitige Hinzufügungen) wird zu einer BusinessException
private async transaction<R>(work: (manager: EntityManager) => Promise<R>): Promise<R> {
try {
return await this.dataSource.transaction(work);
} catch (e) {
const sqlError = e as { code?: string; message?: string };
if (sqlError.code === 'ER_DUP_ENTRY' && sqlError.message?.includes('unq_persons_first_name_last_name')) {
throw new BusinessException('A person already has these first and last names.');
}
throw e;
}
}
}
|
Gehen wir diesen Code im Einzelnen durch:
- Zeilen 16–19: Die Geschäftsschicht verwendet das DAO sowie [DataSource] von [TypeORM] (die Datenbankverbindung), um Transaktionen zu öffnen;
- Zeilen 25–31: Eine nicht vorhandene Person ist eine [BusinessException];
- Zeilen 33–45: das Hinzufügen einer Person innerhalb einer Transaktion. Regel: Keine zwei Personen dürfen denselben Vor- und Nachnamen haben. Dies wird vor der Schreiboperation geprüft, um eine klare Meldung anzuzeigen;
- Zeilen 47–65: die Änderung. Zusätzliche Regel: das optimistische Sperren (Zeilen 54–56): Das Änderungsformular trägt die Version des Datensatzes, wie sie beim Öffnen des Formulars war. Hat sie sich in der Zwischenzeit geändert (ein anderer Benutzer hat denselben Datensatz geändert), wird die Operation abgelehnt, statt die Arbeit des Benutzers stillschweigend zu überschreiben;
- Zeilen 76–86: [dataSource.transaction(work)] öffnet eine Transaktion, führt [work] aus und bestätigt sie dann ([COMMIT]) oder macht sie rückgängig ([ROLLBACK]), wenn [work] eine Exception auslöst. Zeilen 81–82: Die vorherige Prüfung auf Namensvettern reicht nicht immer aus: Zwei Benutzer können dieselbe Person gleichzeitig hinzufügen, und beide können die Prüfung bestehen. Die Eindeutigkeitsbedingung der Datenbank lässt dagegen keine Ausnahmen zu; der MySQL-Fehler [ER_DUP_ENTRY], durch die Bedingung identifiziert, wird dann zur selben [BusinessException].
9.1.6. Die Web-Schicht
Die Datei [src/web/person-form.dto.ts]:
| import { Transform, Type } from 'class-transformer';
import { IsInt, IsNotEmpty, Max, MaxLength, Min } from 'class-validator';
const clean = ({ value }: { value: unknown }) => (typeof value === 'string' ? value.trim() : value);
// die Felder des Formulars und ihre Constraints (Längen = SQL-Spalten)
export class PersonFormDto {
@Transform(clean)
@IsNotEmpty({ message: 'The first name is required.' })
@MaxLength(30, { message: 'The first name must not exceed 30 characters.' })
firstName: string;
@Transform(clean)
@IsNotEmpty({ message: 'The last name is required.' })
@MaxLength(30, { message: 'The last name must not exceed 30 characters.' })
lastName: string;
@Type(() => Number)
@IsInt({ message: 'The age must be an integer.' })
@Min(0, { message: 'The age must be positive.' })
@Max(150, { message: 'The age cannot exceed 150.' })
age: number;
}
|
Das Formular und seine Bedingungen (siehe Beispiel 19). Die Funktion [validateForm] (Datei [web/validation.ts]) ist die aus Beispiel 19, und [web/flash.ts] ist die aus Beispiel 20, ergänzt um einen Meldungstyp (Erfolg oder Fehler).
Die Datei [src/web/persons.controller.ts]:
| import { Body, Controller, Get, Param, ParseIntPipe, Post, Redirect, Render, Res } from '@nestjs/common';
import { Response } from 'express';
import { BusinessException } from '../business/business.exception';
import { PersonsBusiness } from '../business/persons.business';
import { flash } from './flash';
import { PersonFormDto } from './person-form.dto';
import { validateForm } from './validation';
// die WEB-Schicht: die Anfrage lesen, die Geschäftsschicht aufrufen, die View wählen
@Controller()
export class PersonsController {
constructor(private readonly business: PersonsBusiness) {}
@Get()
@Redirect('/persons')
root(): void {}
@Get('persons')
@Render('list')
async list(): Promise<object> {
return { persons: await this.business.list() };
}
@Get('persons/add')
@Render('form')
addForm(): object {
return { title: 'Add a person', action: '/persons/add', values: {}, errors: {} };
}
@Post('persons/add')
async add(@Body() body: Record<string, string>, @Res() res: Response): Promise<void> {
const view = { title: 'Add a person', action: '/persons/add' };
const { dto, errors } = await validateForm(PersonFormDto, body);
if (Object.keys(errors).length > 0) {
res.render('form', { ...view, values: body, errors, error: 'The form contains errors.' });
return;
}
try {
const p = await this.business.add(dto);
flash(res, { type: 'success', text: `${p.firstName} ${p.lastName} has been added.` });
res.redirect('/persons');
} catch (e) {
// eine Geschäftsregel hat das Hinzufügen abgelehnt: wir zeigen das Formular erneut an
if (!(e instanceof BusinessException)) throw e;
res.render('form', { ...view, values: body, errors: {}, error: e.message });
}
}
@Get('persons/:id/edit')
@Render('form')
async editForm(@Param('id', ParseIntPipe) id: number): Promise<object> {
const p = await this.business.read(id);
return { title: 'Edit a person', action: `/persons/${id}/edit`, values: p, errors: {} };
}
@Post('persons/:id/edit')
async edit(
@Param('id', ParseIntPipe) id: number,
@Body() body: Record<string, string>,
@Res() res: Response,
): Promise<void> {
const view = { title: 'Edit a person', action: `/persons/${id}/edit` };
const { dto, errors } = await validateForm(PersonFormDto, body);
if (Object.keys(errors).length > 0) {
res.render('form', { ...view, values: body, errors, error: 'The form contains errors.' });
return;
}
try {
const p = await this.business.edit(id, Number(body.version), dto);
flash(res, { type: 'success', text: `${p.firstName} ${p.lastName} has been modified.` });
res.redirect('/persons');
} catch (e) {
if (!(e instanceof BusinessException)) throw e;
res.render('form', { ...view, values: body, errors: {}, error: e.message });
}
}
@Post('persons/:id/delete')
async delete(@Param('id', ParseIntPipe) id: number, @Res() res: Response): Promise<void> {
try {
const p = await this.business.delete(id);
flash(res, { type: 'success', text: `${p.firstName} ${p.lastName} has been deleted.` });
} catch (e) {
if (!(e instanceof BusinessException)) throw e;
// kein Formular, das erneut anzuzeigen wäre: der Fehler wird ebenfalls als Flash übermittelt
flash(res, { type: 'danger', text: e.message });
}
res.redirect('/persons');
}
}
|
Kommentieren wir diesen Code:
- Zeile 12: Der Controller kennt nur die Geschäftsschicht;
- Zeilen 14–16: Die Wurzel der Website leitet auf die Liste um;
- Zeilen 18–22: eine asynchrone Action: Die Liste wird aus der Datenbank abgerufen;
- Zeilen 30–47: das Hinzufügen in drei Schritten: Formularvalidierung (Fehler → Seite wird neu geladen), Aufruf der Geschäftsschicht (Erfolg → Pop-up-Meldung und Umleitung), [BusinessException] (→ Seite wird mit der Meldung am Seitenende neu geladen). Eine andere Exception wird erneut ausgelöst ([throw e]): Das ist eine Anomalie, die der Exception-Filter von [NestJS] in einen 500-Fehler umwandelt;
- Zeilen 49–54: das Änderungsformular, vorausgefüllt mit dem aus der Datenbank abgerufenen Datensatz (einschließlich seiner Version);
- Zeilen 56–61: derselbe Ablauf wie beim Hinzufügen; die vom Formular zurückgelieferte Version wird an die Geschäftsschicht übergeben;
- Zeilen 78–89: das Löschen. Es gibt kein Formular, das erneut angezeigt werden müsste: Eventuelle Fehler sind ebenfalls in der Flash-Nachricht enthalten.
Die Datei [src/app.module.ts]:
| import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { databaseConfig } from './config/database.config';
import { PersonsDao } from './dao/persons.dao';
import { Person } from './entities/person.entity';
import { PersonsBusiness } from './business/persons.business';
import { PersonsController } from './web/persons.controller';
@Module({
imports: [
// die Datenbankverbindung, für die gesamte Anwendung
TypeOrmModule.forRoot(databaseConfig()),
// das Repository<T>, das in diesem Modul injizierbar ist
TypeOrmModule.forFeature([Person]),
],
controllers: [PersonsController],
// die drei Schichten: Web (Controller) -> Geschäft -> DAO
providers: [PersonsBusiness, PersonsDao],
})
export class AppModule {}
|
- Zeile 12: die Datenbankverbindung für die gesamte Anwendung;
- Zeile 14: ermöglicht die Injektion des [Repository<Person>];
- Zeile 18: die Services der Geschäftsschicht und das DAO.
Die Datei [views/form.hbs]:
| <h1 class="h3">{{title}}</h1>
<form method="post" action="{{action}}" novalidate>
{{!-- die Version des gelesenen Datensatzes, die mit der Änderung zurückgesendet wird --}}
<input type="hidden" name="version" value="{{values.version}}">
<div class="row g-2 mb-3">
<div class="col-sm-5">
<label class="form-label" for="firstName">First name</label>
<input class="form-control {{#if errors.firstName}}is-invalid{{/if}}" id="firstName" name="firstName"
value="{{values.firstName}}" maxlength="30" required>
{{#if errors.firstName}}<div class="invalid-feedback">{{errors.firstName}}</div>{{/if}}
</div>
<div class="col-sm-5">
<label class="form-label" for="lastName">Last name</label>
<input class="form-control {{#if errors.lastName}}is-invalid{{/if}}" id="lastName" name="lastName"
value="{{values.lastName}}" maxlength="30" required>
{{#if errors.lastName}}<div class="invalid-feedback">{{errors.lastName}}</div>{{/if}}
</div>
<div class="col-sm-2">
<label class="form-label" for="age">Age</label>
<input class="form-control {{#if errors.age}}is-invalid{{/if}}" id="age" name="age" type="number"
value="{{values.age}}" required>
{{#if errors.age}}<div class="invalid-feedback">{{errors.age}}</div>{{/if}}
</div>
</div>
<button class="btn btn-primary" type="submit">Save</button>
<a class="btn btn-link" href="/persons">Back to the list</a>
</form>
|
Zeile 4: das versteckte Feld, das die Version des Datensatzes trägt. Die View wird zum Hinzufügen und zum Ändern von Datensätzen verwendet: Ihr Titel und die URL für das Absenden ([action]) werden vom Controller bereitgestellt. Die Views [list.hbs] und [layout.hbs]sowie das Bestätigungsskript sind dieselben wie in den Beispielen 20 und 21.
9.1.7. Ausführung
Die Verbindungsparameter werden über Umgebungsvariablen übergeben, wenn die Standardwerte nicht passen. Unter [Windows] ([PowerShell]):
| $env:DB_USERNAME="root"; $env:DB_PASSWORD=""; $env:DB_LOGGING="true"; npx nest start
|
Die Liste:

Ein ungültiges Formular:

Ein Namensvetter, in Kleinbuchstaben und ohne Akzente geschrieben: Die Geschäftsregel erkennt ihn, weil MySQL anhand der Kollation der Datenbank vergleicht:

Ein erfolgreiches Hinzufügen und die zugehörigen SQL-Befehle ([DB_LOGGING=true]):

| query: START TRANSACTION
query: SELECT `Person`.`id` AS `Person_id`, `Person`.`version` AS `Person_version`, `Person`.`first_name` AS `Person_first_name`, `Person`.`last_name` AS `Person_last_name`, `Person`.`age` AS `Person_age` FROM `persons` `Person` WHERE ((`Person`.`first_name` = ?) AND (`Person`.`last_name` = ?) AND (`Person`.`id` != ?)) LIMIT 1 -- PARAMETERS: ["Sylvie","Durand",0]
query: INSERT INTO `persons`(`id`, `version`, `first_name`, `last_name`, `age`) VALUES (DEFAULT, 1, ?, ?, ?) -- PARAMETERS: ["Sylvie","Durand",29]
query: SELECT `Person`.`id` AS `Person_id`, `Person`.`version` AS `Person_version` FROM `persons` `Person` WHERE `Person`.`id` = ? -- PARAMETERS: [4]
query: COMMIT
query: SELECT `Person`.`id` AS `Person_id`, `Person`.`version` AS `Person_version`, `Person`.`first_name` AS `Person_first_name`, `Person`.`last_name` AS `Person_last_name`, `Person`.`age` AS `Person_age` FROM `persons` `Person` ORDER BY `Person`.`last_name` ASC, `Person`.`first_name` ASC
|
Wir sehen die Transaktion ([START TRANSACTION] ... [COMMIT]), die Suche nach Duplikaten, das Einfügen mit Version 1 und nach der Umleitung das Lesen der Liste. Das optimistische Sperren: Zwei Formulare sind für denselben Datensatz geöffnet; das erste wird gespeichert (die Version wechselt auf 2); das zweite, das noch Version 1 hat, wird abgelehnt:

Löschen mit Bestätigung:

