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.
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.
-- 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 eller ALTER TABLE ADD FOREIGN KEY. Båda formerna bidrar med samma relationsmetadata.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 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
- 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.
- 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.
- 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.
- 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
| Symptom | Vad som ska kontrolleras |
|---|---|
| En tabell saknas | Kontrollera tolkningsdiagnostik, aktiva flikar och satsordning. En senare DROP eller namnändring kan ändra det slutgiltiga diagrammet. |
| En relation saknas | Kontrollera 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 rader | Placera 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-koden | Kö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 dialekt | Identifierad 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 redigeras | Kontrollera 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.
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
-- 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 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
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.
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.
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-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
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.
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.
// 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.
// 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 existVanlig diagnostik
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
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.
CREATE TYPE type_name AS (
field1 data_type1,
field2 data_type2,
...
);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)
);1.2. Enum-typ
Skapa uppräknade typer med fördefinierade värden för bättre dataintegritet och läsbarhet.
CREATE TYPE enum_name AS ENUM (
'value1',
'value2',
...
);Exempel:
CREATE TYPE status_enum AS ENUM (
'pending',
'active',
'completed',
'cancelled'
);
CREATE TYPE priority_level AS ENUM (
'low', 'medium', 'high', 'critical'
);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.
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 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:
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\`), 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:
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
- Literaler: nummer (
123), strängar ('text') - PostgreSQL-funktioner:
now(),CURRENT_TIMESTAMP,CURRENT_DATE,nextval('seq'::regclass) - MSSQL-funktioner:
GETDATE(),NEWID()
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.
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.
CREATE TABLE tasks (
id INTEGER PRIMARY KEY,
status ENUM('todo', 'doing', 'done'),
priority ENUM('low', 'medium', 'high')
);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.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:
-- 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:
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) är valfri.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:
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 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
-- 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. Använd inte BIGINT, INT, eller en sammansatt primärnyckel med 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 ä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
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 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
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 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.
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 (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.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
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:
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
ALTER TABLE table_name
ADD [CONSTRAINT name] PRIMARY KEY (cols...);Exempel:
ALTER TABLE products
ADD CONSTRAINT pk_products
PRIMARY KEY (product_id);3.3. Lägg till unik begränsning
ALTER TABLE table_name
ADD [CONSTRAINT name] UNIQUE (cols...);Exempel:
ALTER TABLE users
ADD CONSTRAINT uq_users_email
UNIQUE (email);3.4. Lägg till kontrollbegränsning
ALTER TABLE table_name
ADD [CONSTRAINT name] CHECK (expression);Exempel:
ALTER TABLE employees
ADD CONSTRAINT chk_salary
CHECK (salary >= 0);3.5. Exempel på migrering
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 blir contact_email, audit_state tas bort, och det unika indexet ger contact_email en UQ märke.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 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
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. Exempel
Påskynda en frekvent FK-uppslagning (enkelkolumns-IDX):
CREATE INDEX idx_orders_customer ON orders (customer_id);Sammansatt index (dämpat IDX-piller på varje nyckelkolumn):
CREATE INDEX idx_orders_customer_status
ON orders (customer_id, status);Uppgradera en kolumn till UNIQUE utan att ändra dess definition:
CREATE UNIQUE INDEX uq_shipments_tracking
ON shipments (tracking_number);Partiellt / filtrerat unikt index (PUQ, inte ett globalt FK-mål):
CREATE UNIQUE INDEX ux_users_active_email
ON users (email)
WHERE deleted_at IS NULL;MySQL inline-index inuti 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 filtrerat + INCLUDE-index:
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 INDEXpå dem hoppas tyst över — du kommer inte se redundanta piller. - Partiella / filtrerade unika index rendera som
PUQmedWHEREpredikat 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
IDXmä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, PostgreSQLDROP INDEX CONCURRENTLY, MySQLALTER TABLE … ADD/DROP/RENAME INDEX, PostgreSQLALTER INDEX … RENAME, och SQL Server-indexomdöpningar genomsp_rename. Namngivna UQ/PUQ/IDX-metadata följer det slutgiltiga kvarvarande namnet.
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
-- 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 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.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:
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
-- 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, bevarande av uttrycksindex och PostgreSQL:s exakta skiftlägeskänsliga identitet för citerade namn.4.3. MySQL-funktioner
-- 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, 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
-- 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/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.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:
-- 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.tableochschema.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 ENUMochCREATE TYPE … AS (composite), inklusive schema-kvalificerade namn - Inline ENUM & SET (MySQL):
ENUM('a','b')ochSET('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 baraIDENTITY(MSSQL) — alla förenas i diagrammet - Beräknade kolumner:
GENERATED ALWAYS AS (expr) STORED/VIRTUAL(PG/MySQL) och MSSQLcol AS (expr) [PERSISTED]+ barcol AS expr [PERSISTED] - PostgreSQL-arrayer:
type[], storleksanpassadtype[5], nästladetype[][][], 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()), ochON UPDATE CURRENT_TIMESTAMP(MySQL) - FK-åtgärder:
ON DELETE/ON UPDATEmedCASCADE,RESTRICT,SET NULL,SET DEFAULT,NO ACTION, plusMATCH,DEFERRABLE, ochINITIALLYmetadata. Å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, MSSQLsp_rename, och MySQLMODIFY/CHANGE COLUMN - Index: Toppnivå
CREATE/DROP INDEX, PostgreSQLALTER INDEX … RENAME, MySQL lägg till/ta bort/döp om och inlineKEY/INDEX/UNIQUE INDEX/FULLTEXT/SPATIALdefinitioner. Kolumnbaserade index renderas somIDX,UQ, ellerPUQmärken - IF NOT EXISTS, IF EXISTS: hanteras smidigt på båda
CREATEochDROP - Transaktionsomslutare endast för schema:
BEGIN,COMMIT,SET search_path,USE [db](MSSQL), ochSET FOREIGN_KEY_CHECKS(MySQL) hoppas över smidigt - Graciöst hoppade över:
CREATE VIEW,CREATE MATERIALIZED VIEW,CREATE FUNCTION/TRIGGER/SCHEMA/SEQUENCE, procedurellEXECsatser förutomsp_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, ochDROP TYPE - WHERE-filter:
=,!=,<>,>,<,>=,<=,LIKE,IN,NOT IN,NOT LIKE,BETWEEN,NOT BETWEEN,IS NULL, ochIS 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 TYPEvisas 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(), ochNEWID()
✓ SELECT Frågesyntax
- Skrivskyddad SELECT:
SELECTsatser 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, ochLEAD; 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
- Avsluta varje uttryck med ett semikolon (
;) - Definiera
CREATE TYPEföre tabeller som refererar till dem - Definiera
CREATE TABLEföre relateradeINSERT,UPDATE, ellerDELETEsatser - Använd
ALTER TABLEfö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