Aller à la documentation

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.

SQL DDL → Diagramme EROuvrir SQL vers ERD
POUR COMMENCER

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.

PostgreSQL / Démarrage rapide avec PostgreSQL
-- 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;
Syntaxe de schéma : Les relations peuvent être déclarées avec soit en ligne REFERENCES ou ALTER TABLE ADD FOREIGN KEY. Les deux formes fournissent les mêmes métadonnées de relation.
Syntaxe DML : Mettre 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à.
Syntaxe de SELECT : Conservez les requêtes de rapport en lecture seule séparées des scripts de modification. Elles ne doivent référencer que les tables et les lignes produites par le script de schéma/DML.
SQL / Exemple
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

  1. 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.
  2. 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.
  3. 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.
  4. 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

Résoudre les problèmes de l'espace de travail SQL
SymptômeQuoi vérifier
Une table est manquanteVé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 manquanteVé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 lignePlacez 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 SQLExé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 dialecteLa 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.

Conseil pour l'invite IA : Demander un script SQL complet, terminé par un point-virgule. Indiquez à l'IA d'éviter les objets non pris en charge tels que les procédures stockées, les déclencheurs (triggers), les CTE récursives dans les Requêtes SELECT en lecture seule, et 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

SQL / Exemple
-- 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;
Prise en charge de WHERE : =, !=, <>, >, <, >=, <=, 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

Générer des données d'exemple localement : Dans la vue des Données, choisissez Générer des données d’exemple, choisissez la détection automatique ou un dialecte SQL, un dictionnaire de noms de 26 pays ou de l'anglais général, un pourcentage facultatif de valeurs nulles et le nombre de lignes de la table, puis développez une table pour personnaliser ses générateurs, ses plages ou ses valeurs autorisées. Prévisualisez d'abord, puis copiez/téléchargez le SQL ou insérez un nouveau Données d'exemple onglet. Aucune clé IA ni aucune requête de données externe n'est nécessaire. Si vous avez remplacé le schéma intégré, rendez son ancien onglet de données d'exemple e-commerce inactif en premier. La génération préserve les lignes existantes, copie les tuples de clés étrangères complets avec une couverture parent équilibrée, et valide les contraintes prises en charge ainsi que les types scalaires. Les contraintes CHECK composées entièrement de IS NULL / IS NOT NULL, AND, OR et de parenthèses ont la priorité sur le pourcentage de NULL optionnel, y compris les références exclusives post/vidéo. Le catalogue compte plus de 4 200 entrées intégrées, dont plus de 2 600 noms avec orthographe native et identifiants e-mail ASCII, ainsi que des entreprises, des produits, des emplois, des rues, des descriptions en langage naturel et des exemples de localisation dans plus de 40 pays, aux côtés de devises, d'adresses IP, de SKU, de statuts, de couleurs, de dates et de JSON. Les lots prennent en charge jusqu'à 5 000 lignes par table, 10 000 lignes et 150 000 cellules au total, et 5 Mo de SQL. Les cycles de relation vides requis, les domaines uniques épuisés, les noms de table en collision entre schémas et les types complexes requis non pris en charge nécessitent des ajustements avant que la génération ne puisse se terminer. Les valeurs complexes annulables et les références de rupture de cycle peuvent devenir NULL avec une note d'aperçu. Les graines répètent les valeurs de dictionnaire générées ; les valeurs par défaut de la base de données suivent toujours leur comportement normal. Terminez l'examen par l'IA d'abord, et rouvrez le générateur si l'espace de travail SQL change.

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.

Ne demandez pas à l'IA de se fier à : autonome 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.

SQL / Aperçu de la transaction
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;
Dans cet exemple, la vue des Données conserve les éléments 1 et 2. L'élément 3 est supprimé par ROLLBACK TO avant COMMIT. La vue des Requêtes lit ces lignes d'aperçu finales.

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

SQL / Exemple
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.

En lecture seule par conception : Conserver 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.

SQL / Exemple
// 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.

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

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

-- error (unknown table)
INSERT INTO ghost VALUES (1);
-- → error: INSERT INTO "ghost": table does not exist
Toujours exploitable. Chaque erreur et avertissement cite le nom de la table ou de la colonne incriminée, afin que vous puissiez identifier le problème sans relire le script.

Diagnostics courants

SQL / Exemple
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.
Résistant aux pannes. L'analyse de schéma, l'exécution DDL/DML et l'exécution SELECT convertissent le SQL malformé en erreurs visibles afin que vous puissiez continuer à affiner le même script.

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.

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

Exemple :

SQL / 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)
);
Types de données pris en charge : INTEGER, BIGINT, SMALLINT, TEXT, VARCHAR(n), CHAR(n), DECIMAL(p,s), NUMERIC, BOOLEAN, DATE, TIME, TIMESTAMP, FLOAT, REAL, DOUBLE PRECISION, UUID, JSON, JSONB, BYTEA, MONEY, et plus encore.

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.

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

Exemple :

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

CREATE TYPE priority_level AS ENUM (
  'low', 'medium', 'high', 'critical'
);
Important : Les valeurs d'énumération doivent être comprises entre guillemets simples ('valeur'), et non entre guillemets doubles.

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.

SQL / Exemple
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
);
Règle de résolution : 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 :

SQL / Exemple
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 ( ... );
Remarque : Les noms de tables et de colonnes peuvent utiliser des guillemets doubles ("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 :

SQL / Exemple
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

Les valeurs DEFAULT prennent en charge :
  • 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 (en ligne) : Reconnaît 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.

SQL / Exemple
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.

SQL / Exemple
CREATE TABLE tasks (
  id INTEGER PRIMARY KEY,
  status ENUM('todo', 'doing', 'done'),
  priority ENUM('low', 'medium', 'high')
);
Fonctionnement : Les ENUM en ligne sont automatiquement enregistrés en tant que types nommés. Le premier nom simple utilise 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.
Astuce : Si vous avez besoin d'énumérations partagées ou de noms personnalisés, définissez-les explicitement avec 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 :

SQL / Exemple
-- 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 :

SQL / 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)
);
Contraintes prises en charge : PRIMARY KEY, FOREIGN KEY, UNIQUE et CHECK sont tous pris en charge au niveau de la table. Le nom de la contrainte (CONSTRAINT name) est facultatif.
Exactitude des clés étrangères : Si 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 :

SQL / Exemple
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
);
Règle de désambiguïsation : 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

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

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

-- Invalid for SQLite AUTOINCREMENT:
-- 1. BIGINT PRIMARY KEY AUTOINCREMENT
-- 2. INT PRIMARY KEY AUTOINCREMENT
-- 3. AUTOINCREMENT on a composite primary key
Règle SQLite : utiliser exactement INTEGER PRIMARY KEY AUTOINCREMENT. N'utilisez pas BIGINT, INT, ou une clé primaire composite avec AUTOINCREMENT.

PostgreSQL

SQL / Exemple
-- 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
);
Important : 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

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

MSSQL / SQL Server

SQL / Exemple
-- 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
);
Sortie ERD : Chaque formulaire ci-dessus s'affiche de manière identique dans le diagramme — icône de clé PK plus 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

SQL / Exemple
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
);
Modes de base de données : Dans une base de données native, 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.

SQL / Exemple
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
);
AS brut : L'analyseur accepte 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.
Sortie ERD : Toutes les colonnes calculées affichent 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

SQL / Exemple
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 :

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

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

Exemple :

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

3.3. Ajouter une contrainte d'unicité

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

Exemple :

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

3.4. Ajouter une contrainte de vérification

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

Exemple :

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

3.5. Exemple de rejouage de migration

SQL / Exemple
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);
Ce que fait l'ERD : La clé étrangère de contact se résout sur la clé primaire composite de 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

SQL / Exemple
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

SQL / Exemple
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';
Limite de syntaxe : La relecture de migration de SQL vers ERD est intentionnellement plus riche que l'exécution de la vue Données. L'analyse du diagramme final reste confinée au navigateur et ne nécessite pas de connexion à une base de données ; les instructions d'exécution non prises en charge n'affaiblissent pas le modèle de cycle de vie du Constructeur ERD.

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

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

4.2. Exemples

Accélérez une recherche de clé étrangère fréquente (IDX à colonne unique) :

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

Index composite (pastille IDX atténuée sur chaque colonne clé) :

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

Promouvoir une colonne en UNIQUE sans modifier sa définition :

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

Index unique partiel / filtré (PUQ, pas une cible de FK globale) :

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

Index en ligne MySQL dans CREATE TABLE :

SQL / Exemple
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 :

SQL / Exemple
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 INDEX sur ceux-ci est ignorée en silence — vous ne verrez pas de pastilles redondantes.
  • Index uniques partiels / filtrés s'affiche comme PUQ avec le WHERE pré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 IDX indiquent 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, PostgreSQL DROP INDEX CONCURRENTLY, MySQL ALTER TABLE … ADD/DROP/RENAME INDEX, PostgreSQL ALTER INDEX … RENAME, ainsi que le renommage d'index SQL Server via sp_rename. Les métadonnées nommées UQ/PUQ/IDX suivent le dernier nom survivant.
Astuce : Les pastilles IDX composées s'affichent dans un gris atténué pour refléter le langage visuel existant des clés primaires composées (PK) / clés uniques composées (UQ). Une pastille IDX pleine signifie toujours « index sur une seule colonne » — facile à parcourir dans les diagrammes denses.

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

SQL / Exemple
-- 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
);
Spécifique à SQLite : 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.
Exactitude des types : Les tables SQLite ordinaires acceptent des noms de types déclarés arbitraires (tels que 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 :

SQL / Exemple
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

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

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

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

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

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

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

-- Empty body INHERITS (PG-only)
CREATE TABLE child () INHERITS (parent);
PostgreSQL : Prend en charge les types SERIAL, les colonnes d'identité, JSONB, BYTEA, INET, les variantes de timestamp, les tableaux, les types composites et ENUM, 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

SQL / Exemple
-- 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;
Spécifique à MySQL : 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

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

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

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

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

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

-- Multi-statement batches separated by GO are honored
CREATE TABLE [dbo].[Orders] (
  [OrderID] INT IDENTITY NOT NULL PRIMARY KEY  -- bare IDENTITY → (1,1)
);
GO
Spécifique à MSSQL : IDENTITY(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.
Colonnes calculées AS brutes : 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 :

SQL / Exemple
-- 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.table et schema.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 ENUM et CREATE TYPE … AS (composite), y compris les noms qualifiés par un schéma
  • ENUM et SET en ligne (MySQL) : ENUM('a','b') et SET('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 les IDENTITY (MSSQL) — tout est unifié dans le diagramme
  • Colonnes calculées : GENERATED ALWAYS AS (expr) STORED/VIRTUAL (PG/MySQL) et MSSQL col AS (expr) [PERSISTED] + brut col 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()), et ON UPDATE CURRENT_TIMESTAMP (MySQL)
  • Actions FK : ON DELETE / ON UPDATE avec CASCADE, RESTRICT, SET NULL, SET DEFAULT, NO ACTION, plus MATCH, DEFERRABLE, et INITIALLY mé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, MSSQL sp_rename, et MySQL MODIFY/CHANGE COLUMN
  • Index : De niveau supérieur CREATE/DROP INDEX, PostgreSQL ALTER INDEX … RENAME, ajout/suppression/renommage et en ligne pour MySQL KEY/INDEX/UNIQUE INDEX/FULLTEXT/SPATIAL définitions. Les index basés sur des colonnes s'affichent sous forme de IDX, UQ, ou PUQ badges
  • IF NOT EXISTS, IF EXISTS : géré avec élégance sur les deux CREATE et DROP
  • Enveloppes de transaction réservées au schéma : BEGIN, COMMIT, SET search_path, USE [db] (MSSQL), et SET 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édural EXEC instructions autres que sp_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 TABLE modifications de colonne/contrainte, DROP INDEX, TRUNCATE TABLE, INSERT, UPDATE, DELETE, DROP TABLE, DROP VIEW, et DROP TYPE
  • Filtres WHERE : =, !=, <>, >, <, >=, <=, LIKE, IN, NOT IN, NOT LIKE, BETWEEN, NOT BETWEEN, IS NULL, et IS 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 TYPE sont 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(), et NEWID()

✓ Syntaxe de requête SELECT

  • SELECT en lecture seule : SELECT instructions 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, et LEAD; 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
Comportement de la syntaxe : Le DML ne contribue pas à la génération du diagramme de schéma. Les instructions de cycle de vie de table, de type et d'index nommé sont rejouées dans l'ordre source, y compris le renommage, la suppression et la recréation ultérieure sans fuite de métadonnées entre les incarnations d'objets. Les instructions DDL/DML prises en charge s'exécutent en mémoire de haut en bas, et les requêtes SELECT en lecture seule lisent à partir de ce résultat en mémoire sans le modifier.
Bonnes pratiques :
  • Terminez chaque instruction par un point-virgule (;)
  • Définir CREATE TYPE avant les tables qui y font référence
  • Définir CREATE TABLE avant les INSERT, UPDATE, ou DELETE instructions
  • Utiliser ALTER TABLE pour 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
Récupération d'erreurs : Les instructions non prises en charge sont ignorées, et les avertissements/erreurs de syntaxe sont signalés avec suffisamment de contexte pour continuer à affiner le même fichier au lieu de recommencer à zéro.

En suivant ces schémas de syntaxe, Erd Go peut générer votre schéma ERD, prévisualiser les Données en mémoire et exécuter des Requêtes en lecture seule à partir du même fichier SQL.

ErdGo.com - Transformez le SQL en diagrammes et prévisualisez les données plus rapidement