SQL-exempel använder PostgreSQL såvida inte en annan dialekt anges. Korta kodsnuttar förutsätter att deras refererade tabeller redan existerar. Validera DDL i din måldatabas innan du tillämpar den.
Varför visualisera ditt SQL-schema?
En välstrukturerad databas kan innehålla dussintals – till och med hundratals – tabeller, var och en länkad med främmande nycklar, begränsningar och index. Att läsa rå CREATE TABLE satser berättar bara en del av historien. Ett Entitetsrelationsdiagram (ERD) förvandlar den SQL-koden till en visuell karta, vilket gör det betydligt enklare att:
- Identifiera saknade eller felaktiga främmande nyckel-relationer vid en anblick.
- Introducera nya teammedlemmar som snabbt behöver förstå datamodellen.
- Kommunicera schemabeslut i granskningar av pull-requests, arkitekturdokument och intressentmöten.
- Identifiera normaliseringsproblem såsom redundanta kolumner eller cirkulära referenser.
- Planera migreringar och refaktoriseringar genom att se hela beroendegrafen.
Det snabbaste sättet att gå från SQL till diagram är att använda en automatisk ERD-byggare. Med Erd Go-redigerare, du klistrar helt enkelt in din SQL och får ett interaktivt, redigerbart diagram på några sekunder—ingen manuell ritning krävs.
Manuell kontra automatisk ERD-generering
Det finns två breda tillvägagångssätt för att skapa en ERD från ett befintligt schema, och att förstå avvägningarna hjälper dig att välja rätt verktyg för jobbet.
Manuell diagramritning
- Du ritar varje tabellruta för hand i ett verktyg som Lucidchart, draw.io eller till och med en whiteboard.
- Fullständig kreativ kontroll över layout och visuell stil.
- Nackdelar: extremt tidskrävande för stora scheman, lätt att införa avvikelser mellan diagrammet och den faktiska databasen, och du måste uppdatera ritningen varje gång schemat ändras.
Automatisk generering
- Ett verktyg tolkar din SQL DDL (Data Definition Language) och bygger diagrammet programmatiskt.
- Härleder diagrammet från stödda SQL-definitioner. Granska parser-varningar och saknade referenser; automatiserad parsning bevisar inte att SQL-koden eller affärsreglerna är korrekta.
- Att återskapa efter en migrering tar sekunder istället för en manuell redigeringssession.
- Nackdelar: automatisk layout kanske inte ser perfekt ut initialt, så du behöver ibland dra tabeller till en renare ordning.
För de flesta team, automatisk generering med lätt manuell justering är det ideala arbetsflödet. Du får hastighet och noggrannhet.
Steg-för-steg: Generera ett ERD med Erd Go
Följ dessa steg för att förvandla ett stödd SQL-schema till ett läsbart ERD. Stora scheman och ofullständiga dumpar kan behöva rensas före granskning.
Steg 1 — Öppna redigeraren
Navigera till Erd Go-redigerare. Välj en tom SQL-fil eller ett startexempel. Arbetsytan tillhandahåller en SQL-panel och en diagramyta; på mindre skärmar, växla vyer efter behov.
Steg 2 — Klistra in din SQL
Kopiera din CREATE TABLE satser (inklusive främmande nycklar) och klistra in dem i SQL-panelen. Erd Go stöder standard SQL-syntax från PostgreSQL, MySQL, SQLite och SQL Server.
Steg 3 — Se diagrammet växa fram
Redigeraren tolkar din DDL i realtid och renderar tabellrutor med kolumner, datatyper, primärnycklar och pilar för främmande nycklar. Relationer detekteras automatiskt från FOREIGN KEY och REFERENCES klausuler.
Steg 4 — Förfina layouten
Dra tabeller för att flytta dem. Gruppera relaterade entiteter tillsammans för tydlighet. Redigeraren behåller positioner för matchande tabeller när du redigerar det aktuella dokumentet. Att byta namn på eller ersätta tabeller kan kräva en ny layoutgranskning; spara dokumentet för att bevara det för en senare session.
Steg 5 — Exportera eller dela
Exportera en PNG, SVG eller PDF för dokumentation och presentationer. För att dela en skrivskyddad offentlig länk, logga in och spara dokumentet först; granska känsliga schemadetaljer innan du gör det offentligt.
SQL-funktioner som stöds
Erd Go:s tolk hanterar ett brett utbud av DDL-konstruktioner men täckningen är inte identisk med en databasserver. Konsultera syntax som stöds och begränsningar och granska diagnostik vid import av en dump.
| SQL-funktion | Exempel | Hur det visas i ERD |
|---|---|---|
CREATE TABLE | CREATE TABLE users (...); | Renderas som en tabellruta med kolumnlista |
PRIMARY KEY | id SERIAL PRIMARY KEY | Kolumn markerad med en nyckelikon |
FOREIGN KEY / REFERENCES | REFERENCES users (id) | Pil ritad mellan de två tabellerna |
ENUM types | CREATE TYPE status AS ENUM (...); | Visas som en anpassad typ i kolumndefinitionen |
ALTER TABLE | ALTER TABLE orders ADD COLUMN ...; | Kolumn tillagd i den befintliga tabellrutan |
UNIQUE / NOT NULL | email VARCHAR(255) UNIQUE NOT NULL | Begränsningsmärken visas på kolumnen |
DEFAULT values | created_at TIMESTAMP DEFAULT NOW() | Standardvärde behållet i schemametadata och SQL; inspektera kolumndetaljerna |
Ett komplett exempel: E-handelsschema
Kopiera SQL nedan och klistra in den direkt i Erd Go-redigerare för att se ett fullständigt renderat e-handels-Klassdiagram.
-- Enum for order status
CREATE TYPE order_status AS ENUM (
'pending', 'processing', 'shipped', 'delivered', 'cancelled'
);
CREATE TABLE customers (
id SERIAL PRIMARY KEY,
full_name VARCHAR(120) NOT NULL,
email VARCHAR(255) UNIQUE NOT NULL,
phone VARCHAR(20),
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE categories (
id SERIAL PRIMARY KEY,
name VARCHAR(100) NOT NULL,
slug VARCHAR(100) UNIQUE NOT NULL,
parent_id INT REFERENCES categories (id)
);
CREATE TABLE products (
id SERIAL PRIMARY KEY,
name VARCHAR(200) NOT NULL,
description TEXT,
price NUMERIC(10, 2) NOT NULL CHECK (price > 0),
category_id INT REFERENCES categories (id),
sku VARCHAR(50) UNIQUE,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE orders (
id SERIAL PRIMARY KEY,
customer_id INT NOT NULL REFERENCES customers (id),
status order_status DEFAULT 'pending',
total NUMERIC(12, 2) NOT NULL DEFAULT 0,
ordered_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE order_items (
order_id INT NOT NULL REFERENCES orders (id) ON DELETE CASCADE,
product_id INT NOT NULL REFERENCES products (id),
quantity SMALLINT NOT NULL DEFAULT 1 CHECK (quantity > 0),
unit_price NUMERIC(10, 2) NOT NULL,
PRIMARY KEY (order_id, product_id)
);
ALTER TABLE products ADD COLUMN stock INT NOT NULL DEFAULT 0;Detta schema demonstrerar flera mönster samtidigt: en-till-många (customers → orders), många-till-många (orders ↔ products via order_items), en självrefererande främmande nyckel (categories.parent_id), en ENUM typ, CHECK villkor, och en ALTER TABLE sats. Erd Go-redigeraren hanterar alla.
Tips för rena, läsbara ERD:er
Även med automatisk generering gör några få bästa praxis dina diagram betydligt mer användbara:
- Använd konsekventa namngivningskonventioner. Håll dig till
snake_caseför tabeller och kolumner. Namnge kopplingstabeller efter de två entiteter de länkar (t.ex.order_items,student_courses). - Gruppera relaterade tabeller visuellt. Placera
users,roles, ochpermissionstabeller nära varandra, borta från obesläktade produkttabeller. - Minimera korsande linjer. Ordna om tabeller så att främmande nyckel-pilar flödar i samma generella riktning (uppifrån-och-ned eller vänster-till-höger).
- Markera nyckelentiteter. Placera dina viktigaste tabeller (t.ex.
users,orders) i mitten av diagrammet. - Återskapa efter migreringar. Behandla ditt ERD som ett levande dokument. Efter varje schemaändring, klistra in den uppdaterade SQL-koden igen i Erd Go-redigerare för att hålla diagrammet synkroniserat.



