logo
GeekFormat

Convertisseur SQL

Le convertisseur SQL en ligne de GeekFormat transforme en un clic les instructions SQL INSERT et les scripts CREATE TABLE en JSON, CSV, TSV, XML, YAML, tableaux HTML, tableaux Markdown, JSON Lines et bien d'autres formats. Il prend en charge plusieurs instructions INSERT ainsi que l'analyse par lot des tuples à valeurs multiples, reconnaît automatiquement les nombres, chaînes, NULL, booléens et littéraux hexadécimaux, et est compatible avec les styles de guillemets d'identifiants de MySQL, PostgreSQL, SQLite et SQL Server. Les données de plusieurs tables peuvent être exportées séparément ou fusionnées. Vous pouvez également reconstruire des instructions INSERT et changer de dialecte. Le traitement est entièrement local au navigateur, aucune donnée ne quitte votre appareil.

Recommandations connexes

À propos de la conversion SQL : transformer des scripts SQL en JSON/CSV/XML et autres formats

La conversion SQL (SQL Conversion) consiste à extraire les données d'un script SQL et à les réorganiser dans d'autres formats de données tels que JSON, CSV, XML, YAML, HTML ou Markdown. SQL (Structured Query Language, langage de requête structuré) est le langage de requête standard des bases de données relationnelles. Les outils d'export de base de données (mysqldump, pg_dump) produisent généralement les données sous forme d'instructions INSERT dans un script SQL. Ce format, bien pratique pour les imports en base, est malcommode pour la lecture par programme, l'analyse de données ou l'échange entre systèmes, d'où la nécessité de le convertir en formats plus universels.

Les scripts d'export de données SQL courants contiennent deux types d'instructions : CREATE TABLE sert à définir la structure de la table (noms de colonnes, types de données, contraintes), et INSERT INTO ... VALUES (...) insère les données proprement dites. Cet outil analyse ces deux types d'instructions : il extrait les définitions de colonnes et les informations de type de CREATE TABLE, et les lignes de données réelles de INSERT, puis réorganise la sortie dans le format choisi par l'utilisateur. L'ensemble du processus d'analyse s'effectue localement dans le navigateur, sans aucun service backend.

Pourquoi convertir le SQL en d'autres formats ? Le SQL, bien qu'universel, s'avère peu pratique dans les scénarios suivants : premièrement, un programme frontend lit beaucoup plus facilement du JSON que du SQL, sans avoir à intégrer un analyseur SQL ; deuxièmement, les tableurs comme Excel ou Google Sheets prennent nativement en charge le CSV, pas le SQL ; troisièmement, YAML et Markdown sont plus lisibles que le SQL dans les scénarios de configuration et de documentation ; quatrièmement, l'échange de données entre systèmes utilise souvent XML ou JSON comme format neutre. Une fois converti en ces formats universels, les données peuvent être consommées directement par davantage d'outils et de langages.

L'analyseur SQL de cet outil est écrit à la main et se concentre sur les instructions INSERT et CREATE TABLE. Pour les INSERT, il prend en charge les tuples à valeur unique (INSERT INTO t (a,b) VALUES (1,2)) et les tuples à valeurs multiples (INSERT INTO t (a,b) VALUES (1,2), (3,4), (5,6)), en mappant automatiquement les données aux noms de colonnes. Pour CREATE TABLE, il analyse les définitions de colonnes, les types de données (VARCHAR(255), INT, DECIMAL(10,2) etc., avec longueur entre parenthèses), ainsi que les contraintes et clauses NOT NULL, PRIMARY KEY, IF NOT EXISTS, en gérant correctement les parenthèses imbriquées pour éviter les splits erronés.

La reconnaissance des types est essentielle à la conversion SQL. L'outil détermine automatiquement le type à partir de la forme littérale de la valeur : les chaînes simples ou doubles guillemets sont des chaînes de caractères ; NULL (sans tenir compte de la casse) est la valeur nulle ; TRUE/FALSE sont des booléens ; 0x..., X'...', B'...' sont des littéraux hexadécimaux ; et les nombres purs (avec signe, séparateur décimal, notation scientifique) sont des nombres. Cette reconnaissance automatique garantit que les formats convertis (JSON, CSV, etc.) conservent la sémantique des données d'origine (par exemple le nombre 1 et non la chaîne "1"), afin que les programmes en aval traitent correctement les valeurs.

Les différences de styles de guillemets d'identifiants entre dialectes sont un piège fréquent de l'analyse SQL. MySQL utilise par défaut l'accent grave (`) pour entourer les identifiants (noms de tables, de colonnes), PostgreSQL les guillemets doubles ("), SQL Server/T-SQL les crochets ([]), et le SQL standard utilise également les guillemets doubles. La fonction unquoteIdentifier de cet outil reconnaît et supprime automatiquement ces guillemets, en traitant aussi les échappements internes (par exemple `` → `, "" → "). En mode reconstruction SQL, INSERT peut être régénéré dans le style de guillemets du dialecte cible.

L'échappement des chaînes SQL est un autre point technique majeur. La norme SQL prévoit que les simples guillemets à l'intérieur d'une chaîne sont échappés par dédoublement ('It''s' représente It's). MySQL prend en plus en charge l'échappement par antislash (\n, \t, \', \", \\, \0, \Z). L'analyseur de chaînes de cet outil gère les deux mécanismes et restitue correctement le contenu original. Lors de la conversion en CSV, les champs contenant virgule, guillemet ou saut de ligne sont rééchappés conformément à RFC 4180 ; lors de la conversion en XML/HTML, les caractères spéciaux &, <, >, ", ' sont échappés.

Le traitement purement frontend est un principe de conception fondamental de cet outil. Toutes les étapes d'analyse SQL et de conversion de données s'exécutent dans le moteur JavaScript du navigateur, sans aucune donnée envoyée à un serveur. Cela signifie que même si le script SQL contient des informations personnelles, des données commerciales sensibles ou la structure interne d'une base de données, rien ne fuite à l'extérieur. Cette approche convient particulièrement aux exports de bases de production, sans souci de conformité des données. Le traitement frontend élimine aussi la latence réseau ; la vitesse de conversion ne dépend que du processeur et de la mémoire de l'appareil.

Par rapport aux outils traditionnels de conversion SQL en ligne de commande (sql2csv, sqlparser), cet outil présente plusieurs avantages : aucune installation ni configuration d'environnement, utilisation directe depuis la page web ; interface visuelle avec aperçu en temps réel du résultat ; bascule en un clic entre plusieurs formats de sortie ; données d'exemple et documentation intégrées ; conception responsive mobile utilisable partout. En contrepartie, l'outil est centré sur l'extraction de données et ne traite pas les différences complexes entre dialectes (opérateurs JSONB de PostgreSQL, ON DUPLICATE KEY UPDATE de MySQL) ni les fonctionnalités avancées (procédures stockées, fonctions, déclencheurs). Pour ce type de besoins, utilisez des outils natifs de base de données ou des plateformes ETL spécialisées.

Lors de l'utilisation de l'outil de conversion SQL, quelques bonnes pratiques méritent d'être suivies : premièrement, vérifier avant conversion que le script SQL contient des données complètes (instructions INSERT) et non uniquement des requêtes (SELECT), car SELECT n'est pas analysé ; deuxièmement, pour les scripts SQL multi-tables, activer « Sortie séparée multi-tables » afin de conserver les informations de structure de table ; troisièmement, pour le SQL contenant des caractères chinois, activer « Inclure BOM » dans la sortie CSV pour qu'Excel reconnaisse l'encodage ; quatrièmement, pour les gros dumps SQL, désactiver « sortie mise en forme » afin de réduire le volume de sortie ; cinquièmement, pour une migration entre bases de données, utiliser le mode « Reconstruction SQL » pour changer de dialecte, sachant que les types complexes (tableaux PostgreSQL, JSONB) peuvent nécessiter des ajustements manuels.

Cas d'utilisation

  • Convertir en JSON les scripts SQL exportés par mysqldump ou pg_dump, pour l'import de données via API ou la consommation côté frontend
  • Convertir des instructions INSERT de base de données en fichiers CSV, à importer dans Excel/WPS/Google Sheets pour l'analyse de données ou la production de rapports
  • Extraire des données de scripts de sauvegarde SQL au format XML, pour l'échange de données entre systèmes ou l'intégration avec des interfaces SOAP
  • Convertir des données SQL au format de configuration YAML, pour les scénarios de configuration Ansible, Docker Compose, Kubernetes, etc.
  • Convertir des résultats de requêtes SQL (exportés en INSERT) en tableaux HTML, à intégrer directement dans des pages web
  • Convertir des données SQL en tableaux Markdown, à coller dans des README, des sites de documentation ou des blogs techniques
  • Extraire des données de scripts complets CREATE TABLE + INSERT et les convertir en JSON Lines pour l'indexation en masse Elasticsearch
  • Lors d'une migration de base de données, reconstruire des scripts INSERT MySQL en dialecte PostgreSQL pour faciliter l'import entre bases de données
  • Gestion des données de test : convertir des données de seed SQL en configuration JSON, faciles à lire et à versionner par les programmes
  • Démonstrations pédagogiques : convertir des instructions SQL en plusieurs formats pour comparer et aider les apprenants à comprendre les différences entre représentations de données
  • Prétraitement ETL : convertir des dumps SQL amont en JSON/CSV structuré comme entrée des pipelines ETL en aval
  • Analyse de données : extraire des données clés d'exports SQL en CSV, à analyser avec pandas, R et d'autres outils statistiques
  • Livraison client : convertir des exports de base de données aux formats JSON ou CSV, plus universels, à destination de non-techniciens
  • Archivage de données : convertir les scripts INSERT de bases de données historiques en YAML ou Markdown, plus lisibles pour l'archivage

Comment utiliser

  1. Collez le script SQL dans la zone d'entrée à gauche, ou cliquez sur le bouton « Téléverser SQL » pour sélectionner un fichier .sql/.txt
  2. Cliquez sur le bouton « Exemple » pour charger un exemple SQL intégré (avec CREATE TABLE et plusieurs INSERT de tables)
  3. Sélectionnez le format cible (JSON, CSV, XML, YAML et 5 autres) dans le menu déroulant de format en haut du panneau de sortie à droite
  4. Cliquez sur « Paramètres » pour ajuster les options de conversion : sortie mise en forme, inclusion de BOM, sortie séparée multi-tables, séparateur CSV, nom de clé racine JSON, dialecte SQL, etc.
  5. Cliquez sur « Convertir » pour exécuter la conversion. Le résultat s'affiche dans le panneau de droite, la barre d'état en bas indique le nombre de tables, de lignes, d'instructions INSERT et d'autres statistiques
  6. Cliquez sur « Copier » pour copier le résultat dans le presse-papiers, ou sur « Télécharger » pour l'enregistrer en tant que fichier au format correspondant (par exemple result.json, result.csv)
  7. Le changement de format de sortie déclenche automatiquement une nouvelle conversion, sans avoir à cliquer à nouveau sur le bouton Convertir

Fonctionnalités

  • Neuf formats de sortie : JSON, JSON Lines, CSV, TSV, XML, YAML, tableau HTML, tableau Markdown, reconstruction SQL — changez de format en un clic, la reconvertion est automatique
  • Analyse des instructions INSERT : reconnaissance automatique de la syntaxe INSERT INTO ... VALUES (...), prise en charge des tuples uniques et à valeurs multiples (plusieurs lignes de données dans une seule instruction INSERT)
  • Reconnaissance de CREATE TABLE : analyse des instructions CREATE TABLE pour extraire les définitions de colonnes, les types de données, les contraintes NOT NULL, PRIMARY KEY, etc., afin de déduire les types de champs
  • Traitement multi-tables : quand un script contient plusieurs tables, la sortie peut être par table (avec marqueurs de séparation par nom de table) ou fusionnée, en agrégeant automatiquement les colonnes et lignes de chaque table
  • Reconnaissance automatique des types : identification intelligente des nombres (entiers/flottants), chaînes, NULL, booléens (TRUE/FALSE) et littéraux hexadécimaux (0x..., X'...', B'...'), avec conservation de la sémantique de type d'origine
  • Compatibilité multi-dialectes : reconnaissance des accents graves MySQL (`), des guillemets doubles PostgreSQL ("), des crochets SQL Server ([]) et des guillemets standard, suppression automatique des guillemets d'identifiants
  • Échappement des chaînes SQL : traitement de l'échappement standard SQL ('' → ') et de l'échappement par antislash MySQL (\n, \r, \t, \0, \', \") pour restituer correctement les chaînes contenant des caractères spéciaux
  • Reconstruction de dialecte SQL : possibilité de régénérer des instructions INSERT en dialecte MySQL, PostgreSQL, SQLite ou SQL standard, avec nom de table personnalisé et génération facultative de CREATE TABLE
  • Configuration flexible du CSV : séparateur au choix (virgule/point-virgule/Tabulation/Barre verticale), en-tête BOM UTF-8 facultatif (compatible Excel), indentation facilitée, conforme à la norme RFC 4180
  • Plusieurs structures JSON : trois structures de sortie JSON au choix — groupées par table (clé racine tables), données pures (clé racine data) ou tableau pur (sans clé racine), adaptées à différents scénarios de consommation
  • Statistiques en temps réel : après conversion, affichage en temps réel du nombre de tables, du nombre total de lignes, du nombre d'instructions INSERT et du nombre de caractères de sortie, pour vérifier l'intégrité du résultat
  • Téléversement et téléchargement de fichiers : possibilité de téléverser des fichiers .sql/.txt/.csv/.tsv/.json pour une analyse directe, et de télécharger le résultat dans le format correspondant (.json, .csv, .yaml)
  • Gestion de l'historique : panneau latéral intégré à gauche qui enregistre automatiquement les dernières entrées SQL converties, pour recharger rapidement des scripts précédents
  • Responsive sur mobile : passage automatique à une disposition en onglets entrée/résultat sur smartphone, panneau double redimensionnable sur ordinateur, toutes les interactions sont disponibles sur mobile
  • Traitement entièrement local au navigateur : toutes les étapes d'analyse et de conversion s'exécutent dans le JavaScript du navigateur, sans aucune requête serveur. Les données SQL ne quittent pas l'appareil — idéal pour les exports de base de données contenant des informations sensibles

FAQ

Vers quels formats peut-on convertir le SQL ?

Cet outil prend en charge neuf formats de sortie : JSON (tableau structuré), JSON Lines (un objet JSON par ligne), CSV (séparé par virgule), TSV (séparé par tabulation), XML (document XML standard avec balises), YAML (format de configuration), tableau HTML (stylisé, visualisable directement dans le navigateur), tableau Markdown (syntaxe de documentation) et reconstruction SQL (régénération d'instructions INSERT avec dialecte au choix). Un simple clic dans le menu déroulant de format à droite permet de basculer et de reconvertir automatiquement.

Quelles instructions SQL sont prises en charge ?

L'outil analyse principalement les instructions INSERT INTO ... VALUES (...) pour extraire les données et reconnaît les instructions CREATE TABLE pour obtenir les définitions de colonnes et les informations de type. Il prend en charge les INSERT uniques, les INSERT à tuples multiples (plusieurs lignes dans une seule instruction), plusieurs instructions INSERT et les INSERT répartis sur plusieurs tables. Les commentaires (-- une ligne, /* */ multi-lignes, # MySQL une ligne) sont automatiquement supprimés et n'affectent pas l'analyse.

Quels dialectes de base de données sont pris en charge ?

Lors de l'analyse, les styles de guillemets d'identifiants MySQL (accent grave `), PostgreSQL (guillemets doubles "), SQL Server (crochets []) et SQL standard sont compatibles et automatiquement supprimés pour restituer les noms de colonnes et de tables d'origine. En mode reconstruction SQL, INSERT peut être régénéré en dialecte MySQL, PostgreSQL, SQLite ou SQL standard ; les guillemets et la représentation des booléens varient selon le dialecte.

Comment sont gérées les tables multiples dans un script SQL ?

L'outil agrège automatiquement les données INSERT par nom de table. Quand l'option « Sortie séparée multi-tables » est activée dans les paramètres, les formats tabulaires CSV/HTML/Markdown sont segmentés par table (avec marquage du nom de table), tandis que les formats structurés JSON/XML sont regroupés par nom de table. Si l'option est désactivée, CSV ne produit que les données de la première table, et JSON peut être émis sans clé racine sous forme de tableau pur.

Comment sont traités NULL, les booléens et les caractères spéciaux en SQL ?

L'outil reconnaît automatiquement NULL (sans tenir compte de la casse), les booléens TRUE/FALSE, les littéraux hexadécimaux (0x..., X'...', B'...'), les entiers et les flottants. Les chaînes sont traitées avec l'échappement SQL standard ('' → ') et l'échappement par antislash MySQL (\n, \t, \' etc.) pour restituer correctement le contenu original avec sauts de ligne, guillemets et caractères spéciaux. En sortie CSV, les champs contenant virgule, guillemet ou saut de ligne sont entourés de guillemets et échappés conformément à la norme RFC 4180.

Quelle est la structure du JSON converti ?

La sortie JSON prend en charge trois structures : « clé racine tables » (groupée par nom de table, recommandée pour plusieurs tables), « clé racine data » (encapsulation unifiée), « sans clé racine » (tableau pur, adapté à une table unique ou au traitement en flux). Par exemple, une table unique users devient [{"id":1,"name":"Alice"},...], plusieurs tables sont groupées par nom en {"users":[...],"orders":[...]}. Au choix dans les paramètres.

Les fichiers SQL téléversés sont-ils stockés sur le serveur ?

Non. Cet outil est une application purement frontend. Toutes les étapes d'analyse et de conversion s'exécutent localement dans le JavaScript du navigateur, sans envoyer le contenu SQL ni les résultats vers un serveur. Les fichiers téléversés sont lus directement dans le navigateur via FileReader et supprimés automatiquement à la fermeture de la page. Convient aux exports de base de données contenant des données personnelles ou sensibles.

Les identifiants entre crochets de SQL Server sont-ils pris en charge ?

Oui. L'outil reconnaît les identifiants entre crochets de SQL Server/T-SQL (par exemple [users], [order details]) et supprime automatiquement les crochets pour restituer les noms d'origine. Les accents graves MySQL et les guillemets doubles PostgreSQL sont également pris en charge. En mode reconstruction SQL, le choix du dialecte détermine le style de guillemets utilisé pour régénérer INSERT.

Pourquoi la conversion de mon script SQL ne produit-elle aucune donnée ?

Vérifiez que le SQL contient des instructions INSERT INTO ... VALUES (...). Cet outil n'analyse que les instructions INSERT pour extraire les données ; les requêtes SELECT ne produisent aucun résultat. S'il n'y a que des instructions CREATE TABLE, l'avertissement « Seul CREATE TABLE a été détecté, aucune ligne de données à convertir » s'affiche. Assurez-vous que le script SQL est un export de données (dump) et non des requêtes.

Les procédures stockées, fonctions et déclencheurs sont-ils pris en charge ?

Non. Cet outil est spécialisé dans l'extraction de données et n'analyse que les instructions INSERT et CREATE TABLE. Les procédures stockées (CREATE PROCEDURE), fonctions (CREATE FUNCTION), déclencheurs (CREATE TRIGGER) et vues (CREATE VIEW) ne sont pas analysés. Pour migrer ces objets, utilisez des outils natifs comme pg_dump ou mysqldump.

Les caractères chinois sont-ils correctement affichés dans le fichier CSV converti sous Excel ?

Oui. En activant l'option « Inclure BOM » dans les paramètres, le fichier CSV est doté d'un en-tête BOM UTF-8 (\uFEFF), et Excel reconnaît correctement l'encodage et affiche les caractères non ASCII comme le chinois. Sans BOM, certaines versions d'Excel peuvent afficher le chinois UTF-8 en caractères erronés. Les tableurs modernes tels que Google Sheets ou WPS reconnaissent généralement l'encodage correctement même sans BOM.

Peut-on reconstruire des instructions INSERT à partir d'un script SQL ?

Oui. Avec le format de sortie « Reconstruction SQL », vous pouvez régénérer des instructions INSERT. Vous pouvez choisir le dialecte cible (MySQL/PostgreSQL/SQLite/SQL standard), personnaliser le nom de table et générer facultativement une instruction CREATE TABLE (les types de colonnes INT/BIGINT/FLOAT/VARCHAR/TEXT/BOOLEAN sont déduits automatiquement à partir des données). Idéal pour reconvertir un script MySQL en dialecte PostgreSQL ou pour réimporter après modification du nom de table.

Quelle est la différence entre JSON Lines et JSON ? Quand utiliser JSON Lines ?

La sortie JSON est un tableau JSON complet ([{...},{...}]), adapté aux programmes qui chargent tout en mémoire. JSON Lines (également appelé NDJSON) contient un objet JSON indépendant par ligne, adapté au traitement en flux, à l'import de gros volumes, à l'API bulk d'Elasticsearch, à l'analyse de logs, etc., où la lecture ligne par ligne limite l'empreinte mémoire. L'outil permet de basculer librement entre les deux formats.

L'ordre original des colonnes est-il conservé dans le résultat ?

Oui. L'outil conserve l'ordre des colonnes tel que spécifié dans l'instruction INSERT. Si l'INSERT ne précise pas explicitement les noms de colonnes (par exemple INSERT INTO t VALUES (...)), des noms de colonnes de remplacement comme col_1, col_2, etc., sont générés en fonction du nombre de valeurs de la première ligne. L'ordre des colonnes de chaque table est conservé indépendamment et présenté par table lors de l'export fusionné.

Quelle est la taille maximale de fichier SQL prise en charge ?

Il n'y a théoriquement pas de limite stricte ; la limite dépend de la mémoire du navigateur. Les dumps SQL de quelques dizaines de Mo sont généralement traités couramment, tandis que les très gros fichiers (plusieurs centaines de Mo) peuvent ralentir en cas de mémoire navigateur insuffisante. Pour les très gros fichiers, il est conseillé de les découper en plusieurs petits fichiers à convertir par lots, ou de désactiver « sortie mise en forme » pour réduire la consommation mémoire. L'analyse s'effectue localement dans le navigateur et n'est pas limitée par le transfert réseau.

Dépannage

Aucune donnée en sortie après conversion ?

Cause 1 : le script SQL ne contient que des requêtes SELECT. Cet outil n'analyse que les instructions INSERT pour extraire les données et n'exécute aucune requête. Solution : utilisez mysqldump/pg_dump pour exporter les données sous forme d'instructions INSERT. Cause 2 : le script SQL ne contient que des CREATE TABLE sans ligne de données ; un avertissement s'affiche alors. Cause 3 : la syntaxe INSERT n'est pas standard (par exemple mot-clé VALUES manquant) ; vérifiez la syntaxe SQL. Cause 4 : tout le contenu SQL est commenté (-- ou /* */) ; vérifiez qu'aucun caractère de commentaire n'a été laissé par erreur.

Les caractères chinois s'affichent en caractères erronés dans Excel ?

Excel reconnaît par défaut le CSV en encodage GBK, de sorte que le chinois en UTF-8 s'affiche en caractères erronés. Solution : activez l'option « Inclure BOM » dans les paramètres. Le fichier CSV produit contiendra un en-tête BOM UTF-8 (\uFEFF), et Excel reconnaîtra correctement l'encodage UTF-8. Si un CSV sans BOM a déjà été exporté, vous pouvez le réenregistrer au format « UTF-8 avec BOM » dans un éditeur de texte avant de l'ouvrir dans Excel, ou l'ouvrir directement avec Google Sheets, WPS ou un autre tableur moderne.

Les nombres deviennent des chaînes dans le JSON ?

Cause : le nombre est entouré de guillemets dans le SQL (par exemple '123' au lieu de 123), l'outil l'analyse donc comme une chaîne. Solution : vérifiez si les nombres sont entourés de guillemets dans le script SQL et supprimez-les. Si les données d'origine sont ainsi (par exemple codes postaux souvent stockés en chaîne), il s'agit du comportement attendu, car la sémantique de chaîne évite la perte de zéros en tête (01234 n'est pas converti en 1234).

Erreur lors de la conversion de chaînes contenant des caractères spéciaux ?

Cause : les caractères spéciaux (saut de ligne, guillemet, antislash) de la chaîne SQL ne sont pas correctement échappés. Cet outil prend en charge l'échappement SQL standard ('' → ') et l'échappement par antislash MySQL (\n, \' etc.). Cependant, si le SQL d'origine utilise un échappement non standard (par exemple chaînes E'...' de PostgreSQL), la restitution peut échouer. Solution : vérifiez la conformité de l'échappement SQL et ajustez-le manuellement dans un éditeur de texte avant la conversion si nécessaire.

Lors de la conversion d'un SQL multi-tables, seule la première table apparaît ?

Cause : l'option « Sortie séparée multi-tables » n'est pas activée ; les formats tabulaires tels que CSV/HTML/Markdown ne produisent par défaut que la première table. Solution : activez « Sortie séparée multi-tables » dans les paramètres. Le CSV sera segmenté par table (avec marqueur # Table: nom de table), et le JSON sera regroupé par nom de table ({nom_table1:[...],nom_table2:[...]}). À noter : le format JSON Lines ne distingue pas les tables ; toutes les lignes sont fusionnées.

Après reconstruction SQL, les guillemets des noms de tables ou de colonnes sont incorrects ?

Cause : le dialecte choisi lors de la reconstruction est erroné. Les dialectes utilisent des styles de guillemets différents (accent grave MySQL, guillemets doubles PostgreSQL, crochets SQL Server). Solution : sélectionnez le dialecte SQL cible dans les paramètres ; l'outil régénère INSERT avec le style de guillemets correspondant. Par exemple, en choisissant PostgreSQL, le nom de table devient "users" ; en choisissant MySQL, il devient `users`.

Glossaire

SQL (Structured Query Language)
Langage de requête structuré, langage standard de requête et d'opération pour les bases de données relationnelles (MySQL, PostgreSQL, Oracle, SQL Server, SQLite). Comprend des sous-langages comme DDL (définition de données), DML (manipulation de données), DQL (interrogation de données) et DCL (contrôle de données).
Instruction INSERT
Instruction SQL permettant d'insérer des données dans une table, syntaxe INSERT INTO table (cols) VALUES (vals). Prend en charge les tuples uniques et multiples pour l'insertion en lot. Cet outil analyse principalement les instructions INSERT pour extraire les données.
Instruction CREATE TABLE
Instruction DDL SQL de création de table. Définit les noms de colonnes, types de données et contraintes (NOT NULL, PRIMARY KEY, UNIQUE, etc.). Cet outil peut analyser CREATE TABLE pour extraire les définitions de colonnes.
Tuple VALUES
Liste de valeurs entre parenthèses après le mot-clé VALUES dans une instruction INSERT, par exemple (1, 'Alice', TRUE). Une instruction INSERT peut contenir plusieurs tuples pour l'insertion en lot : VALUES (1,'A'), (2,'B'), (3,'C').
Dialecte SQL
Différences d'extension des éditeurs de bases de données par rapport à la norme SQL, par exemple les guillemets d'identifiants (accent grave MySQL, guillemets doubles PostgreSQL, crochets SQL Server), les booléens (TRUE/1), les colonnes auto-incrémentées (AUTO_INCREMENT/SERIAL), etc.
Guillemets d'identifiants
Caractères spéciaux en SQL servant à entourer les noms de tables et de colonnes. MySQL utilise l'accent grave `name`, PostgreSQL et le SQL standard les guillemets doubles "name", SQL Server les crochets [name]. Servent à échapper les mots réservés ou pour les scénarios sensibles à la casse.
Échappement SQL
Mécanisme permettant de représenter des caractères spéciaux dans les chaînes SQL. La norme SQL utilise le dédoublement des simples guillemets ('') pour un guillemet simple ; MySQL prend aussi en charge l'échappement par antislash (\n, \t, \', \\). Cet outil sait restituer les deux mécanismes d'échappement.
Valeur NULL
Valeur spéciale en SQL représentant une donnée manquante ou inconnue, sans tenir compte de la casse (NULL/null/Null). NULL n'est pas égal à la chaîne vide ni à 0. En JSON, NULL est mappé à null ; en CSV, il est généralement représenté par un champ vide.
Littéral hexadécimal
Syntaxe littérale en SQL pour représenter des données binaires. MySQL prend en charge les formes 0x... et X'...', PostgreSQL X'...' et B'...' (binaire). Cet outil conserve les littéraux hexadécimaux tels quels.
JSON Lines (NDJSON)
Format textuel avec un objet JSON indépendant par ligne, extension .jsonl. Adapté au traitement en flux, à l'import de gros volumes et à l'API bulk d'Elasticsearch, plus économe en mémoire qu'un tableau JSON complet.
RFC 4180
Norme internationale du format CSV (Common Format and MIME Type for Comma-Separated Values Files) qui définit les règles de séparation des champs, d'échappement par guillemets et de traitement des sauts de ligne. La sortie CSV de cet outil est conforme à cette norme.
BOM (Byte Order Mark)
Marque d'ordre des octets, caractère U+FEFF. Un BOM en début de fichier UTF-8 aide des logiciels comme Excel à reconnaître l'encodage et évite l'affichage erroné des caractères chinois. La sortie CSV de cet outil peut inclure facultativement un BOM.
SQL Dump
Fichier de script SQL exporté depuis une base de données, généralement produit par des outils comme mysqldump ou pg_dump, contenant des instructions CREATE TABLE et INSERT pour les sauvegardes et migrations de base de données.
DDL (Data Definition Language)
Langage de définition de données, sous-ensemble de SQL comprenant les instructions CREATE, ALTER, DROP, utilisé pour définir et modifier la structure d'une base de données (tables, vues, index, etc.).

Comparaison des formats de sortie pris en charge

Comparaison des caractéristiques et cas d'usage des neuf formats de sortie :

FormatExtensionCaractéristiqueCas d'usage idéal
JSON.jsonTableau structuré, types conservésAPI, lecture programme, données frontend
JSON Lines.jsonlUn objet JSON par ligneTraitement en flux, Elasticsearch, big data
CSV.csvTableau à virgules, RFC 4180Excel, analyse de données, rapports
TSV.tsvTableau à tabulationsColler dans un tableur, bioinformatique
XML.xmlDocument structuré avec balises et attributsInterfaces SOAP, fichiers de config, systèmes Java
YAML.yamlFormat de configuration le plus lisibleAnsible, K8s, configuration CI/CD
HTML.htmlTableau stylisé, visualisable dans le navigateurAffichage web, e-mails, rapports
Markdown.mdSyntaxe de tableau MarkdownREADME, sites de doc, blogs techniques
Reconstruction SQL.sqlINSERT régénéré, dialecte modifiableMigration entre bases, modification de nom de table

Règles de reconnaissance des types de valeurs SQL

Règles de reconnaissance des types lors de l'analyse des valeurs SQL (basées sur la forme littérale) :

Littéral SQLType reconnuSortie JSONSortie CSV
123Entier123123
-45Entier négatif-45-45
3.14Flottant3.143.14
1e10Notation scientifique1000000000010000000000
'hello'Chaîne"hello"hello
NULLValeur nullenull(vide)
TRUEBooléen vraitrueTRUE
FALSEBooléen fauxfalseFALSE
0xFFHexadécimal"0xFF"0xFF
X'4142'Hexadécimal"X'4142'"X'4142'

Styles de guillemets d'identifiants selon les dialectes de base de données

Différences de guillemets d'identifiants (noms de tables, de colonnes) entre les principales bases de données :

Base de donnéesStyle de guillemetsExempleRemarque
MySQL/MariaDBAccent grave ``users`Activé par défaut, distingue les mots réservés
PostgreSQLGuillemets doubles ""users"Sensible à la casse, style SQL standard
SQLiteGuillemets doubles "/Accent grave`/Crochets[]"users" / [users]Compatible avec plusieurs styles
SQL ServerCrochets [][users]Style par défaut T-SQL
OracleGuillemets doubles ""users"Majuscules forcées, guillemets pour préserver la casse
SQL standardGuillemets doubles ""users"Norme ANSI SQL

Privacy & Security

Toutes les opérations de ce convertisseur SQL s'effectuent entièrement localement dans votre navigateur : l'analyse SQL, l'extraction de données et la conversion de format sont exécutées côté client dans le JavaScript du navigateur, sans qu'aucun contenu SQL, fichier téléversé ou résultat de conversion ne soit envoyé via le réseau à un serveur. Les téléversements de fichiers sont lus directement en mémoire via l'API FileReader native du navigateur, sans service intermédiaire. Aucun cookie de suivi n'est utilisé, aucune saisie utilisateur ni donnée d'utilisation n'est collectée. À la fermeture ou au rechargement de la page, toutes les entrées et sorties sont automatiquement effacées de la mémoire (l'historique est uniquement conservé localement dans le localStorage du navigateur). Convient aux scripts d'export de base de données contenant des informations personnelles ou commerciales sensibles.

Authoritative References