kind: reference

ER-Modelle als Text

Wie du ein ER-Modell in einer .er-Datei schreibst, was die ER-Werkstatt daraus macht und wie sie Beziehungen in Tabellen übersetzt. Zum Nachschlagen; ein Feld zum Ausprobieren steht gleich darunter.

1. Ausprobieren

Schreib links ein Modell; rechts erscheint es als Diagramm, darunter die Tabellen und das SQL. Hier wird nichts gespeichert. Für deine eigenen Modelle nimmst du eine .er-Datei in VS Code.

SQL

So wurde übersetzt

2. Ein Modell schreiben

Aufbau einer Datei

Eine .er-Datei besteht aus Entitäten und Beziehungen, in beliebiger Reihenfolge. Was hinter # steht, ist ein Kommentar. Leere Zeilen sind egal.

# Filme und ihre Genres
entity movie
  id: int, primary key
  title: text

entity genre
  id: int, primary key
  name: text, unique

relationship has_genre: movie n:m genre

Alle Namen schreibst du klein, mit Buchstaben, Ziffern und _, ohne Leerzeichen und Umlaute: german_title, nicht deutscher Titel. Aus den Namen werden später Tabellen und Spalten. Die Schlüsselwörter sind Englisch: entity, relationship, primary key, optional, unique, as.

Entitäten und Attribute

entity name beginnt eine Entität. Jede eingerückte Zeile darunter ist ein Attribut: name: typ und danach, mit Kommas, Markierungen.

Typ	Bedeutung	In MySQL
`int`	ganze Zahl	`INT`
`text`	Text bis 255 Zeichen	`VARCHAR(255)`
`varchar(n)`	Text bis `n` Zeichen	`VARCHAR(n)`
`decimal(p,s)`	Kommazahl mit `p` Stellen, davon `s` nach dem Komma, z. B. `decimal(6,2)` für Preise	`DECIMAL(p,s)`
`float`	Kommazahl, ungefähr	`FLOAT`
`date`	Datum	`DATE`
`datetime`	Datum mit Uhrzeit	`DATETIME`
`bool`	wahr oder falsch	`BOOLEAN`

Markierung	Bedeutung
`primary key`	gehört zum Primärschlüssel: bestimmt jeden Datensatz eindeutig. Jede Entität braucht einen. Mehrere Attribute mit `primary key` bilden ihn zusammen. Das ältere `key` funktioniert noch, die ER-Werkstatt schlägt dann `primary key` vor.
`optional`	darf leer bleiben (`NULL`). Ohne die Markierung muss immer ein Wert da sein (`NOT NULL`).
`unique`	kein Wert darf doppelt vorkommen

entity book
  isbn: varchar(17), primary key
  title: text
  price: decimal(6,2), optional
  published: date

Beziehungen und Kardinalitäten

relationship name: entity_a KARDINALITÄT entity_b

Die Kardinalität sagt, mit wie vielen Datensätzen der anderen Seite einer verbunden sein kann. Du liest sie in Schreibrichtung:

Kardinalität	Lies	Beispiel
`1:1`	zu einem `a` gehört höchstens ein `b` und umgekehrt	`relationship holds: person 1:1 passport`
`1:n`	zu einem `a` gehören viele `b`, zu einem `b` ein `a`	`relationship writes: author 1:n book`
`n:1`	wie `1:n`, nur andersherum geschrieben	`relationship lives_in: student n:1 city`
`n:m`	auf beiden Seiten viele	`relationship takes: student n:m course`

Eine Beziehung kann eine Entität mit sich selbst verbinden: relationship friend: person n:m person.

Drei oder mehr Entitäten zählst du mit Kommas auf. So eine Beziehung braucht immer eine eigene Tabelle:

relationship credit: movie, crew, job as movie_crew

Attribute einer Beziehung stehen eingerückt darunter, wie bei einer Entität. Sie landen in der Tabelle, die die Beziehung speichert:

relationship takes: student n:m course
  grade: int, optional

Eigener Tabellenname: Mit as name am Ende bestimmst du, wie die Tabelle einer Beziehung heißt.

3. Was die ER-Werkstatt daraus macht

Vom Modell zu Tabellen

So übersetzt die ER-Werkstatt ein Modell. In der Vorschau steht es für dein Modell unter »So wurde übersetzt«.

Im Modell	In der Datenbank
Entität	eine Tabelle mit demselben Namen; die Attribute mit `primary key` bilden den Primärschlüssel
`1:n` oder `n:1`	keine eigene Tabelle. Die Tabelle auf der n-Seite bekommt einen Fremdschlüssel auf die 1-Seite, z. B. `city_id` in `student`. Er darf nicht leer sein.
`1:1`	keine eigene Tabelle. Die zweite Entität bekommt einen Fremdschlüssel auf die erste, mit `UNIQUE`
`n:m`	eine eigene Tabelle `a_b` (z. B. `movie_genre`) mit den Schlüsseln beider Seiten als Fremdschlüssel; zusammen sind sie der Primärschlüssel
drei oder mehr Entitäten	eine eigene Tabelle, benannt nach allen Entitäten oder nach `as`; alle Fremdschlüssel zusammen sind der Primärschlüssel
Beziehung einer Entität mit sich selbst	`n:m`: eine Tabelle mit dem Namen der Beziehung und den Spalten `from_…_id` und `to_…_id`. `1:n`: ein Fremdschlüssel wie `mentor_person_id` (Name der Beziehung, dann der Tabelle), der leer sein darf
Attribut einer Beziehung	eine Spalte in der Tabelle, die die Beziehung speichert

Ein Fremdschlüssel heißt nach der Tabelle, auf die er zeigt, und deren Schlüssel: movie_id zeigt auf movie.id.

Die drei Diagramme

Ansicht	Was du siehst
Chen	Rechteck = Entität, Raute = Beziehung, Ellipse = Attribut, unterstrichen = Schlüssel. An den Linien steht die Kardinalität.
Krähenfuß	Kästen mit Attributen; am Linienende ein Strich für »eins«, ein Krähenfuß für »viele«. Eine n:m-Beziehung ist noch eine Linie.
Tabellen	die Tabellen, wie sie in der Datenbank entstehen: jede n:m-Beziehung ist eine eigene Tabelle. `PK` = Primärschlüssel, `FK` = Fremdschlüssel.

4. Werkzeuge

Die ER-Werkstatt in VS Code

Eine Datei mit der Endung .er öffnet VS Code mit der ER-Werkstatt.

Was	Wie
Fehler	rot unterstrichen, mit Erklärung unter der Maus; alle im Bereich »Probleme« (`StrgShiftM`)
Diagramm anzeigen	»ER-Diagramm anzeigen« oben rechts im Editor, oder `StrgK`, dann `V`
Kästen verschieben	mit der Maus; die Positionen stehen in der versteckten Datei `.name.er.layout.json` neben dem Modell. »Neu anordnen« ordnet alles wieder automatisch an.
SQL erzeugen	»SQL erzeugen« schreibt `name.sql` neben das Modell. Eine Datei, die nicht von der ER-Werkstatt stammt, wird nur nach Rückfrage überschrieben.
Tabellen anlegen	im Terminal: `mysql < name.sql`. Die Datei beginnt mit `DROP TABLE IF EXISTS`: Vorhandene Tabellen mit diesen Namen werden samt Inhalt gelöscht und neu angelegt.
Diagramm sichern	»Als SVG speichern« schreibt `name-chen.svg`, `name-crowfoot.svg` oder `name-tables.svg`

Auf der Kommandozeile

Die ER-Werkstatt ist eine JavaScript-Datei, die auch ohne VS Code läuft, zum Beispiel für Skripte. Im Workspace liegt sie im Ordner der Erweiterung; die Quelle ist src/vscode-extensions/er/core/er-core.js im Repository des Workspaces.

Merke dir den Pfad zuerst in einer Variablen:

ER=$(ls /workspace/.extensions/hackschule.hackschule-er-*/core/er-core.js | tail -1)

Dann erzeugt node $ER dasselbe wie die Befehle in VS Code:

node $ER --sql film.er > film.sql
node $ER --svg tables film.er > film-tables.svg
node $ER --json film.er