Hoppa till dokumentationen

FRÅN SCHEMA TILL DIAGRAM

SQL till ERD: guide

Omvandla databasschemat till ett diagram. Lär dig stödd SQL, förhandsgranska data och fråga modellen.

SQL DDL → ER-diagramÖppna SQL till ERD
KOMMA IGÅNG

AI-redo SQL-syntaxkontrakt

Använd denna sida som ett kompakt kontrakt när du ber en AI att skriva eller redigera SQL för Erd Go. Föredra syntaxmönstren nedan, håll satser kompletta och semikolon-avslutade, och undvik databasobjekt som inte stöds såvida du inte bara behöver rå SQL utanför Erd Go. SQLite, PostgreSQL, MySQL och MSSQL-syntax stöds över den delade delmängden nedan. SQL-till-ERD-konvertering körs helt i webbläsaren, och dess parser- och förhandsgranskningsmotorer är låsta av tusentals enhets- och integrationstester som täcker produktionsscheman i verkligheten (SaaS, bank, socialt, analys, EHR).

SQLite

INTEGER PRIMARY KEY rowid-regler, typlösa kolumner, AUTOINCREMENT, WITHOUT ROWID, validerade STRICT-tabeller, FK-åtgärder och migreringar

PostgreSQL

ENUM & sammansatta typer, arrayer, JSONB, SERIAL, identitetskolumner, NULLS NOT DISTINCT, uttrycksindex, schemaidentitet och skiftlägeskänslighet för citerade namn

MySQL

AUTO_INCREMENT, inline ENUM & SET, backticks, COMMENT, UNSIGNED/SIGNED, inline-index, CHANGE/MODIFY COLUMN, och FIRST/AFTER-placering

MSSQL

IDENTITY, NVARCHAR(MAX), hakparenteser för namn, klustrade index, GO-batchar, ALTER COLUMN, beräknade kolumner, namngivna standardvärden och temporala perioder

DDL

CREATE TYPE, CREATE TABLE, ALTER TABLE-migreringsuppspelning, CREATE INDEX och säkra DROP-satser för schemaform

DML / SELECT

INSERT, UPDATE, DELETE för förhandsgranskningsdata, plus skrivskyddad SELECT-syntax för joins, CTE:er, aggregat, fönsterfunktioner och rapporter

Snabbstart

Använd detta som ett modell-svar när du ber en AI om Erd Go-kompatibel SQL: anpassade typer först, tabeller därefter, relationsbegränsningar efter tabeller när det är användbart, sedan exempel-DML. Håll skrivskyddade SELECT-frågor separata.

PostgreSQL / PostgreSQL snabbstart
-- 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;
Schemasyntax: Relationer kan deklareras med antingen inline REFERENCES eller ALTER TABLE ADD FOREIGN KEY. Båda formerna bidrar med samma relationsmetadata.
DML-syntax: Placera INSERT, UPDATE, och DELETE efter schemats DDL. Skriptet utvärderas uppifrån och ner, så exempelrader bör referera till tabeller och typer som redan finns.
SELECT-syntax: Håll skrivskyddade rapportfrågor separerade från ändringsskript. De bör endast referera till tabeller och rader som skapats av schemat/DML-skriptet.
SQL / Exempel
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-flikar & filimport

Starta en ny SQL-fil med ett exempel, en tom Schema-flik eller Importera SQL-filer. Exemplet separerar schema och data i flikar. Lägg till SQL-flik skapar en annan redigeringsflik; dubbelklicka på dess titel för att byta namn på den.

Aktiva flikar kompileras tillsammans i sin synliga ordning för Klassdiagram, Datavy, Frågevy och AI-förfrågningar. En inaktiv flik förblir ett sparat utkast och exkluderas från dessa arbetsflöden. Placera typer och tabeller före satser som är beroende av dem.

Import av SQL-filer accepterar flera SQL-textfiler och granskar tolkningsproblem tillsammans före import. Detta hjälper till att lösa referenser mellan filer. Använd flikordningen för att hålla beroenden och migreringssteg avsiktliga.

Använd piltangenter och Home/End i flikfältet för att växla flikar, Alt+Vänster/Höger för att sortera om dem och Shift+Alt+F för att formatera SQL i editorn.

Öppna SQL-utforskaren bredvid flikarna för ett ändringsbart mappträd. Skapa kapslade mappar och SQL-filer, välj en fil för att öppna den och organisera med dra-och-släpp. Radåtgärds-popupen stöder Byt namn och Ta bort fil; klicka utanför för att stänga den. Om du tar bort den sista filen förblir en tom SQL-fil öppen. Mappar ändrar inte körningsordningen. Att ta bort en mapp behåller dess filer och undermappar i föräldern. Spara behåller mappträdet och panelinställningen.

Redigera och granska diagrammet

SQL är källan till schemats innebörd. Använd Lägg till tabell för att skapa en tabell, eller välj tabell- och kolumnåtgärder på arbetsytan för att redigera kolumner och kopplingar. Schemaändringar på arbetsytan uppdaterar även de tillhörande SQL-flikarna samt diagrammet.

Att ta bort en kolumn förhandsgranskar påverkade kopplingar, nycklar, index och beroende SQL. Granska borttagningen eller kaskaden innan du bekräftar. Komplexa migreringar eller ej stödda beroende satser kan kräva direkt SQL-redigering.

Använd ERD-hälsopoängen för att inspektera strukturella fynd och välja att ta del av relationsförslag. Föreslagna relationer behöver granskas; de ersätter inte deklarerade främmande nycklar eller etablerar affärsregler automatiskt.

Ordna tabeller med Layoutläge, zooma eller Anpassa till skärm, hitta tabeller med Tabellnavigator och använd Tabellfärger eller minikartan för att navigera i ett stort diagram. Håll muspekaren över eller fokusera på en verktygsfältskontroll för dess hjälptext.

Välj en tabell och öppna Color Picker för solida eller gradientförinställningar. Ange ett hex-värde eller välj Custom bredvid för att använda den inbyggda färgväljaren. Båda kontrollerna förblir synkroniserade; Save behåller tabellfärgen.

När tabellverktyg är inställda på endast vid hovring, visas Lägg till kolumn när du hovrar över den sista synliga raden eller fokuserar knappen med tangentbordet. Verktyg som alltid är synliga håller den visad.

Välj Tabellgrupper i verktygsfältet för SQL-arbetsytan, sedan Ny grupp. Ge gruppen ett namn och en färg, välj dess tabeller och välj Skapa grupp. En vald tabell börjar markerad. En tabell tillhör en grupp; formuläret visar när ditt val kommer att flytta en tabell ut ur en annan grupp. Upp till 50 grupper stöds, med namn på upp till 160 tecken.

Klicka på en grupprubrik för att redigera dess namn, färg eller medlemmar. Dra rubriken för att flytta dess tabeller tillsammans; släpp för att tillämpa flytten. Escape, pekare-avbrott eller förlorat fönsterfokus avbryter förhandsgranskningen. "Ungroup tables" tar bort ramen men behåller tabellerna, deras positioner, SQL och relationer.

Gruppramar följer live-tabellkorten och visas i Anpassa till skärm, minikartan och export av bilder för aktuell vy eller hela diagrammet. Grupper är valfria visuella tillstånd som sparas med SQL-dokumentet. Äldre filer behåller sin befintliga layout, och tillfälligt saknade tabellnamn förblir i sin grupp tills de återgår till den tolkade SQL-koden. Tabellgrupper tillhör SQL till ERD; Klassdiagram-paket använder en separat modell.

AI-granskning inuti SQL-redigeraren

  1. Ange en specifik ändring i Ask AI för att redigera SQL och välja en tillgänglig modell. Gemini API-nyckel är tillgänglig när du vill använda din egen Gemini-nyckel.
  2. Granska de föreslagna ändringarna och den temporära diagramförhandsgranskningen. Förfrågan använder ögonblicksbilden från den aktiva fliken som togs när den skickades; ett svar sparas inte automatiskt.
  3. Acceptera eller avvisa enskilda ändringar, eller använd åtgärderna för de återstående ändringarna. Navigera mellan kodändringar med F7 och Shift+F7. Skyddade inaktiva flikar förblir utkast.
  4. Inspektera den accepterade SQL-koden och spara sedan dokumentet. Kopiera AI-prompt i den här guiden låter dig också använda dokumentationen med en assistent utanför appen.

Data, frågor, exporter & sparade filer

Använd knapparna för ERD, Data och Fråga för att växla arbetsbänk. Datavy materialiserar stödd DDL och DML i webbläsaren och exponerar tabeller, rader, typer och en exekveringslogg. Ändra storlek på rutnätskolumner genom att dra i deras kanter eller dubbelklicka för att anpassa. Dubbelklicka på en datacell eller tryck på Enter för att redigera; booleska och enum-fält erbjuder giltiga värden. Lägg till rad följer dina schema-standardvärden. Importera CSV, TSV, TXT eller XLSX med en förhandsgranskning av kolumnmappning. NULL och tom text förblir distinkta. Validerade ändringar blir SQL i en flik för dataredigeringar och kan ångras. Ladda ner tabellrader eller frågeresultat som CSV.

Spara kommer ihåg den valda Klassdiagram-, Data- eller Frågearbetsbänken; återöppning återställer den, inklusive Data/Fråga på telefoner. Äldre filer startar i Klassdiagram. Inbyggda datum/tidsredigerare bevarar stödda värden, medan tidsstämplar med bråkdelar eller tidszonsförskjutningar förblir redigerbara som text. Databasgenererade identiteter förblir skrivskyddade.

Frågevyn kör skrivskyddade SELECT-frågor mot de aktuella tabellerna i minnet. Den stöder syntaxen som dokumenteras nedan; den ansluter inte till en extern databas. Frågetexten sparas med SQL-dokumentkontexten.

Spara kommer även ihåg den valda Datatabellen. Återöppning återställer den, med den första tabellen som reserv om den inte är tillgänglig. Schemafält matchar namn, typer och regler; hovra över en regelbricka för dess förklaring. Gå till SQL bredvid tabellrubriken öppnar dess definierande SQL-flik och visar CREATE TABLE-satsen, vilket återöppnar SQL-panelen när den är dold samtidigt som Data-val och utkast behålls. Frågeresultat kombinerar antal, tidsåtgång, Anpassa, Kopiera och CSV i en rubrik.

Dra den smala avdelaren mellan Frågeredigeraren och resultaten, eller mellan Dataschemat och rader, för att ändra storlek på panelerna. Piltangenter ändrar storlek på en fokuserad avdelare, Escape avbryter en dragning, och dubbelklick återställer den. Dessa panelstorlekar förblir tillfälliga arbetsyteinställningar.

Generera exempeldata använder dina kolumntyper, namn, relationer och begränsningar. Exempelspråk styr namn plus naturliga produkt-/beskrivningsfraser på 17 språk. Granska föreslagna generatorer och intervall, förhandsgranska resultatet och infoga sedan explicit en separat flik för exempeldata. Booleska värden visas som true/false; ID:n förblir numeriska. Generering ersätter aldrig befintliga rader.

Välj Exportera ERD för att välja PNG, bildbaserad SVG eller PDF med HD-, 2K- eller 4K-storlek. Exporterade bilder ersätter inte ett redigerbart sparat dokument.

Logga in och använd Spara SQL och ERD för att spara SQL- och diagramkontexten, inklusive flikar, tillämpade rutnätsredigeringar, frågetext och layout. Spara kontrollerar först en aktiv cell eller ett utkast till en ny rad; ogiltig data förblir synlig för korrigering. Importförhandsgranskningar behöver sin explicita Import-åtgärd. Öppna sparade filer från fillistan och använd Dela på ett ägt sparat dokument för att konfigurera offentlig åtkomst och distribuera dess skrivskyddade länk.

SQL-, Prisma- och Builder-dokument öppnas i sina egna verktyg. Prisma och Builder har separata fillistor och molnbaserad lagring. Uppmaningar om osparade ändringar skyddar redigerade dokument när du lämnar en arbetsyta; spara dina ändringar innan du delar eller byter bort.

Felsök SQL-arbetsytan

Felsök SQL-arbetsytan
SymptomVad som ska kontrolleras
En tabell saknasKontrollera tolkningsdiagnostik, aktiva flikar och satsordning. En senare DROP eller namnändring kan ändra det slutgiltiga diagrammet.
En relation saknasKontrollera att både tabeller och kolumner existerar, att antalet kolumner för främmande nycklar matchar och att den refererade nyckeln är globalt unik. Schemakvalificera tvetydiga namn.
Datavy visar inga raderPlacera INSERT efter dess CREATE TABLE i en aktiv flik. Inspektera exekveringsloggen för avvisade rader eller en transaktionsåterställning.
Frågeresultaten matchar inte längre SQL-kodenKör frågan igen efter att ha ändrat schemat eller data; använd de aktuella tabellerna i minnet.
Lägg till tabell föreslår en annan dialektIdentifierad syntax för aktiv arbetsyta prioriteras framför det manuellt valda reservalternativet. Granska SQL-språkindikatorn och tabellspecifika standardinställningar.
En sparad fil kan inte redigerasKontrollera inloggning och ägarskap. En offentlig länk ger skrivskyddad åtkomst; använd Försök igen eller Öppna filer för återställningsbara inläsningsfel.

AI-syntaxarbetsflöde

När du använder en AI-assistent, be den producera SQL i denna ordning. Detta håller resultatet lätt att tolka, lätt att diagramföra och lätt att förhandsgranska med exempelrader eller skrivskyddade frågor.

1. Definiera domäner först

Placera CREATE TYPE enum/komposit-definitioner före tabeller som refererar till dem. Föredra explicita namn framför ad hoc-inline-typer när en domän delas.

2. Skapa bastabeller

Använd CREATE TABLE för kolumner, primärnycklar, unikhet, standardvärden, kontroller, genererade kolumner och infogade främmande nycklar.

3. Spela upp migreringar igen

Använd ALTER TABLE för tillagda begränsningar, namnbyten, borttagna kolumner, ändringar av kolumntyp/nullbarhet och cirkulära främmande nycklar.

4. Lägg till data och frågor sist

Placera INSERT/UPDATE/DELETE efter all DDL. Håll SELECT-frågor separerade från schemaändringar när du vill ha resultatuppsättningar.

Tips för AI-prompt: Be om ett komplett, semikolon-avslutat SQL-skript. Säg åt AI:n att undvika objekt som inte stöds, såsom lagrade procedurer, triggers, rekursiva CTE:er i skrivskyddade SELECT-frågor, och ALTER TYPE. Uttrycksindex bevaras med en varning; begär enkla kolumnnycklar när du behöver ERD-indexmärken.

DDL & DML-syntax

Dessa satsformer är säkra för AI-genererade schemaskript och exempeldata. Samma syntax driver ERD-struktur och förhandsgranskningsrader i minnet, så behåll DDL före DML och undvik externa databasspecifika bieffekter.

Uttalanden som stöds

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

-- Data statements
INSERT INTO table_name [(col1, col2, ...)] VALUES (...), (...);
UPDATE table_name SET col1 = value WHERE condition;
DELETE FROM table_name WHERE condition;
WHERE-stöd: =, !=, <>, >, <, >=, <=, LIKE, NOT LIKE, IN, NOT IN, BETWEEN, NOT BETWEEN, IS NULL, IS NOT NULL, plus AND / OR kombinationer. NULL-jämförelser följer SQL-standardens UNKNOWN-logik — col = NULL matchar aldrig; använd col IS NULL istället. Okända tilldelningsmål, referenser till högerkolumner och filterkolumner avvisar hela mutationen innan några radändringar sker.

Förhandsgranska semantik för AI-genererad DML

Generera exempeldata lokalt: I Datavy, välj Generera exempeldata, välj automatisk detektering eller en SQL-dialekt, en namnordbok från 26 länder eller allmän engelska, en valfri procentsats för null-värden och tabellradantal, och expandera en tabell för att anpassa dess generatorer, intervall eller tillåtna värden. Förhandsgranska först, kopiera/ladda ner sedan SQL eller infoga en ny Exempeldata flik. Ingen AI-nyckel eller extern dataförfrågan behövs. Om du ersatte det inbyggda schemat, gör dess gamla exempeldataflik för handel inaktiv först. Genereringen bevarar befintliga rader, kopierar kompletta främmande nyckeltupler med balanserad föräldratäckning och validerar stödda begränsningar och skalära typer. CHECK-begränsningar som helt består av IS NULL / IS NOT NULL, AND, OR och parenteser prioriteras framför den valfria NULL-procenten, inklusive exklusiva post-/videoreferenser. Katalogen har över 4 200 inbyggda poster, inklusive mer än 2 600 namn med infödd stavning och ASCII-e-posthantaggar, plus företag, produkter, jobb, gator, beskrivningar på naturligt språk och platsexempel i över 40 länder, tillsammans med valutor, IP-adresser, SKU:er, statusar, färger, datum och JSON. Batchar stöder upp till 5 000 rader per tabell, 10 000 rader och 150 000 celler totalt, samt 5 MB SQL. Krävs tomma relationscykler, uttömda unika domäner, kolliderande tabellnamn över scheman och ej stödda komplexa typer som krävs behöver justeras innan genereringen kan slutföras. Nullbara komplexa värden och cykelbrytande referenser kan bli NULL med en förhandsgranskningsnotering. Seeds upprepar genererade ordboksvärden; databasstandardvärden följer fortfarande sitt normala beteende. Slutför AI-granskningen först och öppna generatorn igen om SQL-arbetsytan ändras.

Rader spelas upp från början

DDL- och DML-satser tillämpas tillsammans i källordning; varje datasats använder schemat som är aktivt vid den tidpunkten.

Typer förblir inspekterbara

Namngivna enums och sammansatta typer skapade med CREATE TYPE förblir en del av det tolkade schemat.

Begränsningar efterlevs

PK, FK, NOT NULL, UNIQUE, DEFAULT, CHECK, genererade kolumner och enum-domäner påverkar förhandsgranskningsrader.

Fel bör kunna åtgärdas

Föredra explicita kolumnlistor och konkreta WHERE-klausuler så att diagnostik kan peka på exakt tabell eller kolumn.

Be inte AI att förlita sig på: fristående SELECT resultatuppsättningar i huvudschemat/DML-skriptet, procedurkroppar som inte stöds eller externa databasanrop. CREATE VIEW, CREATE OR REPLACE VIEW, och MSSQL CREATE OR ALTER VIEW materialiseras från deras SELECT resultat för förhandsgranskning; håll ad hoc-frågor med skrivskyddade rättigheter separerade.

Transaktioner i Datavy

Datavy stöder BEGIN, COMMIT, ROLLBACK, SAVEPOINT, ROLLBACK TO och RELEASE i förhandsgranskningen i minnet. Dessa satser påverkar förhandsgranskningsrader; de sparas aldrig i en extern databas.

SQLite, PostgreSQL och SQL Server behåller transaktionell DDL i förhandsgranskningen. MySQL DDL genomför den aktiva transaktionen. SQLite PRAGMA foreign_keys och MySQL SET FOREIGN_KEY_CHECKS påverkar efterföljande DML-validering.

ERD-renderaren ignorerar transaktionsomslag och representerar schemasatser i källordning. En transaktionsåterställning i Datavy kan därför producera en annan uppsättning tabeller än diagrammet. Kontrollera varje arbetsbänk för det beteende du testar.

SQL / Förhandsgranska transaktion
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;
I det här exemplet behåller Datavy objekt 1 och 2. Objekt 3 tas bort av ROLLBACK TO före COMMIT. Frågevy läser dessa slutgiltiga förhandsgranskningsrader.

SELECT-frågesyntax

Be AI att behålla skrivskyddade rapportfrågor som SELECT satser. Dessa kan referera till tabellerna och raderna som producerats av schemat/DML-skriptet och är användbara för kopplingar, filter, summor och rapportformade resultatuppsättningar utan att kräva en live-databas.

Frågeform som stöds

SQL / Exempel
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;

Endast SELECT

Frågeredigeraren accepterar SELECT-satser, inklusive SELECT utan FROM och WITH CTE:er som löses upp till SELECT.

Kopplingar & filter

INNER, LEFT, RIGHT, FULL och CROSS joins, WHERE-villkor, EXISTS, IN-underfrågor, BETWEEN, LIKE, ILIKE och NULL-kontroller.

Aggregeringar

GROUP BY, HAVING, COUNT, SUM, AVG, MIN, MAX, ARRAY_AGG, GROUP_CONCAT, STRING_AGG och DISTINCT-varianter.

Sortering & paginering

ORDER BY namn eller ordinaler, ASC/DESC, NULLS FIRST/LAST, LIMIT/OFFSET, TOP och FETCH FIRST.

Avancerat stöd för SELECT

CTE:er & härledda tabeller

WITH-klausuler, nästlade SELECT-satser i FROM, skalära underfrågor, EXISTS, NOT EXISTS, IN och NOT IN stöds.

Ställ in operatorer

UNION, UNION ALL, INTERSECT och EXCEPT kan kombinera kompatibla resultatuppsättningar.

Fönsterfunktioner

ROW_NUMBER, RANK, DENSE_RANK, NTILE, LAG, LEAD, FIRST_VALUE och LAST_VALUE med OVER och PARTITION BY. Sorterade fönster använder SQL-standardramen som är peer-medveten, och NTILE tilldelar större buckets först.

Dialekthjälpare

Vanliga SQLite-, PostgreSQL-, MySQL- och MSSQL-funktioner är normaliserade för förhandsgranskning, inklusive JSON- och datum/sträng-hjälpare.

Skrivskyddad genom design: Behåll INSERT, UPDATE, DELETE, CREATE, ALTER, och DROP satser i schemat/DML-skriptet. Frågesyntax bör förbli SELECT-endast.

Diagnostik & Fel

Syntaxdiagnostik visar schema-tolkning, DDL/DML-exekvering och skrivskyddade SELECT-problem med tydliga meddelanden. Tolkningsfel inkluderar rad/kolumnpositioner när möjligt, och exekveringsmeddelanden pekar tillbaka på tabellen, kolumnen eller satsformen som behöver korrigeras.

Fel vid schematolkning

Schematolken (SQLite, PostgreSQL, MySQL och MSSQL) rapporterar problem med två allvarlighetsgrader: fel stoppar en enskild sats från att bidra till schemat; varning behåller giltig syntax men flaggar något användaren bör känna till.

SQL / Exempel
// 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
}

Parserfel

Tomma PRIMARY KEY / UNIQUE / FOREIGN KEY-kolumnlistor, saknade obligatoriska datatyper (inklusive SQLite STRICT-kolumner), matchande parenteser saknas, oväntade kommatecken och felformaterade begränsningar.

Tokenizer-varningar

Oavslutade strängar, oavslutade blockkommentarer, matchande parenteser och misstänkta CHECK-uttryck över flera rader.

Varningar för främmande nycklar

FK:er som pekar på en okänd tabell, okänd kolumn, tvetydigt schemablad eller icke-PK/icke-UNIQUE-mål tas bort från diagrammet med en beskrivande varning.

Grupperad diagnostik

Varningar grupperas efter orsak, inklusive tappad relation, okänd tabell, okänd kolumn, icke-unikt FK-mål, varningar och tolkningsfel.

Tom SQL

Tom indata är giltig och skapar ett tomt schema. Endast ogiltig indata som inte är strängar kastar fel.

DDL/DML-körningslogg

Varje exekverat DDL- eller DML-uttryck lägger till en strukturerad post i exekveringsloggen i minnet. Meddelandeströmmen bevarar kronologisk ordning och klassificerar varje uttryck som fel, varning, eller framgång.

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

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

-- error (unknown table)
INSERT INTO ghost VALUES (1);
-- → error: INSERT INTO "ghost": table does not exist
Alltid genomförbart. Varje fel och varning citerar det felaktiga tabell-/kolumnnamnet, så att du kan lokalisera problemet utan att läsa om skriptet.

Vanlig diagnostik

SQL / Exempel
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.
Kraschsäker. Schemaparsning, DDL/DML-exekvering och SELECT-exekvering återställer felaktig SQL till synliga fel så att du kan fortsätta förfina samma skript.

CREATE TYPE

Definiera anpassade datatyper för återanvändning i ditt databasschema. Namngivna enum- och sammansatta typer bör visas före tabeller som refererar till dem, inklusive schema-kvalificerade referenser.

1.1. Sammansatt typ

Definiera anpassade sammansatta typer med flera fält av olika datatyper.

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

Exempel:

SQL / Exempel
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)
);
Datatyper som stöds: INTEGER, BIGINT, SMALLINT, TEXT, VARCHAR(n), CHAR(n), DECIMAL(p,s), NUMERIC, BOOLEAN, DATE, TIME, TIMESTAMP, FLOAT, REAL, DOUBLE PRECISION, UUID, JSON, JSONB, BYTEA, MONEY med flera.

1.2. Enum-typ

Skapa uppräknade typer med fördefinierade värden för bättre dataintegritet och läsbarhet.

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

Exempel:

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

CREATE TYPE priority_level AS ENUM (
  'low', 'medium', 'high', 'critical'
);
Viktigt: Enum-värden måste omslutas av enkla citattecken ('värde'), inte dubbla citattecken.

1.3. Schemakvalificerade typer

Användardefinierade typer löses med samma schemamedvetenhet som tabeller. Om två scheman definierar samma lövnamn håller Klassdiagrammet dem åtskilda; om en typ är unik förblir visningsnamnet enkelt.

SQL / Exempel
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
);
Upplösningsregel: s1.status löses aldrig upp till s2.status bara för att båda delar lövnamnet status. Kvalificerade typnamn är strikta, medan okvalificerade namn endast löses upp när de är entydiga.

CREATE TABLE

Definiera databastabeller med kolumner, datatyper och begränsningar.

2.1. Grundläggande tabellstruktur

Den allmänna syntaxen för att skapa en tabell:

SQL / Exempel
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 ( ... );
Notera: Tabell- och kolumnnamn kan använda dubbla citattecken ("name"), backticks (\`name\`), eller hakparenteser ([name]) för att undfly specialtecken eller reserverade nyckelord.

2.2. Definitioner på kolumnnivå

Varje kolumn kan inkludera olika begränsningar och egenskaper:

SQL / Exempel
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)
);

PRIMÄRNYCKEL

Identifierar varje rad unikt

UNIQUE

Säkerställer att kolumnvärden är distinkta

NOT NULL

Förhindrar null-värden

DEFAULT

Ställer in standardvärden (literaler eller funktioner)

CHECK

Validerar data med booleska uttryck

REFERENCES

Skapar främmande nyckelrelationer

Stöd för DEFAULT-värden:
  • Literaler: nummer (123), strängar ('text')
  • PostgreSQL-funktioner: now(), CURRENT_TIMESTAMP, CURRENT_DATE, nextval('seq'::regclass)
  • MSSQL-funktioner: GETDATE(), NEWID()
REFERENCES (inline): Känner igen REFERENCES table(column), schema-kvalificerad REFERENCES schema.table(column), utelämnade målkolumner såsom REFERENCES departments, och FK-åtgärder såsom ON DELETE CASCADE, ON UPDATE SET NULL, MATCH FULL, och DEFERRABLE INITIALLY DEFERRED.

2.3. Genererade / beräknade kolumner

Snabbguide. Se den dedikerade Beräknade kolumner avsnitt nedan för den fullständiga uppdelningen per dialekt, inklusive MSSQL-formen med bara AS.

SQL / Exempel
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-typer

Du kan deklarera en ENUM direkt i en kolumndefinition (MySQL-stil). Tolken kommer att registrera den som en namngiven enum och ersätta kolumntypen automatiskt.

SQL / Exempel
CREATE TABLE tasks (
  id INTEGER PRIMARY KEY,
  status ENUM('todo', 'doing', 'done'),
  priority ENUM('low', 'medium', 'high')
);
Hur det fungerar: Inline-ENUM:er registreras automatiskt som namngivna typer. Det första enkla namnet använder column_enum (till exempel, status_enum); senare tabeller med en annan definition för samma kolumnnamn får ett tabellkvalificerat namn såsom tasks_status_enum så att domäner aldrig kollapsar av misstag.
Tips: Om du behöver delade enums eller anpassade namn, definiera dem explicit med CREATE TYPE ... AS ENUM istället.

2.5. Begränsningar på tabellnivå

Definiera begränsningar i slutet av tabellkroppen. Användbart för sammansatta nycklar och begränsningar för flera kolumner:

SQL / Exempel
-- 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)

Exempel:

SQL / Exempel
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)
);
Begränsningar som stöds: PRIMÄRNYCKEL, FRÄMMANDE NYCKEL, UNIQUE och CHECK stöds alla på tabellnivå. Begränsningsnamnet (CONSTRAINT name) är valfri.
Korrekt hantering av främmande nycklar: If REFERENCES ref_table utelämnar målkolumnlistan, löser Erd Go upp den till den refererade tabellens primärnyckel, inklusive sammansatta primärnycklar. Om du anger målkolumner explicit måste de backas upp av en PRIMARY KEY, UNIQUE-begränsning eller global CREATE UNIQUE INDEX; filtrerade / partiella unika index räknas inte som FK-mål. Ogiltiga relationer tas bort med en varning.

2.6. Kolumnnamn med reserverade ord

Ord som key, index, value, och name är reserverade i vissa dialekter men används ofta som kolumnnamn i andra. Tolken avambiguerar automatiskt när nästa token är en känd datatyp, så bar okvoterad användning fungerar:

SQL / Exempel
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
);
Regel för disambiguering: KEY / INDEX / FULLTEXT / SPATIAL följt av ett datatyp-nyckelord (VARCHAR, INT, …) är en kolumn. Följt av en identifierare och en kolumnlista inom parentes, är det ett index. För absolut säkerhet, citera kolumnen med "key", `key`, eller [key].

Identity / Auto-Increment-kolumner

Använd den inbyggda identitetssyntaxen för den valda dialekten. Alla stödda former producerar en primärnyckelkolumn med AUTO_INCREMENT markör, men SQLite har en strikt regel: AUTOINCREMENT kräver en enskild INTEGER PRIMARY KEY kolumn.

SQLite

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

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

-- Invalid for SQLite AUTOINCREMENT:
-- 1. BIGINT PRIMARY KEY AUTOINCREMENT
-- 2. INT PRIMARY KEY AUTOINCREMENT
-- 3. AUTOINCREMENT on a composite primary key
SQLite-regel: använd exakt INTEGER PRIMARY KEY AUTOINCREMENT. Använd inte BIGINT, INT, eller en sammansatt primärnyckel med AUTOINCREMENT.

PostgreSQL

SQL / Exempel
-- 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
);
Viktigt: GENERATED ALWAYS AS IDENTITY är en identitet kolumn (auto-inkrement), skild från GENERATED ALWAYS AS (expression) vilket är en beräknad kolumn. Tolken håller dem isär automatiskt.

MySQL

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

MSSQL / SQL Server

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

-- Bare IDENTITY (defaults to (1,1))
CREATE TABLE [dbo].[Orders] (
  [OrderID] INT IDENTITY NOT NULL PRIMARY KEY
);
ERD-utdata: Varje formulär ovan visas identiskt i diagrammet — PK-nyckelikon plus AUTO_INCREMENT tagg — så att du kan blanda dialekter i ett schema utan att förlora auto-inkrement-tipset.

Beräknade kolumner (per dialekt)

En beräknad kolumn härleder sitt värde från ett uttryck över andra kolumner i samma rad. Stöds i alla fyra dialekter med deras respektive syntaxer.

PostgreSQL & MySQL — GENERATED ALWAYS AS

SQL / Exempel
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
);
Databaslägen: I en inbyggd databas, STORED lagrar det beräknade värdet och VIRTUAL beräknar det vid läsning. Erd Go håller förhandsgranskningsvärden i minnet; ERD:n bevarar varje läge som kolumnmetadata.

MSSQL / SQL Server — kolumn AS-uttryck [PERSISTED]

MSSQL har sin egen syntax: column_name AS expression, valfritt följt av PERSISTED (och valfritt NOT NULL). Både inom parentes och bar uttrycksformer stöds.

SQL / Exempel
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
);
Bar AS: Tolken accepterar col AS expression (inga omgivande parenteser) — inklusive funktionsanrop som DATEADD(...), tabell-kvalificerade referenser som c.GrowthDurationDays, och CASE uttryck — som avslutas vid nästa kolumn-komma, PERSISTED, eller slutet av tabellkroppen.
ERD-utdata: Alla beräknade kolumner visas COMPUTED som typen och uttrycket bevarat i kolumnens extra / verktygstips.

ALTER TABLE

Vanlig migreringsstil ALTER TABLE satser spelas upp igen efter tabellskapande, så det slutgiltiga schemat återspeglar tillagda kolumner, begränsningar, namnbyten, borttagna kolumner och ändringar i kolumntyp/nullbarhet. PostgreSQL-dump-syntax med ALTER TABLE ONLY bevarar den kvalificerade tabellidentiteten.

Lägg till & begränsa

ADD COLUMN, ADD PRIMARY KEY, ADD UNIQUE, ADD CHECK och ADD FOREIGN KEY återspeglas i ERD:t.

Byt namn & ta bort

Byten av namn på tabeller, kolumner, begränsningar och index—inklusive MySQL RENAME TABLE, PostgreSQL ALTER INDEX och SQL Server sp_rename—förblir bundna till rätt objektinkarnation före senare DROP-operationer.

Kolumnändringar

PostgreSQL ALTER COLUMN TYPE/SET DATA TYPE/SET eller DROP DEFAULT/nullability, MSSQL ALTER COLUMN och MySQL MODIFY/CHANGE COLUMN spelas upp igen.

Relationssäkerhet

Främmande nycklar valideras mot det slutgiltiga tabelltillståndet efter migrering, inklusive ändringar i PK/UQ/index och exakt antal käll-/målkolumner.

3.1. Lägg till främmande nyckel

SQL / Exempel
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];

Exempel:

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

3.2. Lägg till primärnyckel

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

Exempel:

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

3.3. Lägg till unik begränsning

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

Exempel:

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

3.4. Lägg till kontrollbegränsning

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

Exempel:

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

3.5. Exempel på migrering

SQL / Exempel
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);
Vad ERD gör: Kontakt-FK:n löser upp till den sammansatta primärnyckeln på app.accounts, owner_email blir contact_email, audit_state tas bort, och det unika indexet ger contact_email en UQ märke.

3.6. MySQL CHANGE / MODIFY COLUMN

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

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

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

3.7. MSSQL / SQL Server ALTER COLUMN

SQL / Exempel
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';
Syntaxgräns: SQL-till-ERD-migreringsuppspelning är avsiktligt rikare än körning av Datavy. Tolkning av det slutgiltiga diagrammet förblir endast i webbläsaren och kräver ingen databasanslutning; instruktioner som endast stöds vid körning försvagar inte Klassdiagrammets livscykelmodell.

CREATE INDEX

Index-DDL tolkas över alla fyra dialekter. Enkla kolumnnycklar visas som små ERD-märken: IDX för icke-unika hastighetsökningar, UQ för globala unika index, och PUQ för filtrerade / partiella unika index. Uttrycksposter bevaras i parserns utdata och rapporteras när de inte korrekt kan mappas till en kolumnbricka.

IDX-märke

Icke-unikt index. Solid markör på kolumnen. Sammansatta index dämpar markören (grå) på varje nyckelkolumn så att enkelkolumn kontra fler-kolumn är tydligt vid en anblick.

UQ-märke

Från ett globalt CREATE UNIQUE INDEX. Uppför sig som en UNIQUE-begränsning för FK-validering och kolumnmarkering.

PUQ-märke

Från CREATE UNIQUE INDEX ... WHERE. Visar det partiella unikhetspredikatet men validerar inte FK-mål som globalt unika.

Undertryckningsregel

Starkare begränsningar vinner: PK ⟶ UQ ⟶ PUQ ⟶ IDX. En starkare nyckel nedgraderas aldrig av ett senare index.

Flera dialekter

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

4.1. Syntax

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

4.2. Exempel

Påskynda en frekvent FK-uppslagning (enkelkolumns-IDX):

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

Sammansatt index (dämpat IDX-piller på varje nyckelkolumn):

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

Uppgradera en kolumn till UNIQUE utan att ändra dess definition:

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

Partiellt / filtrerat unikt index (PUQ, inte ett globalt FK-mål):

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

MySQL inline-index inuti CREATE TABLE:

SQL / Exempel
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 filtrerat + INCLUDE-index:

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

4.3. Beteende & semantik

  • Funktionella / uttrycksindex (t.ex. CREATE INDEX … ON t (lower(email))) bevaras och ger en explicit varning men ingen bricka — de mappar inte rent till en enskild kolumn.
  • INCLUDE-kolumner (täckande kolumner) tolkas men får aldrig märken — endast nyckelkolumner får pill-ikonen.
  • PK / UQ-kolumner är starkare garantier än IDX, så alla senare CREATE INDEX på dem hoppas tyst över — du kommer inte se redundanta piller.
  • Partiella / filtrerade unika index rendera som PUQ med WHERE predikat i kolumndetaljer. De accepteras inte som globalt unika mål för validering av främmande nycklar.
  • Slutgiltiga märken är ordningsoberoende: en global unik garanti undertrycker en redundant IDX märke om det unika eller icke-unika indexet visas först. Metadata för sammansatta index behålls likaså oavsett deklarationsordning.
  • Index på okända tabeller / kolumner släpps tyst — användbart vid portning av partiella scheman utan att bryta diagrammet.
  • Indexlivscykel inkluderar toppnivå CREATE/DROP INDEX, PostgreSQL DROP INDEX CONCURRENTLY, MySQL ALTER TABLE … ADD/DROP/RENAME INDEX, PostgreSQL ALTER INDEX … RENAME, och SQL Server-indexomdöpningar genom sp_rename. Namngivna UQ/PUQ/IDX-metadata följer det slutgiltiga kvarvarande namnet.
Tips: Sammansatta IDX-piller renderas i en dämpad grå färg för att spegla det befintliga visuella språket för sammansatta PK / sammansatta UQ. Ett solitt IDX-piller betyder alltid "enkolumnsindex" — lätt att skanna i täta diagram.

Stöd för flera dialekter

Tolken på webbläsarsidan hanterar syntaxskillnader mellan SQLite, PostgreSQL, MySQL och MSSQL utan en databasanslutning. Autodetektering använder strukturella syntaxsignaler och förblir neutral för genuint blandad dialekt-input; anropare kan också tillhandahålla en explicit dialekt. Exemplen nedan följer samma standardordning: SQLite först, sedan PostgreSQL, MySQL och MSSQL.

4.1. SQLite-funktioner

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

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

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

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

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

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

-- IF NOT EXISTS works as expected
CREATE TABLE IF NOT EXISTS sessions (
  token   TEXT PRIMARY KEY,
  user_id INTEGER REFERENCES users(id),
  expires TEXT
);
SQLite-specifikt: INTEGER PRIMARY KEY (rowid-alias), AUTOINCREMENT, WITHOUT ROWID, STRICT tabeller, typlösa icke-STRICT-kolumner, typaffiniteter (INTEGER, TEXT, REAL, NUMERIC, BLOB), datetime('now') / CURRENT_TIMESTAMP standardvärden och standard REFERENCES med ON DELETE / ON UPDATE åtgärder.
Typkorrekthet: Vanliga SQLite-tabeller accepterar godtyckliga deklarerade typnamn (såsom VARCHAR(255), BOOLEAN, eller TIMESTAMP) och kan utelämna en typ. STRICT-tabeller följer SQLite:s exakta tillåtna uppsättning: INT, INTEGER, REAL, TEXT, BLOB, eller ANY; varje STRICT-kolumn måste deklarera en.

Exempel på SQLite-migreringsuppspelning:

SQL / Exempel
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-funktioner

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

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

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

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

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

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

-- Empty body INHERITS (PG-only)
CREATE TABLE child () INHERITS (parent);
PostgreSQL: Stöder SERIAL-typer, identitetskolumner, JSONB, BYTEA, INET, tidsstämpelvarianter, arrayer, sammansatta typer och ENUM-typer, UNIQUE NULLS NOT DISTINCT, bevarande av uttrycksindex och PostgreSQL:s exakta skiftlägeskänsliga identitet för citerade namn.

4.3. MySQL-funktioner

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

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

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

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

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

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

  -- Inline indexes become ERD badges when they map to columns
  INDEX idx_name (`name`),
  FULLTEXT KEY ft_bio (`bio`),
  UNIQUE INDEX ux_name (`name`),
  UNIQUE KEY uk_email (`email`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
MySQL-specifikt: AUTO_INCREMENT, COMMENT, signerade modifierare, heltal/text/blob/spatiala varianter, inline ENUM och SET, inline-index, CHANGE COLUMN, MODIFY COLUMN, FIRST/AFTER fysisk placering, ON UPDATE CURRENT_TIMESTAMP, och vanliga tabellalternativ.

4.4. MSSQL / SQL Server-funktioner

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

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

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

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

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

-- Multi-statement batches separated by GO are honored
CREATE TABLE [dbo].[Orders] (
  [OrderID] INT IDENTITY NOT NULL PRIMARY KEY  -- bare IDENTITY → (1,1)
);
GO
MSSQL-specifikt: IDENTITY(seed, increment), NVARCHAR(MAX), datum/tid, binära, XML, identifierare och spatiala typer, ROWGUIDCOL, klustrade index, GO satser, ALTER COLUMN, beräknade kolumner, namngivna DEFAULT ... FOR column villkor, genererade temporala kolumner, och PERIOD FOR SYSTEM_TIME.
Bar-AS beräknade kolumner: col AS expression PERSISTED (inga omgivande parenteser) stöds fullt ut, inklusive funktionsanrop (DATEADD, LEFT, …), tabell-kvalificerade kolumnreferenser (c.col), och CASE uttryck.

4.5. Stilar för citering av identifierare

Alla tre huvudsakliga citeringskonventioner stöds:

SQL / Exempel
-- 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
);

Anteckningar & Tips

Viktiga detaljer om syntaxstöd: vad som bidrar till schemastruktur, vilken DDL/DML som kan spelas upp med exempelrader, vad SELECT-frågor kan läsa och var gränserna går.

✓ Stöd för Schema / ERD-syntax

  • Flera dialekter: SQLite, PostgreSQL, MySQL och MSSQL-syntax kan dela ett skript; automatisk detektering förblir neutral när starka signaler är genuint blandade
  • Skiftlägesokänsliga nyckelord: CREATE, TABLE, ALTER, etc. kan skrivas med valfritt skiftläge
  • Citerade identifierare: Dubbla citattecken ("name"), backticks (`name`), och klammerparenteser ([name])
  • Reserverade kolumnnamn: Bar key, index, value, name, order, etc. accepteras när de följs av en datatyp
  • Schemakvalificerade namn: schema.table och schema.type (t.ex., public.users, dbo.Orders, app.status_enum) — schemaprefix på användardefinierade typer bevaras för strikt sökning och förenklas för visning endast när de är otvetydiga
  • Kommentarer: Enkelrad (-- comment) och blockkommentarer (/* comment */) hoppas automatiskt över
  • BOM & CRLF: UTF-8 byte-order-mark och Windows-radbrytningar hanteras transparent
  • Anpassade typer: CREATE TYPE … AS ENUM och CREATE TYPE … AS (composite), inklusive schema-kvalificerade namn
  • Inline ENUM & SET (MySQL): ENUM('a','b') och SET('a','b','c') inuti kolumntyper — automatiskt registrerade som namngivna typer och namngivna efter tabell/kolumn när dubbla kolumnnamn använder olika domäner
  • Begränsningar: Kolumnnivå och tabellnivå PRIMARY KEY, FOREIGN KEY, UNIQUE, CHECK (inklusive sammansatta varianter med flera kolumner). FK-mål valideras mot primärnycklar, unika begränsningar eller globala unika index
  • Identity / auto-increment: SERIAL/BIGSERIAL (PG), GENERATED ALWAYS/BY DEFAULT AS IDENTITY (PG), AUTO_INCREMENT (MySQL), IDENTITY(1,1) och bara IDENTITY (MSSQL) — alla förenas i diagrammet
  • Beräknade kolumner: GENERATED ALWAYS AS (expr) STORED/VIRTUAL (PG/MySQL) och MSSQL col AS (expr) [PERSISTED] + bar col AS expr [PERSISTED]
  • PostgreSQL-arrayer: type[], storleksanpassad type[5], nästlade type[][][], och matriser av användardefinierade typer (t.ex. webhook_event[])
  • Standardvärden: Literaler, dollar-citerade strängar, funktionsanrop (now(), CURRENT_TIMESTAMP, GETDATE(), NEWID(), NEWSEQUENTIALID(), gen_random_uuid(), nextval()), och ON UPDATE CURRENT_TIMESTAMP (MySQL)
  • FK-åtgärder: ON DELETE / ON UPDATE med CASCADE, RESTRICT, SET NULL, SET DEFAULT, NO ACTION, plus MATCH, DEFERRABLE, och INITIALLY metadata. Åtgärder bevaras som relationsmetadata.
  • Migreringsuppspelning: ALTER TABLE ADD COLUMN, lägg till/ta bort/döp om nycklar och begränsningar, tabell-/kolumn-/indexomdöpningar, DROP COLUMN, ALTER COLUMN TYPE/SET DATA TYPE, SET/DROP DEFAULT, SET/DROP NOT NULL, MSSQL sp_rename, och MySQL MODIFY/CHANGE COLUMN
  • Index: Toppnivå CREATE/DROP INDEX, PostgreSQL ALTER INDEX … RENAME, MySQL lägg till/ta bort/döp om och inline KEY/INDEX/UNIQUE INDEX/FULLTEXT/SPATIAL definitioner. Kolumnbaserade index renderas som IDX, UQ, eller PUQ märken
  • IF NOT EXISTS, IF EXISTS: hanteras smidigt på båda CREATE och DROP
  • Transaktionsomslutare endast för schema: BEGIN, COMMIT, SET search_path, USE [db] (MSSQL), och SET FOREIGN_KEY_CHECKS (MySQL) hoppas över smidigt
  • Graciöst hoppade över: CREATE VIEW, CREATE MATERIALIZED VIEW, CREATE FUNCTION/TRIGGER/SCHEMA/SEQUENCE, procedurell EXEC satser förutom sp_rename, DECLARE, PRINT, PARTITION BY, INHERITS (inklusive tom kropp), WITH OIDS, STORAGE PLAIN, EXCLUDE USING gist, och satskroppar som inte påverkar ERD-strukturen

✓ DDL/DML Förhandsgranskningssyntax

  • Topp-till-botten-exekvering: Skriptet spelas upp i satsordning, så exempeldata bör komma efter schemat det refererar till
  • Uttalanden som stöds: CREATE TYPE, CREATE TABLE, CREATE VIEW, CREATE INDEX, ALTER TABLE ändringar av kolumn/villkor, DROP INDEX, TRUNCATE TABLE, INSERT, UPDATE, DELETE, DROP TABLE, DROP VIEW, och DROP TYPE
  • WHERE-filter: =, !=, <>, >, <, >=, <=, LIKE, IN, NOT IN, NOT LIKE, BETWEEN, NOT BETWEEN, IS NULL, och IS NOT NULL
  • Radmaterialisering: Tabeller visar radantal, strukturmetadata och aktuell rad-data efter att DML-satser har exekverats
  • Namngivna typer: ENUM och sammansatta typer skapade med CREATE TYPE visas separat från tabeller
  • Exekveringslogg: Framgångs-, varnings- och felstatusar fångas för okända kolumner, saknade tabeller, dubbla nycklar, NULL-överträdelser och breda uppdateringar/raderingar; ogiltiga mutationsbindningar misslyckas innan rader ändras
  • Standardutvärdering: Literala standardvärden plus funktioner som now(), CURRENT_TIMESTAMP, CURRENT_DATE, GETDATE(), och NEWID()

✓ SELECT Frågesyntax

  • Skrivskyddad SELECT: SELECT satser kan läsa tabellerna i minnet som producerats från huvud-SQL-filen
  • Resultatmetadata: Kolumner, radantal, förfluten tid, NULL/boolean/nummerformatering och frågefel bevaras med SELECT-resultatet
  • Relationella frågor: Kopplingar, WHERE-filter, GROUP BY, HAVING, ORDER BY, LIMIT/OFFSET, TOP, FETCH FIRST, CTE:er, härledda tabeller, underfrågor och mängdoperatorer
  • Analytiska hjälpare: Aggregeringar, vanliga skalära funktioner, JSON-hjälpare, datum/sträng-funktioner och fönsterfunktioner såsom ROW_NUMBER, RANK, NTILE, FIRST_VALUE, LAST_VALUE, LAG, och LEAD; ordnade standardramar inkluderar den nuvarande peer-gruppen

✗ Stöds fortfarande inte / Hoppas över

  • ÄNDRA TYP: Kan inte ändra befintliga ENUM- eller sammansatta typer
  • LIKE-klausul: CREATE TABLE foo (LIKE bar INCLUDING …) hoppas över graciöst — kopierade kolumner materialiseras inte
  • INHERITS kolumnarv: Den INHERITS (parent) klausulen i sig tolkas utan fel, men ärvda kolumner dras inte in i barntabellen för ERD-ändamål
  • Indexkörning: Index-DDL kan skapa schemamärken, men förhandsgranskningskörning modellerar inte lagringsmotorer, frågeplanerare eller indexprestanda
  • SELECT-gränser: Skrivskyddad frågesyntax stöder inte rekursiva CTE:er, exekvering mot extern databas, lagrade procedurer eller ändringsuttryck
  • Andra objekt: Triggers, lagrade procedurer, funktioner och sekvenser
  • Extern exekvering: DDL/DML-förhandsgranskning ansluter inte till en riktig databas eller sparar rader utanför den aktuella SQL-filen
Syntaxbeteende: DML bidrar inte till generering av schemadiagram. Tabell-, typ- och namngivna index-livscykelsatser spelas upp i källordning, inklusive namnbyte, borttagning och senare återskapande utan att läcka metadata mellan objektinkarnationer. DDL/DML-satser som stöds körs i minnet från topp till botten, och skrivskyddade SELECT-frågor läser från det minnesbaserade resultatet utan att ändra det.
Bästa praxis:
  • Avsluta varje uttryck med ett semikolon (;)
  • Definiera CREATE TYPE före tabeller som refererar till dem
  • Definiera CREATE TABLE före relaterade INSERT, UPDATE, eller DELETE satser
  • Använd ALTER TABLE för främmande nycklar när tabeller refererar till varandra (cirkulära beroenden)
  • Använd DDL för struktur först, sedan DML för att validera exempelrader och begränsningsbeteende.
  • Behåll demodata i själva SQL-filen eftersom förhandsgranskningsrader härleds från skriptet
Felåterställning: Uttalanden som inte stöds hoppas över, och syntaxvarningar/fel visas med tillräckligt sammanhang för att fortsätta förfina samma fil istället för att börja om från början.

Genom att följa dessa syntaxmönster kan Erd Go generera ditt ERD-schema, förhandsgranska data i minnet och köra skrivskyddade frågor från samma SQL-fil.

ErdGo.com - Omvandla SQL till diagram och förhandsgranska data snabbare