DU SCHÉMA AU DIAGRAMME
SQL vers ERD : guide
Transformez votre schéma de base de données en diagramme. Découvrez le SQL pris en charge, prévisualisez les données et interrogez votre modèle.
Contrat de syntaxe SQL prêt pour l'IA
Utilisez cette page comme contrat compact lorsque vous demandez à une IA d'écrire ou de modifier du SQL pour Erd Go. Préférez les motifs de syntaxe ci-dessous, gardez les instructions complètes et terminées par un point-virgule, et évitez les objets de base de données non pris en charge à moins d'avoir uniquement besoin de SQL brut en dehors d'Erd Go. Les syntaxes SQLite, PostgreSQL, MySQL et MSSQL sont prises en charge dans le sous-ensemble partagé ci-dessous. La conversion SQL vers ERD s'exécute entièrement dans le navigateur, et ses moteurs d'analyse et d'aperçu sont verrouillés par des milliers de tests unitaires et d'intégration couvrant des schémas de production du monde réel (SaaS, banque, social, analytique, DME).
SQLite
Règles de ligne INTEGER PRIMARY KEY, colonnes sans type, AUTOINCREMENT, WITHOUT ROWID, tables STRICT validées, actions de clés étrangères (FK) et rejeu de migration
PostgreSQL
Types ENUM et composites, tableaux, JSONB, SERIAL, colonnes d'identité, NULLS NOT DISTINCT, index d'expression, identité de schéma et sensibilité à la casse des noms entre guillemets
MySQL
AUTO_INCREMENT, ENUM & SET en ligne, guillemets inversés, COMMENT, UNSIGNED/SIGNED, index en ligne, CHANGE/MODIFY COLUMN, et placement FIRST/AFTER
MSSQL
IDENTITY, NVARCHAR(MAX), noms entre crochets, index cluster, lots GO, ALTER COLUMN, colonnes calculées, valeurs par défaut nommées et périodes temporelles
DDL
CREATE TYPE, CREATE TABLE, rejouage de migration ALTER TABLE, CREATE INDEX et instructions DROP sécurisées pour la forme du schéma
DML / SELECT
INSERT, UPDATE, DELETE pour l'aperçu des données, ainsi que la syntaxe SELECT en lecture seule pour les jointures, les CTE, les agrégats, les fenêtres et les rapports
Démarrage rapide
Utilisez ceci comme réponse modèle lorsque vous demandez à une IA du SQL compatible avec Erd Go : types personnalisés d'abord, tables ensuite, contraintes de relation après les tables si utile, puis DML d'exemple. Gardez les requêtes SELECT en lecture seule séparées.
-- 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 ou ALTER TABLE ADD FOREIGN KEY. Les deux formes fournissent les mêmes métadonnées de relation.INSERT, UPDATE, et DELETE après le DDL du schéma. Le script est évalué de haut en bas, de sorte que les lignes d'exemple doivent faire référence à des tables et des types qui existent déjà.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;Onglets SQL et importation de fichiers
Démarrez un nouveau fichier SQL avec un exemple, un onglet de schéma vide ou Importer des fichiers SQL. L'exemple sépare le schéma et les données en onglets. Ajouter un onglet SQL crée un autre onglet d'éditeur ; double-cliquez sur son titre pour le renommer.
Les onglets actifs se compilent ensemble dans leur ordre visible pour l'ERD, la vue Données, la vue Requête et les requêtes IA. Un onglet inactif reste un brouillon enregistré et est exclu de ces flux de travail. Placez les types et les tables avant les instructions qui en dépendent.
L'importation de fichiers SQL accepte plusieurs fichiers SQL textuels et examine les problèmes d'analyse en même temps avant l'importation. Cela aide à résoudre les références entre les fichiers. Utilisez l'ordre des onglets pour maintenir intentionnelles les dépendances et les étapes de migration.
Utilisez les touches fléchées et Début/Fin dans la barre d'onglets pour changer d'onglet, Alt+Gauche/Droite pour les réorganiser, et Shift+Alt+F pour formater le SQL dans l'éditeur.
Ouvrez l'explorateur SQL à côté des onglets pour afficher une arborescence de dossiers redimensionnable. Créez des dossiers et des fichiers SQL imbriqués, sélectionnez un fichier pour l'ouvrir et organisez-les par glisser-déposer. Le menu contextuel des actions sur les lignes prend en charge le renommage et la suppression de fichiers ; cliquez à l'extérieur pour le fermer. La suppression du dernier fichier maintient un fichier SQL vide ouvert. Les dossiers ne modifient pas l'ordre d'exécution. La suppression d'un dossier conserve ses fichiers et ses sous-dossiers dans le dossier parent. L'enregistrement conserve l'arborescence des dossiers et la préférence de panneau.
Modifier et vérifier le diagramme
Le SQL est la source de la signification du schéma. Utilisez Ajouter une table pour construire une table, ou sélectionnez des actions de table et de colonne sur le canevas pour modifier les colonnes et les connexions. Les modifications de schéma sur le canevas mettent à jour les onglets SQL propriétaires ainsi que le diagramme.
La suppression d'une colonne prévisualise les connexions, clés, index et SQL dépendant affectés. Examinez la suppression ou la cascade avant de confirmer. Des migrations complexes ou des instructions dépendantes non prises en charge peuvent nécessiter une modification directe du SQL.
Utilisez le score de santé de l'ERD pour inspecter les constatations structurelles et les suggestions de relations optionnelles. Les relations suggérées nécessitent une révision ; elles ne remplacent pas les clés étrangères déclarées et n'établissent pas de règles métier automatiquement.
Organisez les tables avec le Mode de disposition, zoomez ou Ajuster à l'écran, trouvez des tables avec le Navigateur de tables, et utilisez les Couleurs de table ou la minicarte pour naviguer dans un grand diagramme. Survolez ou focalisez un contrôle de la barre d'outils pour afficher son texte d'aide.
Sélectionnez une table et ouvrez le Sélecteur de couleurs pour des préréglages unis ou en dégradé. Entrez une valeur hexadécimale ou choisissez Personnalisé à côté pour utiliser le sélecteur de couleurs natif. Les deux contrôles restent synchronisés ; Enregistrer conserve la couleur de la table.
Lorsque les outils de table sont configurés pour s'afficher uniquement au survol, Ajouter une colonne apparaît lorsque vous survolez la dernière ligne visible ou que vous focalisez le bouton au clavier. Les outils toujours visibles le maintiennent affiché.
Choisissez Groupes de tables dans la barre d'outils du canevas SQL, puis Nouveau groupe. Donnez un nom et une couleur au groupe, sélectionnez ses tables et choisissez Créer un groupe. Une table sélectionnée commence cochée. Une table appartient à un seul groupe ; le formulaire indique quand votre sélection déplacera une table hors d'un autre groupe. Jusqu'à 50 groupes sont pris en charge, avec des noms pouvant aller jusqu'à 160 caractères.
Cliquez sur l'en-tête d'un groupe pour modifier son nom, sa couleur ou ses membres. Glissez l'en-tête pour déplacer ses tables ensemble ; relâchez pour appliquer le déplacement. Échap, l'annulation du pointeur ou la perte du focus de la fenêtre annule l'aperçu. Dissocier les tables supprime le cadre tout en conservant les tables, leurs positions, le SQL et les relations.
Les cadres de groupe suivent les cartes de tables en direct et apparaissent dans Ajuster à l'écran, la minicarte, ainsi que dans les exportations d'images de la vue actuelle ou de l'ensemble du diagramme. Les groupes sont des états visuels facultatifs enregistrés avec le document SQL. Les fichiers plus anciens conservent leur mise en page existante et les noms de tables temporairement manquants restent dans leur groupe jusqu'à ce qu'ils reviennent au code SQL analysé. Les groupes de tables appartiennent à SQL vers ERD ; les paquets du Diagramme de classes utilisent un modèle distinct.
Examen par l'IA dans l'éditeur SQL
- Entrez une modification spécifique dans Demander à l'IA pour modifier le SQL et choisir un modèle disponible. Définir la clé API Gemini est disponible lorsque vous souhaitez utiliser votre propre clé Gemini.
- Examinez les modifications proposées et l'aperçu temporaire du diagramme. La requête utilise l'instantané de l'onglet actif capturé lors de son envoi ; une réponse n'est pas enregistrée automatiquement.
- Acceptez ou rejetez des modifications individuelles, ou utilisez les actions pour les modifications restantes. Naviguez dans les modifications de code avec F7 et Maj+F7. Les onglets inactifs protégés restent des brouillons.
- Inspectez le code SQL accepté, puis enregistrez le document. Copier l'invite IA (AI Prompt) dans ce guide vous permet également d'utiliser la documentation avec un assistant en dehors de l'application.
Données, requêtes, exportations et fichiers enregistrés
Utilisez les boutons ERD, Données et Requête pour basculer entre les espaces de travail. La vue des données matérialise les DDL et DML pris en charge dans le navigateur et expose les tables, les lignes, les types et un journal d'exécution. Redimensionnez les colonnes de la grille en faisant glisser leurs bords ou double-cliquez pour ajuster. Double-cliquez sur une cellule de données ou appuyez sur Entrée pour modifier ; les champs booléens et énumérés offrent des valeurs valides. Ajouter une ligne respecte les valeurs par défaut de votre schéma. Importez CSV, TSV, TXT ou XLSX avec un aperçu du mappage de colonnes. NULL et le texte vide restent distincts. Les modifications validées deviennent du SQL dans un onglet de modifications de données et peuvent être annulées. Téléchargez les lignes de la table ou les résultats de requêtes au format CSV.
Enregistrer mémorise le plan de travail Constructeur ERD, Données ou Requête sélectionné ; la réouverture le restaure, y compris Données/Requête sur les téléphones. Les fichiers plus anciens démarrent dans Constructeur ERD. Les éditeurs de date/heure natifs préservent les valeurs prises en charge, tandis que les horodatages avec fractions ou décalages de fuseau horaire restent modifiables sous forme de texte. Les identités générées par la base de données restent en lecture seule.
La vue de requête exécute des requêtes SELECT en lecture seule par rapport aux tables en mémoire actuelles. Elle prend en charge la syntaxe documentée ci-dessous ; elle ne se connecte pas à une base de données externe. Le texte de la requête est enregistré avec le contexte du document SQL.
Enregistrer mémorise également la table de Données sélectionnée. La réouverture la restaure, avec la première table comme solution de repli si elle n'est pas disponible. Les champs de schéma alignent les noms, les types et les règles ; survolez un badge de règle pour obtenir son explication. Aller à SQL à côté du titre de la table ouvre son onglet SQL de définition et révèle l'instruction CREATE TABLE, rouvrant le panneau SQL lorsqu'il est masqué tout en conservant la sélection de Données et les brouillons. Les résultats de la requête combinent les totaux, le chronométrage, l'ajustement, la copie et le CSV dans un seul en-tête.
Faites glisser le diviseur fin entre l'éditeur de requêtes et les résultats, ou entre le schéma de données et les lignes, pour redimensionner les volets. Les touches fléchées redimensionnent un diviseur ciblé, Échap annule un déplacement et un double-clic le réinitialise. Ces tailles de volets restent des préférences temporaires de l'espace de travail.
La génération de données d'exemple utilise vos types de colonnes, noms, relations et contraintes. Le langage d'échantillonnage contrôle les noms ainsi que les phrases naturelles de produits/descriptions dans 17 langues. Examinez les générateurs et plages suggérés, prévisualisez le résultat, puis insérez explicitement un onglet Données d'exemple distinct. Les booléens s'affichent sous forme de vrai/faux ; les identifiants restent numériques. La génération ne remplace jamais les lignes existantes.
Choisissez Exporter l'ERD pour sélectionner PNG, SVG avec fond image ou PDF avec des dimensions HD, 2K ou 4K. Les images exportées ne remplacent pas un document enregistré modifiable.
Connectez-vous et utilisez Enregistrer SQL et ERD pour enregistrer le contexte SQL et du diagramme, y compris les onglets, les modifications de grille appliquées, le texte de la requête et la mise en page. L'enregistrement vérifie d'abord une cellule active ou le brouillon d'une nouvelle ligne ; les données non valides restent visibles pour correction. Les aperçus d'importation nécessitent leur action d'importation explicite. Ouvrez les fichiers enregistrés à partir de la liste des fichiers et utilisez Partager sur un document enregistré possédé pour configurer l'accès public et distribuer son lien en lecture seule.
Les documents SQL, Prisma et Constructeur s'ouvrent dans leurs propres outils. Prisma et Constructeur ont des listes de fichiers distinctes et un enregistrement cloud uniquement. Les invites de modification non enregistrée protègent les documents modifiés lors du départ d'un espace de travail ; enregistrez vos modifications avant de partager ou de changer de page.
Résoudre les problèmes de l'espace de travail SQL
| Symptôme | Quoi vérifier |
|---|---|
| Une table est manquante | Vérifiez les diagnostics d'analyse, les onglets actifs et l'ordre des instructions. Un DROP ou un renommage ultérieur peut modifier le diagramme final. |
| Une relation est manquante | Vérifiez que les tables et les colonnes existent, que le nombre de colonnes de clés étrangères correspond et que la clé référencée est globalement unique. Qualifiez par le schéma les noms ambigus. |
| La vue des données ne montre aucune ligne | Placez INSERT après son CREATE TABLE dans un onglet actif. Inspectez le journal d'exécution pour les lignes rejetées ou une annulation de transaction. |
| Les résultats de la requête ne correspondent plus au SQL | Exécutez à nouveau la requête après avoir modifié le schéma ou les données ; utilisez les tables en mémoire actuelles. |
| Ajouter une table suggère un autre dialecte | La syntaxe de l'espace de travail actif détecté est prioritaire sur le repli sélectionné manuellement. Vérifiez l'indicateur de langage SQL et les paramètres par défaut spécifiques à la table. |
| Un fichier enregistré ne peut pas être modifié | Vérifiez la connexion et la propriété. Un lien public accorde un accès en lecture seule ; utilisez Réessayer ou Ouvrir des fichiers pour les erreurs de chargement récupérables. |
Flux de travail de syntaxe par IA
Lors de l'utilisation d'un assistant IA, demandez-lui de produire du SQL dans cet ordre. Cela permet de garder le résultat facile à analyser, facile à représenter en diagramme et facile à prévisualiser avec des lignes d'exemple ou des requêtes en lecture seule.
1. Définir les domaines en premier
Placez les définitions CREATE TYPE enum/composite avant les tables qui y font référence. Préférez des noms explicites aux types en ligne ad hoc lorsqu'un domaine est partagé.
2. Créer les tables de base
Utilisez CREATE TABLE pour les colonnes, les clés primaires, l'unicité, les valeurs par défaut, les vérifications, les colonnes générées et les clés étrangères en ligne.
3. Rejouer les migrations
Utilisez ALTER TABLE pour les contraintes ajoutées, les renommages, les colonnes supprimées, les modifications de type/nullabilité de colonne et les clés étrangères circulaires.
4. Ajouter les données et les requêtes en dernier
Placez INSERT/UPDATE/DELETE après tout le DDL. Gardez les requêtes SELECT séparées de la mutation de schéma lorsque vous souhaitez des ensembles de résultats.
ALTER TYPE. Les index d'expression sont conservés avec un avertissement ; demandez des clés de colonne simples lorsque vous avez besoin de badges d'index ERD.Syntaxe DDL et DML
Ces formes d'instructions sont sûres pour les scripts de schéma générés par IA et les données d'exemple. La même syntaxe pilote la structure de l'ERD et les lignes d'aperçu en mémoire, donc gardez le DDL avant le DML et évitez les effets secondaires externes spécifiques à la base de données.
Instructions prises en charge
-- 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 combinaisons. Les comparaisons NULL suivent la logique UNKNOWN standard du SQL — col = NULL ne correspond jamais ; utilisez col IS NULL à la place. Les cibles d'affectation inconnues, les références de colonnes de droite et les colonnes de filtre rejettent la mutation complète avant toute modification de ligne.Sémantique de l'aperçu pour le DML généré par l'IA
Les lignes sont rejouées à partir de zéro
Les instructions DDL et DML sont appliquées ensemble dans l'ordre source ; chaque instruction de données utilise le schéma actif à ce moment-là.
Les types restent inspectables
Les enums nommés et les types composites créés avec CREATE TYPE restent intégrés au schéma analysé.
Les contraintes sont appliquées
Les colonnes PK, FK, NOT NULL, UNIQUE, DEFAULT, CHECK, les colonnes générées et les domaines d'énumération affectent les lignes d'aperçu.
Les erreurs doivent pouvoir être corrigées
Préférez des listes de colonnes explicites et des clauses WHERE concrètes afin que les diagnostics puissent pointer vers la table ou la colonne exacte.
SELECT ensembles de résultats dans le script de schéma/DML principal, corps procéduraux non pris en charge ou appels de base de données externes. CREATE VIEW, CREATE OR REPLACE VIEW, et MSSQL CREATE OR ALTER VIEW sont matérialisées à partir de leur SELECT résultat pour l'aperçu ; gardez les requêtes ad hoc en lecture seule séparées.Transactions dans la vue des données
La vue des données prend en charge BEGIN, COMMIT, ROLLBACK, SAVEPOINT, ROLLBACK TO et RELEASE dans l'aperçu en mémoire. Ces instructions affectent les lignes de l'aperçu ; elles ne valident jamais vers une base de données externe.
SQLite, PostgreSQL et SQL Server conservent le DDL transactionnel dans l'aperçu. Le DDL MySQL valide la transaction active. SQLite PRAGMA foreign_keys et MySQL SET FOREIGN_KEY_CHECKS affectent la validation DML ultérieure.
Le moteur de rendu ERD ignore les enveloppes de transaction et représente les instructions de schéma dans l'ordre source. Une annulation de transaction (rollback) dans la vue des données peut donc produire un ensemble de tables différent de celui du diagramme. Vérifiez chaque espace de travail pour connaître le comportement que vous testez.
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;Syntaxe de requête SELECT
Demander à l'IA de conserver les Requêtes de rapport en lecture seule comme SELECT instructions. Celles-ci peuvent référencer les tables et les lignes produites par le script de schéma/DML et sont utiles pour les jointures, les filtres, les totaux et les ensembles de résultats sous forme de rapport sans nécessiter de base de données en direct.
Forme de requête prise en charge
WITH dept_totals AS (
SELECT department_id, COUNT(*) AS employee_count, SUM(salary) AS payroll
FROM employees
GROUP BY department_id
)
SELECT d.name,
dt.employee_count,
dt.payroll
FROM dept_totals dt
JOIN departments d ON d.id = dt.department_id
WHERE dt.employee_count >= 1
ORDER BY dt.payroll DESC
LIMIT 10;SELECT uniquement
L'éditeur de requêtes accepte les instructions SELECT, y compris SELECT sans FROM et les CTE WITH qui se résolvent en SELECT.
Jointures et filtres
Jointures INNER, LEFT, RIGHT, FULL et CROSS, conditions WHERE, EXISTS, sous-requêtes IN, BETWEEN, LIKE, ILIKE et vérifications NULL.
Agrégats
GROUP BY, HAVING, COUNT, SUM, AVG, MIN, MAX, ARRAY_AGG, GROUP_CONCAT, STRING_AGG et variantes DISTINCT.
Tri et pagination
Noms ou ordinaux ORDER BY, ASC/DESC, NULLS FIRST/LAST, LIMIT/OFFSET, TOP et FETCH FIRST.
Prise en charge avancée de SELECT
CTE et tables dérivées
Les clauses WITH, les SELECT imbriqués dans FROM, les sous-requêtes scalaires, EXISTS, NOT EXISTS, IN et NOT IN sont pris en charge.
Opérateurs d'ensembles
UNION, UNION ALL, INTERSECT et EXCEPT peuvent combiner des ensembles de résultats compatibles.
Fonctions de fenêtrage
ROW_NUMBER, RANK, DENSE_RANK, NTILE, LAG, LEAD, FIRST_VALUE et LAST_VALUE avec OVER et PARTITION BY. Les fenêtres ordonnées utilisent le cadre par défaut SQL sensible aux pairs, et NTILE attribue d'abord les plus grands compartiments.
Aides aux dialectes
Les fonctions courantes de SQLite, PostgreSQL, MySQL et MSSQL sont normalisées pour l'aperçu, y compris les assistants JSON et date/chaîne de caractères.
INSERT, UPDATE, DELETE, CREATE, ALTER, et DROP instructions dans le script de schéma/DML. La syntaxe des requêtes doit rester SELECT-uniquement.Diagnostics et erreurs
Les diagnostics de syntaxe mettent en évidence les problèmes d'analyse de schéma, d'exécution DDL/DML et de SELECT en lecture seule avec des messages clairs. Les erreurs d'analyse incluent les positions de ligne/colonne lorsque cela est possible, et les messages d'exécution pointent vers la table, la colonne ou la forme d'instruction qui doit être corrigée.
Erreurs d'analyse de schéma
L'analyseur de schéma (SQLite, PostgreSQL, MySQL et MSSQL) signale les problèmes avec deux niveaux de gravité : erreur empêche une seule instruction de contribuer au schéma ; avertissement conserve une syntaxe valide mais signale quelque chose que l'utilisateur devrait savoir.
// 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
}Erreurs de l'analyseur
Listes de colonnes PRIMARY KEY / UNIQUE / FOREIGN KEY vides, types de données requis manquants (y compris les colonnes SQLite STRICT), parenthèses non appariées, virgules inattendues et contraintes mal formées.
Avertissements du tokeniseur
Chaînes non fermées, commentaires de bloc non fermés, parenthèses non assorties et expressions CHECK suspectes sur plusieurs lignes.
Avertissements de clés étrangères
Les clés étrangères qui pointent vers une table inconnue, une colonne inconnue, une feuille de schéma ambiguë ou une cible non-PK/non-UNIQUE sont supprimées du diagramme avec un avertissement descriptif.
Diagnostics groupés
Les avertissements sont regroupés par cause, notamment Relation supprimée, Table inconnue, Colonne inconnue, Cible de clé étrangère non unique, Avertissements et Erreurs d'analyse.
SQL vide
Une entrée vide est valide et produit un seul schéma vide. Seules les entrées non textuelles invalides génèrent une erreur.
Journal d'exécution DDL/DML
Chaque instruction DDL ou DML exécutée ajoute une entrée structurée au journal d'exécution en mémoire. Le flux de messages préserve l'ordre chronologique et classe chaque instruction comme erreur, avertissement, ou succès.
// 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 existDiagnostics courants
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
Définissez des types de données personnalisés à réutiliser dans le schéma de votre base de données. Les types énumérés et composites nommés doivent apparaître avant les tables qui y font référence, y compris les références qualifiées par le schéma.
1.1. Type composite
Définissez des types composites personnalisés avec plusieurs champs de divers types de données.
CREATE TYPE type_name AS (
field1 data_type1,
field2 data_type2,
...
);Exemple :
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. Type Enum
Créer des types énumérés avec des valeurs prédéfinies pour une meilleure intégrité et lisibilité des Données.
CREATE TYPE enum_name AS ENUM (
'value1',
'value2',
...
);Exemple :
CREATE TYPE status_enum AS ENUM (
'pending',
'active',
'completed',
'cancelled'
);
CREATE TYPE priority_level AS ENUM (
'low', 'medium', 'high', 'critical'
);1.3. Types qualifiés par un schéma
Les types définis par l'utilisateur sont résolus avec la même sensibilisation au schéma que les tables. Si deux schémas définissent le même nom de feuille, l'ERD les maintient distincts ; si un type est unique, le nom d'affichage reste simple.
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 ne se résout jamais en s2.status simplement parce qu'ils partagent le nom de feuille status. Les noms de types qualifiés sont stricts, tandis que les noms non qualifiés ne sont résolus qu'en l'absence d'ambiguïté.CREATE TABLE
Définissez des tables de base de données avec des colonnes, des types de données et des contraintes.
2.1. Structure de table de base
La syntaxe générale pour créer une table :
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"), les guillemets inversés (\`name\`), ou les crochets carrés ([name]) pour échapper aux caractères spéciaux ou aux mots-clés réservés.2.2. Définitions au niveau de la colonne
Chaque colonne peut inclure diverses contraintes et propriétés :
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
Identifie de manière unique chaque ligne
UNIQUE
Garantit que les valeurs des colonnes sont distinctes
NOT NULL
Empêche les valeurs nulles
DEFAULT
Définit les valeurs par défaut (littéraux ou fonctions)
CHECK
Valide les données avec des expressions booléennes
REFERENCES
Crée des relations de clés étrangères
- Littéraux : nombres (
123), les chaînes de caractères ('text') - Fonctions PostgreSQL :
now(),CURRENT_TIMESTAMP,CURRENT_DATE,nextval('seq'::regclass) - Fonctions MSSQL :
GETDATE(),NEWID()
REFERENCES table(column), qualifié par un schéma REFERENCES schema.table(column), les colonnes cibles omises telles que REFERENCES departments, et les actions de clés étrangères telles que ON DELETE CASCADE, ON UPDATE SET NULL, MATCH FULL, et DEFERRABLE INITIALLY DEFERRED.2.3. Colonnes générées / calculées
Référence rapide. Voir le document dédié Colonnes calculées section ci-dessous pour la ventilation complète par dialecte, y compris la forme nue AS de 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. Types ENUM en ligne
Vous pouvez déclarer un ENUM directement dans la définition d'une colonne (style MySQL). L'analyseur l'enregistrera en tant qu'énumération nommée et remplacera automatiquement le type de colonne.
CREATE TABLE tasks (
id INTEGER PRIMARY KEY,
status ENUM('todo', 'doing', 'done'),
priority ENUM('low', 'medium', 'high')
);column_enum (par exemple, status_enum); les tables ultérieures ayant une définition différente pour le même nom de colonne obtiennent un nom qualifié par la table tel que tasks_status_enum afin que les domaines ne s'effondrent jamais accidentellement.CREATE TYPE ... AS ENUM à la place.2.5. Contraintes au niveau de la table
Définissez les contraintes à la fin du corps de la table. Utile pour les clés composites et les contraintes à plusieurs colonnes :
-- 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)Exemple :
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) est facultatif.REFERENCES ref_table omet la liste des colonnes cibles, Erd Go la résout vers la clé primaire de la table référencée, y compris les clés primaires composites. Si vous spécifiez explicitement les colonnes cibles, elles doivent être adossées à une PRIMARY KEY, à une contrainte UNIQUE ou à une contrainte globale CREATE UNIQUE INDEX; les index uniques filtrés / partiels ne comptent pas comme cibles de clés étrangères. Les relations non valides sont supprimées avec un avertissement.2.6. Noms de colonnes de mots réservés
Des mots comme key, index, value, et name sont réservés dans certains dialectes mais couramment utilisés comme noms de colonnes dans d'autres. L'analyseur lève l'ambiguïté automatiquement lorsque le jeton suivant est un type de données connu, de sorte que l'utilisation nue sans guillemets fonctionne :
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 suivi d'un mot-clé de type de données (VARCHAR, INT, …) est un colonne. Suivi d'un identifiant et d'une liste de colonnes entre parenthèses, il s'agit d'un index. Pour une sécurité absolue, mettez la colonne entre guillemets avec "key", `key`, ou [key].Colonnes d'identité / d'incrémentation automatique
Utilisez la syntaxe d'identité native pour le dialecte sélectionné. Toutes les formes prises en charge produisent une colonne de clé primaire avec le AUTO_INCREMENT marqueur, mais SQLite a une règle stricte : AUTOINCREMENT nécessite un seul INTEGER PRIMARY KEY colonne.
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. N'utilisez pas BIGINT, INT, ou une clé primaire composite avec 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 est un identité colonne (incrémentation automatique), distincte de GENERATED ALWAYS AS (expression) qui est un calculé colonne. L'analyseur les sépare automatiquement.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 étiquette — vous pouvez donc mélanger les dialectes dans un seul schéma sans perdre l'indice d'incrémentation automatique.Colonnes calculées (par dialecte)
Une colonne calculée tire sa valeur d'une expression portant sur d'autres colonnes de la même ligne. Pris en charge dans les quatre dialectes avec leurs syntaxes respectives.
PostgreSQL et 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 stocke la valeur calculée et VIRTUAL le calcule à la lecture. Erd Go conserve les valeurs d'aperçu en mémoire ; l'ERD préserve chaque mode en tant que métadonnées de colonne.MSSQL / SQL Server — colonne AS expression [PERSISTED]
MSSQL possède sa propre syntaxe : column_name AS expression, éventuellement suivi de PERSISTED (et éventuellement NOT NULL). Les deux entre parenthèses et nu les formes d'expression sont prises en charge.
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 (sans parenthèses superflues) — y compris les appels de fonctions tels que DATEADD(...), les références qualifiées par la table comme c.GrowthDurationDays, et CASE expressions — se terminant à la virgule de colonne suivante, PERSISTED, ou la fin du corps de la table.COMPUTED comme type et l'expression préservée dans les options supplémentaires de colonne / info-bulle.ALTER TABLE
De style migration courant ALTER TABLE instructions sont rejouées après la création de la table, de sorte que le schéma final reflète les colonnes ajoutées, les contraintes, les renommages, les colonnes supprimées et les modifications de type/nullabilité des colonnes. La syntaxe de vidage PostgreSQL utilisant ALTER TABLE ONLY préserve l'identité de la table qualifiée.
Ajouter et contraindre
ADD COLUMN, ADD PRIMARY KEY, ADD UNIQUE, ADD CHECK et ADD FOREIGN KEY sont reflétés dans l'ERD.
Renommer et supprimer
Les renommer de table, de colonne, de contrainte et d'index — y compris MySQL RENAME TABLE, PostgreSQL ALTER INDEX et SQL Server sp_rename — restent liés à la bonne incarnation d'objet avant les opérations DROP ultérieures.
Modifications de colonnes
PostgreSQL ALTER COLUMN TYPE/SET DATA TYPE/SET ou DROP DEFAULT/nullabilité, MSSQL ALTER COLUMN et MySQL MODIFY/CHANGE COLUMN sont rejoués.
Sécurité des relations
Les clés étrangères sont validées par rapport à l'état final de la table après la relecture de la migration, y compris les modifications de PK/UQ/index et le nombre exact de colonnes source/cible.
3.1. Ajouter une clé étrangère
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];Exemple :
ALTER TABLE orders
ADD CONSTRAINT fk_orders_customer
FOREIGN KEY (customer_id)
REFERENCES customers(id)
ON DELETE CASCADE;3.2. Ajouter une clé primaire
ALTER TABLE table_name
ADD [CONSTRAINT name] PRIMARY KEY (cols...);Exemple :
ALTER TABLE products
ADD CONSTRAINT pk_products
PRIMARY KEY (product_id);3.3. Ajouter une contrainte d'unicité
ALTER TABLE table_name
ADD [CONSTRAINT name] UNIQUE (cols...);Exemple :
ALTER TABLE users
ADD CONSTRAINT uq_users_email
UNIQUE (email);3.4. Ajouter une contrainte de vérification
ALTER TABLE table_name
ADD [CONSTRAINT name] CHECK (expression);Exemple :
ALTER TABLE employees
ADD CONSTRAINT chk_salary
CHECK (salary >= 0);3.5. Exemple de rejouage de migration
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 devient contact_email, audit_state est supprimé, et l'index unique donne contact_email un UQ badge.3.6. CHANGE / MODIFY COLUMN de 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 de 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
Le code DDL d'index est analysé dans les quatre dialectes. Les clés de colonnes simples s'affichent sous forme de petits badges ERD : IDX pour les accélérations non uniques, UQ pour les index uniques globaux, et PUQ pour les index uniques filtrés / partiels. Les entrées d'expression sont conservées dans la sortie de l'analyseur et signalées lorsqu'elles ne peuvent pas être mappées honnêtement à un badge de colonne.
Badge IDX
Index non unique. Pilule pleine sur la colonne. Les index composites atténuent la pilule (en gris) sur chaque colonne de clé afin que la distinction entre colonne unique et multi-colonne soit évidente au premier coup d'œil.
Badge UQ
À partir d'un CREATE UNIQUE INDEX global. Se comporte comme une contrainte UNIQUE pour la validation des clés étrangères et l'attribution de badges de colonnes.
Badge PUQ
À partir de CREATE UNIQUE INDEX ... WHERE. Affiche le prédicat d'unicité partielle mais ne valide pas les cibles de clés étrangères comme globalement uniques.
Règle de suppression
Les contraintes les plus fortes l'emportent : PK ⟶ UQ ⟶ PUQ ⟶ IDX. Une clé plus forte n'est jamais rétrogradée par un index ultérieur.
Multi-dialecte
PostgreSQL CONCURRENTLY / USING / INCLUDE / WHERE, MySQL FULLTEXT/SPATIAL et KEY/INDEX en ligne, MSSQL CLUSTERED/NONCLUSTERED avec INCLUDE, index standard SQLite.
4.1. Syntaxe
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. Exemples
Accélérez une recherche de clé étrangère fréquente (IDX à colonne unique) :
CREATE INDEX idx_orders_customer ON orders (customer_id);Index composite (pastille IDX atténuée sur chaque colonne clé) :
CREATE INDEX idx_orders_customer_status
ON orders (customer_id, status);Promouvoir une colonne en UNIQUE sans modifier sa définition :
CREATE UNIQUE INDEX uq_shipments_tracking
ON shipments (tracking_number);Index unique partiel / filtré (PUQ, pas une cible de FK globale) :
CREATE UNIQUE INDEX ux_users_active_email
ON users (email)
WHERE deleted_at IS NULL;Index en ligne MySQL dans 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 index filtré + INCLUDE :
CREATE NONCLUSTERED INDEX idx_active_orders
ON orders (customer_id)
INCLUDE (total)
WHERE status = 'active';4.3. Comportement et sémantique
- Index fonctionnels / d'expression (par ex.
CREATE INDEX … ON t (lower(email))) sont conservés et génèrent un avertissement explicite, mais aucun badge — elles ne se mappent pas proprement à une seule colonne. - Colonnes INCLUDE (colonnes de couverture) sont analysées mais jamais étiquetées — seules les colonnes clés obtiennent le badge.
- Colonnes PK / UQ sont des garanties plus fortes que IDX, donc tout
CREATE INDEXsur ceux-ci est ignorée en silence — vous ne verrez pas de pastilles redondantes. - Index uniques partiels / filtrés s'affiche comme
PUQavec leWHEREprédicat dans les détails des colonnes. Ils ne sont pas acceptés comme cibles globalement uniques pour la validation des clés étrangères. - Les badges finaux sont invariants par rapport à l'ordre : une garantie d'unicité globale supprime un
IDXindiquent si l'index unique ou non unique apparaît en premier. Les métadonnées d'index composite sont également conservées indépendamment de l'ordre de déclaration. - Index sur des tables / colonnes inconnues sont ignorées silencieusement — utile lors du portage de schémas partiels sans casser le diagramme.
- Cycle de vie de l'index comprend de niveau supérieur
CREATE/DROP INDEX, PostgreSQLDROP INDEX CONCURRENTLY, MySQLALTER TABLE … ADD/DROP/RENAME INDEX, PostgreSQLALTER INDEX … RENAME, ainsi que le renommage d'index SQL Server viasp_rename. Les métadonnées nommées UQ/PUQ/IDX suivent le dernier nom survivant.
Prise en charge multi-dialecte
L'analyseur côté navigateur gère les différences de syntaxe entre SQLite, PostgreSQL, MySQL et MSSQL sans connexion à une base de données. La détection automatique utilise des signaux de syntaxe structurelle et reste neutre pour les entrées de dialectes véritablement mixtes ; les appelants peuvent également fournir un dialecte explicite. Les exemples ci-dessous suivent le même ordre standard : SQLite en premier, puis PostgreSQL, MySQL et MSSQL.
4.1. Fonctionnalités de 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 tables, colonnes non STRICT sans type, affinités de type (INTEGER, TEXT, REAL, NUMERIC, BLOB), datetime('now') / CURRENT_TIMESTAMP valeurs par défaut et standard REFERENCES avec ON DELETE / ON UPDATE actions.VARCHAR(255), BOOLEAN, ou TIMESTAMP) et peuvent omettre un type. Les tables STRICT suivent l'ensemble exact autorisé par SQLite : INT, INTEGER, REAL, TEXT, BLOB, ou ANY; chaque colonne STRICT doit en déclarer un.Exemple de relecture de migration 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. Fonctionnalités de 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, la préservation des index d'expression et la sensibilité exacte à la casse de PostgreSQL pour les noms entre guillemets.4.3. Fonctionnalités de 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, les modificateurs signés, les variantes entier/texte/blob/spatial, en ligne ENUM et SET, les index en ligne, CHANGE COLUMN, MODIFY COLUMN, FIRST/AFTER placement physique, ON UPDATE CURRENT_TIMESTAMP, et les options courantes de table.4.4. Fonctionnalités de 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), date/heure, binaire, XML, types d'identifiants et spatiaux, ROWGUIDCOL, les index clusterisés, GO lots, ALTER COLUMN, les colonnes calculées, nommées DEFAULT ... FOR column des contraintes, des colonnes temporelles générées et PERIOD FOR SYSTEM_TIME.col AS expression PERSISTED (sans parenthèses superflues) est entièrement pris en charge, y compris les appels de fonctions (DATEADD, LEFT, …), les références de colonnes qualifiées par la table (c.col), et CASE expressions.4.5. Styles de citation des identifiants
Les trois principales conventions de citation sont prises en charge :
-- 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
);Notes et astuces
Détails importants sur la prise en charge de la syntaxe : ce qui contribue à la structure du schéma, quel code DDL/DML peut être rejoué avec des lignes d'exemple, quelles requêtes SELECT peuvent être lues et où se trouvent les limites.
✓ Prise en charge de la syntaxe de schéma / ERD
- Multi-dialecte : La syntaxe SQLite, PostgreSQL, MySQL et MSSQL peut partager un script ; la détection automatique reste neutre lorsque des signaux forts sont véritablement mélangés
- Mots-clés insensibles à la casse : CREATE, TABLE, ALTER, etc. peuvent être écrits dans n'importe quelle casse
- Identifiants entre guillemets : Guillemets doubles (
"name"), les guillemets inversés (`name`), et les crochets ([name]) - Noms de colonnes de mots réservés : Brut
key,index,value,name,order, etc., sont acceptés lorsqu'ils sont suivis d'un type de données - Noms qualifiés par le schéma :
schema.tableetschema.type(par exemple,public.users,dbo.Orders,app.status_enum) — les préfixes de schéma sur les types définis par l'utilisateur sont conservés pour une recherche stricte et simplifiés pour l'affichage uniquement en cas d'absence d'ambiguïté - Commentaires : Sur une seule ligne (
-- comment) et les commentaires de bloc (/* comment */) sont automatiquement ignorés - BOM & CRLF : La marque d'ordre d'octets UTF-8 et les fins de ligne Windows sont gérées de manière transparente
- Types personnalisés :
CREATE TYPE … AS ENUMetCREATE TYPE … AS (composite), y compris les noms qualifiés par un schéma - ENUM et SET en ligne (MySQL) :
ENUM('a','b')etSET('a','b','c')à l'intérieur des types de colonnes — auto-enregistrés en tant que types nommés et nommés par espace de noms par table/colonne lorsque des noms de colonnes en double utilisent des domaines différents - Contraintes : Au niveau de la colonne et au niveau de la table
PRIMARY KEY,FOREIGN KEY,UNIQUE,CHECK(y compris les variantes composites multi-colonnes). Les cibles de clés étrangères sont validées par rapport aux clés primaires, aux contraintes d'unicité ou aux index uniques globaux - Identité / incrémentation automatique :
SERIAL/BIGSERIAL(PG),GENERATED ALWAYS/BY DEFAULT AS IDENTITY(PG),AUTO_INCREMENT(MySQL),IDENTITY(1,1)et lesIDENTITY(MSSQL) — tout est unifié dans le diagramme - Colonnes calculées :
GENERATED ALWAYS AS (expr) STORED/VIRTUAL(PG/MySQL) et MSSQLcol AS (expr) [PERSISTED]+ brutcol AS expr [PERSISTED] - Tableaux PostgreSQL :
type[], dimensionnétype[5], imbriquétype[][][], et les tableaux de types définis par l'utilisateur (par ex.,webhook_event[]) - Valeurs par défaut : Littéraux, chaînes délimitées par des dollars, appels de fonctions (
now(),CURRENT_TIMESTAMP,GETDATE(),NEWID(),NEWSEQUENTIALID(),gen_random_uuid(),nextval()), etON UPDATE CURRENT_TIMESTAMP(MySQL) - Actions FK :
ON DELETE/ON UPDATEavecCASCADE,RESTRICT,SET NULL,SET DEFAULT,NO ACTION, plusMATCH,DEFERRABLE, etINITIALLYmétadonnées. Les actions sont conservées en tant que métadonnées de relation. - Rejeu de migration :
ALTER TABLE ADD COLUMN, ajout/suppression/renommage de clés et de contraintes, renommage de tables/colonnes/index,DROP COLUMN,ALTER COLUMN TYPE/SET DATA TYPE,SET/DROP DEFAULT,SET/DROP NOT NULL, MSSQLsp_rename, et MySQLMODIFY/CHANGE COLUMN - Index : De niveau supérieur
CREATE/DROP INDEX, PostgreSQLALTER INDEX … RENAME, ajout/suppression/renommage et en ligne pour MySQLKEY/INDEX/UNIQUE INDEX/FULLTEXT/SPATIALdéfinitions. Les index basés sur des colonnes s'affichent sous forme deIDX,UQ, ouPUQbadges - IF NOT EXISTS, IF EXISTS : géré avec élégance sur les deux
CREATEetDROP - Enveloppes de transaction réservées au schéma :
BEGIN,COMMIT,SET search_path,USE [db](MSSQL), etSET FOREIGN_KEY_CHECKS(MySQL) sont ignorées avec élégance - Ignoré avec élégance :
CREATE VIEW,CREATE MATERIALIZED VIEW,CREATE FUNCTION/TRIGGER/SCHEMA/SEQUENCE, procéduralEXECinstructions autres quesp_rename,DECLARE,PRINT,PARTITION BY,INHERITS(y compris le corps vide),WITH OIDS,STORAGE PLAIN,EXCLUDE USING gist, et les corps d'instructions qui n'affectent pas la structure de l'ERD
✓ Syntaxe d'aperçu DDL/DML
- Exécution de haut en bas : Le script est rejoué dans l'ordre des instructions, de sorte que les données d'exemple doivent venir après le schéma qu'elles référencent
- Instructions prises en charge :
CREATE TYPE,CREATE TABLE,CREATE VIEW,CREATE INDEX,ALTER TABLEmodifications de colonne/contrainte,DROP INDEX,TRUNCATE TABLE,INSERT,UPDATE,DELETE,DROP TABLE,DROP VIEW, etDROP TYPE - Filtres WHERE :
=,!=,<>,>,<,>=,<=,LIKE,IN,NOT IN,NOT LIKE,BETWEEN,NOT BETWEEN,IS NULL, etIS NOT NULL - Matérialisation des lignes : Les tables affichent le nombre de lignes, les métadonnées de structure et les données de lignes actuelles après l'exécution des instructions DML
- Types nommés : Types ENUM et composites créés avec
CREATE TYPEsont présentés séparément des tables - Journal d'exécution : Les états de réussite, d'avertissement et d'erreur sont capturés pour les colonnes inconnues, les tables manquantes, les clés en double, les violations de NULL et les mises à jour/suppressions globales ; les liaisons de mutation non valides échouent avant que les lignes ne soient modifiées
- Évaluation par défaut : Valeurs par défaut littérales plus des fonctions telles que
now(),CURRENT_TIMESTAMP,CURRENT_DATE,GETDATE(), etNEWID()
✓ Syntaxe de requête SELECT
- SELECT en lecture seule :
SELECTinstructions peuvent lire les tables en mémoire produites à partir du fichier SQL principal - Métadonnées de résultat : Les colonnes, les nombres de lignes, le temps écoulé, le formatage NULL/booléen/nombre et les erreurs de Requête sont préservés avec le résultat du SELECT
- Requêtes relationnelles : Jointures, filtres WHERE, GROUP BY, HAVING, ORDER BY, LIMIT/OFFSET, TOP, FETCH FIRST, CTE, tables dérivées, sous-requêtes et opérateurs enensemblistes
- Assistants analytiques : Agrégats, fonctions scalaires courantes, assistants JSON, fonctions de date/chaîne et fonctions de fenêtrage telles que
ROW_NUMBER,RANK,NTILE,FIRST_VALUE,LAST_VALUE,LAG, etLEAD; les cadres par défaut ordonnés incluent le groupe de pairs actuel
✗ Toujours non pris en charge / Ignoré
- ALTER TYPE : Impossible de modifier les types ENUM ou composites existants
- Clause LIKE :
CREATE TABLE foo (LIKE bar INCLUDING …)est ignoré avec élégance — les colonnes copiées ne sont pas matérialisées - Héritage de colonnes INHERITS : Le
INHERITS (parent)la clause elle-même s'analyse sans erreur, mais les colonnes héritées ne sont pas intégrées dans la table enfant à des fins d'ERD - Exécution d'index : Le code DDL d'index peut créer des badges de schéma, mais l'exécution de l'aperçu ne modélise pas les moteurs de stockage, les planificateurs de requêtes ni les performances des index.
- Limites de SELECT : La syntaxe de requête en lecture seule ne prend pas en charge les CTE récursives, l'exécution de base de données externe, les procédures stockées ou les instructions de mutation
- Autres objets : Déclencheurs, procédures stockées, fonctions et séquences
- Exécution externe : L'aperçu DDL/DML ne se connecte pas à une base de données réelle et ne conserve pas les lignes en dehors du fichier SQL actuel
- Terminez chaque instruction par un point-virgule (
;) - Définir
CREATE TYPEavant les tables qui y font référence - Définir
CREATE TABLEavant lesINSERT,UPDATE, ouDELETEinstructions - Utiliser
ALTER TABLEpour les clés étrangères lorsque les tables se référencent mutuellement (dépendances circulaires) - Utilisez d'abord le DDL pour la structure, puis le DML pour valider les lignes d'exemple et le comportement des contraintes
- Conservez les données de démonstration dans le fichier SQL lui-même, car les lignes d'aperçu sont dérivées du script