VAN SCHEMA NAAR DIAGRAM
SQL naar ERD: handleiding
Zet je databaseschema om in een diagram. Leer welke SQL wordt ondersteund, bekijk gegevens en voer query’s uit op je model.
AI-gereed SQL-syntaxiscontract
Gebruik deze pagina als een compact contract bij het vragen aan een AI om SQL te schrijven of te bewerken voor Erd Go. Geef de voorkeur aan de onderstaande syntaxispatronen, houd statements volledig en beëindigd met puntkomma's, en vermijd niet-ondersteunde databaseobjecten, tenzij u alleen ruwe SQL buiten Erd Go nodig heeft. SQLite-, PostgreSQL-, MySQL- en MSSQL-syntaxis worden ondersteund in de gedeelde subset hieronder. SQL-naar-ERD-conversie draait volledig in de browser, en de parser- en preview-engines zijn vergrendeld door duizenden eenheids- en integratietests die echte productieschema's (SaaS, bankwezen, sociaal, analyse, EHR) dekken.
SQLite
INTEGER PRIMARY KEY rowid-regels, typeloze kolommen, AUTOINCREMENT, WITHOUT ROWID, gevalideerde STRICT-tabellen, FK-acties en migratieherhaling
PostgreSQL
ENUM & samengestelde typen, arrays, JSONB, SERIAL, identiteitskolommen, NULLS NOT DISTINCT, expressie-indexen, schema-identiteit en hoofdlettergevoeligheid van geciteerde namen
MySQL
AUTO_INCREMENT, inline ENUM & SET, backticks, COMMENT, UNSIGNED/SIGNED, inline indexen, CHANGE/MODIFY COLUMN en FIRST/AFTER-plaatsing
MSSQL
IDENTITY, NVARCHAR(MAX), namen tussen haken, geclusterde indexen, GO-batches, ALTER COLUMN, berekende kolommen, benoemde standaardwaarden en temporele perioden
DDL
CREATE TYPE, CREATE TABLE, ALTER TABLE migratieherhaling, CREATE INDEX en veilige DROP-instructies voor schemavorm
DML / SELECT
INSERT, UPDATE, DELETE voor voorbeeldgegevens, plus alleen-lezen SELECT-syntaxis voor joins, CTE's, aggregaten, vensters en rapporten
Snelle start
Gebruik dit als een modelreactie bij het vragen van een AI om Erd Go-compatibele SQL: eerst aangepaste typen, daarna tabellen, daarna relatiebeperkingen na tabellen wanneer nuttig, dan voorbeeld DML. Houd read-only SELECT-query's apart.
-- 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 of ALTER TABLE ADD FOREIGN KEY. Beide vormen dragen dezelfde relatiemetadata bij.INSERT, UPDATE, en DELETE na de schema DDL. Het script wordt van boven naar beneden geëvalueerd, dus voorbeeldrijen moeten verwijzen naar tabellen en typen die al bestaan.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-tabbladen & bestandsimport
Start een nieuw SQL-bestand met een voorbeeld, een leeg Schema-tabblad of Importeer SQL-bestanden. Het voorbeeld scheidt schema en gegevens in tabbladen. Voeg SQL-tabblad voegt een ander editor-tabblad toe; dubbelklik op de titel om het te hernoemen.
Actieve tabbladen compileren samen in hun zichtbare volgorde voor het ERD, Gegevensweergave, Queryweergave en AI-verzoeken. Een inactief tabblad blijft een opgeslagen concept en wordt uitgesloten van die workflows. Plaats typen en tabellen vóór instructies die ervan afhangen.
SQL-bestanden importeren accepteert meerdere tekst-SQL-bestanden en beoordeelt parseerproblemen samen vóór import. Dit helpt bij het oplossen van verwijzingen tussen bestanden. Gebruik de tabvolgorde om afhankelijkheden en migratiestappen doelbewust te houden.
Gebruik pijltoetsen en Home/End in de tab-strip om van tabblad te wisselen, Alt+Links/Rechts om ze opnieuw te rangschikken, en Shift+Alt+F om SQL in de editor op te maken.
Open SQL Verkenner naast de tabbladen voor een aanpasbare mapstructuur. Maak geneste mappen en SQL-bestanden, selecteer een bestand om het te openen en organiseer met slepen/neerzetten. De rij-actiepop-up ondersteunt Bestandsnaam wijzigen en Verwijderen; klik buiten de pop-up om deze te sluiten. Het verwijderen van het laatste bestand houdt een leeg SQL-bestand geopend. Mappen wijzigen de uitvoeringsvolgorde niet. Het verwijderen van een map behoudt de bestanden en onderliggende mappen in de bovenliggende map. Opslaan behoudt de mapstructuur en paneelvoorkeur.
Het diagram bewerken en controleren
SQL is de bron van de schema-betekenis. Gebruik Tabel toevoegen om een tabel te construeren, of selecteer tabel- en kolomacties op het canvas om kolommen en verbindingen te bewerken. Canvas-schema-edities werken de bijbehorende SQL-tabbladen bij, evenals het diagram.
Het verwijderen van een kolom toont een voorbeeld van de getroffen verbindingen, sleutels, indexen en afhankelijke SQL. Beoordeel de verwijdering of cascade voordat u bevestigt. Complexe migraties of niet-ondersteunde afhankelijke verklaringen kunnen directe SQL-bewerking vereisen.
Gebruik de ERD-gezondheidsscore om structurele bevindingen te inspecteren en optionele relatiesuggesties. Voorgestelde relaties behoeven beoordeling; ze vervangen geen gedeclareerde vreemde sleutels of stellen automatisch bedrijfsregels vast.
Schik tabellen met de Layout-modus, zoom in/uit of Passend op scherm, vind tabellen met de Tabelnavigator en gebruik Tabelkleuren of de minimap om door een groot diagram te navigeren. Beweeg over of focus op een werkbalkbesturingselement voor de hulptekst.
Selecteer een tabel en open Kleurkiezer voor effen of verloopvoorinstellingen. Voer een hexadecimale waarde in of kies 'Aangepast' ernaast om de systeemeigen kleurkiezer te gebruiken. Beide bedieningselementen blijven gesynchroniseerd; Opslaan behoudt de tabelkleur.
Wanneer tabelhulpmiddelen zijn ingesteld op alleen-hover, verschijnt 'Kolom toevoegen' wanneer u met de muis over de laatst zichtbare rij gaat of de knop met het toetsenbord selecteert. Altijd zichtbare hulpmiddelen houden deze zichtbaar.
Kies Tabelgroepen op de werkbalk van het SQL-canvas en vervolgens Nieuwe groep. Geef de groep een naam en kleur, selecteer de bijbehorende tabellen en kies Groep maken. Een geselecteerde tabel begint aangevinkt. Een tabel behoort tot één groep; het formulier toont wanneer uw selectie een tabel uit een andere groep verplaatst. Er worden maximaal 50 groepen ondersteund, met namen van maximaal 160 tekens.
Klik op een groepskoptekst om de naam, kleur of leden te bewerken. Sleep de koptekst om de tabellen samen te verplaatsen; laat los om de verplaatsing toe te passen. Escape, pointerannulering of het verliezen van de vensterfocus annuleert het voorbeeld. Tabellen de-groeperen verwijdert het frame terwijl de tabellen, hun posities, SQL en relaties behouden blijven.
Groepframes volgen de live tabelkaarten en verschijnen in Passend op scherm, de minimap en afbeeldingsexport van huidige weergave of hele diagram. Groepen zijn optionele visuele staten die met het SQL-document worden opgeslagen. Oudere bestanden behouden hun bestaande lay-out en tijdelijk ontbrekende tabelnamen blijven in hun groep totdat ze terugkeren naar de ontleedde SQL. Tabelgroepen behoren tot SQL naar ERD; Klassendiagrampakketten gebruiken een afzonderlijk model.
AI-beoordeling in de SQL-editor
- Voer een specifieke wijziging in bij Vraag AI om SQL te bewerken en kies een beschikbaar model. 'Gemini-API-sleutel instellen' is beschikbaar wanneer u uw eigen Gemini-sleutel wilt gebruiken.
- Bekijk de voorgestelde wijzigingen en de tijdelijke diagramvoorbeeldweergave. Het verzoek gebruikt de snapshot van het actieve tabblad die is vastgelegd toen het werd verzonden; een antwoord wordt niet automatisch opgeslagen.
- Accepteer of wijs individuele wijzigingen af, of gebruik de acties voor de resterende wijzigingen. Navigeer door codewijzigingen met F7 en Shift+F7. Beveiligde inactieve tabbladen blijven concepten.
- Inspecteer de geaccepteerde SQL en sla het document op. Met AI-prompt kopiëren in deze handleiding kunt u de documentatie ook gebruiken met een assistent buiten de app.
Gegevens, queries, exports en opgeslagen bestanden
Gebruik de knoppen ERD, Gegevens en Query om werkbanken te wisselen. Gegevensweergave materialiseert ondersteunde DDL en DML in de browser en toont tabellen, rijen, typen en een uitvoeringslogboek. Pas rasterkolommen aan door hun randen te slepen of dubbelklik om te passen. Dubbelklik op een Gegevenscel of druk op Enter om te bewerken; Booleaanse en enum-velden bieden geldige waarden. Rij toevoegen volgt uw schema-standaarden. Importeer CSV, TSV, TXT of XLSX met een kolomtoewijzingsvoorbeeld. NULL en lege tekst blijven verschillend. Gevalideerde bewerkingen worden SQL in een tabblad Gegevensbewerkingen en kunnen ongedaan worden gemaakt. Download tabelrijen of Queryresultaten als CSV.
Opslaan onthoudt de geselecteerde ERD-, Gegevens- of Query-werkbank; heropenen herstelt deze, inclusief Gegevens/Query op telefoons. Oudere bestanden starten in ERD. Native datum/tijd-editors behouden ondersteunde waarden, terwijl tijdstempels met fracties of tijdzoneverschuivingen bewerkbaar blijven als tekst. Door de database gegenereerde identiteiten blijven alleen-lezen.
Query View voert alleen-lezen SELECT-queries uit tegen de huidige in-memory tabellen. Het ondersteunt de hieronder gedocumenteerde syntaxis; er wordt geen verbinding gemaakt met een externe database. Querytekst wordt opgeslagen met de SQL-documentcontext.
Opslaan onthoudt ook de geselecteerde Gegevens tabel. Heropenen herstelt deze, met de eerste tabel als fallback indien deze niet beschikbaar is. Schemavelden komen overeen met namen, typen en regels; zweef over een regelbadge voor de uitleg. Ga naar SQL naast de tabelkop opent het bijbehorende SQL-tabblad en toont de CREATE TABLE-instructie, waarbij het SQL-paneel wordt heropend wanneer het verborgen is, terwijl de Gegevens selectie en concepten behouden blijven. Queryresultaten combineren tellingen, timing, Fit, Kopiëren en CSV in één header.
Sleep de smalle verdeler tussen de Query-editor en de resultaten, of tussen Gegevensschema en rijen, om de deelvensters te verschalen. Pijltoetsen schalen een geselecteerde verdeler, Escape annuleert het slepen en dubbelklikken herstelt de beginstand. Deze deelvensterafmetingen blijven tijdelijke werkruimtevoorkeuren.
Voorbeeldgegevens genereren gebruikt uw kolumntypen, namen, relaties en beperkingen. Voorbeeldtaal beheerst namen plus natuurlijke product-/beschrijvingszinnen in 17 talen. Bekijk voorgestelde generatoren en bereiken, bekijk het voorbeeld en voeg expliciet een afzonderlijk tabblad Voorbeeldgegevens in. Booleaanse waarden worden weergegeven als true/false; ID's blijven numeriek. Generatie vervangt nooit bestaande rijen.
Kies ERD exporteren om PNG, SVG met afbeelding of PDF te selecteren met HD-, 2K- of 4K-formaten. Geëxporteerde afbeeldingen vervangen geen bewerkbaar opgeslagen document.
Meld u aan en gebruik SQL en ERD opslaan om de SQL en diagramcontext op te slaan, inclusief tabbladen, toegepaste rasterbewerkingen, querytekst en lay-out. Opslaan controleert eerst een actieve cel of een concept voor een nieuwe rij; ongeldige gegevens blijven zichtbaar voor correctie. Importvoorbeelden hebben hun expliciete Import-actie nodig. Open opgeslagen bestanden vanuit de bestandslijst en gebruik Delen op een geclaimd opgeslagen document om openbare toegang te configureren en de alleen-lezenkoppeling ervan te distribueren.
SQL-, Prisma- en Builder-documenten worden geopend in hun eigen tools. Prisma en Builder hebben afzonderlijke bestandslijsten en cloud-only opslag. Prompts voor onopgeslagen wijzigingen beschermen bewerkte documenten bij het verlaten van een werkruimte; sla uw wijzigingen op voordat u deelt of wegschakelt.
Problemen oplossen met de SQL-werkruimte
| Symptoom | Wat te controleren |
|---|---|
| Een tabel ontbreekt | Controleer parseerdiagnostiek, actieve tabbladen en instructievolgorde. Een latere DROP of hernoeming kan het uiteindelijke diagram wijzigen. |
| Een relatie ontbreekt | Controleer of beide tabellen en kolommen bestaan, of de aantallen vreemde-sleutelkolommen overeenkomen en of de gerefereerde sleutel wereldwijd uniek is. Geef schema-kwalificatie op voor dubbelzinnige namen. |
| Gegevensweergave toont geen rijen | Plaats INSERT na de CREATE TABLE in een actief tabblad. Inspecteer het uitvoerlogboek op afgewezen rijen of een transactierolback. |
| Queryresultaten komen niet langer overeen met de SQL | Voer de query opnieuw uit na het wijzigen van het schema of de gegevens; gebruik de huidige in-memory tabellen. |
| Tabel toevoegen stelt een ander dialect voor | Gedetecteerde syntaxis van de actieve werkruimte heeft voorrang op de handmatig geselecteerde terugvaloptie. Controleer de SQL-taalindicator en tabelspecifieke standaarden. |
| Een opgeslagen bestand kan niet worden bewerkt | Controleer aanmelding en eigendom. Een openbare link verleent alleen-lezen toegang; gebruik Opnieuw proberen of Bestanden openen voor herstelbare laadfouten. |
AI-syntaxisworkflow
Wanneer je een AI-assistent gebruikt, vraag deze dan om SQL in deze volgorde te produceren. Dit zorgt ervoor dat het resultaat eenvoudig te parseren, eenvoudig te diagrammeren en eenvoudig te bekijken is met voorbeeldrijen of alleen-lezen queries.
1. Definieer eerst domeinen
Plaats CREATE TYPE enum-/composietdefinities vóór tabellen die hiernaar verwijzen. Geef de voorkeur aan expliciete namen boven ad-hoc inline-typen wanneer een domein wordt gedeeld.
2. Maak basistabellen aan
Gebruik CREATE TABLE voor kolommen, primaire sleutels, uniciteit, standaarden, checks, gegenereerde kolommen en inline vreemde sleutels.
3. Migraties opnieuw uitvoeren
Gebruik ALTER TABLE voor toegevoegde beperkingen, hernoemingen, verwijderde kolommen, wijzigingen in kolomtypen/nullability en circulaire vreemde sleutels.
4. Voeg als laatste gegevens en query's toe
Plaats INSERT/UPDATE/DELETE na alle DDL. Houd SELECT-queries gescheiden van schemamutatie wanneer u resultaatsets wilt.
ALTER TYPE. Expressie-indexen worden behouden met een waarschuwing; vraag om eenvoudige kolomsleutels wanneer u ERD-indexbadges nodig hebt.DDL- en DML-syntaxis
Deze statement-vormen zijn veilig voor door AI gegenereerde schema-scripts en voorbeeldgegevens. Dezelfde syntaxis stuurt de ERD-structuur en de in-memory preview-rijen, dus houd DDL vóór DML en vermijd externe database-specifieke neveneffecten.
Ondersteunde Statements
-- 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 combinaties. NULL-vergelijkingen volgen de SQL-standaard UNKNOWN-logica — col = NULL komt nooit overeen; gebruik col IS NULL in plaats daarvan. Onbekende toewijzingsdoelen, verwijzingen naar de rechterkolom en filterkolommen verwerpen de volledige mutatie voordat er rijwijzigingen plaatsvinden.Voorbeeldsemantiek voor door AI gegenereerde DML
Rijen worden opnieuw afgespeeld vanaf nul
DDL- en DML-instructies worden samen toegepast in de volgorde van de bron; elke gegevensinstructie gebruikt het schema dat op dat moment actief is.
Typen blijven inspecteerbaar
Benoemde enums en samengestelde typen gemaakt met CREATE TYPE blijven deel uitmaken van het geparseerde schema.
Beperkingen worden afgedwongen
PK, FK, NOT NULL, UNIQUE, DEFAULT, CHECK, gegenereerde kolommen en enum-domeinen beïnvloeden voorbeeldrijën.
Fouten moeten oplosbaar zijn
Geef de voorkeur aan expliciete kolomlijsten en concrete WHERE-clausules zodat diagnoses naar de exacte tabel of kolom kunnen wijzen.
SELECT resultaatsets in het hoofd-schema/DML-script, niet-ondersteunde procedurele bodies, of externe databaseaanroepen. CREATE VIEW, CREATE OR REPLACE VIEW, en MSSQL CREATE OR ALTER VIEW worden gematerialiseerd uit hun SELECT resultaat voor voorbeeld; houd ad-hoc alleen-lezen queries apart.Transacties in Gegevensweergave
Gegevensweergave ondersteunt BEGIN, COMMIT, ROLLBACK, SAVEPOINT, ROLLBACK TO en RELEASE in het in-memory voorbeeld. Deze instructies beïnvloeden voorbeeldrijen; ze worden nooit doorgevoerd (commit) naar een externe database.
SQLite, PostgreSQL en SQL Server behouden transactionele DDL in de preview. MySQL DDL committeert de actieve transactie. SQLite PRAGMA foreign_keys en MySQL SET FOREIGN_KEY_CHECKS beïnvloeden de daaropvolgende DML-validatie.
De ERD-renderer negeert transactiewrappers en vertegenwoordigt schemadeclaraties in bronvolgorde. Een transactierolback in Gegevensweergave kan daarom een andere set tabellen produceren dan het diagram. Controleer elke workbench op het gedrag dat u test.
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 Query Syntaxis
Vraag AI om alleen-lezen rapportagequeries te behouden als SELECT statements. Deze kunnen verwijzen naar de tabellen en rijen die zijn geproduceerd door het schema/DML-script en zijn nuttig voor joins, filters, totalen en rapport-vormige resultaatsets zonder dat een live database nodig is.
Ondersteunde Query Vorm
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;SELECT alleen
De query-editor accepteert SELECT-statements, inclusief SELECT zonder FROM en WITH CTE's die worden opgelost tot SELECT.
Joins & filters
INNER-, LEFT-, RIGHT-, FULL- en CROSS-joins, WHERE-voorwaarden, EXISTS, IN-subqueries, BETWEEN, LIKE, ILIKE en NULL-controles.
Aggregaten
GROUP BY, HAVING, COUNT, SUM, AVG, MIN, MAX, ARRAY_AGG, GROUP_CONCAT, STRING_AGG en DISTINCT-varianten.
Sortering en paginering
ORDER BY namen of ordinalen, ASC/DESC, NULLS FIRST/LAST, LIMIT/OFFSET, TOP en FETCH FIRST.
Geavanceerde SELECT-ondersteuning
CTEs & afgeleide tabellen
WITH-clausules, geneste SELECTs in FROM, scalaire subqueries, EXISTS, NOT EXISTS, IN en NOT IN worden ondersteund.
Stel operatoren in
UNION, UNION ALL, INTERSECT en EXCEPT kunnen compatibele resultaatsets combineren.
Window-functies
ROW_NUMBER, RANK, DENSE_RANK, NTILE, LAG, LEAD, FIRST_VALUE en LAST_VALUE met OVER en PARTITION BY. Geordende vensters gebruiken het peer-bewuste SQL-standaardframe en NTILE wijst grotere buckets eerst toe.
Dialecthulpfuncties
Veelvoorkomende SQLite-, PostgreSQL-, MySQL- en MSSQL-functies zijn genormaliseerd voor voorbeeldweergave, inclusief JSON- en datum-/tekenreekshelpers.
INSERT, UPDATE, DELETE, CREATE, ALTER, en DROP statements in het schema/DML-script. Querysyntaxis moet blijven SELECT-only.Diagnostiek en fouten
Syntaxisdiagnostiek behandelt schema-parsing, DDL/DML-uitvoering en alleen-lezen SELECT-problemen met duidelijke berichten. Parseerfouten bevatten waar mogelijk regel-/kolomposities, en uitvoeringsberichten wijzen terug naar de tabel, kolom of statementvorm die correctie behoeft.
Schema Parse Fouten
De schema-parser (SQLite, PostgreSQL, MySQL en MSSQL) rapporteert problemen met twee ernstgraden: fout stopt een enkele instructie van het bijdragen aan het schema; waarschuwing behoudt geldige syntaxis, maar markeert iets waarvan de gebruiker op de hoogte moet zijn.
// 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
}Parserfouten
Lege PRIMARY KEY / UNIQUE / FOREIGN KEY-kolomlijsten, ontbrekende vereiste datatypes (inclusief SQLite STRICT-kolommen), niet-overeenkomende haakjes, onverwachte komma's en onjuist gevormde beperkingen.
Tokenizer waarschuwingen
Niet-gesloten strings, niet-gesloten blokcommentaren, ontbrekende haakjes en verdachte CHECK-expressies over regels heen.
Waarschuwingen voor vreemde sleutels
FK's die verwijzen naar een onbekende tabel, onbekende kolom, dubzinnig schemablad of doel dat geen PK/UNIQUE is, worden uit het diagram verwijderd met een beschrijvende waarschuwing.
Gegroepeerde diagnostiek
Waarschuwingen worden gegroepeerd per oorzaak, waaronder Verwijderde relatie, Onbekende tabel, Onbekende kolom, Niet-uniek FK-doel, Waarschuwingen en Parseerfouten.
Lege SQL
Lege invoer is geldig en produceert een leeg schema. Alleen ongeldige niet-tekenreeksen genereren een fout.
DDL/DML-uitvoeringslogboek
Elke uitgevoerde DDL- of DML-instructie voegt één gestructureerd item toe aan het uitvoeringslogboek in het geheugen. De berichtenstroom behoudt de chronologische volgorde en classificeert elke instructie als fout, waarschuwing, of succes.
// 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 existVeelvoorkomende diagnose
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
Definieer aangepaste gegevenstypen voor hergebruik in je databaseschema. Benoemde enum- en samengestelde typen moeten verschijnen vóór tabellen die hiernaar verwijzen, inclusief schemagekwalificeerde verwijzingen.
1.1. Samengesteld type
Definieer aangepaste samengestelde typen met meerdere velden van verschillende gegevenstypen.
CREATE TYPE type_name AS (
field1 data_type1,
field2 data_type2,
...
);Voorbeeld:
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-type
Geenumereerde typen maken met vooraf gedefinieerde waarden voor betere gegevensintegriteit en leesbaarheid.
CREATE TYPE enum_name AS ENUM (
'value1',
'value2',
...
);Voorbeeld:
CREATE TYPE status_enum AS ENUM (
'pending',
'active',
'completed',
'cancelled'
);
CREATE TYPE priority_level AS ENUM (
'low', 'medium', 'high', 'critical'
);1.3. Schema-gekwalificeerde typen
Door de gebruiker gedefinieerde typen worden opgelost met hetzelfde schema-bewustzijn als tabellen. Als twee schema's dezelfde leaf-naam definiëren, houdt de ERD ze gescheiden; als een type uniek is, blijft de weergavenaam eenvoudig.
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 wordt nooit opgelost naar s2.status alleen maar omdat beide dezelfde bladnaam delen status. Gekwalificeerde typenamen zijn strikt, terwijl ongekwalificeerde namen alleen worden opgelost als ze eenduidig zijn.CREATE TABLE
Definieer databasetabellen met kolommen, gegevenstypen en beperkingen.
2.1. Basistabelstructuur
De algemene syntaxis voor het maken van een tabel:
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\`), of vierkante haken ([name]) voor het escapen van speciale tekens of gereserveerde trefwoorden.2.2. Definities op kolomniveau
Elke kolom kan verschillende beperkingen en eigenschappen bevatten:
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
Identificeert elke rij uniek
UNIEK
Zorgt ervoor dat kolomwaarden uniek zijn
NOT NULL
Voorkomt null-waarden
DEFAULT
Stelt standaardwaarden in (literals of functies)
CHECK
Valideert gegevens met booleaanse expressies
REFERENCES
Maakt vreemde sleutelrelaties (foreign key) aan
- Letterlijke waarden: getallen (
123), tekenreeksen ('text') - PostgreSQL-functies:
now(),CURRENT_TIMESTAMP,CURRENT_DATE,nextval('seq'::regclass) - MSSQL-functies:
GETDATE(),NEWID()
REFERENCES table(column), schemagekwalificeerde REFERENCES schema.table(column), weggelaten doelkolommen zoals REFERENCES departments, en FK-acties zoals ON DELETE CASCADE, ON UPDATE SET NULL, MATCH FULL, en DEFERRABLE INITIALLY DEFERRED.2.3. Gegenereerde / berekende kolommen
Snelle referentie. Zie de toegewijde Berekende kolommen sectie hieronder voor de volledige per-dialect-uitsplitsing inclusief de MSSQL bare-AS-vorm.
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
U kunt een ENUM rechtstreeks definiëren in een kolomdefinitie (MySQL-stijl). De parser registreert het als een benoemde enum en vervangt automatisch het kolomtype.
CREATE TABLE tasks (
id INTEGER PRIMARY KEY,
status ENUM('todo', 'doing', 'done'),
priority ENUM('low', 'medium', 'high')
);column_enum (bijvoorbeeld, status_enum); latere tabellen met een andere definitie voor dezelfde kolomnaam krijgen een tabelgekwalificeerde naam zoals tasks_status_enum zodat domeinen nooit per ongeluk instorten.CREATE TYPE ... AS ENUM in plaats daarvan.2.5. Beperkingen op tabelniveau
Definieer beperkingen aan het einde van het tabelorgaan. Handig voor samengestelde sleutels en kolomoverschrijdende beperkingen:
-- 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)Voorbeeld:
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) is optioneel.REFERENCES ref_table laat de doelkolomlijst weg, Erd Go lost deze op naar de primaire sleutel van de gerefereerde tabel, inclusief samengestelde primaire sleutels. Als u doelkolommen expliciet specificeert, moeten deze worden ondersteund door een PRIMARY KEY, UNIQUE constraint, of globaal CREATE UNIQUE INDEX; gefilterde / partiële unieke indexen tellen niet mee als FK-doelen. Ongeldige relaties worden verwijderd met een waarschuwing.2.6. Kolomnamen met gereserveerde woorden
Woorden zoals key, index, value, en name zijn gereserveerd in sommige dialecten, maar worden vaak gebruikt als kolomnamen in andere. De parser maakt automatisch onderscheid wanneer het volgende token een bekend gegevenstype is, dus onbeschermd gebruik werkt:
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 gevolgd door een datatype-trefwoord ("VARCHAR, INT, …) is een kolom. Gevolgd door een id en een kolommenlijst tussen haakjes, is het een index. Voor absolute veiligheid omsluit u de kolom met "key", `key`, of [key].Identiteits- / autoincrementkolommen
Gebruik de native identiteitssyntaxis voor de geselecteerde dialect. Alle ondersteunde vormen produceren een primaire sleutelkolom met de AUTO_INCREMENT markering, maar SQLite heeft één strikte regel: AUTOINCREMENT vereist een enkele INTEGER PRIMARY KEY kolom.
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. Gebruik niet BIGINT, INT, of een samengestelde primaire sleutel met 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 is een identiteit kolom (auto-increment), verschillend van GENERATED ALWAYS AS (expression) wat een berekend kolom. De parser houdt ze automatisch gescheiden.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 — zodat je dialecten in één schema kunt mixen zonder de auto-increment hint te verliezen.Berekende kolommen (per dialect)
Een berekende kolom ontleent zijn waarde aan een expressie over andere kolommen in dezelfde rij. Ondersteund in alle vier dialecten met hun respectievelijke syntaxes.
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 slaat de berekende waarde op en VIRTUAL berekent deze bij het lezen. Erd Go houdt voorbeeldwaarden in het geheugen; de ERD behoudt elke modus als kolommetadata.MSSQL / SQL Server — kolom AS expressie [PERSISTED]
MSSQL heeft zijn eigen syntaxis: column_name AS expression, optioneel gevolgd door PERSISTED (en optioneel NOT NULL). Beide tussen haakjes en kaal expressievormen worden ondersteund.
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 (geen omliggende haakjes) — inclusief functie-aanroepen zoals DATEADD(...), tabelgekwalificeerde verwijzingen zoals c.GrowthDurationDays, en CASE expressies — eindigend bij de volgende kolom-komma, PERSISTED, of het einde van de tabelbody.COMPUTED als het type en de uitdrukking die behouden blijven in de kolom-extra's / tooltip.ALTER TABLE
Veelvoorkomende migratiestijl ALTER TABLE statements worden opnieuw afgespeeld na tabelaanmaak, zodat het uiteindelijke schema toegevoegde kolommen, beperkingen, hernoemingen, verwijderde kolommen en kolomtype/nullability-wijzigingen weerspiegelt. PostgreSQL dump-syntaxis met ALTER TABLE ONLY behoudt de gekwalificeerde tabelidentiteit.
Toevoegen & beperken
ADD COLUMN, ADD PRIMARY KEY, ADD UNIQUE, ADD CHECK en ADD FOREIGN KEY worden weergegeven in het ERD.
Hernoemen en verwijderen
Hernoemen van tabellen, kolommen, beperkingen en indexen - inclusief MySQL RENAME TABLE, PostgreSQL ALTER INDEX en SQL Server sp_rename - blijven gebonden aan de juiste objectinstantie vóór latere DROP-bewerkingen.
Kolomwijzigingen
PostgreSQL ALTER COLUMN TYPE/SET DATA TYPE/SET of DROP DEFAULT/nullability, MSSQL ALTER COLUMN en MySQL MODIFY/CHANGE COLUMN worden opnieuw uitgevoerd.
Relatieveiligheid
Vreemde sleutels worden gevalideerd tegen de definitieve tabelstatus na migratie-replay, inclusief PK/UQ/indexwijzigingen en exacte bron-/doelkolomaantallen.
3.1. Vreemde sleutel toevoegen
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];Voorbeeld:
ALTER TABLE orders
ADD CONSTRAINT fk_orders_customer
FOREIGN KEY (customer_id)
REFERENCES customers(id)
ON DELETE CASCADE;3.2. Primaire sleutel toevoegen
ALTER TABLE table_name
ADD [CONSTRAINT name] PRIMARY KEY (cols...);Voorbeeld:
ALTER TABLE products
ADD CONSTRAINT pk_products
PRIMARY KEY (product_id);3.3. Unieke beperking toevoegen
ALTER TABLE table_name
ADD [CONSTRAINT name] UNIQUE (cols...);Voorbeeld:
ALTER TABLE users
ADD CONSTRAINT uq_users_email
UNIQUE (email);3.4. Controlebeperking toevoegen
ALTER TABLE table_name
ADD [CONSTRAINT name] CHECK (expression);Voorbeeld:
ALTER TABLE employees
ADD CONSTRAINT chk_salary
CHECK (salary >= 0);3.5. Voorbeeld van migratieherhaling
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 wordt contact_email, audit_state is verwijderd, en de unieke index geeft contact_email een UQ badge.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 wordt geparseerd over alle vier de dialecten. Eenvoudige kolomseutels worden weergegeven als kleine ERD-badges: IDX voor niet-unieke snelheidsverbeteringen, UQ voor globale unieke indexen, en PUQ voor gefilterde / gedeeltelijke unieke indexen. Expressie-invoer blijft behouden in de parseruitvoer en wordt gerapporteerd wanneer deze niet eerlijk kan worden toegewezen aan een kolom-badge.
IDX-badge
Niet-unieke index. Vaste pil op de kolom. Samengestelde indexen dempen de pil (grijs) op elke sleutelkolom, zodat een enkele kolom versus meerdere kolommen in één oogopslag duidelijk is.
UQ-badge
Van een globale CREATE UNIQUE INDEX. Gedraagt zich als een UNIQUE-beperking voor FK-validatie en kolombadges.
PUQ-badge
Van CREATE UNIQUE INDEX ... WHERE. Toont het partiële uniekheidspredikaat, maar valideert FK-doelen niet als wereldwijd uniek.
Onderdrukkingsregel
Sterkere beperkingen winnen: PK ⟶ UQ ⟶ PUQ ⟶ IDX. Een sterkere sleutel wordt nooit gedegradeerd door een latere index.
Meerdere dialecten
PostgreSQL CONCURRENTLY / USING / INCLUDE / WHERE, MySQL FULLTEXT/SPATIAL & inline KEY/INDEX, MSSQL CLUSTERED/NONCLUSTERED met INCLUDE, SQLite standaard indexen.
4.1. Syntaxis
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. Voorbeelden
Versnel een veelgebruikte FK-opzoeking (index met één kolom):
CREATE INDEX idx_orders_customer ON orders (customer_id);Samengestelde index (gedempte IDX-pilletjes op elke sleutelkolom):
CREATE INDEX idx_orders_customer_status
ON orders (customer_id, status);Promoveer een kolom naar UNIQUE zonder de definitie ervan te wijzigen:
CREATE UNIQUE INDEX uq_shipments_tracking
ON shipments (tracking_number);Gedeeltelijke / gefilterde unieke index (PUQ, geen globale FK-doel):
CREATE UNIQUE INDEX ux_users_active_email
ON users (email)
WHERE deleted_at IS NULL;MySQL inline index binnen 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 gefilterd + INCLUDE-index:
CREATE NONCLUSTERED INDEX idx_active_orders
ON orders (customer_id)
INCLUDE (total)
WHERE status = 'active';4.3. Gedrag en semantiek
- Functionele / expressie-indexen (bijv.
CREATE INDEX … ON t (lower(email))) worden behouden en genereren een expliciete waarschuwing, maar geen badge — ze komen niet netjes overeen met één kolom. - INCLUDE-kolommen (dekkende kolommen) worden geparseerd maar krijgen nooit een badge — alleen sleutelkolommen krijgen de pil.
- PK / UQ-kolommen zijn sterkere garanties dan IDX, dus elke latere
CREATE INDEXop wordt stilzwijgend overgeslagen — u ziet geen redundante 'pills'. - Gedeeltelijke / gefilterde unieke indexen weergeven als
PUQmet deWHEREpredicaat in kolomdetails. Ze worden niet geaccepteerd als globaal unieke doelen voor validatie van vreemde sleutels. - Uiteindelijke badges zijn volgorde-invariënt: een wereldwijde unieke garantie onderdrukt een redundante
IDXbadge of het unieke of niet-unieke index eerst verschijnt. Samengestelde indexmetadata wordt eveneens behouden, ongeacht de declaratievolgorde. - Indexen op onbekende tabellen / kolommen worden stilzwijgend verwijderd - handig bij het overzetten van gedeeltelijke schema's zonder het diagram te breken.
- Indexlevenscyclus bevat top-level
CREATE/DROP INDEX, PostgreSQLDROP INDEX CONCURRENTLY, MySQLALTER TABLE … ADD/DROP/RENAME INDEX, PostgreSQLALTER INDEX … RENAME, en SQL Server-indexhernoemingen viasp_rename. Benoemde UQ/PUQ/IDX-metadata volgt de uiteindelijke overgebleven naam.
Ondersteuning voor meerdere dialecten
De browser-gebaseerde parser behandelt syntactische verschillen tussen SQLite, PostgreSQL, MySQL en MSSQL zonder databaseverbinding. Automatische detectie gebruikt structurele syntactische signalen en blijft neutraal voor werkelijk gemengde dialectinvoer; aanroepers kunnen ook een expliciet dialect opgeven. Voorbeelden hieronder volgen dezelfde standaardvolgorde: eerst SQLite, dan PostgreSQL, MySQL en MSSQL.
4.1. SQLite-functies
-- 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, typeless niet-STRICT kolommen, type-affiniteiten ("INTEGER, TEXT, REAL, NUMERIC, BLOB), datetime('now') / CURRENT_TIMESTAMP standaardwaarden en standaard REFERENCES met ON DELETE / ON UPDATE acties.VARCHAR(255), BOOLEAN, of TIMESTAMP) en kunnen een type weglaten. STRICT-tabellen volgen de exacte toegestane set van SQLite: INT, INTEGER, REAL, TEXT, BLOB, of ANY; elke STRICT-kolom moet er één declareren.SQLite-migratiespeling voorbeeld:
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-functies
-- 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, behoud van expressie-indexen en de exacte hoofdlettergevoelige identiteit van PostgreSQL voor geciteerde namen.4.3. MySQL-functies
-- 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, getekende modifiers, integer/text/blob/ruimtelijke varianten, inline ENUM en SET, inline indexen, CHANGE COLUMN, MODIFY COLUMN, FIRST/AFTER fysieke plaatsing, ON UPDATE CURRENT_TIMESTAMP, en algemene tabelopties.4.4. MSSQL / SQL Server-functies
-- 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), datum/tijd, binair, XML, identificatie- en ruimtelijke typen, ROWGUIDCOL, geclusterde indexen, GO batches, ALTER COLUMN, berekende kolommen, benoemde DEFAULT ... FOR column constraints, gegenereerde temporele kolommen, en PERIOD FOR SYSTEM_TIME.col AS expression PERSISTED (geen omliggende haakjes) wordt volledig ondersteund, inclusief functie-aanroepen (DATEADD, LEFT, …), tabelgekwalificeerde kolomverwijzingen (c.col), en CASE expressies.4.5. Stijlen voor identificatieaanhalingstekens
Alle drie de belangrijkste aanhalingstekens worden ondersteund:
-- 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
);Notities en tips
Belangrijke details over syntaxisondersteuning: wat bijdraagt aan de schemastructuur, welke DDL/DML kan worden afgespeeld met voorbeeldrijen, welke SELECT-query's kunnen worden gelezen en waar de limieten liggen.
✓ Schema / ERD Syntax Ondersteuning
- Meerdere dialecten: SQLite-, PostgreSQL-, MySQL- en MSSQL-syntaxis kunnen een script delen; automatische detectie blijft neutraal wanneer sterke signalen echt gemengd zijn
- Niet-hoofdlettergevoelige trefwoorden: CREATE, TABLE, ALTER, etc. kunnen in elk hoofdlettertype worden geschreven
- Tussen aanhalingstekens geplaatste identificatoren: Dubbele aanhalingstekens (
"name"), backticks (`name`), en haken ([name]) - Gereserveerde kolomnamen: Kaal
key,index,value,name,order, enz. worden geaccepteerd wanneer ze worden gevolgd door een gegevenstype - Schema-qualified names:
schema.tableenschema.type(bijv.,public.users,dbo.Orders,app.status_enum) — schemaprefixes op door de gebruiker gedefinieerde typen worden behouden voor strikt opzoeken en alleen vereenvoudigd voor weergave wanneer dit eenduidig is - Opmerkingen: Enkele regel ("
-- comment) en blokopmerkingen (/* comment */) worden automatisch overgeslagen - BOM & CRLF: UTF-8 byte-order-mark en Windows-regeleinden worden transparant afgehandeld
- Aangepaste typen:
CREATE TYPE … AS ENUMenCREATE TYPE … AS (composite), inclusief schemagekwalificeerde namen - Inline ENUM & SET (MySQL):
ENUM('a','b')enSET('a','b','c')binnen kolomtypen - automatisch geregistreerd als benoemde typen en genamed naar tabel/kolom wanneer dubbele kolomnamen verschillende domeinen gebruiken - Beperkingen: Kolomniveau en tabelniveau
PRIMARY KEY,FOREIGN KEY,UNIQUE,CHECK(inclusief samengestelde kolommen met meerdere kolommen). FK-doelen worden gevalideerd tegen primaire sleutels, unieke beperkingen of globale unieke indexen - Identiteit / auto-increment:
SERIAL/BIGSERIAL(PG),GENERATED ALWAYS/BY DEFAULT AS IDENTITY(PG),AUTO_INCREMENT(MySQL),IDENTITY(1,1)en kaleIDENTITY(MSSQL) — alles komt samen in het diagram - Berekende kolommen:
GENERATED ALWAYS AS (expr) STORED/VIRTUAL(PG/MySQL) en MSSQLcol AS (expr) [PERSISTED]+ kalecol AS expr [PERSISTED] - PostgreSQL-arrays:
type[], van formaat voorzientype[5], genestetype[][][], en arrays van door de gebruiker gedefinieerde typen (bijv.,webhook_event[]) - Standaardwaarden: Letterlijke waarden, dollar-aangehaalde tekenreeksen, functieaanroepen (
now(),CURRENT_TIMESTAMP,GETDATE(),NEWID(),NEWSEQUENTIALID(),gen_random_uuid(),nextval()), enON UPDATE CURRENT_TIMESTAMP(MySQL) - FK-acties:
ON DELETE/ON UPDATEmetCASCADE,RESTRICT,SET NULL,SET DEFAULT,NO ACTION, plusMATCH,DEFERRABLE, enINITIALLYmetadata. Acties worden bewaard als relatiemetadata. - Migratie opnieuw afspelen:
ALTER TABLE ADD COLUMN, sleutels en beperkingen toevoegen/verwijderen/hernoemen, hernoemen van tabellen/kolommen/indexen,DROP COLUMN,ALTER COLUMN TYPE/SET DATA TYPE,SET/DROP DEFAULT,SET/DROP NOT NULL, MSSQLsp_rename, en MySQLMODIFY/CHANGE COLUMN - Indexen: Top-level
CREATE/DROP INDEX, PostgreSQLALTER INDEX … RENAME, MySQL toevoegen/verwijderen/hernoemen en inlineKEY/INDEX/UNIQUE INDEX/FULLTEXT/SPATIALdefinities. Kolom-gebaseerde indexen worden weergegeven alsIDX,UQ, ofPUQbadges - IF NOT EXISTS, IF EXISTS: gracieus afgehandeld aan beide zijden
CREATEenDROP - Schema-only transaction wrappers:
BEGIN,COMMIT,SET search_path,USE [db](MSSQL), enSET FOREIGN_KEY_CHECKS(MySQL) worden netjes overgeslagen - Sierlijk overgeslagen:
CREATE VIEW,CREATE MATERIALIZED VIEW,CREATE FUNCTION/TRIGGER/SCHEMA/SEQUENCE, procedureleEXECstatements anders dansp_rename,DECLARE,PRINT,PARTITION BY,INHERITS(inclusief lege body),WITH OIDS,STORAGE PLAIN,EXCLUDE USING gist, en instructieteksten die de ERD-structuur niet beïnvloeden
✓ DDL/DML Preview Syntax
- Top-naar-beneden uitvoering: Het script wordt afgespeeld in statement-volgorde, dus voorbeeldgegevens moeten na het schema komen waarnaar ze verwijzen
- Ondersteunde statements:
CREATE TYPE,CREATE TABLE,CREATE VIEW,CREATE INDEX,ALTER TABLEkolom/constraint-wijzigingen,DROP INDEX,TRUNCATE TABLE,INSERT,UPDATE,DELETE,DROP TABLE,DROP VIEW, enDROP TYPE - WHERE-filters:
=,!=,<>,>,<,>=,<=,LIKE,IN,NOT IN,NOT LIKE,BETWEEN,NOT BETWEEN,IS NULL, enIS NOT NULL - Rijmaterialisatie: Tabellen tonen rijtellingen, structuurmetadata en huidige rijgegevens na DML-statements.
- Benoemde typen: ENUM- en samengestelde typen gemaakt met
CREATE TYPEworden afzonderlijk van tabellen weergegeven - Uitvoeringslogboek: Succes-, waarschuwings- en foutstatussen worden vastgelegd voor onbekende kolommen, ontbrekende tabellen, dubbele sleutels, NULL-schendingen en brede updates/deletes; ongeldige mutatiebindingen falen voordat rijen veranderen
- Standaard evaluatie: Letterlijke standaardwaarden plus functies zoals
now(),CURRENT_TIMESTAMP,CURRENT_DATE,GETDATE(), enNEWID()
✓ SELECT Query Syntax
- Alleen-lezen SELECT:
SELECTstatements kunnen de in-memory tabellen lezen die zijn geproduceerd uit het hoofd-SQL-bestand - Resultaatmetadata: Kolommen, rijtellingen, verstreken tijd, NULL/booleaanse/getalnotatie en queryfouten blijven behouden bij het SELECT-resultaat
- Relationele queries: Joins, WHERE-filters, GROUP BY, HAVING, ORDER BY, LIMIT/OFFSET, TOP, FETCH FIRST, CTE's, afgeleide tabellen, subquery's en set-operatoren
- Analytische hulpmiddelen: Aggregaten, veelvoorkomende scalaire functies, JSON-helpers, datum-/tekenreeksfuncties en vensterfuncties zoals
ROW_NUMBER,RANK,NTILE,FIRST_VALUE,LAST_VALUE,LAG, enLEAD; geordende standaardframes bevatten de huidige leeftijdsgroep
✗ Nog Niet Ondersteund / Overgeslagen
- ALTER TYPE: Kan bestaande ENUM- of samengestelde typen niet wijzigen
- LIKE-clausule:
CREATE TABLE foo (LIKE bar INCLUDING …)wordt netjes overgeslagen — gekopieerde kolommen worden niet gematerialiseerd - INHERITS-kolomovererving: De
INHERITS (parent)clausule zelf parseert zonder fouten, maar overgeërfde kolommen worden niet naar de kindtabel gehaald voor ERD-doeleinden - Indexexecutie: Index-DDL kan schemabadges maken, maar voorbeeldexecutie modeleert geen opslagengines, queryplanners of indexprestaties
- SELECT limieten: Alleen-lezen querysyntaxis ondersteunt geen recursieve CTE's, externe database-uitvoering, opgeslagen procedures of mutatiestatements
- Andere objecten: Triggers, opgeslagen procedures, functies en sequenties
- Externe uitvoering: DDL/DML-voorbeeld maakt geen verbinding met een echte database en slaat geen rijen op buiten het huidige SQL-bestand
- Sluit elke instructie af met een puntkomma (
;) - Definiëren
CREATE TYPEvóór tabellen die ernaar verwijzen - Definiëren
CREATE TABLEvóór gerelateerdeINSERT,UPDATE, ofDELETEstatements - Gebruik
ALTER TABLEvoor vreemde sleutels wanneer tabellen naar elkaar verwijzen (circulaire afhankelijkheden) - Gebruik DDL eerst voor structuur, daarna DML om voorbeeldrijen en beperkingsgedrag te valideren
- Bewaar demogegevens in het SQL-bestand zelf omdat voorbeeldrijen worden afgeleid uit het script