DA SCHEMA A DIAGRAMMA
SQL a ERD: guida
Trasforma lo schema del database in un diagramma. Scopri il SQL supportato, visualizza i dati e interroga il modello.
Contratto di sintassi SQL pronto per l'IA
Usa questa pagina come contratto compatto quando chiedi a un'IA di scrivere o modificare SQL per Erd Go. Preferisci i modelli di sintassi riportati di seguito, mantieni le istruzioni complete e terminate da punto e virgola, ed evita oggetti del database non supportati a meno che tu non abbia bisogno solo di SQL grezzo all'esterno di Erd Go. Le sintassi SQLite, PostgreSQL, MySQL e MSSQL sono supportate nell'ambito del sottoinsieme condiviso sottostante. La conversione da SQL a ERD viene eseguita interamente nel browser e i suoi motori di parser e anteprima sono garantiti da migliaia di test unitari e di integrazione che coprono schemi di produzione del mondo reale (SaaS, banking, social, analytics, EHR).
SQLite
Regole rowid di INTEGER PRIMARY KEY, colonne senza tipi, AUTOINCREMENT, WITHOUT ROWID, tabelle STRICT validate, azioni FK e riproduzione delle migrazioni
PostgreSQL
ENUM e tipi compositi, array, JSONB, SERIAL, colonne identity, NULLS NOT DISTINCT, indici di espressione, identità dello schema e distinzione tra maiuscole e minuscole per i nomi tra virgolette
MySQL
AUTO_INCREMENT, ENUM e SET in linea, apici inversi, COMMENT, UNSIGNED/SIGNED, indici in linea, CHANGE/MODIFY COLUMN e posizionamento FIRST/AFTER
MSSQL
IDENTITY, NVARCHAR(MAX), nomi tra parentesi quadre, indici clustered, batch GO, ALTER COLUMN, colonne calcolate, valori predefiniti denominati e periodi temporali
DDL
CREATE TYPE, CREATE TABLE, riesecuzione della migrazione ALTER TABLE, CREATE INDEX e istruzioni DROP sicure per la forma dello schema
DML / SELECT
INSERT, UPDATE, DELETE per l'anteprima dei dati, oltre alla sintassi SELECT di sola lettura per join, CTE, aggregazioni, finestre e report
Avvio rapido
Usa questo come risposta modello quando chiedi a un'IA SQL compatibile con Erd Go: prima i tipi personalizzati, poi le tabelle, i vincoli di relazione dopo le tabelle quando utile, e infine un DML di esempio. Mantieni separate le query SELECT in sola lettura.
-- 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 o ALTER TABLE ADD FOREIGN KEY. Entrambe le forme contribuiscono con gli stessi metadati di relazione.INSERT, UPDATE, e DELETE dopo il DDL dello schema. Lo script viene valutato dall'alto verso il basso, quindi le righe di esempio dovrebbero fare riferimento a tabelle e tipi già esistenti.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;Schede SQL e importazione file
Inizia un nuovo file SQL con un esempio, una scheda Schema vuota o Importa file SQL. L'esempio separa lo schema e i dati in schede. La scheda Aggiungi SQL crea un'altra scheda dell'editor; fai doppio clic sul suo titolo per rinominarla.
Le schede attive vengono compilate insieme nell'ordine in cui sono visibili per l'Editor ERD, la vista Dati, la vista Query e le richieste AI. Una scheda inattiva rimane una bozza salvata ed è esclusa da quei flussi di lavoro. Posiziona i tipi e le tabelle prima delle istruzioni che dipendono da essi.
Importa file SQL accetta più file di testo SQL e verifica insieme i problemi di parsing prima dell'importazione. Questo aiuta a risolvere i riferimenti tra i file. Usa l'ordine delle schede per mantenere intenzionali le dipendenze e i passaggi di migrazione.
Usa i tasti freccia e Inizio/Fine nella barra delle schede per cambiare scheda, Alt+Sinistra/Destra per riordinarle e Shift+Alt+F per formattare SQL nell'editor.
Apri SQL Explorer accanto alle schede per un albero di cartelle ridimensionabile. Crea cartelle annidate e file SQL, seleziona un file per aprirlo e organizzalo con il drag/drop. Il popup delle azioni sulla riga supporta Rinomina ed Elimina file; fai clic all'esterno per chiuderlo. L'eliminazione dell'ultimo file mantiene aperto un file SQL vuoto. Le cartelle non modificano l'ordine di esecuzione. La rimozione di una cartella mantiene i suoi file e le cartelle figlio nel genitore. Salva mantiene l'albero delle cartelle e la preferenza del pannello.
Modifica e verifica il diagramma
L'SQL è la fonte del significato dello schema. Utilizza Aggiungi tabella per costruire una tabella, oppure seleziona le azioni di tabella e colonna sulla tela per modificare colonne e connessioni. Le modifiche allo schema sulla tela aggiornano le schede SQL proprietarie e il diagramma.
La rimozione di una colonna mostra in anteprima le connessioni interessate, le chiavi, gli indici e il SQL dipendente. Rivedi la rimozione o la cascata prima di confermare. Migrazioni complesse o istruzioni dipendenti non supportate possono richiedere la modifica diretta del SQL.
Usa il punteggio di stato dell'ERD per ispezionare i rilievi strutturali e le relazioni suggerite opzionali. Le relazioni suggerite richiedono una revisione; non sostituiscono le chiavi esterne dichiarate né stabiliscono automaticamente regole aziendali.
Disponi le tabelle con la Modalità Layout, zoom o Adatta allo schermo, trova le tabelle con il Navigatore tabelle e usa i Colori tabella o la minimappa per navigare in un diagramma di grandi dimensioni. Passa con il mouse sopra o concentrati su un controllo della barra degli strumenti per visualizzarne il testo della guida.
Seleziona una tabella e apri il Selettore colore per preimpostazioni a tinta unita o sfumate. Inserisci un valore esadecimale o scegli Personalizzato accanto ad esso per usare il selettore colore nativo. Entrambi i controlli rimangono sincronizzati; Salva mantiene il colore della tabella.
Quando gli strumenti per le tabelle sono impostati su solo al passaggio del mouse, Aggiungi colonna appare quando si passa il mouse sull'ultima riga visibile o si mette a fuoco il pulsante tramite tastiera. Gli strumenti sempre visibili lo mantengono mostrato.
Scegli Gruppi di tabelle sulla barra degli strumenti dell'area di disegno SQL, quindi Nuovo gruppo. Assegna al gruppo un nome e un colore, seleziona le sue tabelle e scegli Crea gruppo. Una tabella selezionata inizia spuntata. Una tabella appartiene a un gruppo; il modulo mostra quando la tua selezione sposterà una tabella fuori da un altro gruppo. Sono supportati fino a 50 gruppi, con nomi fino a 160 caratteri.
Fai clic sull'intestazione di un gruppo per modificarne il nome, il colore o i membri. Trascina l'intestazione per spostare le sue tabelle insieme; rilascia per applicare lo spostamento. Esc, l'annullamento del puntatore o la perdita dello stato attivo della finestra annullano l'anteprima. "Separa tabelle" rimuove la cornice mantenendo le tabelle, le loro posizioni, il codice SQL e le relazioni.
I frame di gruppo seguono le schede delle tabelle attive e compaiono in Adatta allo schermo, nella minimappa e nelle esportazioni di immagini della vista corrente o dell'intero diagramma. I gruppi sono uno stato visivo opzionale salvato con il documento SQL. I file meno recenti mantengono il loro layout esistente e i nomi delle tabelle temporaneamente mancanti rimangono nel loro gruppo fino al loro ritorno nel SQL analizzato. I gruppi di tabelle appartengono a SQL a ERD; i package del Diagramma delle classi utilizzano un modello separato.
Revisione IA all'interno dell'editor SQL
- Inserisci una modifica specifica in Chiedi all'IA per modificare il SQL e scegli un modello disponibile. L'impostazione della chiave API di Gemini è disponibile quando desideri utilizzare la tua chiave Gemini.
- Rivedi le modifiche proposte e l'anteprima temporanea del diagramma. La richiesta utilizza l'istantanea della scheda attiva acquisita al momento dell'invio; una risposta non viene salvata automaticamente.
- Accetta o rifiuta le singole modifiche, oppure usa le azioni per le modifiche rimanenti. Spostati tra le modifiche del codice con F7 e Shift+F7. Le schede inattive protette rimangono bozze.
- Ispeziona l'SQL accettato, quindi salva il documento. Copia AI Prompt in questa guida ti consente anche di utilizzare la documentazione con un assistente al di fuori dell'app.
Dati, query, esportazioni e file salvati
Usa i pulsanti ERD, Dati e Query per passare da un ambiente di lavoro all'altro. La vista Dati materializza i DDL e DML supportati nel browser ed espone tabelle, righe, tipi e un registro di esecuzione. Ridimensiona le colonne della griglia trascinandone i bordi o fai doppio clic per adattarle. Fai doppio clic su una cella Dati o premi Invio per modificare; i campi booleani ed enum offrono valori validi. Aggiungi riga segue le impostazioni predefinite dello schema. Importa CSV, TSV, TXT o XLSX con un'anteprima della mappatura delle colonne. I valori NULL e i testi vuoti rimangono distinti. Le modifiche convalidate diventano SQL in una scheda delle modifiche ai Dati e possono essere annullate. Scarica le righe delle tabelle o i risultati delle Query come CSV.
Salva ricorda l'ambiente di lavoro ERD, Dati o Query selezionato; la riapertura lo ripristina, inclusi Dati/Query sui telefoni. I file più vecchi si avviano in ERD. Gli editor nativi di data/ora mantengono i valori supportati, mentre i timestamp con frazioni o offset di fuso orario rimangono modificabili come testo. Le identità generate dal database rimangono in sola lettura.
La vista Query esegue query SELECT in sola lettura contro le tabelle correnti in memoria. Supporta la sintassi documentata di seguito; non si connette a un database esterno. Il testo della query viene salvato con il contesto del documento SQL.
Salva ricorda anche la tabella Dati selezionata. La riapertura la ripristina, utilizzando la prima tabella come soluzione alternativa se non è disponibile. I campi dello schema allineano nomi, tipi e regole; passa il mouse sopra il badge di una regola per visualizzarne la spiegazione. Vai a SQL accanto all'intestazione della tabella apre la relativa scheda SQL definitoria e rivela l'istruzione CREATE TABLE, riaprendo il pannello SQL quando è nascosto mentre mantiene la selezione dei Dati e le bozze. I risultati della Query combinano conteggi, tempistiche, Adatta, Copia e CSV in un'unica intestazione.
Trascina il divisore sottile tra l'editor di Query e i risultati, o tra lo Schema dei Dati e le righe, per ridimensionare i riquadri. I tasti freccia ridimensionano un divisore focalizzato, Esc annulla un trascinamento e il doppio clic lo ripristina. Queste dimensioni dei riquadri rimangono preferenze temporanee dell'area di lavoro.
La generazione di dati di esempio utilizza i tipi di colonna, i nomi, le relazioni e i vincoli. La lingua dei dati di esempio controlla i nomi e le frasi naturali di prodotti/descrizioni in 17 lingue. Rivedi i generatori e gli intervalli suggeriti, visualizza l'anteprima del risultato, quindi inserisci esplicitamente una scheda Dati di esempio separata. I booleani vengono visualizzati come true/false; gli ID rimangono numerici. La generazione non sostituisce mai le righe esistenti.
Scegli Esporta ERD per selezionare PNG, SVG basato su immagini o PDF con dimensioni HD, 2K o 4K. Le immagini esportate non sostituiscono un documento salvato modificabile.
Accedi e usa Salva SQL ed ERD per salvare il contesto SQL e del diagramma, comprese schede, modifiche alla griglia applicate, testo della query e layout. Salva controlla prima una cella attiva o una bozza di nuova riga; i dati non validi rimangono visibili per la correzione. Le anteprime di importazione richiedono la relativa azione Importa esplicita. Apri i file salvati dall'elenco dei file e usa Condividi su un documento salvato di tua proprietà per configurare l'accesso pubblico e distribuirne il link di sola lettura.
I documenti SQL, Prisma e Builder si aprono nei propri strumenti. Prisma e Builder hanno elenchi di file separati e il salvataggio solo su cloud. Gli avvisi relativi alle modifiche non salvate proteggono i documenti modificati quando si esce da uno spazio di lavoro; salva le tue modifiche prima di condividere o passare ad altro.
Risolvere i problemi dello spazio di lavoro SQL
| Sintomo | Cosa verificare |
|---|---|
| Manca una tabella | Controlla la diagnostica di analisi, le schede attive e l'ordine delle istruzioni. Un DROP o una rinomina successivi possono modificare il diagramma finale. |
| Manca una relazione | Verifica che entrambe le tabelle e colonne esistano, che il conteggio delle colonne delle chiavi esterne corrisponda e che la chiave referenziata sia univoca a livello globale. Qualifica con lo schema i nomi ambigui. |
| La vista Dati non mostra righe | Inserisci INSERT dopo il relativo CREATE TABLE in una scheda attiva. Ispeziona il log di esecuzione per righe rifiutate o rollback di transazioni. |
| I risultati della query non corrispondono più al codice SQL | Esegui nuovamente la query dopo aver modificato lo schema o i dati; usa le tabelle correnti in memoria. |
| Aggiungi tabella suggerisce un dialetto diverso | La sintassi dell'area di lavoro attiva rilevata ha la priorità rispetto al fallback selezionato manualmente. Esamina l'indicatore del linguaggio SQL e i valori predefiniti specifici della tabella. |
| Un file salvato non può essere modificato | Verifica l'accesso e la proprietà. Un link pubblico garantisce l'accesso in sola lettura; usa Riprova o Apri file per gli errori di caricamento recuperabili. |
Flusso di lavoro della sintassi IA
Quando usi un assistente IA, chiedigli di produrre SQL in questo ordine. Questo rende il risultato facile da analizzare, facile da rappresentare in un diagramma e facile da visualizzare in anteprima con righe di esempio o query in sola lettura.
1. Definisci prima i domini
Inserisci le definizioni CREATE TYPE enum/composite prima delle tabelle che le referenziano. Preferisci nomi espliciti rispetto a tipi inline ad hoc quando un dominio è condiviso.
2. Crea tabelle di base
Usa CREATE TABLE per colonne, chiavi primarie, univocità, valori predefiniti, controlli, colonne generate e chiavi esterne inline.
3. Ripeti le migrazioni
Usa ALTER TABLE per vincoli aggiunti, rinomine, colonne eliminate, modifiche a tipo/annullabilità delle colonne e chiavi esterne circolari.
4. Aggiungi dati e query per ultimi
Inserisci INSERT/UPDATE/DELETE dopo tutto il DDL. Mantieni le query SELECT separate dalla mutazione dello schema quando desideri set di risultati.
ALTER TYPE. Gli indici basati su espressioni vengono conservati con un avviso; richiedi chiavi di colonna semplici quando hai bisogno dei badge degli indici nell'Editor ERD.Sintassi DDL e DML
Queste forme di istruzione sono sicure per gli script di schema e i Dati di esempio generati dall'IA. La stessa sintassi gestisce la struttura dell'ERD e le righe di anteprima in memoria, quindi mantieni il DDL prima del DML ed evita effetti collaterali esterni specifici del database.
Istruzioni supportate
-- 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, più AND / OR combinazioni. I confronti con NULL seguono la logica UNKNOWN dello standard SQL — col = NULL non corrisponde mai; usa col IS NULL invece. I target di assegnazione sconosciuti, i riferimenti alle colonne a destra e le colonne di filtro rifiutano la mutazione completa prima di qualsiasi modifica alle righe.Anteprima della semantica per DML generato dall'IA
Le righe vengono riprodotte da zero
Le istruzioni DDL e DML vengono applicate insieme nell'ordine di origine; ogni istruzione sui dati utilizza lo schema attivo in quel momento.
I tipi rimangono ispezionabili
I tipi enumerati denominati e i tipi compositi creati con CREATE TYPE rimangono parte dello schema analizzato.
I vincoli vengono applicati
Le colonne PK, FK, NOT NULL, UNIQUE, DEFAULT, CHECK, le colonne generate e i domini enum influenzano le righe di anteprima.
Gli errori dovrebbero essere risolvibili
Preferisci elenchi di colonne espliciti e clausole WHERE concrete in modo che la diagnostica possa indicare esattamente la tabella o la colonna.
SELECT set di risultati nello script di schema/DML principale, corpi procedurali non supportati o chiamate a database esterni. CREATE VIEW, CREATE OR REPLACE VIEW, e MSSQL CREATE OR ALTER VIEW sono materializzati dai loro SELECT risultato per l'anteprima; mantieni separate le query ad hoc in sola lettura.Transazioni nella vista Dati
La vista Dati supporta BEGIN, COMMIT, ROLLBACK, SAVEPOINT, ROLLBACK TO e RELEASE nell'anteprima in memoria. Queste istruzioni influenzano le righe dell'anteprima; non eseguono mai il commit su un database esterno.
SQLite, PostgreSQL e SQL Server mantengono il DDL transazionale nell'anteprima. Il DDL di MySQL esegue il commit della transazione attiva. PRAGMA foreign_keys di SQLite e SET FOREIGN_KEY_CHECKS di MySQL influenzano la successiva convalida DML.
Il renderer ERD ignora i wrapper di transazione e rappresenta le istruzioni dello schema nell'ordine di origine. Un rollback di transazione nella vista Dati può quindi produrre un insieme di tabelle diverso dal diagramma. Controlla ciascun workbench per il comportamento che stai testando.
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;Sintassi della Query SELECT
Chiedi all'IA di mantenere le query di reportistica di sola lettura come SELECT istruzioni. Queste possono fare riferimento alle tabelle e alle righe prodotte dallo script di schema/DML e sono utili per join, filtri, totali e set di risultati strutturati come report senza richiedere un database attivo.
Struttura della query supportata
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;Solo SELECT
L'editor di query accetta istruzioni SELECT, incluse le SELECT senza FROM e le CTE WITH che si risolvono in una SELECT.
Join & filtri
Join INNER, LEFT, RIGHT, FULL e CROSS, condizioni WHERE, EXISTS, subquery IN, BETWEEN, LIKE, ILIKE e controlli NULL.
Aggregazioni
GROUP BY, HAVING, COUNT, SUM, AVG, MIN, MAX, ARRAY_AGG, GROUP_CONCAT, STRING_AGG e varianti DISTINCT.
Ordinamento e paginazione
ORDER BY nomi o ordinali, ASC/DESC, NULLS FIRST/LAST, LIMIT/OFFSET, TOP e FETCH FIRST.
Supporto SELECT avanzato
CTE e tabelle derivate
Sono supportate le clausole WITH, le SELECT annidate in FROM, le sottoquery scalari, EXISTS, NOT EXISTS, IN e NOT IN.
Operatori insiemistici
UNION, UNION ALL, INTERSECT ed EXCEPT possono combinare set di risultati compatibili.
Funzioni finestra
ROW_NUMBER, RANK, DENSE_RANK, NTILE, LAG, LEAD, FIRST_VALUE e LAST_VALUE con OVER e PARTITION BY. Le finestre ordinate utilizzano il frame predefinito SQL peer-aware e NTILE assegna prima i bucket più grandi.
Helper dei dialetti
Le funzioni comuni di SQLite, PostgreSQL, MySQL e MSSQL sono normalizzate per l'anteprima, inclusi gli helper per JSON e data/stringa.
INSERT, UPDATE, DELETE, CREATE, ALTER, e DROP istruzioni nello script di schema/DML. La sintassi della query dovrebbe rimanere SELECT-solo.Diagnostica ed errori
La diagnostica della sintassi rileva problemi di analisi dello schema, esecuzione DDL/DML e SELECT in sola lettura con messaggi chiari. Gli errori di analisi includono le posizioni di riga/colonna quando possibile, e i messaggi di esecuzione rimandano alla tabella, colonna o struttura dell'istruzione che richiede correzione.
Errori di analisi dello schema
Il parser dello schema (SQLite, PostgreSQL, MySQL e MSSQL) segnala i problemi con due livelli di gravità: errore impedisce a una singola istruzione di contribuire allo schema; avviso mantiene una sintassi valida ma segnala qualcosa che l'utente dovrebbe sapere.
// 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
}Errori del parser
Elenchi di colonne PRIMARY KEY / UNIQUE / FOREIGN KEY vuoti, tipi di dati richiesti mancanti (incluse le colonne STRICT di SQLite), parentesi non abbinate, virgole impreviste e vincoli mal formati.
Avvisi del tokenizer
Stringhe non chiuse, commenti di blocco non chiusi, parentesi non corrispondenti ed espressioni CHECK multilinea sospette.
Avvisi sulle chiavi estere
Le FK che puntano a una tabella sconosciuta, una colonna sconosciuta, una foglia di schema ambigua o una destinazione non-PK/non-UNIQUE vengono rimosse dal diagramma con un avviso descrittivo.
Diagnostica raggruppata
Gli avvisi sono raggruppati per causa, inclusi Dropped relation, Unknown table, Unknown column, Non-unique FK target, Warnings ed Parse errors.
SQL vuoto
Un input vuoto è valido e produce uno schema vuoto. Solo gli input non stringa non validi generano un errore.
Registro di esecuzione DDL/DML
Ogni istruzione DDL o DML eseguita aggiunge una voce strutturata al log di esecuzione in memoria. Il flusso di messaggi preserva l'ordine cronologico e classifica ciascuna istruzione come errore, avviso, o successo.
// 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 existDiagnostica comune
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
Definisci tipi di dati personalizzati da riutilizzare nello schema del database. I tipi enum e composti con nome dovrebbero apparire prima delle tabelle che li fanno riferimento, inclusi i riferimenti con qualifica di schema.
1.1. Tipo composto
Definisci tipi composti personalizzati con più campi di vari tipi di dati.
CREATE TYPE type_name AS (
field1 data_type1,
field2 data_type2,
...
);Esempio:
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. Tipo Enum
Crea tipi enumerati con valori predefiniti per una migliore integrità e leggibilità dei dati.
CREATE TYPE enum_name AS ENUM (
'value1',
'value2',
...
);Esempio:
CREATE TYPE status_enum AS ENUM (
'pending',
'active',
'completed',
'cancelled'
);
CREATE TYPE priority_level AS ENUM (
'low', 'medium', 'high', 'critical'
);1.3. Tipi qualificati da schema
I tipi definiti dall'utente vengono risolti con la stessa consapevolezza dello schema utilizzata per le tabelle. Se due schemi definiscono lo stesso nome foglia, l'ERD li mantiene distinti; se un tipo è unico, il nome visualizzato rimane semplice.
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 non si risolve mai in s2.status solo perché entrambi condividono il nome della foglia status. I nomi di tipo qualificati sono rigorosi, mentre i nomi non qualificati si risolvono solo quando non sono ambigui.CREATE TABLE
Definisci tabelle di database con colonne, tipi di dati e vincoli.
2.1. Struttura di tabella di base
La sintassi generale per la creazione di una tabella:
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"), apici inversi (\`name\`), o parentesi quadre ([name]) per l'escaping di caratteri speciali o parole chiave riservate.2.2. Definizioni a livello di colonna
Ciascuna colonna può includere vari vincoli e proprietà:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
username VARCHAR(50) UNIQUE NOT NULL,
email TEXT NOT NULL CHECK (email LIKE '%@%'),
status VARCHAR(20) DEFAULT 'active',
created_at TIMESTAMP DEFAULT now(),
department_id INTEGER REFERENCES departments(id)
);PRIMARY KEY
Identifica in modo univoco ciascuna riga
UNIQUE
Assicura che i valori delle colonne siano distinti
NOT NULL
Previene valori nulli
DEFAULT
Imposta valori predefiniti (letterali o funzioni)
CHECK
Convalida i Dati con espressioni booleane
REFERENCES
Crea relazioni di chiave esterna
- Valori letterali: numeri (
123), stringhe ('text') - Funzioni PostgreSQL:
now(),CURRENT_TIMESTAMP,CURRENT_DATE,nextval('seq'::regclass) - Funzioni MSSQL:
GETDATE(),NEWID()
REFERENCES table(column), con prefisso di schema REFERENCES schema.table(column), colonne di destinazione omesse come REFERENCES departments, e azioni FK come ON DELETE CASCADE, ON UPDATE SET NULL, MATCH FULL, e DEFERRABLE INITIALLY DEFERRED.2.3. Colonne generate / calcolate
Riferimento rapido. Vedi il dedicato Colonne calcolate sezione sottostante per l'analisi dettagliata per ogni dialetto, inclusa la forma con AS semplice di MSSQL.
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. Tipi ENUM inline
Puoi dichiarare un ENUM direttamente in una definizione di colonna (stile MySQL). Il parser lo registrerà come enum con nome e sostituirà automaticamente il tipo di colonna.
CREATE TABLE tasks (
id INTEGER PRIMARY KEY,
status ENUM('todo', 'doing', 'done'),
priority ENUM('low', 'medium', 'high')
);column_enum (per esempio, status_enum); le tabelle successive con una definizione diversa per lo stesso nome di colonna ottengono un nome qualificato dalla tabella come tasks_status_enum in modo che i domini non collassino mai accidentalmente.CREATE TYPE ... AS ENUM invece.2.5. Vincoli a livello di tabella
Definisci i vincoli alla fine del corpo della tabella. Utile per chiavi composte e vincoli su più colonne:
-- 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)Esempio:
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) è facoltativo.REFERENCES ref_table omette l'elenco delle colonne di destinazione, Erd Go la risolve nella chiave primaria della tabella referenziata, comprese le chiavi primarie composite. Se specifichi esplicitamente le colonne di destinazione, queste devono essere supportate da una PRIMARY KEY, un vincolo UNIQUE o globale CREATE UNIQUE INDEX; gli indici unici filtrati / parziali non contano come destinazioni di FK. Le relazioni non valide vengono rimosse con un avviso.2.6. Nomi di colonne con parole riservate
Parole come key, index, value, e name sono riservate in alcuni dialetti ma comunemente usate come nomi di colonna in altri. Il parser risolve le ambiguità automaticamente quando il token successivo è un tipo di dato noto, quindi l'uso senza virgolette funziona:
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 seguito da una parola chiave del tipo di dati (VARCHAR, INT, …) è un colonna. Seguito da un identificatore e un elenco di colonne tra parentesi, è un indice. Per assoluta sicurezza, metti tra virgolette la colonna con "key", `key`, o [key].Colonne Identity / Auto-Increment
Usa la sintassi di identità nativa per il dialetto selezionato. Tutte le forme supportate producono una colonna chiave primaria con AUTO_INCREMENT marcatore, ma SQLite ha una regola ferrea: AUTOINCREMENT richiede un singolo INTEGER PRIMARY KEY colonna.
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. Non usare BIGINT, INT, o una chiave primaria composta con 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 è un identità colonna (auto-incremento), distinta da GENERATED ALWAYS AS (expression) che è un calcolato colonna. Il parser le mantiene separate automaticamente.MySQL
CREATE TABLE users (
id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
email VARCHAR(255) NOT NULL UNIQUE
) ENGINE=InnoDB;MSSQL / SQL Server
-- IDENTITY(seed, increment)
CREATE TABLE [dbo].[Customers] (
[CustomerID] BIGINT IDENTITY(1,1) NOT NULL CONSTRAINT pk_customer PRIMARY KEY,
[Email] NVARCHAR(255) NOT NULL
);
-- Bare IDENTITY (defaults to (1,1))
CREATE TABLE [dbo].[Orders] (
[OrderID] INT IDENTITY NOT NULL PRIMARY KEY
);AUTO_INCREMENT tag — così puoi combinare i dialetti in un unico schema senza perdere il suggerimento sull'incremento automatico.Colonne calcolate (per dialetto)
Una colonna calcolata deriva il suo valore da un'espressione su altre colonne nella stessa riga. Supportata in tutti e quattro i dialetti con le rispettive sintassi.
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 memorizza il valore calcolato e VIRTUAL lo calcola durante la lettura. Erd Go mantiene i valori di anteprima in memoria; l'ERD conserva ciascuna modalità come metadato della colonna.MSSQL / SQL Server — colonna AS espressione [PERSISTED]
MSSQL ha una sua sintassi: column_name AS expression, facoltativamente seguito da PERSISTED (e facoltativamente NOT NULL). Entrambi tra parentesi e bare le forme di espressione sono supportate.
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 (senza parentesi circostanti) — incluse le chiamate di funzione come DATEADD(...), riferimenti qualificati per tabella come c.GrowthDurationDays, e CASE espressioni — che terminano alla virgola della colonna successiva, PERSISTED, o fine del corpo della tabella.COMPUTED come tipo e l'espressione conservata negli extra della colonna / tooltip.ALTER TABLE
Stile di migrazione comune ALTER TABLE le istruzioni vengono rieseguite dopo la creazione della tabella, in modo che lo schema finale rifletta colonne aggiunte, vincoli, rinomine, colonne eliminate e modifiche a tipo/annullabilità delle colonne. La sintassi di dump PostgreSQL che usa ALTER TABLE ONLY preserva l'identità qualificata della tabella.
Aggiungi e vincola
ADD COLUMN, ADD PRIMARY KEY, ADD UNIQUE, ADD CHECK e ADD FOREIGN KEY si riflettono nell'Editor ERD.
Rinomina ed elimina
Rinomine di tabelle, colonne, vincoli e indici—inclusi MySQL RENAME TABLE, PostgreSQL ALTER INDEX e SQL Server sp_rename—rimangono collegate alla corretta incarnazione dell'oggetto prima di successive operazioni DROP.
Modifiche alle colonne
PostgreSQL ALTER COLUMN TYPE/SET DATA TYPE/SET o DROP DEFAULT/nullability, MSSQL ALTER COLUMN e MySQL MODIFY/CHANGE COLUMN vengono riprodotti.
Sicurezza delle relazioni
Le chiavi estere vengono convalidate rispetto allo stato finale della tabella dopo la riproduzione della migrazione, incluse le modifiche a PK/UQ/indice e il conteggio esatto delle colonne di origine/destinazione.
3.1. Aggiungi chiave esterna
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];Esempio:
ALTER TABLE orders
ADD CONSTRAINT fk_orders_customer
FOREIGN KEY (customer_id)
REFERENCES customers(id)
ON DELETE CASCADE;3.2. Aggiungi chiave primaria
ALTER TABLE table_name
ADD [CONSTRAINT name] PRIMARY KEY (cols...);Esempio:
ALTER TABLE products
ADD CONSTRAINT pk_products
PRIMARY KEY (product_id);3.3. Aggiungi vincolo unico
ALTER TABLE table_name
ADD [CONSTRAINT name] UNIQUE (cols...);Esempio:
ALTER TABLE users
ADD CONSTRAINT uq_users_email
UNIQUE (email);3.4. Aggiungi vincolo di controllo
ALTER TABLE table_name
ADD [CONSTRAINT name] CHECK (expression);Esempio:
ALTER TABLE employees
ADD CONSTRAINT chk_salary
CHECK (salary >= 0);3.5. Esempio di ripetizione della migrazione
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 diventa contact_email, audit_state viene rimosso e l'indice univoco fornisce contact_email un UQ badge.3.6. CHANGE / MODIFY COLUMN di MySQL
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. ALTER COLUMN di MSSQL / SQL Server
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
Il DDL dell'indice viene analizzato in tutti e quattro i dialetti. Le chiavi di colonna semplici vengono visualizzate come piccoli badge ERD: IDX per velocizzazioni non uniche, UQ per gli indici unici globali, e PUQ per indici unici filtrati / parziali. Le voci delle espressioni vengono conservate nell'output del parser e segnalate quando non possono essere mappate fedelmente a un badge di colonna.
Badge IDX
Indice non univoco. Pillola solida sulla colonna. Gli indici composti disattivano la pillola (grigia) su ogni colonna chiave, rendendo ovvia a colpo d'occhio la differenza tra colonna singola e multi-colonna.
Badge UQ
Da un CREATE UNIQUE INDEX globale. Si comporta come un vincolo UNIQUE per la validazione delle FK e l'etichettatura delle colonne.
Badge PUQ
Da CREATE UNIQUE INDEX ... WHERE. Mostra il predicato di unicità parziale ma non convalida le destinazioni delle FK come globalmente uniche.
Regola di soppressione
I vincoli più forti hanno la precedenza: PK ⟶ UQ ⟶ PUQ ⟶ IDX. Una chiave più forte non viene mai declassata da un indice successivo.
Multi-dialetto
PostgreSQL CONCURRENTLY / USING / INCLUDE / WHERE, MySQL FULLTEXT/SPATIAL & KEY/INDEX in linea, MSSQL CLUSTERED/NONCLUSTERED con INCLUDE, indici standard SQLite.
4.1. Sintassi
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. Esempi
Velocizza una ricerca frequente per FK (IDX a colonna singola):
CREATE INDEX idx_orders_customer ON orders (customer_id);Indice composito (pillola IDX tenue su ogni colonna chiave):
CREATE INDEX idx_orders_customer_status
ON orders (customer_id, status);Promuovi una colonna a UNIQUE senza alterarne la definizione:
CREATE UNIQUE INDEX uq_shipments_tracking
ON shipments (tracking_number);Indice univoco parziale / filtrato (PUQ, non una destinazione FK globale):
CREATE UNIQUE INDEX ux_users_active_email
ON users (email)
WHERE deleted_at IS NULL;Indice inline MySQL all'interno di 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 indice filtrato + INCLUDE:
CREATE NONCLUSTERED INDEX idx_active_orders
ON orders (customer_id)
INCLUDE (total)
WHERE status = 'active';4.3. Comportamento e semantica
- Indici funzionali / di espressione (ad es.
CREATE INDEX … ON t (lower(email))) vengono preservati e producono un avviso esplicito ma nessun badge — non si mappano chiaramente su una singola colonna. - Colonne INCLUDE (colonne di copertura) vengono analizzate ma non ricevono mai un badge: solo le colonne chiave guadagnano la pillola.
- Colonne PK / UQ sono garanzie più forti rispetto a IDX, quindi qualsiasi successivo
CREATE INDEXsu di essi viene ignorata silenziosamente — non vedrai pillole ridondanti. - Indici univoci parziali / filtrati vengono visualizzati come
PUQcon ilWHEREpredicato nei dettagli della colonna. Non sono accettati come destinazioni globalmente univoche per la convalida delle chiavi esterne. - I badge finali sono invarianti rispetto all'ordine: una garanzia di unicità globale sopprime un
IDXbadge indipendentemente dal fatto che appaia prima l'indice unique o non-unique. I metadati dell'indice composito vengono ugualmente conservati a prescindere dall'ordine di dichiarazione. - Indici su tabelle / colonne sconosciute vengono ignorati silenziosamente — utile quando si portano schemi parziali senza interrompere il diagramma.
- Ciclo di vita dell'indice include di livello superiore
CREATE/DROP INDEX, PostgreSQLDROP INDEX CONCURRENTLY, MySQLALTER TABLE … ADD/DROP/RENAME INDEX, PostgreSQLALTER INDEX … RENAME, e rinomina degli indici di SQL Server tramitesp_rename. I metadati denominati UQ/PUQ/IDX seguono il nome superstite finale.
Supporto multi-dialetto
Il parser lato browser gestisce le differenze sintattiche tra SQLite, PostgreSQL, MySQL e MSSQL senza una connessione al database. Il rilevamento automatico utilizza segnali sintattici strutturali e rimane neutrale per input con dialetti genuinamente misti; i chiamanti possono anche fornire un dialetto esplicito. Gli esempi seguenti seguono lo stesso ordine standard: prima SQLite, poi PostgreSQL, MySQL e MSSQL.
4.1. Funzionalità di SQLite
-- 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 (alias rowid), AUTOINCREMENT, WITHOUT ROWID, STRICT tabelle, colonne non-STRICT senza tipo, affinità di tipo (INTEGER, TEXT, REAL, NUMERIC, BLOB), datetime('now') / CURRENT_TIMESTAMP valori predefiniti e standard REFERENCES con ON DELETE / ON UPDATE azioni.VARCHAR(255), BOOLEAN, o TIMESTAMP) e possono omettere un tipo. Le tabelle STRICT seguono l'insieme esatto consentito da SQLite: INT, INTEGER, REAL, TEXT, BLOB, o ANY; ogni colonna STRICT deve dichiararne una.Esempio di riproduzione della migrazione SQLite:
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. Funzionalità di PostgreSQL
-- 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, conservazione degli indici basati su espressioni e distinzione esatta tra maiuscole e minuscole di PostgreSQL per i nomi tra virgolette.4.3. Funzionalità di MySQL
-- 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, modificatori di segno, varianti intero/testo/blob/spaziali, inline ENUM e SET, indici inline, CHANGE COLUMN, MODIFY COLUMN, FIRST/AFTER posizionamento fisico, ON UPDATE CURRENT_TIMESTAMP, e opzioni di tabella comuni.4.4. Funzionalità di MSSQL / SQL Server
-- 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), data/ora, binari, XML, identificatori e tipi spaziali, ROWGUIDCOL, indici cluster, GO batch, ALTER COLUMN, colonne calcolate, denominate DEFAULT ... FOR column vincoli, colonne temporali generate e PERIOD FOR SYSTEM_TIME.col AS expression PERSISTED (senza parentesi circostanti) è completamente supportato, incluse le chiamate di funzione (DATEADD, LEFT, …), riferimenti di colonna qualificati per tabella (c.col), e CASE espressioni.4.5. Stili di quotazione degli identificatori
Sono supportate tutte e tre le principali convenzioni di virgolettatura:
-- 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
);Note e suggerimenti
Dettagli importanti sul supporto della sintassi: cosa contribuisce alla struttura dello schema, quale DDL/DML può essere riprodotto con righe di esempio, cosa possono leggere le query SELECT e dove sono i limiti.
✓ Supporto della sintassi Schema / ERD
- Multi-dialetto: La sintassi di SQLite, PostgreSQL, MySQL e MSSQL può condividere uno script; il rilevamento automatico rimane neutrale quando i segnali forti sono realmente misti
- Parole chiave case-insensitive: CREATE, TABLE, ALTER, ecc. possono essere scritti in qualsiasi maiuscole/minuscole
- Identificatori tra virgolette: Doppi apici (
"name"), apici inversi (`name`), e parentesi quadre ([name]) - Nomi di colonne con parole riservate: Grezzo
key,index,value,name,order, ecc. sono accettati se seguiti da un tipo di dato - Nomi qualificati dallo schema:
schema.tableeschema.type(ad esempio,public.users,dbo.Orders,app.status_enum) — i prefissi di schema sui tipi definiti dall'utente vengono preservati per una ricerca rigorosa e semplificati per la visualizzazione solo quando non sono ambigui - Commenti: A riga singola (
-- comment) e commenti multilinea (/* comment */) vengono ignorati automaticamente - BOM & CRLF: Il byte-order-mark UTF-8 e le interruzioni di riga Windows vengono gestiti in modo trasparente
- Tipi personalizzati:
CREATE TYPE … AS ENUMeCREATE TYPE … AS (composite), inclusi i nomi con prefisso di schema - ENUM & SET inline (MySQL):
ENUM('a','b')eSET('a','b','c')all'interno dei tipi di colonna — registrati automaticamente come tipi con nome e inseriti nello spazio dei nomi per tabella/colonna quando nomi di colonna duplicati utilizzano domini diversi - Vincoli: A livello di colonna e a livello di tabella
PRIMARY KEY,FOREIGN KEY,UNIQUE,CHECK(incluse varianti composte multi-colonna). Le destinazioni delle FK vengono convalidate rispetto a chiavi primarie, vincoli unici o indici univoci globali - Identity / auto-increment:
SERIAL/BIGSERIAL(PG),GENERATED ALWAYS/BY DEFAULT AS IDENTITY(PG),AUTO_INCREMENT(MySQL),IDENTITY(1,1)e sempliciIDENTITY(MSSQL) — si uniscono tutte nel diagramma - Colonne calcolate:
GENERATED ALWAYS AS (expr) STORED/VIRTUAL(PG/MySQL) e MSSQLcol AS (expr) [PERSISTED]+ nudocol AS expr [PERSISTED] - Array PostgreSQL:
type[], con dimensionitype[5], annidatitype[][][], e array di tipi definiti dall'utente (ad es.,webhook_event[]) - Valori predefiniti: Valori letterali, stringhe racchiuse tra virgolette dollaro, chiamate di funzione (
now(),CURRENT_TIMESTAMP,GETDATE(),NEWID(),NEWSEQUENTIALID(),gen_random_uuid(),nextval()), eON UPDATE CURRENT_TIMESTAMP(MySQL) - Azioni FK:
ON DELETE/ON UPDATEconCASCADE,RESTRICT,SET NULL,SET DEFAULT,NO ACTION, piùMATCH,DEFERRABLE, eINITIALLYmetadati. Le azioni vengono conservate come metadati della relazione. - Riproduzione della migrazione:
ALTER TABLE ADD COLUMN, aggiunta/eliminazione/rinomina di chiavi e vincoli, rinomina di tabelle/colonne/indici,DROP COLUMN,ALTER COLUMN TYPE/SET DATA TYPE,SET/DROP DEFAULT,SET/DROP NOT NULL, MSSQLsp_rename, e MySQLMODIFY/CHANGE COLUMN - Indici: Di primo livello
CREATE/DROP INDEX, PostgreSQLALTER INDEX … RENAME, MySQL aggiunta/eliminazione/rinomina e incorporatoKEY/INDEX/UNIQUE INDEX/FULLTEXT/SPATIALdefinizioni. Gli indici basati su colonne vengono visualizzati comeIDX,UQ, oPUQbadge - IF NOT EXISTS, IF EXISTS: gestito correttamente su entrambi
CREATEeDROP - Wrapper di transazione solo schema:
BEGIN,COMMIT,SET search_path,USE [db](MSSQL), eSET FOREIGN_KEY_CHECKS(MySQL) vengono elegantemente ignorati - Ignorato correttamente:
CREATE VIEW,CREATE MATERIALIZED VIEW,CREATE FUNCTION/TRIGGER/SCHEMA/SEQUENCE, proceduraleEXECistruzioni diverse dasp_rename,DECLARE,PRINT,PARTITION BY,INHERITS(corpo vuoto incluso),WITH OIDS,STORAGE PLAIN,EXCLUDE USING gist, e corpi delle istruzioni che non influiscono sulla struttura dell'Editor ERD
✓ Sintassi di anteprima DDL/DML
- Esecuzione dall'alto verso il basso: Lo script viene eseguito nell'ordine delle istruzioni, quindi i dati di esempio devono trovarsi dopo lo schema a cui fanno riferimento
- Istruzioni supportate:
CREATE TYPE,CREATE TABLE,CREATE VIEW,CREATE INDEX,ALTER TABLEmodifiche a colonne/vincoli,DROP INDEX,TRUNCATE TABLE,INSERT,UPDATE,DELETE,DROP TABLE,DROP VIEW, eDROP TYPE - Filtri WHERE:
=,!=,<>,>,<,>=,<=,LIKE,IN,NOT IN,NOT LIKE,BETWEEN,NOT BETWEEN,IS NULL, eIS NOT NULL - Materializzazione delle righe: Le tabelle mostrano il numero di righe, i metadati di struttura e i dati della riga corrente dopo l'esecuzione delle istruzioni DML
- Tipi denominati: ENUM e tipi compositi creati con
CREATE TYPEvengono mostrati separatamente dalle tabelle - Log di esecuzione: Stati di successo, avviso ed errore vengono acquisiti per colonne sconosciute, tabelle mancanti, chiavi duplicate, violazioni di NULL e aggiornamenti/eliminazioni estese; i binding di mutazione non validi falliscono prima che le righe cambino
- Valutazione predefinita: Valori predefiniti letterali più funzioni come
now(),CURRENT_TIMESTAMP,CURRENT_DATE,GETDATE(), eNEWID()
✓ Sintassi della Query SELECT
- SELECT in sola lettura:
SELECTle istruzioni possono leggere le tabelle in memoria prodotte dal file SQL principale - Metadati del risultato: Colonne, conteggio righe, tempo trascorso, formattazione NULL/booleana/numerica ed errori di query vengono preservati con il risultato della SELECT
- Query relazionali: Join, filtri WHERE, GROUP BY, HAVING, ORDER BY, LIMIT/OFFSET, TOP, FETCH FIRST, CTE, tabelle derivate, sottoquery e operatori di insieme
- Helper analitici: Aggregazioni, funzioni scalari comuni, helper JSON, funzioni di data/stringa e funzioni di finestra come
ROW_NUMBER,RANK,NTILE,FIRST_VALUE,LAST_VALUE,LAG, eLEAD; i frame predefiniti ordinati includono il gruppo di peer corrente
✗ Ancora non supportato / Omesso
- ALTER TYPE: Impossibile modificare ENUM o tipi composti esistenti
- Clausola LIKE:
CREATE TABLE foo (LIKE bar INCLUDING …)viene ignorato correttamente — le colonne copiate non vengono materializzate - Ereditarietà delle colonne INHERITS: Il
INHERITS (parent)la clausola stessa viene analizzata senza errori, ma le colonne ereditate non vengono inserite nella tabella figlia ai fini del grafico ERD - Esecuzione dell'indice: Il DDL dell'indice può creare badge di schema, ma l'esecuzione dell'anteprima non modella i motori di archiviazione, i pianificatori di query o le prestazioni dell'indice
- Limiti SELECT: La sintassi delle query in sola lettura non supporta CTE ricorsive, esecuzione su database esterni, stored procedure o istruzioni di mutazione
- Altri oggetti: Trigger, stored procedure, funzioni e sequenze
- Esecuzione esterna: L'anteprima DDL/DML non si connette a un database reale né rende persistenti le righe all'esterno del file SQL corrente
- Termina ogni istruzione con un punto e virgola (
;) - Definisci
CREATE TYPEprima delle tabelle che vi fanno riferimento - Definisci
CREATE TABLEprima di quelli correlatiINSERT,UPDATE, oDELETEistruzioni - Usa
ALTER TABLEper le chiavi esterne quando le tabelle si riferiscono a vicenda (dipendenze circolari) - Usa prima il DDL per la struttura, poi il DML per convalidare le righe di esempio e il comportamento dei vincoli
- Mantieni i dati demo nel file SQL stesso perché le righe di anteprima sono derivate dallo script