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.
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.
-- 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;REFERENCES oder ALTER TABLE ADD FOREIGN KEY. Beide Formen tragen dieselben Beziehungsmetadaten bei.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 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
- 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.
- Ü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.
- 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.
- Ü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
| Symptom | Was 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 Zeilen | Platzieren 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 überein | Fü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 vor | Die 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 werden | Prü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.
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
-- 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;=, !=, <>, >, <, >=, <=, 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
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.
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.
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;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
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.
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.
// 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.
// Each log entry is:
{
type: "success" | "warning" | "error",
message: "Inserted 3 row(s) into \"users\"",
timestamp: 1734567890123 // ms since epoch, monotonic
}-- 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 existGängige Diagnosen
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.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.
CREATE TYPE type_name AS (
field1 data_type1,
field2 data_type2,
...
);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)
);1.2. Enum-Typ
Erstellen Sie Aufzählungstypen mit vordefinierten Werten für bessere Datenintegrität und Lesbarkeit.
CREATE TYPE enum_name AS ENUM (
'value1',
'value2',
...
);Beispiel:
CREATE TYPE status_enum AS ENUM (
'pending',
'active',
'completed',
'cancelled'
);
CREATE TYPE priority_level AS ENUM (
'low', 'medium', 'high', 'critical'
);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.
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
);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:
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 ( ... );"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:
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
- Literale: Zahlen ("
123), Strings ('text') - PostgreSQL-Funktionen:
now(),CURRENT_TIMESTAMP,CURRENT_DATE,nextval('seq'::regclass) - MSSQL-Funktionen:
GETDATE(),NEWID()
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.
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.
CREATE TABLE tasks (
id INTEGER PRIMARY KEY,
status ENUM('todo', 'doing', 'done'),
priority ENUM('low', 'medium', 'high')
);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.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:
-- 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:
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)
);CONSTRAINT name) ist optional.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:
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
);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
-- 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 keyINTEGER PRIMARY KEY AUTOINCREMENT. Verwenden Sie nicht BIGINT, INT, oder ein zusammengesetzter Primärschlüssel mit AUTOINCREMENT.PostgreSQL
-- 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
);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
CREATE TABLE users (
id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
email VARCHAR(255) NOT NULL UNIQUE
) ENGINE=InnoDB;MSSQL / SQL Server
-- 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
);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
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
);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.
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
);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.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
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:
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
ALTER TABLE table_name
ADD [CONSTRAINT name] PRIMARY KEY (cols...);Beispiel:
ALTER TABLE products
ADD CONSTRAINT pk_products
PRIMARY KEY (product_id);3.3. Eindeutige Einschränkung hinzufügen
ALTER TABLE table_name
ADD [CONSTRAINT name] UNIQUE (cols...);Beispiel:
ALTER TABLE users
ADD CONSTRAINT uq_users_email
UNIQUE (email);3.4. CHECK-Einschränkung hinzufügen
ALTER TABLE table_name
ADD [CONSTRAINT name] CHECK (expression);Beispiel:
ALTER TABLE employees
ADD CONSTRAINT chk_salary
CHECK (salary >= 0);3.5. Beispiel für Migration-Wiederholung
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);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
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
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';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
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 parameters4.2. Beispiele
Beschleunigung einer häufigen FK-Suche (Einzelspalten-IDX):
CREATE INDEX idx_orders_customer ON orders (customer_id);Zusammengesetzter Index (gedämpfte IDX-Pille an jeder Schlüsselspalte):
CREATE INDEX idx_orders_customer_status
ON orders (customer_id, status);Eine Spalte zu UNIQUE befördern, ohne ihre Definition zu ändern:
CREATE UNIQUE INDEX uq_shipments_tracking
ON shipments (tracking_number);Teilweiser / gefilterter eindeutiger Index (PUQ, kein globales FK-Ziel):
CREATE UNIQUE INDEX ux_users_active_email
ON users (email)
WHERE deleted_at IS NULL;MySQL Inline-Index innerhalb von CREATE TABLE:
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:
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 INDEXdarauf wird stillschweigend übersprungen — Sie sehen keine redundanten Pills. - Teilweise / gefilterte eindeutige Indizes rendern als
PUQmit dem/derWHEREPrä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
IDXKennzeichen, 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, PostgreSQLDROP INDEX CONCURRENTLY, MySQLALTER TABLE … ADD/DROP/RENAME INDEX, PostgreSQLALTER INDEX … RENAME, und SQL Server Indexumbenennungen übersp_rename. Benannte UQ/PUQ/IDX-Metadaten folgen dem letzten verbleibenden Namen.
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
-- 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
);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.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:
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
-- 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);UNIQUE NULLS NOT DISTINCT, Ausdrucksindex-Beibehaltung und die exakte Groß-/Kleinschreibung von PostgreSQL für Anführungszeichen.4.3. MySQL-Funktionen
-- 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;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
-- 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)
);
GOIDENTITY(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.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:
-- 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.tableundschema.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 ENUMundCREATE TYPE … AS (composite), einschließlich schemaqualifizierter Namen - Inline ENUM & SET (MySQL):
ENUM('a','b')undSET('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 nacktIDENTITY(MSSQL) — alle vereinigen sich im Diagramm - Berechnete Spalten:
GENERATED ALWAYS AS (expr) STORED/VIRTUAL(PG/MySQL) und MSSQLcol AS (expr) [PERSISTED]+ barecol AS expr [PERSISTED] - PostgreSQL-Arrays:
type[], dimensioniertetype[5], verschachteltetype[][][], 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()), undON UPDATE CURRENT_TIMESTAMP(MySQL) - FK-Aktionen:
ON DELETE/ON UPDATEmitCASCADE,RESTRICT,SET NULL,SET DEFAULT,NO ACTION, plusMATCH,DEFERRABLE, undINITIALLYMetadaten. 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, MSSQLsp_rename, und MySQLMODIFY/CHANGE COLUMN - Indizes: Top-Level
CREATE/DROP INDEX, PostgreSQLALTER INDEX … RENAME, MySQL Hinzufügen/Löschen/Umbenennen und InlineKEY/INDEX/UNIQUE INDEX/FULLTEXT/SPATIALDefinitionen. Spaltenbasierte Indizes werden dargestellt alsIDX,UQ, oderPUQKennzeichen - IF NOT EXISTS, IF EXISTS: wird auf beiden Seiten problemlos gehandhabt
CREATEundDROP - Transaktions-Wrapper nur für Schemata:
BEGIN,COMMIT,SET search_path,USE [db](MSSQL) undSET FOREIGN_KEY_CHECKS(MySQL) werden anmutig übersprungen - Anstandslos übersprungen:
CREATE VIEW,CREATE MATERIALIZED VIEW,CREATE FUNCTION/TRIGGER/SCHEMA/SEQUENCE, prozeduraleEXECAnweisungen außersp_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 TABLESpalten-/Constraint-Änderungen,DROP INDEX,TRUNCATE TABLE,INSERT,UPDATE,DELETE,DROP TABLE,DROP VIEW, undDROP TYPE - WHERE-Filter:
=,!=,<>,>,<,>=,<=,LIKE,IN,NOT IN,NOT LIKE,BETWEEN,NOT BETWEEN,IS NULL, undIS 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 TYPEwerden 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(), undNEWID()
✓ SELECT-Abfragesyntax
- Schreibgeschütztes SELECT:
SELECTAnweisungen 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, undLEAD; 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
- Beenden Sie jede Anweisung mit einem Semikolon (
;) - Definieren
CREATE TYPEvor Tabellen, die auf sie verweisen - Definieren
CREATE TABLEvor verbundenenINSERT,UPDATE, oderDELETEAnweisungen - Verwenden
ALTER TABLEfü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.