Zur Dokumentation springen

VOM SCHEMA ZUM DIAGRAMM

SQL zu ERD: Leitfaden

Verwandeln Sie Ihr Datenbankschema in ein Diagramm. Lernen Sie unterstütztes SQL kennen, zeigen Sie Daten an und fragen Sie Ihr Modell ab.

SQL DDL → ER-DiagrammSQL zu ERD öffnen
ERSTE SCHRITTE

KI-bereiter SQL-Syntaxvertrag

Verwende diese Seite als kompakten Vertrag, wenn du eine KI bittest, SQL für Erd Go zu schreiben oder zu bearbeiten. Bevorzuge die untenstehenden Syntaxmuster, halte Anweisungen vollständig und mit Semikolon abgeschlossen und vermeide nicht unterstützte Datenbankobjekte, es sei denn, du benötigst nur rohes SQL außerhalb von Erd Go. SQLite-, PostgreSQL-, MySQL- und MSSQL-Syntax werden im untenstehenden gemeinsamen Teilbereich unterstützt. Die SQL-zu-ERD-Konvertierung läuft vollständig im Browser, und ihre Parser- und Vorschaumengines sind durch Tausende von Unit- und Integrationstests abgesichert, die reale Produktionsschemas (SaaS, Banking, Social, Analytics, EHR) abdecken.

SQLite

INTEGER PRIMARY KEY rowid-Regeln, typenlose Spalten, AUTOINCREMENT, WITHOUT ROWID, validierte STRICT-Tabellen, FK-Aktionen und Migrationswiederholung

PostgreSQL

ENUM- und verbundene Typen (composite types), Arrays, JSONB, SERIAL, Identitätsspalten (identity columns), NULLS NOT DISTINCT, Ausdrucksindizes (expression indexes), Schemaidentität und Groß-/Kleinschreibung bei Namen in Anführungszeichen

MySQL

AUTO_INCREMENT, Inline-ENUM & SET, Backticks, COMMENT, UNSIGNED/SIGNED, Inline-Indizes, CHANGE/MODIFY COLUMN und FIRST/AFTER-Platzierung

MSSQL

IDENTITY, NVARCHAR(MAX), geklammerte Namen, geclusterte Indizes, GO-Batches, ALTER COLUMN, berechnete Spalten, benannte Standards und temporale Zeiträume

DDL

CREATE TYPE, CREATE TABLE, ALTER TABLE Migration-Wiederholung, CREATE INDEX und sichere DROP-Anweisungen für die Schemageometrie

DML / SELECT

INSERT, UPDATE, DELETE für Vorschaudaten sowie schreibgeschützte SELECT-Syntax für Joins, CTEs, Aggregate, Fenster und Berichte

Schnellstart

Verwende dies als Modellantwort, wenn du eine KI nach Erd-Go-kompatiblem SQL fragst: zuerst benutzerdefinierte Typen, dann Tabellen, danach Beziehungseinschränkungen nach den Tabellen, wenn dies nützlich ist, und schließlich Beispiels-DML. Halte Nur-Lese-SELECT-Abfragen separat.

PostgreSQL / PostgreSQL Schnellstart
-- Define custom types
CREATE TYPE status_enum AS ENUM (
  'active', 'inactive', 'suspended'
);

-- Create tables with constraints
CREATE TABLE departments (
  id SERIAL PRIMARY KEY,
  name VARCHAR(100) NOT NULL UNIQUE
);

CREATE TABLE employees (
  id SERIAL PRIMARY KEY,
  name VARCHAR(100) NOT NULL,
  email TEXT UNIQUE NOT NULL,
  status status_enum DEFAULT 'active',
  department_id INTEGER,
  salary NUMERIC(10, 2) DEFAULT 0
);

-- Add constraints via ALTER TABLE
ALTER TABLE employees
  ADD CONSTRAINT fk_dept
  FOREIGN KEY (department_id)
  REFERENCES departments(id);

-- Add sample data after schema DDL
INSERT INTO departments (id, name) VALUES
  (1, 'Engineering'),
  (2, 'Design');

INSERT INTO employees (id, name, email, status, department_id, salary) VALUES
  (1, 'Alice', '[email protected]', 'active', 1, 1500.00),
  (2, 'Bob', '[email protected]', 'inactive', 2, 1200.00);

UPDATE employees
  SET status = 'active'
  WHERE id = 2;
Schema-Syntax: Beziehungen können entweder inline deklariert werden REFERENCES oder ALTER TABLE ADD FOREIGN KEY. Beide Formen tragen dieselben Beziehungsmetadaten bei.
DML-Syntax: Setzen INSERT, UPDATE, und DELETE nach dem Schema-DDL. Das Skript wird von oben nach unten ausgewertet, sodass Beispielzeilen auf Tabellen und Typen verweisen sollten, die bereits existieren.
SELECT-Syntax: Halten Sie schreibgeschützte Berichtsabfragen getrennt von Mutationsskripten. Sie sollten nur auf Tabellen und Zeilen verweisen, die vom Schema/DML-Skript erzeugt wurden.
SQL / Beispiel
SELECT e.name, d.name AS department, e.salary
FROM employees e
JOIN departments d ON d.id = e.department_id
WHERE e.status = 'active'
ORDER BY e.salary DESC;

SQL-Tabs & Dateiimport

Starten Sie eine neue SQL-Datei mit einem Beispiel, einem leeren Schema-Tab oder Importieren Sie SQL-Dateien. Das Beispiel trennt Schema und Daten in Tabs. „SQL-Tab hinzufügen“ erstellt einen weiteren Editor-Tab; doppelklicken Sie auf den Titel, um ihn umzubenennen.

Aktive Tabs werden für ERD, Datenansicht, Abfrageansicht und KI-Anfragen in ihrer sichtbaren Reihenfolge zusammen kompiliert. Ein inaktiver Tab bleibt ein gespeicherter Entwurf und ist von diesen Arbeitsabläufen ausgeschlossen. Platzieren Sie Typen und Tabellen vor Anweisungen, die von ihnen abhängen.

SQL-Dateien importieren akzeptiert mehrere Text-SQL-Dateien und überprüft Parsing-Probleme gemeinsam vor dem Import. Dies hilft beim Auflösen von Referenzen zwischen Dateien. Verwenden Sie die Tabulatorreihenfolge, um Abhängigkeiten und Migrationsschritte beabsichtigt zu halten.

Verwenden Sie die Pfeiltasten sowie Pos1/Ende in der Reiterleiste, um zwischen Reitern zu wechseln, Alt+Links/Rechts, um sie neu anzuordnen, und Umschalt+Alt+F, um SQL im Editor zu formatieren.

Öffnen Sie den SQL-Explorer neben den Tabs für einen in der Größe anpassbaren Ordnerbaum. Erstellen Sie untergeordnete Ordner und SQL-Dateien, wählen Sie eine Datei aus, um sie zu öffnen, und organisieren Sie diese per Drag & Drop. Das Reihenaktions-Popup unterstützt Umbenennen und Datei löschen; klicken Sie außerhalb, um es zu schließen. Das Löschen der letzten Datei hält eine leere SQL-Datei geöffnet. Ordner ändern die Ausführungsreihenfolge nicht. Das Entfernen eines Ordners behält dessen Dateien und untergeordnete Ordner im übergeordneten Ordner bei. Speichern behält den Ordnerbaum und die Panel-Präferenz bei.

Diagramm bearbeiten und prüfen

SQL ist die Quelle der Schemabedeutung. Verwenden Sie Tabelle hinzufügen, um eine Tabelle zu erstellen, oder wählen Sie Tabellen- und Spaltenaktionen auf der Arbeitsfläche aus, um Spalten und Verbindungen zu bearbeiten. Schemaänderungen auf der Arbeitsfläche aktualisieren sowohl die zugehörigen SQL-Registerkarten als auch das Diagramm.

Das Entfernen einer Spalte zeigt eine Vorschau der betroffenen Verbindungen, Schlüssel, Indizes und abhängigen SQL-Anweisungen an. Überprüfen Sie die Entfernung oder Kaskadierung vor der Bestätigung. Komplexe Migrationen oder nicht unterstützte abhängige Anweisungen können eine direkte SQL-Bearbeitung erfordern.

Verwenden Sie den ERD-Gesundheitswert, um strukturelle Ergebnisse zu untersuchen und vorgeschlagene Beziehungen zu akzeptieren. Vorgeschlagene Beziehungen müssen überprüft werden; sie ersetzen keine deklarierten Fremdschlüssel und legen nicht automatisch Geschäftsregeln fest.

Tabellen mit Layoutmodus anordnen, zoomen oder an Bildschirm anpassen, Tabellen mit dem Tabellen-Navigator finden und Tabellenfarben oder die Mini-Karte zur Navigation in einem großen Diagramm verwenden. Fahren Sie mit der Maus über ein Symbol in der Symbolleiste oder setzen Sie den Fokus darauf, um dessen Hilfetext anzuzeigen.

Wählen Sie eine Tabelle aus und öffnen Sie die Farbauswahl für Vollton- oder Verlaufs-Voreinstellungen. Geben Sie einen Hex-Wert ein oder wählen Sie daneben „Benutzerdefiniert“, um die native Farbauswahl zu verwenden. Beide Steuerelemente bleiben synchronisiert; Speichern behält die Tabellenfarbe bei.

Wenn Tabellenwerkzeuge auf Nur-Hover eingestellt sind, wird „Spalte hinzufügen“ angezeigt, wenn Sie mit der Maus über die letzte sichtbare Zeile fahren oder die Schaltfläche über die Tastatur fokussieren. Immer sichtbare Werkzeuge lassen sie dauerhaft anzeigen.

Wählen Sie Gruppentabellen auf der SQL-Canvas-Symbolleiste und dann Neue Gruppe. Geben Sie der Gruppe einen Namen und eine Farbe, wählen Sie ihre Tabellen aus und wählen Sie Gruppe erstellen. Eine ausgewählte Tabelle beginnt angekreuzt. Eine Tabelle gehört zu einer Gruppe; das Formular zeigt an, wann Ihre Auswahl eine Tabelle aus einer anderen Gruppe verschiebt. Bis zu 50 Gruppen werden unterstützt, mit Namen bis zu 160 Zeichen.

Klicken Sie auf einen Gruppenheader, um dessen Namen, Farbe oder Mitglieder zu bearbeiten. Ziehen Sie den Header, um seine Tabellen gemeinsam zu bewegen; lassen Sie ihn los, um die Bewegung anzuwenden. Escape, Zeigerabbruch oder das Verlieren des Fensterfokus bricht die Vorschau ab. Tabellen entgruppieren entfernt den Rahmen, während die Tabellen, ihre Positionen, SQL und Beziehungen erhalten bleiben.

Gruppenrahmen folgen den Live-Tabellenkarten und erscheinen in Anpassen an Bildschirm, der Minimap und Bildexporten der aktuellen Ansicht oder des gesamten Diagramms. Gruppen sind ein optionaler visueller Status, der im SQL-Dokument gespeichert wird. Ältere Dateien behalten ihr bestehendes Layout bei, und vorübergehend fehlende Tabellennamen verbleiben in ihrer Gruppe, bis sie zum geparsten SQL zurückkehren. Tabellengruppen gehören zu SQL zu ERD; Klassendiagramm-Pakete verwenden ein separates Modell.

KI-Überprüfung im SQL-Editor

  1. Geben Sie eine spezifische Änderung in Frag KI ein, um SQL zu bearbeiten und ein verfügbares Modell auszuwählen. „Gemini-API-Schlüssel festlegen“ ist verfügbar, wenn Sie Ihren eigenen Gemini-Schlüssel verwenden möchten.
  2. Überprüfen Sie die vorgeschlagenen Änderungen und die temporäre Diagrammvorschau. Die Anfrage verwendet den Snapshot des aktiven Tabs, der zum Zeitpunkt des Sendens erfasst wurde; eine Antwort wird nicht automatisch gespeichert.
  3. Akzeptieren oder Ablehnen einzelner Änderungen oder Verwenden Sie die Aktionen für die verbleibenden Änderungen. Navigieren Sie mit F7 und Umschalt+F7 durch Codeänderungen. Geschützte inaktive Tabs bleiben Entwürfe.
  4. Überprüfen Sie das akzeptierte SQL und speichern Sie dann das Dokument. Das Kopieren von KI-Prompts in dieser Anleitung ermöglicht es Ihnen auch, die Dokumentation mit einem Assistenten außerhalb der App zu verwenden.

Daten, Abfragen, Exportieren & gespeicherte Dateien

Verwenden Sie die Schaltflächen ERD, Daten und Abfrage, um zwischen den Arbeitsbereichen zu wechseln. Die Datenansicht materialisiert unterstützte DDL und DML im Browser und zeigt Tabellen, Zeilen, Typen und ein Ausführungsprotokoll an. Ändern Sie die Größe von Rasterspalten durch Ziehen der Ränder oder per Doppelklick zur Anpassung. Doppelklicken Sie auf eine Datenzelle oder drücken Sie die Eingabetaste zum Bearbeiten; boolesche und Enum-Felder bieten gültige Werte an. Das Hinzufügen einer Zeile folgt Ihren Schema-Standardwerten. Importieren Sie CSV, TSV, TXT oder XLSX mit einer Vorschau der Spaltenzuordnung. NULL und leerer Text bleiben unterschieden. Validierte Bearbeitungen werden im Tab „Datenbearbeitungen“ zu SQL und können rückgängig gemacht werden. Laden Sie Tabellenzeilen oder Abfrageergebnisse als CSV herunter.

Speichern merkt sich die ausgewählte ERD-, Daten- oder Abfrage-Workbench; beim erneuten Öffnen wird diese wiederhergestellt, einschließlich Daten/Abfrage auf Mobiltelefonen. Ältere Dateien starten im Klassendiagramm. Native Datums-/Zeit-Editoren bewahren unterstützte Werte, während Zeitstempel mit Bruchteilen oder Zeitzonen-Offsets als Text bearbeitbar bleiben. Datenbankgenerierte Identitäten bleiben schreibgeschützt.

Die Abfrageansicht (Query View) führt schreibgeschützte SELECT-Abfragen für die aktuellen Tabellen im Arbeitsspeicher aus. Sie unterstützt die unten dokumentierte Syntax; sie stellt keine Verbindung zu einer externen Datenbank her. Der Abfragetext wird mit dem SQL-Dokumentkontext gespeichert.

Speichern merkt sich auch die ausgewählte Datentabelle. Beim erneuten Öffnen wird sie wiederhergestellt, wobei die erste Tabelle als Fallback dient, falls sie nicht verfügbar ist. Schema-Felder gleichen Namen, Typen und Regeln ab; fahren Sie mit der Maus über ein Regel-Badge, um dessen Erklärung zu sehen. „Zu SQL“ neben der Tabellenüberschrift öffnet den zugehörigen SQL-Tab und zeigt das CREATE TABLE-Statement an, wobei das SQL-Panel bei Bedarf wieder geöffnet wird, während die Datenauswahl und Entwürfe erhalten bleiben. Abfrageergebnisse kombinieren Anzahl, Zeitmessung, Anpassen, Kopieren und CSV in einer Kopfzeile.

Ziehen Sie die schmale Trennlinie zwischen dem Abfrage-Editor und den Ergebnissen oder zwischen Datenschema und Zeilen, um die Bereiche in der Größe anzupassen. Pfeiltasten verändern die Größe einer fokussierten Trennlinie, Escape bricht das Ziehen ab und ein Doppelklick setzt es zurück. Diese Bereichsgrößen bleiben temporäre Arbeitsbereichseinstellungen.

Das Generieren von Beispieldaten verwendet Ihre Spaltentypen, Namen, Beziehungen und Einschränkungen. Die Sprachsteuerung für Beispiele steuert Namen sowie natürliche Produkt-/Beschreibungsphrasen in 17 Sprachen. Überprüfen Sie vorgeschlagene Generatoren und Bereiche, zeigen Sie das Ergebnis in der Vorschau an und fügen Sie dann explizit eine separate Beispieldaten-Registerkarte ein. Booleans werden als wahr/falsch angezeigt; IDs bleiben numerisch. Die Generierung ersetzt niemals bestehende Zeilen.

Wählen Sie ERD exportieren, um PNG, bildunterstütztes SVG oder PDF mit HD-, 2K- oder 4K-Größe auszuwählen. Exportierte Bilder ersetzen kein bearbeitbares gespeichertes Dokument.

Melden Sie sich an und verwenden Sie SQL und ERD speichern, um den SQL- und Diagrammkontext zu speichern, einschließlich Tabs, angewendeter Rasterbearbeitungen, Abfragetext und Layout. Speichern prüft zuerst eine aktive Zelle oder einen Entwurf für eine neue Zeile; ungültige Daten bleiben zur Korrektur sichtbar. Import-Vorschauen erfordern ihre explizite Import-Aktion. Öffnen Sie gespeicherte Dateien aus der Dateiliste und verwenden Sie Teilen bei einem eigenen gespeicherten Dokument, um den öffentlichen Zugriff zu konfigurieren und den schreibgeschützten Link zu verteilen.

SQL-, Prisma- und Builder-Dokumente werden in ihren eigenen Tools geöffnet. Prisma und Builder haben separate Dateilisten und Cloud-only-Speicherung. Eingabeaufforderungen bei nicht gespeicherten Änderungen schützen bearbeitete Dokumente beim Verlassen eines Arbeitsbereichs; speichern Sie Ihre Änderungen, bevor Sie diese teilen oder wechseln.

Fehlerbehebung im SQL-Arbeitsbereich

Fehlerbehebung im SQL-Arbeitsbereich
SymptomWas zu überprüfen ist
Eine Tabelle fehltÜberprüfen Sie Parser-Diagnosen, aktive Tabs und die Anweisungsreihenfolge. Ein späteres DROP oder Umbenennen kann das finale Diagramm ändern.
Eine Beziehung fehltÜberprüfen Sie, ob beide Tabellen und Spalten existieren, die Spaltenanzahl von Fremdschlüsseln übereinstimmt und der referenzierte Schlüssel global eindeutig ist. Qualifizieren Sie mehrdeutige Namen mit dem Schema.
Datenansicht zeigt keine ZeilenPlatzieren Sie INSERT in einem aktiven Tab nach dem dazugehörigen CREATE TABLE. Überprüfen Sie das Ausführungsprotokoll auf abgelehnte Zeilen oder ein Transaktions-Rollback.
Abfrageergebnisse stimmen nicht mehr mit dem SQL übereinFühren Sie die Abfrage nach dem Ändern des Schemas oder der Daten erneut aus; verwenden Sie die aktuellen In-Memory-Tabellen.
Tabelle hinzufügen schlägt einen anderen Dialekt vorDie erkannte Syntax des aktiven Arbeitsbereichs hat Vorrang vor dem manuell ausgewählten Fallback. Überprüfen Sie den SQL-Sprachindikator und die tabellenspezifischen Standards.
Eine gespeicherte Datei kann nicht bearbeitet werdenPrüfe Anmeldung und Besitz. Ein öffentlicher Link gewährt schreibgeschützten Zugriff; verwende Erneut versuchen oder Dateien öffnen bei wiederherstellbaren Ladefehlern.

KI-Syntax-Workflow

Wenn Sie einen KI-Assistenten verwenden, bitten Sie ihn, SQL in dieser Reihenfolge zu erstellen. Dies hält das Ergebnis einfach zu parsen, einfach zu diagrammieren und einfach mit Beispielzeilen oder schreibgeschützten Abfragen in der Vorschau anzuzeigen.

1. Domänen zuerst definieren

Platzieren Sie CREATE TYPE-Enum-/Composite-Definitionen vor Tabellen, die darauf verweisen. Bevorzugen Sie explizite Namen gegenüber Ad-hoc-Inline-Typen, wenn eine Domäne gemeinsam genutzt wird.

2. Basistabellen erstellen

Verwenden Sie CREATE TABLE für Spalten, Primärschlüssel, Eindeutigkeit, Standardwerte, Prüfungen, generierte Spalten und Inline-Fremdschlüssel.

3. Migrationen erneut abspielen

Verwenden Sie ALTER TABLE für hinzugefügte Einschränkungen, Umbenennungen, gelöschte Spalten, Änderungen an Spaltentyp/Nullbarkeit und zirkuläre Fremdschlüssel.

4. Daten und Abfragen zuletzt hinzufügen

Platzieren Sie INSERT/UPDATE/DELETE nach allen DDL-Befehlen. Halten Sie SELECT-Abfragen von der Schema-Mutation getrennt, wenn Sie Ergebnismengen wünschen.

KI-Prompt-Tipp: Fordern Sie ein vollständiges, mit Semikolon abgeschlossenes SQL-Skript an. Weisen Sie die KI an, nicht unterstützte Objekte wie gespeicherte Prozeduren, Trigger, rekursive CTEs in schreibgeschützten SELECT-Abfragen zu vermeiden, und ALTER TYPE. Ausdrucksindizes werden mit einer Warnung beibehalten; fordern Sie einfache Spaltenschlüssel an, wenn Sie ERD-Index-Badges benötigen.

DDL- und DML-Syntax

Diese Anweisungsformen sind sicher für KI-generierte Schemaskripte und Beispieldaten. Dieselbe Syntax steuert die ERD-Struktur und die In-Memory-Vorschauzeilen, daher sollten DDL vor DML stehen und externe datenbankspezifische Nebeneffekte vermieden werden.

Unterstützte Anweisungen

SQL / Beispiel
-- Schema statements
CREATE TYPE type_name AS ENUM (...);
CREATE TYPE type_name AS (...);
CREATE TABLE table_name (...);
CREATE OR REPLACE TABLE table_name (...);
CREATE VIEW view_name AS SELECT ...;
CREATE OR REPLACE VIEW view_name AS SELECT ...;
CREATE OR ALTER VIEW view_name AS SELECT ...;
ALTER TABLE table_name ADD ...;
ALTER TABLE table_name DROP COLUMN column_name;
ALTER TABLE table_name RENAME COLUMN old_name TO new_name;
CREATE INDEX index_name ON table_name (column_name);
DROP INDEX index_name;
TRUNCATE TABLE table_name;
DROP TABLE [IF EXISTS] table_name;
DROP VIEW [IF EXISTS] view_name;
DROP TYPE [IF EXISTS] type_name;

-- Data statements
INSERT INTO table_name [(col1, col2, ...)] VALUES (...), (...);
UPDATE table_name SET col1 = value WHERE condition;
DELETE FROM table_name WHERE condition;
WHERE-Unterstützung: =, !=, <>, >, <, >=, <=, LIKE, NOT LIKE, IN, NOT IN, BETWEEN, NOT BETWEEN, IS NULL, IS NOT NULL, plus AND / OR Kombinationen. NULL-Vergleiche folgen der UNKNOWN-Logik des SQL-Standards – col = NULL stimmt niemals überein; verwenden Sie col IS NULL stattdessen. Unbekannte Zuweisungsziele, Spaltenverweise in der rechten Spalte und Filterskalen lehnen die gesamte Mutation ab, bevor Zeilen geändert werden.

Vorschau-Semantik für KI-generierte DML

Beispieldaten lokal generieren: Wählen Sie in der Datenansicht Beispieldaten erzeugen, wählen Sie automatische Erkennung oder ein SQL-Dialekt, ein Namenswörterbuch aus 26 Ländern oder allgemeines Englisch, einen optionalen Nullwertprozentsatz und Tabellenzeilenzahlen, und erweitern Sie eine Tabelle, um ihre Generatoren, Bereiche oder zulässigen Werte anzupassen. Vorschau zuerst, dann SQL kopieren/herunterladen oder eine neue einfügen Beispieldaten Registerkarte. Es ist kein KI-Schlüssel oder externe Datenanforderung erforderlich. Wenn Sie das integrierte Schema ersetzt haben, deaktivieren Sie zuerst dessen alte Commerce-Beispieldaten-Registerkarte. Die Generierung behält bestehende Zeilen bei, kopiert vollständige Fremdschlüssel-Tupel mit ausgewogener Eltern-Abdeckung und validiert unterstützte Einschränkungen und Skalartypen. CHECK-Einschränkungen, die vollständig aus IS NULL / IS NOT NULL, AND, OR und Klammern bestehen, haben Vorrang vor dem optionalen NULL-Prozentsatz, einschließlich exklusiver Post-/Video-Referenzen. Der Katalog verfügt über über 4.200 integrierte Einträge, darunter mehr als 2.600 Namen mit nativer Schreibweise und ASCII-E-Mail-Handles sowie Unternehmen, Produkte, Jobs, Straßen, natürlichsprachliche Beschreibungen und Standortbeispiele in über 40 Ländern neben Währungen, IP-Adressen, SKUs, Status, Farben, Daten und JSON. Stapel unterstützen bis zu 5.000 Zeilen pro Tabelle, 10.000 Zeilen und 150.000 Zellen insgesamt sowie 5 MB SQL. Erforderliche leere Beziehungszyklen, erschöpfte eindeutige Domänen, kollidierende Tabellennamen über Schemas hinweg und nicht unterstützte erforderliche komplexe Typen erfordern Anpassungen, bevor die Generierung abgeschlossen werden kann. Nullable komplexe Werte und zyklusbrechende Referenzen können mit einem Vorschauhinweis NULL werden. Seeds wiederholen generierte Wörterbuchwerte; Datenbank-Standardwerte folgen weiterhin ihrem normalen Verhalten. Schließen Sie zuerst die KI-Überprüfung ab und öffnen Sie den Generator erneut, wenn sich der SQL-Arbeitsbereich ändert.

Zeilen werden von Grund auf neu abgespielt

DDL- und DML-Anweisungen werden in Quellreihenfolge gemeinsam angewendet; jede Datenanweisung verwendet das zu diesem Zeitpunkt aktuelle Schema.

Typen bleiben inspizierbar

Benannte Enums und zusammengesetzte Typen, die mit CREATE TYPE erstellt wurden, bleiben Teil des analysierten Schemas.

Einschränkungen werden durchgesetzt

PK, FK, NOT NULL, UNIQUE, DEFAULT, CHECK, generierte Spalten und Enum-Domänen beeinflussen Vorschaureihen.

Fehler sollten behebbar sein

Bevorzugen Sie explizite Spaltenlisten und konkrete WHERE-Klauseln, damit Diagnosen auf die genaue Tabelle oder Spalte verweisen können.

Verlangen Sie nicht von der KI, sich zu verlassen auf: Eigenständig SELECT Ergebnismengen im Hauptschema-/DML-Skript, nicht unterstützte Prozedurkörper oder externe Datenbankaufrufe. CREATE VIEW, CREATE OR REPLACE VIEW, und MSSQL CREATE OR ALTER VIEW werden aus ihrem SELECT Ergebnis für die Vorschau; halten Sie Ad-hoc-Abfragen mit Lesezugriff getrennt.

Transaktionen in der Datenansicht

Die Datenansicht unterstützt BEGIN, COMMIT, ROLLBACK, SAVEPOINT, ROLLBACK TO und RELEASE in der In-Memory-Vorschau. Diese Anweisungen beeinflussen die Vorschauzeilen; sie werden niemals in einer externen Datenbank festgeschrieben.

SQLite, PostgreSQL und SQL Server behalten transaktionales DDL in der Vorschau bei. MySQL-DDL führt einen Commit der aktiven Transaktion durch. SQLite PRAGMA foreign_keys und MySQL SET FOREIGN_KEY_CHECKS beeinflussen die nachfolgende DML-Validierung.

Der ERD-Renderer ignoriert Transaktions-Wrapper und stellt Schema-Anweisungen in der Reihenfolge der Quelle dar. Ein Transaktions-Rollback in der Datenansicht kann daher eine andere Menge an Tabellen erzeugen als das Diagramm. Überprüfen Sie jede Arbeitsumgebung auf das Verhalten, das Sie testen.

SQL / Transaktionsvorschau
CREATE TABLE preview_items (
  id INTEGER PRIMARY KEY,
  label TEXT NOT NULL
);
INSERT INTO preview_items (id, label) VALUES (1, 'Before transaction');

BEGIN;
INSERT INTO preview_items (id, label) VALUES (2, 'Keep this row');
SAVEPOINT before_trial;
INSERT INTO preview_items (id, label) VALUES (3, 'Undo this row');
ROLLBACK TO before_trial;
RELEASE before_trial;
COMMIT;
In diesem Beispiel behält die Datenansicht die Elemente 1 und 2 bei. Element 3 wird durch ROLLBACK TO vor COMMIT entfernt. Die Abfrageansicht liest diese endgültigen Vorschauzeilen.

SELECT-Abfragesyntax

KI bitten, schreibgeschützte Reporting-Abfragen beizubehalten als SELECT Anweisungen. Diese können auf die Tabellen und Zeilen verweisen, die durch das Schema-/DML-Skript erzeugt wurden, und sind nützlich für Joins, Filter, Summen und berichtsähnliche Ergebnismengen, ohne dass eine echte Datenbank erforderlich ist.

Unterstützte Abfrageform

SQL / Beispiel
WITH dept_totals AS (
  SELECT department_id, COUNT(*) AS employee_count, SUM(salary) AS payroll
  FROM employees
  GROUP BY department_id
)
SELECT d.name,
       dt.employee_count,
       dt.payroll
FROM dept_totals dt
JOIN departments d ON d.id = dt.department_id
WHERE dt.employee_count >= 1
ORDER BY dt.payroll DESC
LIMIT 10;

Nur SELECT

Der Abfrage-Editor akzeptiert SELECT-Anweisungen, einschließlich SELECT ohne FROM und WITH-CTEs, die zu einem SELECT aufgelöst werden.

Joins & Filter

INNER-, LEFT-, RIGHT-, FULL- und CROSS-Joins, WHERE-Bedingungen, EXISTS, IN-Unterabfragen, BETWEEN, LIKE, ILIKE und NULL-Prüfungen.

Aggregate

GROUP BY, HAVING, COUNT, SUM, AVG, MIN, MAX, ARRAY_AGG, GROUP_CONCAT, STRING_AGG und DISTINCT-Varianten.

Sortierung & Paging

ORDER BY Namen oder Ordnungszahlen, ASC/DESC, NULLS FIRST/LAST, LIMIT/OFFSET, TOP und FETCH FIRST.

Erweiterte SELECT-Unterstützung

CTEs & abgeleitete Tabellen

WITH-Klauseln, verschachtelte SELECTs in FROM, skalare Unterabfragen, EXISTS, NOT EXISTS, IN und NOT IN werden unterstützt.

Operatoren festlegen

UNION, UNION ALL, INTERSECT und EXCEPT können kompatible Ergebnismengen kombinieren.

Fensterfunktionen

ROW_NUMBER, RANK, DENSE_RANK, NTILE, LAG, LEAD, FIRST_VALUE und LAST_VALUE mit OVER und PARTITION BY. Geordnete Fenster verwenden den Peer-bewussten SQL-Standard-Frame, und NTILE weist größere Buckets zuerst zu.

Dialekthilfen

Gängige SQLite-, PostgreSQL-, MySQL- und MSSQL-Funktionen werden für die Vorschau normalisiert, einschließlich JSON- und Datums-/Zeichenfolgen-Helfern.

Konstruktionsbedingt schreibgeschützt: Behalten INSERT, UPDATE, DELETE, CREATE, ALTER, und DROP Anweisungen im Schema-/DML-Skript. Die Abfragesyntax sollte bleiben SELECT-nur.

Diagnose & Fehler

Syntaxdiagnosen zeigen Probleme bei der Schema-Analyse, DDL/DML-Ausführung und schreibgeschützten SELECT-Abfragen mit klaren Meldungen an. Analysefehler enthalten nach Möglichkeit Zeilen-/Spaltenpositionen, und Ausführungsmeldungen verweisen auf die Tabelle, Spalte oder Anweisungsform, die korrigiert werden muss.

Schema-Parsing-Fehler

Der Schema-Parser (SQLite, PostgreSQL, MySQL und MSSQL) meldet Probleme mit zwei Schweregraden: Fehler verhindert, dass eine einzelne Anweisung zum Schema beiträgt; Warnung behält eine gültige Syntax bei, markiert jedoch etwas, das der Benutzer wissen sollte.

SQL / Beispiel
// Every entry the editor receives has this shape:
{
  message:  "Column 'a' missing data type",
  severity: "error" | "warning",
  position: { line: 1, column: 17, index: 16 },
  token?:   { type, value, raw }   // present for parser-side errors
}

Parser-Fehler

Leere PRIMARY KEY / UNIQUE / FOREIGN KEY-Spaltenlisten, fehlende erforderliche Datentypen (einschließlich SQLite STRICT-Spalten), nicht übereinstimmende Klammern, unerwartete Kommas und fehlerhafte Einschränkungen.

Tokenizer-Warnungen

Nicht geschlossene Zeichenfolgen, nicht geschlossene Blockkommentare, nicht übereinstimmende Klammern und verdächtige zeilenübergreifende CHECK-Ausdrücke.

Fremdschlüssel-Warnungen

FKs, die auf eine unbekannte Tabelle, eine unbekannte Spalte, einen mehrdeutigen Schema-Endknoten oder ein Nicht-PK/Nicht-UNIQUE-Ziel verweisen, werden mit einer beschreibenden Warnung aus dem Diagramm entfernt.

Gruppierte Diagnosen

Warnungen werden nach Ursache gruppiert, einschließlich Gelöschte Relation, Unbekannte Tabelle, Unbekannte Spalte, Nicht-eindeutiges FK-Ziel, Warnungen und Parse-Fehler.

Leeres SQL

Eine leere Eingabe ist gültig und erzeugt ein leeres Schema. Nur ungültige Nicht-String-Eingaben lösen einen Fehler aus.

DDL-/DML-Ausführungsprotokoll

Jede ausgeführte DDL- oder DML-Anweisung fügt einen strukturierten Eintrag zum speicherinternen Ausführungsprotokoll hinzu. Der Nachrichtenstrom bewahrt die chronologische Reihenfolge und klassifiziert jede Anweisung als Fehler, Warnung, oder Erfolg.

SQL / Beispiel
// Each log entry is:
{
  type:      "success" | "warning" | "error",
  message:   "Inserted 3 row(s) into \"users\"",
  timestamp: 1734567890123  // ms since epoch, monotonic
}
SQL / Beispiel
-- Examples ────────────────────────────────────────────────
-- success
CREATE TABLE users (id INT PRIMARY KEY);
-- → success: Table "users" created with 1 columns

-- warning (no WHERE clause)
UPDATE users SET id = 99;
-- → warning: UPDATE "users": no WHERE clause — all 2 row(s) will be affected
-- → success: Updated 2 row(s) in "users"

-- error (unknown table)
INSERT INTO ghost VALUES (1);
-- → error: INSERT INTO "ghost": table does not exist
Immer handlungsfähig. Jeder Fehler und jede Warnung nennt den betroffenen Tabellen-/Spaltennamen, sodass Sie das Problem ohne erneutes Lesen des Skripts lokalisieren können.

Gängige Diagnosen

SQL / Beispiel
error    : INSERT INTO "x": unknown column(s): foo
warning  : INSERT INTO "x" row 3: expected 4 values but got 3
warning  : UPDATE "x": setting NOT NULL column "name" to NULL
warning  : DELETE FROM "x": no WHERE clause — all 1200 row(s) will be removed
error    : DROP: table "ghost" does not exist
warning  : ALTER "x": column "old_col" does not exist
warning  : Relation dropped: foreign key 'posts.user_id' references column
           'users.no_such' which does not exist on table 'users'.
warning  : Relation dropped: foreign key 'events.email' references 'users.email',
           but the target is only partial-unique, not globally unique.
Absturzsicher. Schema-Parsing, DDL/DML-Ausführung und SELECT-Ausführung wandeln fehlerhaftes SQL in sichtbare Fehler um, sodass Sie das Skript weiter verfeinern können.

CREATE TYPE

Definiere benutzerdefinierte Datentypen zur Wiederverwendung in deinem Datenbankschema. Benannte Enum- und zusammengesetzte Typen sollten vor Tabellen erscheinen, die auf sie verweisen, einschließlich schemaqualifizierter Verweise.

1.1. Zusammengesetzter Typ

Definiere benutzerdefinierte zusammengesetzte Typen mit mehreren Feldern verschiedener Datentypen.

SQL / Beispiel
CREATE TYPE type_name AS (
  field1 data_type1,
  field2 data_type2,
  ...
);

Beispiel:

SQL / Beispiel
CREATE TYPE address_type AS (
  street VARCHAR(100),
  city TEXT,
  postal_code INTEGER
);

CREATE TYPE coordinates AS (
  latitude DECIMAL(10, 8),
  longitude DECIMAL(11, 8)
);
Unterstützte Datentypen: INTEGER, BIGINT, SMALLINT, TEXT, VARCHAR(n), CHAR(n), DECIMAL(p,s), NUMERIC, BOOLEAN, DATE, TIME, TIMESTAMP, FLOAT, REAL, DOUBLE PRECISION, UUID, JSON, JSONB, BYTEA, MONEY und mehr.

1.2. Enum-Typ

Erstellen Sie Aufzählungstypen mit vordefinierten Werten für bessere Datenintegrität und Lesbarkeit.

SQL / Beispiel
CREATE TYPE enum_name AS ENUM (
  'value1',
  'value2',
  ...
);

Beispiel:

SQL / Beispiel
CREATE TYPE status_enum AS ENUM (
  'pending',
  'active',
  'completed',
  'cancelled'
);

CREATE TYPE priority_level AS ENUM (
  'low', 'medium', 'high', 'critical'
);
Wichtig: Enum-Werte müssen in einfache Anführungszeichen ('Wert') eingeschlossen werden, nicht in doppelte.

1.3. Schema-qualifizierte Typen

Benutzerdefinierte Typen werden mit demselben Schema-Bewusstsein wie Tabellen aufgelöst. Wenn zwei Schemas denselben Blattnamen definieren, hält das ERD sie getrennt; wenn ein Typ eindeutig ist, bleibt der Anzeigename einfach.

SQL / Beispiel
CREATE TYPE s1.status AS ENUM ('draft', 'active');
CREATE TYPE s2.status AS ENUM ('queued', 'done');

CREATE TABLE s1.items (
  id    INT PRIMARY KEY,
  state s1.status
);

CREATE TABLE s2.items (
  id    INT PRIMARY KEY,
  state s2.status
);
Auflösungsregel: s1.status wird niemals aufgelöst zu s2.status nur weil beide denselben Blattnamen haben status. Qualifizierte Typnamen sind strikt, während unqualifizierte Namen nur aufgelöst werden, wenn sie eindeutig sind.

CREATE TABLE

Definiere Datenbanktabellen mit Spalten, Datentypen und Constraints.

2.1. Grundlegende Tabellenstruktur

Die allgemeine Syntax zum Erstellen einer Tabelle:

SQL / Beispiel
CREATE TABLE table_name (
  column_name data_type [constraints],
  ...
  -- table-level constraints (optional)
);

-- Also supports:
CREATE TABLE IF NOT EXISTS table_name ( ... );
CREATE TABLE schema_name.table_name ( ... );
Hinweis: Tabellen- und Spaltennamen können doppelte Anführungszeichen verwenden ("name"), Backticks (\`name\`), oder eckige Klammern ([name]) zum Escapen von Sonderzeichen oder reservierten Schlüsselwörtern.

2.2. Spaltenbezogene Definitionen

Jede Spalte kann verschiedene Einschränkungen und Eigenschaften enthalten:

SQL / Beispiel
CREATE TABLE users (
  id INTEGER PRIMARY KEY,
  username VARCHAR(50) UNIQUE NOT NULL,
  email TEXT NOT NULL CHECK (email LIKE '%@%'),
  status VARCHAR(20) DEFAULT 'active',
  created_at TIMESTAMP DEFAULT now(),
  department_id INTEGER REFERENCES departments(id)
);

PRIMARY KEY

Identifiziert jede Zeile eindeutig

UNIQUE

Stellt sicher, że Spaltenwerte unterschiedlich sind

NICHT NULL

Verhindert Nullwerte

DEFAULT

Legt Standardwerte fest (Literale oder Funktionen)

CHECK

Validiert Daten mit booleschen Ausdrücken

REFERENCES

Erstellt Fremdschlüsselbeziehungen

DEFAULT-Werte unterstützen:
  • Literale: Zahlen ("123), Strings ('text')
  • PostgreSQL-Funktionen: now(), CURRENT_TIMESTAMP, CURRENT_DATE, nextval('seq'::regclass)
  • MSSQL-Funktionen: GETDATE(), NEWID()
REFERENCES (inline): Erkennt REFERENCES table(column), schemaqualifizierte REFERENCES schema.table(column), ausgelassene Zielspalten wie REFERENCES departments, und FK-Aktionen wie ON DELETE CASCADE, ON UPDATE SET NULL, MATCH FULL, und DEFERRABLE INITIALLY DEFERRED.

2.3. Generierte / Berechnete Spalten

Kurzreferenz. Siehe das dedizierte Berechnete Spalten Abschnitt unten für die vollständige Aufschlüsselung nach Dialekt, einschließlich der nackten MSSQL-AS-Form.

SQL / Beispiel
CREATE TABLE products (
  id SERIAL PRIMARY KEY,
  price NUMERIC(10, 2),
  quantity INTEGER,

  -- PostgreSQL / MySQL: parenthesized expression
  total NUMERIC GENERATED ALWAYS AS (price * quantity) STORED,

  -- MySQL VIRTUAL column
  discount NUMERIC GENERATED ALWAYS AS (price * 0.1) VIRTUAL
);

2.4. Inline ENUM-Typen

Sie können ein ENUM direkt in einer Spaltendefinition deklarieren (im MySQL-Stil). Der Parser registriert es als benanntes Enum und ersetzt den Spaltentyp automatisch.

SQL / Beispiel
CREATE TABLE tasks (
  id INTEGER PRIMARY KEY,
  status ENUM('todo', 'doing', 'done'),
  priority ENUM('low', 'medium', 'high')
);
Wie es funktioniert: Inline-ENUMs werden automatisch als benannte Typen registriert. Der erste einfache Name verwendet column_enum (zum Beispiel, status_enum); spätere Tabellen mit einer anderen Definition für denselben Spaltennamen erhalten einen tabellenqualifizierten Namen wie tasks_status_enum damit Domänen niemals versehentlich kollabieren.
Tipp: Wenn Sie gemeinsame Enums oder benutzerdefinierte Namen benötigen, definieren Sie diese explizit mit CREATE TYPE ... AS ENUM stattdessen.

2.5. Tabellenbezogene Einschränkungen

Definiere Constraints am Ende des Tabellenkörpers. Nützlich für zusammengesetzte Schlüssel und Mehrspalten-Constraints:

SQL / Beispiel
-- Syntax:
[CONSTRAINT name] PRIMARY KEY (col1, col2, ...)

[CONSTRAINT name] FOREIGN KEY (col1, col2, ...)
  REFERENCES ref_table(ref_col1, ref_col2, ...)
  [MATCH FULL|PARTIAL|SIMPLE]
  [ON DELETE CASCADE|RESTRICT|SET NULL|SET DEFAULT|NO ACTION]
  [ON UPDATE CASCADE|RESTRICT|SET NULL|SET DEFAULT|NO ACTION]
  [DEFERRABLE|NOT DEFERRABLE] [INITIALLY DEFERRED|IMMEDIATE]

[CONSTRAINT name] UNIQUE (col1, col2, ...)

[CONSTRAINT name] CHECK (expression)

Beispiel:

SQL / Beispiel
CREATE TABLE order_items (
  order_id INTEGER,
  product_id INTEGER,
  quantity INTEGER CHECK (quantity > 0),
  unit_price NUMERIC(10, 2),

  CONSTRAINT pk_order_items
    PRIMARY KEY (order_id, product_id),
  CONSTRAINT fk_order
    FOREIGN KEY (order_id) REFERENCES orders(id),
  CONSTRAINT fk_product
    FOREIGN KEY (product_id) REFERENCES products(id),
  CONSTRAINT uq_order_product
    UNIQUE (order_id, product_id),
  CONSTRAINT chk_price
    CHECK (unit_price >= 0)
);
Unterstützte Constraints: PRIMARY KEY, FOREIGN KEY, UNIQUE und CHECK werden alle auf Tabellenebene unterstützt. Der Constraint-Name (CONSTRAINT name) ist optional.
Fremdschlüssel-Korrektheit: If REFERENCES ref_table lässt die Zielspaltenliste weg, Erd Go löst sie zum Primärschlüssel der referenzierten Tabelle auf, einschließlich zusammengesetzter Primärschlüssel. Wenn Sie Zielspalten explizit angeben, müssen diese durch einen PRIMARY KEY, eine UNIQUE-Constraint oder global abgesichert sein CREATE UNIQUE INDEX; gefilterte / partielle eindeutige Indizes zählen nicht als FK-Ziele. Ungültige Beziehungen werden mit einer Warnung verworfen.

2.6. Reservierte Spaltennamen

Wörter wie key, index, value, und name sind in einigen Dialekten reserviert, werden aber in anderen häufig als Spaltennamen verwendet. Der Parser löst Mehrdeutigkeiten automatisch auf, wenn das nächste Token ein bekannter Datentyp ist, sodass die Verwendung ohne Anführungszeichen funktioniert:

SQL / Beispiel
CREATE TABLE feature_flags (
  id        BIGSERIAL PRIMARY KEY,
  org_id    BIGINT NOT NULL,
  key       VARCHAR(128) NOT NULL,   -- 'key' as column name → OK
  index     INT,                     -- 'index' as column name → OK
  value     TEXT,                    -- 'value' as column name → OK
  enabled   BOOLEAN NOT NULL DEFAULT FALSE,
  UNIQUE (org_id, key)
);

-- The MySQL "KEY ... (cols)" index form is still recognized correctly
CREATE TABLE posts (
  id   INT PRIMARY KEY,
  body TEXT,
  KEY idx_body (body),                 -- treated as index, adds IDX badge
  FULLTEXT KEY ft_body (body)          -- treated as fulltext index badge
);
Eindeutigkeitsregel: KEY / INDEX / FULLTEXT / SPATIAL gefolgt von einem Datentyp-Schlüsselwort (VARCHAR, INT, …) ist ein Spalte. Gefolgt von einem Bezeichner und einer in Klammern gesetzten Spaltenliste ist es ein Index. Um absolute Sicherheit zu gewährleisten, setzen Sie die Spalte in Anführungszeichen mit "key", `key`, oder [key].

Identitäts-/Auto-Increment-Spalten

Verwende die native Identitätssyntax für den ausgewählten Dialekt. Alle unterstützten Formen erzeugen eine Primärschlüsselspalte mit dem AUTO_INCREMENT Marker, aber SQLite hat eine strenge Regel: AUTOINCREMENT erfordert ein einzelnes INTEGER PRIMARY KEY Spalte.

SQLite

SQL / Beispiel
-- Rowid alias; auto assigns a value when omitted
CREATE TABLE users (
  id INTEGER PRIMARY KEY,
  email TEXT NOT NULL UNIQUE
);

-- AUTOINCREMENT prevents rowid reuse after DELETE
CREATE TABLE events (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  name TEXT NOT NULL
);

-- Invalid for SQLite AUTOINCREMENT:
-- 1. BIGINT PRIMARY KEY AUTOINCREMENT
-- 2. INT PRIMARY KEY AUTOINCREMENT
-- 3. AUTOINCREMENT on a composite primary key
SQLite-Regel: verwenden genau INTEGER PRIMARY KEY AUTOINCREMENT. Verwenden Sie nicht BIGINT, INT, oder ein zusammengesetzter Primärschlüssel mit AUTOINCREMENT.

PostgreSQL

SQL / Beispiel
-- Classic SERIAL family
CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  big_id BIGSERIAL,
  small_id SMALLSERIAL
);

-- Modern SQL-standard identity columns
CREATE TABLE events (
  id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  name TEXT
);

CREATE TABLE invoices (
  id BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY
);
Wichtig: GENERATED ALWAYS AS IDENTITY ist ein Identität Spalte (Auto-Inkrement), unterschiedlich von GENERATED ALWAYS AS (expression) was ein(e) berechnet Spalte. Der Parser hält sie automatisch auseinander.

MySQL

SQL / Beispiel
CREATE TABLE users (
  id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
  email VARCHAR(255) NOT NULL UNIQUE
) ENGINE=InnoDB;

MSSQL / SQL Server

SQL / Beispiel
-- IDENTITY(seed, increment)
CREATE TABLE [dbo].[Customers] (
  [CustomerID] BIGINT IDENTITY(1,1) NOT NULL CONSTRAINT pk_customer PRIMARY KEY,
  [Email] NVARCHAR(255) NOT NULL
);

-- Bare IDENTITY (defaults to (1,1))
CREATE TABLE [dbo].[Orders] (
  [OrderID] INT IDENTITY NOT NULL PRIMARY KEY
);
ERD-Ausgabe: Jedes Formular oben wird im Diagramm identisch angezeigt – PK-Schlüsselsymbol plus AUTO_INCREMENT Tag – sodass Sie Dialekte in einem Schema mischen können, ohne den Auto-Inkrement-Hinweis zu verlieren.

Berechnete Spalten (pro Dialekt)

Eine berechnete Spalte leitet ihren Wert aus einem Ausdruck über andere Spalten in derselben Zeile ab. Unterstützt in allen vier Dialekten mit ihren jeweiligen Syntaxen.

PostgreSQL & MySQL — GENERATED ALWAYS AS

SQL / Beispiel
CREATE TABLE products (
  id SERIAL PRIMARY KEY,
  price NUMERIC(10,2),
  qty INTEGER,
  total NUMERIC GENERATED ALWAYS AS (price * qty) STORED,
  discount NUMERIC GENERATED ALWAYS AS (price * 0.1) VIRTUAL
);

-- Complex expressions, including CASE
CREATE TABLE orders (
  id BIGSERIAL PRIMARY KEY,
  qty INT,
  flag INT GENERATED ALWAYS AS (CASE WHEN qty > 100 THEN 1 ELSE 0 END) STORED
);
Datenbankmodi: In einer nativen Datenbank, STORED speichert den berechneten Wert und VIRTUAL berechnet ihn beim Lesen. Erd Go hält Vorschauwerte im Speicher; das ERD bewahrt jeden Modus als Spaltenmetadaten auf.

MSSQL / SQL Server — Spalte AS Ausdruck [PERSISTED]

MSSQL hat seine eigene Syntax: column_name AS expression, optional gefolgt von PERSISTED (und optional NOT NULL). Beide eingeklammert und bloß Ausdrucksformen werden unterstützt.

SQL / Beispiel
CREATE TABLE [dbo].[Customers] (
  [CustomerID] BIGINT IDENTITY(1,1) NOT NULL CONSTRAINT pk_c PRIMARY KEY,
  [FirstName] NVARCHAR(50) NOT NULL,
  [LastName]  NVARCHAR(50) NOT NULL,

  -- Parenthesized form
  [FullName] AS ([FirstName] + ' ' + [LastName]) PERSISTED,

  -- Bare form (no parens) — also accepted
  [Initials] AS LEFT([FirstName], 1) + LEFT([LastName], 1)
);

CREATE TABLE [dbo].[Loans] (
  [LoanID] BIGINT IDENTITY(1,1) NOT NULL PRIMARY KEY,
  [StartDate] DATE NOT NULL,
  [TermMonths] INT NOT NULL,

  -- Function call in a bare AS expression
  [MaturityDate] AS DATEADD(MONTH, [TermMonths], [StartDate]) PERSISTED,

  -- CASE expression in a bare AS
  [SignedAmount] AS CASE WHEN [TermMonths] > 12 THEN 1 ELSE 0 END
);
Nur ALS: Der Parser akzeptiert col AS expression (keine umgebenden Klammern) – einschließlich Funktionsaufrufen wie DATEADD(...), tabellenqualifizierte Referenzen wie c.GrowthDurationDays, und CASE Ausdrücke — endend am nächsten Spalten-Komma, PERSISTED, oder Ende des Tabellenkörpers.
ERD-Ausgabe: Alle berechneten Spalten anzeigen COMPUTED als Typ und der Ausdruck bleiben in den Spaltenzusätzen / im Tooltip erhalten.

ALTER TABLE

Gängige Migrationsstile ALTER TABLE Anweisungen werden nach der Tabellenerstellung erneut ausgeführt, sodass das finale Schema hinzugefügte Spalten, Einschränkungen, Umbenennungen, gelöschte Spalten sowie Änderungen des Spaltentyps/der Nullbarkeit widerspiegelt. PostgreSQL-Dump-Syntax mit ALTER TABLE ONLY erhält die qualifizierte Tabellenidentität.

Hinzufügen & Einschränken

ADD COLUMN, ADD PRIMARY KEY, ADD UNIQUE, ADD CHECK und ADD FOREIGN KEY spiegeln sich im ERD wider.

Umbenennen & löschen

Umbenennungen von Tabellen, Spalten, Constraints und Indizes – einschließlich MySQL RENAME TABLE, PostgreSQL ALTER INDEX und SQL Server sp_rename – bleiben vor späteren DROP-Operationen an die korrekte Objektinstanz gebunden.

Spaltenänderungen

PostgreSQL ALTER COLUMN TYPE/SET DATA TYPE/SET or DROP DEFAULT/nullability, MSSQL ALTER COLUMN, and MySQL MODIFY/CHANGE COLUMN werden wiedergegeben.

Beziehungssicherheit

Fremdschlüssel werden anhand des finalen Tabellenzustands nach der Migrationswiedergabe validiert, einschließlich PK/UQ/Index-Änderungen und genauer Quell-/Ziel-Spaltenanzahlen.

3.1. Fremdschlüssel hinzufügen

SQL / Beispiel
ALTER TABLE table_name
  ADD [CONSTRAINT name] FOREIGN KEY (cols...)
    REFERENCES ref_table[(ref_cols...)]
    [ON DELETE action] [ON UPDATE action]
    [DEFERRABLE|NOT DEFERRABLE] [INITIALLY DEFERRED|IMMEDIATE];

Beispiel:

SQL / Beispiel
ALTER TABLE orders
  ADD CONSTRAINT fk_orders_customer
  FOREIGN KEY (customer_id)
  REFERENCES customers(id)
  ON DELETE CASCADE;

3.2. Primärschlüssel hinzufügen

SQL / Beispiel
ALTER TABLE table_name
  ADD [CONSTRAINT name] PRIMARY KEY (cols...);

Beispiel:

SQL / Beispiel
ALTER TABLE products
  ADD CONSTRAINT pk_products
  PRIMARY KEY (product_id);

3.3. Eindeutige Einschränkung hinzufügen

SQL / Beispiel
ALTER TABLE table_name
  ADD [CONSTRAINT name] UNIQUE (cols...);

Beispiel:

SQL / Beispiel
ALTER TABLE users
  ADD CONSTRAINT uq_users_email
  UNIQUE (email);

3.4. CHECK-Einschränkung hinzufügen

SQL / Beispiel
ALTER TABLE table_name
  ADD [CONSTRAINT name] CHECK (expression);

Beispiel:

SQL / Beispiel
ALTER TABLE employees
  ADD CONSTRAINT chk_salary
  CHECK (salary >= 0);

3.5. Beispiel für Migration-Wiederholung

SQL / Beispiel
CREATE TYPE app.ticket_status AS ENUM ('new', 'open', 'closed');

CREATE TABLE app.accounts (
  tenant_id  INT NOT NULL,
  account_no TEXT NOT NULL,
  status     app.ticket_status NOT NULL DEFAULT 'new',
  PRIMARY KEY (tenant_id, account_no)
);

CREATE TABLE app.contacts (
  tenant_id   INT NOT NULL,
  account_no  TEXT NOT NULL,
  owner_email TEXT,
  CONSTRAINT fk_contacts_account
    FOREIGN KEY (tenant_id, account_no)
    REFERENCES app.accounts
    ON DELETE CASCADE
    DEFERRABLE INITIALLY DEFERRED
);

ALTER TABLE app.contacts ADD COLUMN audit_state TEXT;
ALTER TABLE app.contacts ALTER COLUMN owner_email TYPE VARCHAR(320);
ALTER TABLE app.contacts ALTER COLUMN owner_email SET NOT NULL;
ALTER TABLE app.contacts RENAME COLUMN owner_email TO contact_email;
ALTER TABLE app.contacts DROP COLUMN audit_state;

CREATE UNIQUE INDEX ux_contacts_email
  ON app.contacts (contact_email);
Was das ERD tut: Der Kontakt-FK löst sich auf den zusammengesetzten Primärschlüssel auf bei app.accounts, owner_email wird zu contact_email, audit_state wird entfernt, und der eindeutige Index gibt contact_email ein UQ Kennzeichen.

3.6. MySQL CHANGE / MODIFY COLUMN

SQL / Beispiel
CREATE TABLE `customers` (
  `id` BIGINT AUTO_INCREMENT PRIMARY KEY,
  `email` VARCHAR(320) NOT NULL,
  UNIQUE INDEX `ux_customers_email` (`email`)
) ENGINE=InnoDB;

CREATE TABLE `orders` (
  `id` BIGINT AUTO_INCREMENT PRIMARY KEY,
  `customer_email` VARCHAR(320),
  `status` ENUM('new','paid') NOT NULL DEFAULT 'new',
  `old_note` VARCHAR(50),
  CONSTRAINT `fk_orders_customer`
    FOREIGN KEY (`customer_email`)
    REFERENCES `customers`(`email`)
    ON DELETE SET NULL
) ENGINE=InnoDB;

ALTER TABLE `orders`
  CHANGE COLUMN `old_note` `note` VARCHAR(255) NOT NULL;
ALTER TABLE `orders`
  MODIFY COLUMN `status` ENUM('new','paid') NOT NULL DEFAULT 'paid';

3.7. MSSQL / SQL Server ALTER COLUMN

SQL / Beispiel
CREATE TABLE [dbo].[Customers] (
  [CustomerID] INT IDENTITY(1,1) NOT NULL,
  [Email] NVARCHAR(320) NOT NULL,
  CONSTRAINT [PK_Customers] PRIMARY KEY CLUSTERED ([CustomerID]),
  CONSTRAINT [UQ_Customers_Email] UNIQUE NONCLUSTERED ([Email])
);

CREATE TABLE [dbo].[Orders] (
  [OrderID] INT IDENTITY(1,1) NOT NULL,
  [CustomerEmail] NVARCHAR(320),
  [LegacyNote] NVARCHAR(50),
  CONSTRAINT [PK_Orders] PRIMARY KEY NONCLUSTERED ([OrderID]),
  CONSTRAINT [FK_Orders_Customers]
    FOREIGN KEY ([CustomerEmail])
    REFERENCES [dbo].[Customers]([Email])
    ON DELETE SET NULL
);

ALTER TABLE [dbo].[Orders]
  ALTER COLUMN [LegacyNote] NVARCHAR(255) NOT NULL;
ALTER TABLE [dbo].[Orders]
  ADD [CreatedAt] DATETIME2 NOT NULL DEFAULT '2026-01-01';
Syntaxgrenze: Die SQL-zu-ERD-Migrationswiedergabe ist absichtlich umfangreicher als die Ausführung in der Datenansicht. Das Parsen des endgültigen Diagramms bleibt browserbasiert und erfordert keine Datenbankverbindung; nicht unterstützte, reine Ausführungsanweisungen schwächen das ERD-Lebenszyklusmodell nicht.

CREATE INDEX

Index-DDL wird über alle vier Dialekte analysiert. Einfache Spaltenschlüssel werden als kleine ERD-Badges angezeigt: IDX für nicht-eindeutige Beschleunigungen, UQ für globale eindeutige Indizes und PUQ für gefilterte / partielle eindeutige Indizes. Ausdruckseinträge werden in der Parser-Ausgabe beibehalten und gemeldet, wenn sie nicht eindeutig auf ein Spalten-Badge abgebildet werden können.

IDX-Badge

Nicht eindeutiger Index. Solide Pille auf der Spalte. Zusammengesetzte Indizes dämpfen die Pille (grau) auf jeder Schlüsselspalte, sodass Einzelspalten- vs. Mehrspalten-Indizes auf einen Blick erkennbar sind.

UQ-Badge

Aus einem globalen CREATE UNIQUE INDEX. Verhält sich wie eine UNIQUE-Beschränkung für die FK-Validierung und Spaltenkennzeichnung.

PUQ-Badge

Aus CREATE UNIQUE INDEX ... WHERE. Zeigt das partielle Eindeutigkeitsprädikat, validiert FK-Ziele jedoch nicht als global eindeutig.

Unterdrückungsregel

Stärkere Constraints gewinnen: PK ⟶ UQ ⟶ PUQ ⟶ IDX. Ein stärkerer Schlüssel wird niemals durch einen späteren Index herabgestuft.

Multi-Dialekt

PostgreSQL CONCURRENTLY / USING / INCLUDE / WHERE, MySQL FULLTEXT/SPATIAL & inline KEY/INDEX, MSSQL CLUSTERED/NONCLUSTERED mit INCLUDE, SQLite Standardindizes.

4.1. Syntax

SQL / Beispiel
CREATE [UNIQUE] INDEX [IF NOT EXISTS] [name]
  ON [schema.]table (col1 [ASC|DESC] [NULLS FIRST|LAST], col2, ...)
  [INCLUDE (cols)]      -- PG / MSSQL: covering columns (no badge added)
  [WHERE predicate]     -- PG / MSSQL: partial / filtered index
  [USING method]        -- PG: btree, hash, gin, gist, brin
  [WITH (options)];     -- storage parameters

4.2. Beispiele

Beschleunigung einer häufigen FK-Suche (Einzelspalten-IDX):

SQL / Beispiel
CREATE INDEX idx_orders_customer ON orders (customer_id);

Zusammengesetzter Index (gedämpfte IDX-Pille an jeder Schlüsselspalte):

SQL / Beispiel
CREATE INDEX idx_orders_customer_status
  ON orders (customer_id, status);

Eine Spalte zu UNIQUE befördern, ohne ihre Definition zu ändern:

SQL / Beispiel
CREATE UNIQUE INDEX uq_shipments_tracking
  ON shipments (tracking_number);

Teilweiser / gefilterter eindeutiger Index (PUQ, kein globales FK-Ziel):

SQL / Beispiel
CREATE UNIQUE INDEX ux_users_active_email
  ON users (email)
  WHERE deleted_at IS NULL;

MySQL Inline-Index innerhalb von CREATE TABLE:

SQL / Beispiel
CREATE TABLE posts (
  id INT PRIMARY KEY,
  slug VARCHAR(160) NOT NULL,
  body TEXT,
  UNIQUE INDEX ux_posts_slug (slug),
  KEY idx_posts_body (body),
  FULLTEXT KEY ft_body (body)
);

MSSQL / SQL Server gefiltert + INCLUDE Index:

SQL / Beispiel
CREATE NONCLUSTERED INDEX idx_active_orders
  ON orders (customer_id)
  INCLUDE (total)
  WHERE status = 'active';

4.3. Verhalten & Semantik

  • Funktionale / Ausdrucks-Indizes (z.B. CREATE INDEX … ON t (lower(email))) bleiben erhalten und erzeugen eine explizite Warnung, aber kein Abzeichen — sie lassen sich nicht sauber auf eine einzelne Spalte abbilden.
  • INCLUDE-Spalten (abgedeckte Spalten) werden geparst, aber niemals ausgezeichnet – nur Schlüsselspalten erhalten den Punkt.
  • PK- / UQ-Spalten sind stärkere Garantien als IDX, daher jedes spätere CREATE INDEX darauf wird stillschweigend übersprungen — Sie sehen keine redundanten Pills.
  • Teilweise / gefilterte eindeutige Indizes rendern als PUQ mit dem/der WHERE Prädikat in den Spaltendetails. Sie werden nicht als global eindeutige Ziele für die Fremdschlüsselvalidierung akzeptiert.
  • Die Reihenfolge der letzten Badges spielt keine Rolle: eine globale Eindeutigkeitsgarantie unterdrückt ein redundantes IDX Kennzeichen, ob der eindeutige oder nicht eindeutige Index zuerst erscheint. Metadaten für zusammengesetzte Indizes werden unabhängig von der Deklarationsreihenfolge ebenfalls beibehalten.
  • Indizes für unbekannte Tabellen / Spalten werden stillschweigend verworfen – nützlich beim Portieren von Teilschemas, ohne das Diagramm zu beschädigen.
  • Index-Lebenszyklus enthält die oberste Ebene CREATE/DROP INDEX, PostgreSQL DROP INDEX CONCURRENTLY, MySQL ALTER TABLE … ADD/DROP/RENAME INDEX, PostgreSQL ALTER INDEX … RENAME, und SQL Server Indexumbenennungen über sp_rename. Benannte UQ/PUQ/IDX-Metadaten folgen dem letzten verbleibenden Namen.
Tipp: Zusammengesetzte IDX-Pillen werden in einem gedämpften Grau dargestellt, um die bestehende visuelle Sprache für zusammengesetzte Primärschlüssel (PK) / zusammengesetzte Eindeutigkeitsschlüssel (UQ) widerzuspiegeln. Eine durchgezogene IDX-Pille bedeutet immer „einspaltiger Index“ – leicht erfassbar in dichten Diagrammen.

Multi-Dialekt-Unterstützung

Der browserseitige Parser verarbeitet Syntaxunterschiede zwischen SQLite, PostgreSQL, MySQL und MSSQL ohne Datenbankverbindung. Die automatische Erkennung verwendet strukturelle Syntaxsignale und bleibt bei wirklich gemischten Dialekteingaben neutral; Aufrufer können auch einen expliziten Dialekt angeben. Die Beispiele unten folgen der gleichen Standardreihenfolge: zuerst SQLite, dann PostgreSQL, MySQL und MSSQL.

4.1. SQLite-Funktionen

SQL / Beispiel
-- SQLite uses type affinities: INTEGER, TEXT, REAL, NUMERIC, BLOB
CREATE TABLE users (
  id       INTEGER PRIMARY KEY,         -- implicit rowid alias
  email    TEXT UNIQUE NOT NULL,
  name     TEXT NOT NULL,
  balance  REAL DEFAULT 0.0,
  metadata BLOB,
  created  TEXT DEFAULT (datetime('now'))
);

-- AUTOINCREMENT prevents rowid reuse after DELETE
CREATE TABLE events (
  id   INTEGER PRIMARY KEY AUTOINCREMENT,
  name TEXT NOT NULL,
  ts   TEXT DEFAULT CURRENT_TIMESTAMP
);

-- WITHOUT ROWID — clustered on the declared PRIMARY KEY
CREATE TABLE kv_store (
  key   TEXT PRIMARY KEY,
  value TEXT
) WITHOUT ROWID;

-- STRICT mode — enforces declared column types
CREATE TABLE audit_log (
  id      INTEGER PRIMARY KEY,
  action  TEXT NOT NULL,
  payload TEXT
) STRICT;

-- STRICT + WITHOUT ROWID combined
CREATE TABLE config (
  key   TEXT PRIMARY KEY,
  value TEXT NOT NULL
) STRICT, WITHOUT ROWID;

-- Foreign keys with ON DELETE / ON UPDATE actions
CREATE TABLE orders (
  id          INTEGER PRIMARY KEY,
  customer_id INTEGER NOT NULL
    REFERENCES users(id) ON DELETE CASCADE ON UPDATE SET NULL,
  total       REAL DEFAULT 0 CHECK (total >= 0)
);

-- IF NOT EXISTS works as expected
CREATE TABLE IF NOT EXISTS sessions (
  token   TEXT PRIMARY KEY,
  user_id INTEGER REFERENCES users(id),
  expires TEXT
);
SQLite-spezifisch: INTEGER PRIMARY KEY (rowid-Alias), AUTOINCREMENT, WITHOUT ROWID, STRICT Tabellen, typungslose nicht-STRICT-Spalten, Typaffinitäten (INTEGER, TEXT, REAL, NUMERIC, BLOB), datetime('now') / CURRENT_TIMESTAMP Standardwerte und Standard REFERENCES mit ON DELETE / ON UPDATE Aktionen.
Typkorrektheit: Gewöhnliche SQLite-Tabellen akzeptieren beliebige deklarierte Typnamen (wie VARCHAR(255), BOOLEAN, oder TIMESTAMP) und können einen Typ weglassen. STRICT-Tabellen folgen dem exakt erlaubten Satz von SQLite: INT, INTEGER, REAL, TEXT, BLOB, oder ANY; jede STRICT-Spalte muss eine deklarieren.

Beispiel für eine SQLite-Migrationswiedergabe:

SQL / Beispiel
CREATE TABLE authors (
  id    INTEGER PRIMARY KEY,
  email TEXT NOT NULL UNIQUE
) STRICT;

CREATE TABLE posts (
  author_id INTEGER NOT NULL
    REFERENCES authors(id) ON DELETE CASCADE ON UPDATE RESTRICT,
  post_id   TEXT NOT NULL,
  body      TEXT,
  PRIMARY KEY (author_id, post_id)
) STRICT, WITHOUT ROWID;

ALTER TABLE posts ADD COLUMN summary TEXT;
ALTER TABLE posts RENAME COLUMN summary TO excerpt;
ALTER TABLE authors RENAME TO writers;

4.2. PostgreSQL-Funktionen

SQL / Beispiel
-- Composite type + ENUM + array column types
CREATE TYPE address AS (street TEXT, city VARCHAR(100), zip VARCHAR(20));
CREATE TYPE org_plan AS ENUM ('free','starter','pro','enterprise');

CREATE TABLE organizations (
  id            BIGSERIAL PRIMARY KEY,
  -- Or: id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
  name          VARCHAR(255) NOT NULL,
  plan          org_plan NOT NULL DEFAULT 'free',

  -- PostgreSQL-specific types
  billing_addr  address,                          -- composite type
  data          JSONB DEFAULT '{}',               -- JSON binary
  tags          TEXT[],                           -- 1-D array
  matrix        INT[5],                           -- sized array
  uuid          UUID DEFAULT gen_random_uuid(),
  ip            INET,
  ts            TIMESTAMPTZ DEFAULT NOW(),

  -- Dollar-quoted defaults
  description   TEXT DEFAULT $$Hello World$$,

  -- Type casting in defaults
  seq_id        INTEGER DEFAULT nextval('org_seq'::regclass)
);

-- Schema-qualified table & type references both work
CREATE TABLE public.users (
  id INTEGER PRIMARY KEY,
  status public.org_plan          -- schema-qualified user-defined type
);

-- Empty body INHERITS (PG-only)
CREATE TABLE child () INHERITS (parent);
PostgreSQL: Unterstützt SERIAL-Typen, Identitätsspalten, JSONB, BYTEA, INET, Zeitstempel-Varianten, Arrays, zusammengesetzte Typen und ENUM-Typen, UNIQUE NULLS NOT DISTINCT, Ausdrucksindex-Beibehaltung und die exakte Groß-/Kleinschreibung von PostgreSQL für Anführungszeichen.

4.3. MySQL-Funktionen

SQL / Beispiel
-- Backtick-quoted identifiers + ENGINE / CHARSET / COLLATE
CREATE TABLE `users` (
  `id` BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
  `name` VARCHAR(100) NOT NULL,

  -- Inline ENUM and SET (auto-registered as named types)
  `status` ENUM('active', 'inactive', 'suspended') NOT NULL DEFAULT 'active',
  `flags`  SET('verified','staff','beta','muted'),

  -- UNSIGNED / SIGNED modifiers + TINYINT(1)
  `age`     TINYINT UNSIGNED,
  `is_pro`  TINYINT(1) UNSIGNED DEFAULT 0,

  -- COMMENT on columns
  `email` VARCHAR(255) COMMENT 'User email address',

  -- Timestamps with ON UPDATE CURRENT_TIMESTAMP
  `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  `updated_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,

  -- MySQL-specific types
  `bio`         MEDIUMTEXT,
  `avatar`      LONGBLOB,
  `birth_year` YEAR(4),
  `location`    POINT,

  -- Inline indexes become ERD badges when they map to columns
  INDEX idx_name (`name`),
  FULLTEXT KEY ft_bio (`bio`),
  UNIQUE INDEX ux_name (`name`),
  UNIQUE KEY uk_email (`email`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
MySQL-spezifisch: AUTO_INCREMENT, COMMENT, vorzeichenbehaftete Modifikatoren, Integer-/Text-/Blob-/räumliche Varianten, Inline- ENUM und SET, Inline-Indizes, CHANGE COLUMN, MODIFY COLUMN, FIRST/AFTER physische Platzierung, ON UPDATE CURRENT_TIMESTAMP, und allgemeine Tabellenoptionen.

4.4. MSSQL / SQL Server-Funktionen

SQL / Beispiel
-- Bracket-quoted identifiers + IDENTITY + computed columns
CREATE TABLE [dbo].[Users] (
  [UserID]      BIGINT IDENTITY(1,1) NOT NULL CONSTRAINT pk_users PRIMARY KEY CLUSTERED,
  [FirstName]   NVARCHAR(50) NOT NULL,
  [LastName]    NVARCHAR(50) NOT NULL,

  -- Computed column (parenthesized form)
  [FullName]    AS ([FirstName] + ' ' + [LastName]) PERSISTED,

  -- Computed column (bare AS form — also supported)
  [Initials]    AS LEFT([FirstName],1) + LEFT([LastName],1),

  -- MSSQL-specific types
  [IsActive]    BIT DEFAULT 1,
  [CreatedAt]   DATETIME2 DEFAULT GETDATE(),
  [UniqueToken] UNIQUEIDENTIFIER DEFAULT NEWID(),
  [SeqToken]    UNIQUEIDENTIFIER DEFAULT NEWSEQUENTIALID() ROWGUIDCOL,
  [Photo]       VARBINARY(MAX),
  [Notes]       NVARCHAR(MAX),
  [Config]      XML,
  [Location]    GEOGRAPHY,
  [TreePath]    HIERARCHYID
) ON [PRIMARY];
GO

-- ALTER TABLE with WITH CHECK and CONSTRAINT WITH (...)
ALTER TABLE [Users] WITH CHECK
  ADD CONSTRAINT [chk_active] CHECK ([IsActive] IN (0,1));
GO

-- Multi-statement batches separated by GO are honored
CREATE TABLE [dbo].[Orders] (
  [OrderID] INT IDENTITY NOT NULL PRIMARY KEY  -- bare IDENTITY → (1,1)
);
GO
MSSQL-spezifisch: IDENTITY(seed, increment), NVARCHAR(MAX), Datums-/Zeit-, Binär-, XML-, Identifikations- und räumliche Typen, ROWGUIDCOL, gruppierte Indizes, GO Batches, ALTER COLUMN, berechnete Spalten, benannte DEFAULT ... FOR column Bedingungen, generierte temporale Spalten und PERIOD FOR SYSTEM_TIME.
Nur-ALS berechnete Spalten: col AS expression PERSISTED (keine umgebenden Klammern) wird vollständig unterstützt, einschließlich Funktionsaufrufen ("DATEADD, LEFT, …), tabellenqualifizierte Spaltenverweise (c.col), und CASE Ausdrücke.

4.5. Stile für Bezeichner-Anführungszeichen

Alle drei gängigen Anführungszeichenkonventionen werden unterstützt:

SQL / Beispiel
-- PostgreSQL / Standard SQL: double quotes
CREATE TABLE "My Table" (
  "Column Name" INTEGER
);

-- MySQL: backtick quotes
CREATE TABLE `my_table` (
  `column_name` INT
);

-- MSSQL / SQL Server: square brackets
CREATE TABLE [my_table] (
  [column_name] INT
);

Notizen & Tipps

Wichtige Details zur Syntaxunterstützung: Was zur Schemastruktur beiträgt, welche DDL/DML mit Beispieldaten wiedergegeben werden kann, was SELECT-Abfragen lesen können und wo die Grenzen liegen.

✓ Schema-/ERD-Syntaxunterstützung

  • Multi-Dialekt: SQLite-, PostgreSQL-, MySQL- und MSSQL-Syntax können sich ein Skript teilen; die automatische Erkennung bleibt neutral, wenn starke Signale tatsächlich gemischt sind
  • Groß-/Kleinschreibungsunabhängige Schlüsselwörter: CREATE, TABLE, ALTER usw. können in Groß- oder Kleinschreibung geschrieben werden
  • Anführungszeichen bei Bezeichnern: Anführungszeichen oben ("name"), Backticks (`name`), und Klammern ([name])
  • Spaltennamen mit reservierten Wörtern: Nur key, index, value, name, order, usw. werden akzeptiert, wenn sie von einem Datentyp gefolgt werden
  • Schema-qualifizierte Namen: schema.table und schema.type (z.B., public.users, dbo.Orders, app.status_enum) – Schema-Präfixe bei benutzdefinierten Typen bleiben für die strikte Suche erhalten und werden nur bei Eindeutigkeit zur Anzeige vereinfacht
  • Kommentare: Einzeilig (-- comment) und Blockkommentare ("/* comment */) werden automatisch übersprungen
  • BOM & CRLF: UTF-8 Byte-Order-Mark und Windows-Zeilenumbrüche werden transparent verarbeitet
  • Benutzerdefinierte Typen: CREATE TYPE … AS ENUM und CREATE TYPE … AS (composite), einschließlich schemaqualifizierter Namen
  • Inline ENUM & SET (MySQL): ENUM('a','b') und SET('a','b','c') innerhalb von Spaltentypen — automatisch als benannte Typen registriert und nach Tabelle/Spalte namenspacespezifisch getrennt, wenn doppelte Spaltennamen unterschiedliche Domänen verwenden
  • Einschränkungen: Spalten- und tabellenbezogen PRIMARY KEY, FOREIGN KEY, UNIQUE, CHECK (einschließlich zusammengesetzter Mehrspaltenvarianten). FK-Ziele werden gegen Primärschlüssel, eindeutige Einschränkungen oder globale eindeutige Indizes validiert
  • Identität / Auto-Increment: SERIAL/BIGSERIAL (PG), GENERATED ALWAYS/BY DEFAULT AS IDENTITY (PG), AUTO_INCREMENT (MySQL), IDENTITY(1,1) und nackt IDENTITY (MSSQL) — alle vereinigen sich im Diagramm
  • Berechnete Spalten: GENERATED ALWAYS AS (expr) STORED/VIRTUAL (PG/MySQL) und MSSQL col AS (expr) [PERSISTED] + bare col AS expr [PERSISTED]
  • PostgreSQL-Arrays: type[], dimensionierte type[5], verschachtelte type[][][], und Arrays von benutzdefinierten Typen (z. B., webhook_event[])
  • Standardwerte: Literale, dollar-gequotete Zeichenketten, Funktionsaufrufe ("now(), CURRENT_TIMESTAMP, GETDATE(), NEWID(), NEWSEQUENTIALID(), gen_random_uuid(), nextval()), und ON UPDATE CURRENT_TIMESTAMP (MySQL)
  • FK-Aktionen: ON DELETE / ON UPDATE mit CASCADE, RESTRICT, SET NULL, SET DEFAULT, NO ACTION, plus MATCH, DEFERRABLE, und INITIALLY Metadaten. Aktionen werden als Beziehungs-Metadaten beibehalten.
  • Migrationswiederholung: ALTER TABLE ADD COLUMN, Hinzufügen/Löschen/Umbenennen von Schlüsseln und Constraints, Umbenennen von Tabellen/Spalten/Indizes, DROP COLUMN, ALTER COLUMN TYPE/SET DATA TYPE, SET/DROP DEFAULT, SET/DROP NOT NULL, MSSQL sp_rename, und MySQL MODIFY/CHANGE COLUMN
  • Indizes: Top-Level CREATE/DROP INDEX, PostgreSQL ALTER INDEX … RENAME, MySQL Hinzufügen/Löschen/Umbenennen und Inline KEY/INDEX/UNIQUE INDEX/FULLTEXT/SPATIAL Definitionen. Spaltenbasierte Indizes werden dargestellt als IDX, UQ, oder PUQ Kennzeichen
  • IF NOT EXISTS, IF EXISTS: wird auf beiden Seiten problemlos gehandhabt CREATE und DROP
  • Transaktions-Wrapper nur für Schemata: BEGIN, COMMIT, SET search_path, USE [db] (MSSQL) und SET FOREIGN_KEY_CHECKS (MySQL) werden anmutig übersprungen
  • Anstandslos übersprungen: CREATE VIEW, CREATE MATERIALIZED VIEW, CREATE FUNCTION/TRIGGER/SCHEMA/SEQUENCE, prozedurale EXEC Anweisungen außer sp_rename, DECLARE, PRINT, PARTITION BY, INHERITS (einschließlich leerem Körper), WITH OIDS, STORAGE PLAIN, EXCLUDE USING gist, und Anweisungskörper, die die ERD-Struktur nicht beeinflussen

✓ DDL/DML-Vorschausyntax

  • Ausführung von oben nach unten: Das Skript wird in der Reihenfolge der Anweisungen wiederholt, daher sollten Beispieldaten nach dem Schema stehen, auf das sie verweisen.
  • Unterstützte Anweisungen: CREATE TYPE, CREATE TABLE, CREATE VIEW, CREATE INDEX, ALTER TABLE Spalten-/Constraint-Änderungen, DROP INDEX, TRUNCATE TABLE, INSERT, UPDATE, DELETE, DROP TABLE, DROP VIEW, und DROP TYPE
  • WHERE-Filter: =, !=, <>, >, <, >=, <=, LIKE, IN, NOT IN, NOT LIKE, BETWEEN, NOT BETWEEN, IS NULL, und IS NOT NULL
  • Zeilenmaterialisierung: Tabellen zeigen Zeilenanzahlen, Strukturmetadaten und aktuelle Zeilendaten an, nachdem DML-Anweisungen ausgeführt wurden
  • Benannte Typen: ENUM- und verbundene Typen erstellt mit CREATE TYPE werden getrennt von Tabellen angezeigt
  • Ausführungsprotokoll: Erfolgs-, Warn- und Fehlerzustände werden für unbekannte Spalten, fehlende Tabellen, doppelte Schlüssel, NULL-Verletzungen und umfassende Updates/Deletes erfasst; ungültige Mutationsbindungen schlagen fehl, bevor Zeilen geändert werden
  • Standardauswertung: Literale Standardwerte plus Funktionen wie now(), CURRENT_TIMESTAMP, CURRENT_DATE, GETDATE(), und NEWID()

✓ SELECT-Abfragesyntax

  • Schreibgeschütztes SELECT: SELECT Anweisungen können die aus der SQL-Hauptdatei erzeugten In-Memory-Tabellen lesen
  • Ergebnismetadaten: Spalten, Zeilenanzahlen, vergangene Zeit, NULL/Boolean/Zahlenformatierung und Abfragefehler werden mit dem SELECT-Ergebnis beibehalten
  • Relationale Abfragen: Joins, WHERE-Filter, GROUP BY, HAVING, ORDER BY, LIMIT/OFFSET, TOP, FETCH FIRST, CTEs, abgeleitete Tabellen, Unterabfragen und Mengenoperatoren
  • Analytische Helfer: Aggregate, allgemeine Skalarfunktionen, JSON-Helfer, Datums-/Zeichenfolgenfunktionen und Fensterfunktionen wie ROW_NUMBER, RANK, NTILE, FIRST_VALUE, LAST_VALUE, LAG, und LEAD; geordnete Standardrahmen enthalten die aktuelle Peer-Gruppe

✗ Noch nicht unterstützt / Übersprungen

  • ALTER TYPE: Bestehende ENUM- oder verbundene Typen können nicht geändert werden
  • LIKE-Klausel: CREATE TABLE foo (LIKE bar INCLUDING …) wird elegant übersprungen – kopierte Spalten werden nicht materialisiert
  • INHERITS-Spaltenvererbung: Das INHERITS (parent) Klausel selbst wird fehlerfrei geparst, aber vererbte Spalten werden für ERD-Zwecke nicht in die untergeordnete Tabelle übernommen
  • Indexausführung: Index-DDL kann Schema-Badges erstellen, aber die Vorschauausführung modelliert keine Speicher-Engines, Abfrageplaner oder Indexleistung
  • SELECT-Beschränkungen: Die Syntax für schreibgeschützte Abfragen unterstützt keine rekursiven CTEs, externe Datenbankausführung, gespeicherte Prozeduren oder Mutationsanweisungen
  • Andere Objekte: Trigger, gespeicherte Prozeduren, Funktionen und Sequenzen
  • Externe Ausführung: Die DDL-/DML-Vorschau stellt keine Verbindung zu einer echten Datenbank her und speichert keine Zeilen außerhalb der aktuellen SQL-Datei dauerhaft
Syntaxverhalten: DML trägt nicht zur Generierung von Schemadiagrammen bei. Tabellen-, Typ- und benannte Index-Lebenszyklus-Anweisungen werden in Quellreihenfolge wiedergegeben, einschließlich Umbenennung, Löschung und späterer Neuerstellung, ohne dass Metadaten zwischen Objektinkarnationen durchsickern. Unterstützte DDL/DML-Anweisungen werden von oben nach unten im Arbeitsspeicher ausgeführt, und schreibgeschützte SELECT-Abfragen lesen aus diesem In-Memory-Ergebnis, ohne es zu verändern.
Best Practices:
  • Beenden Sie jede Anweisung mit einem Semikolon (;)
  • Definieren CREATE TYPE vor Tabellen, die auf sie verweisen
  • Definieren CREATE TABLE vor verbundenen INSERT, UPDATE, oder DELETE Anweisungen
  • Verwenden ALTER TABLE für Fremdschlüssel, wenn Tabellen aufeinander verweisen (zirkuläre Abhängigkeiten)
  • Verwenden Sie zuerst DDL für die Struktur, dann DML, um Beispielzeilen und das Constraint-Verhalten zu validieren.
  • Halten Sie Demodaten in der SQL-Datei selbst, da Vorschauzeilen aus dem Skript abgeleitet werden.
Fehlerbehebung: Nicht unterstützte Anweisungen werden übersprungen, und Syntaxwarnungen/-fehler werden mit ausreichend Kontext angezeigt, um dieselbe Datei weiter zu verfeinern, anstatt von vorne zu beginnen.

Durch Befolgen dieser Syntaxmuster kann Erd Go Ihr ERD-Schema generieren, In-Memory-Daten in der Vorschau anzeigen und schreibgeschützte Abfragen aus derselben SQL-Datei ausführen.

ErdGo.com - Verwandeln Sie SQL in Diagramme und sehen Sie Daten schneller in der Vorschau