JSON en SQL
Convertisseur JSON en SQL gratuit en ligne. Convertit les tableaux JSON en instructions INSERT et génère éventuellement des scripts DDL CREATE TABLE. Compatible avec MySQL, PostgreSQL, SQLite, SQL Server et plus de 20 dialectes SQL avec inférence automatique des types. Traitement 100% dans le navigateur.
Recommandations connexes
À propos de JSON en SQL : déplacer les données JSON vers des bases relationnelles
JSON en SQL est le processus de conversion de données au format JSON (tableaux ou objets JSON) en scripts SQL qu'une base de données relationnelle peut exécuter, spécifiquement des instructions INSERT et CREATE TABLE. JSON (JavaScript Object Notation) est un format léger d'échange de données utilisé partout : API REST, transport frontend vers backend, fichiers de configuration, journaux. Les bases de données relationnelles (MySQL, PostgreSQL, SQLite, SQL Server, Oracle, etc.) sont l'épine dorsale du stockage de données d'entreprise, mais elles nécessitent des structures de table strictes et des instructions SQL pour stocker et interroger les données. Déplacer des données de JSON vers une base de données relationnelle nécessite donc de transformer le JSON en script SQL.
Au cœur de l'outil, chaque objet d'un tableau JSON est converti en une ligne de données. Un objet individuel est traité comme une seule ligne et chaque élément d'un tableau JSON devient une ligne. Les clés de l'objet deviennent les noms de colonnes et les valeurs sont traduites dans le littéral SQL correspondant. Toute la conversion s'exécute localement dans le navigateur, sans backend.
L'inférence de types est le défi technique central de JSON en SQL. JSON n'a que six types primitifs (null, boolean, number, string, array, object), tandis que SQL en a des dizaines (INT, BIGINT, FLOAT, DOUBLE, VARCHAR, TEXT, DATE, TIMESTAMP, BOOLEAN, BIT, etc.). La fonction detectType de cet outil examine la forme littérale de chaque valeur : null correspond à SQL NULL ; true/false à BOOLEAN ; les entiers à INT (plage -2 147 483 648 à 2 147 483 647) ou BIGINT ; les flottants à FLOAT/DOUBLE/REAL selon le dialecte ; les chaînes au format ISO 8601 correspondent à DATE et TIMESTAMP ; les chaînes courtes à VARCHAR(255) ; les chaînes de plus de 255 caractères à TEXT.
L'outil implémente un algorithme de promotion des types : lorsque le type existant d'une colonne entre en conflit avec une nouvelle valeur, il est promu au type le plus large couvrant les deux (par exemple, INT est promu à FLOAT). NULL n'est pas inclus dans cette décision, donc le type déduit reste stable. Comme le type de colonne final est décidé après traitement de toutes les lignes, le résultat est le type globalement optimal pour l'ensemble de données.
Les différences de dialecte sont centralisées dans DIALECT_CONFIG. MySQL enveloppe les identifiants entre apostrophes inversées (`name`), PostgreSQL et le SQL standard utilisent des guillemets doubles ("name"), SQL Server utilise des crochets ([name]). SQLite n'a pas de type BOOLEAN natif, donc 1/0 est utilisé. BigQuery utilise INT64 pour les entiers et STRING pour le texte. Snowflake utilise NUMBER pour les entiers et TIMESTAMP_NTZ pour les horodatages. Oracle utilise VARCHAR2 et NUMBER(1) pour les booléens. DB2 stocke le texte en CLOB. L'outil adapte les guillemets d'identifiant, les types de données et la représentation booléenne au dialecte choisi par l'utilisateur.
La génération de CREATE TABLE s'appuie sur l'inférence de types. Lorsque l'utilisateur active "Générer CREATE TABLE" dans les paramètres, l'outil émet une instruction CREATE TABLE avant le bloc INSERT. Le nom de la table provient de l'entrée utilisateur (par défaut `users`) ; les noms de colonnes proviennent des clés de l'objet JSON ; les types de colonnes proviennent des types SQL déduits. Pour les dialectes qui prennent en charge IF NOT EXISTS, la clause est ajoutée automatiquement pour éviter les erreurs à la recréation ; pour les dialectes qui ne la prennent pas en charge (Oracle PL/SQL, SQL Server T-SQL), elle est omise pour des raisons de compatibilité. CREATE TABLE et INSERT forment ensemble un script d'initialisation complet qui peut être exécuté dans une base de données vide en une seule fois.
L'insertion par lots est la clé de la performance. Convertir 10 000 lignes de JSON en 10 000 instructions INSERT séparées est douloureusement lent. L'outil prend en charge une taille de lot configurable (par défaut 100, plage 1-1000) et fusionne plusieurs lignes en un INSERT avec des tuples multi-valeurs (VALUES (1,2), (3,4), ...). Cela réduit considérablement le nombre d'instructions et offre des performances d'importation 10 à 100 fois supérieures sur la plupart des moteurs. La taille du lot doit être ajustée pour chaque base de données et serveur, car un lot trop volumineux peut dépasser max_allowed_packet sur MySQL.
La tolérance aux erreurs JSON est une fonctionnalité pratique. L'outil inclut une routine de réparation tryFixJSON qui s'exécute lorsque JSON.parse échoue ; si la réparation réussit, l'utilisateur est notifié et la conversion se poursuit. Cela améliore considérablement le taux de réussite en pratique et évite des allers-retours interminables pour de petites erreurs. Tout le traitement est côté client : rien n'est jamais envoyé à un serveur, ce qui élimine tout risque de fuite et rend la conversion quasi instantanée pour des données de taille moyenne (moins de 10 Mo).
Cas d'utilisation
- Convertissez les réponses JSON d'API en instructions INSERT pour importer en masse dans MySQL, PostgreSQL ou d'autres bases de données relationnelles à des fins d'analyse.
- Générez du DDL CREATE TABLE à partir d'une configuration JSON ou d'un dictionnaire de données lors de l'initialisation du schéma d'un nouveau projet.
- Convertissez les mocks frontend ou les fixtures de test en scripts SQL pour amorcer les environnements de développement, staging ou QA.
- Migration de données : transformez les exports JSON de MongoDB, Elasticsearch ou magasins de documents en scripts SQL pour des cibles relationnelles.
- Prétraitement ETL : normalisez les charges JSON amont en instructions INSERT standard que les pipelines en aval peuvent ingérer directement.
- Sauvegarde et restauration : conservez les données métier critiques sous forme JSON portable et régénérez les scripts SQL à la demande pour une restauration rapide.
- Collaboration inter-équipes : convenez d'un contrat JSON et laissez le backend générer en un clic à la fois le DDL de schéma et les scripts INSERT de seed.
- Enseignement et démos : guidez les apprenants à travers la façon dont les données JSON mappent aux instructions SQL, illustrant l'inférence de types et la mécanique d'insertion par lots.
Comment utiliser
- Collez un tableau ou un objet JSON dans l'éditeur de gauche, cliquez sur Télécharger pour charger un fichier .json/.txt, ou cliquez sur Exemple pour charger la démo intégrée.
- Choisissez le dialecte SQL cible dans le menu déroulant de la barre d'outils (MySQL, PostgreSQL, SQLite, SQL Server et plus de 20).
- Cliquez sur Paramètres pour configurer le nom de la table, l'émission ou non de CREATE TABLE et la taille du lot d'insertion (1-1000 lignes par INSERT).
- Cliquez sur Convertir (ou utilisez le raccourci clavier) pour analyser le JSON, déduire les types et afficher le SQL dans le panneau de droite.
- Inspectez le SQL généré et les totaux de lignes/colonnes dans la barre d'état pour vérifier l'intégrité des données.
- Cliquez sur Copier pour mettre le SQL dans le presse-papiers, ou cliquez sur Télécharger pour l'enregistrer comme fichier .sql (par exemple users.sql).
- Exécutez le SQL dans votre client de base de données préféré (Navicat, DBeaver, pgAdmin, MySQL Workbench) pour terminer l'importation des données.
Fonctionnalités
- Génération d'INSERT en masse : convertit les tableaux JSON en instructions INSERT INTO standard avec taille de lot configurable (1-1000 lignes par instruction).
- Sortie DDL CREATE TABLE : bloc DDL optionnel avec types auto-déduits (VARCHAR, INT, BIGINT, FLOAT, BOOLEAN, TIMESTAMP, DATE, TEXT).
- 20+ dialectes SQL : MySQL, PostgreSQL, SQLite, SQL Server, Oracle, DB2, BigQuery, Snowflake, Redshift, DuckDB, ClickHouse, Trino, Spark, Hive et plus.
- Inférence intelligente des types : détecte null, booléens, entiers, flottants, dates ISO 8601 et chaînes courtes ou longues et associe chacune au meilleur type SQL.
- Formateur SQL intégré : propulsé par sql-formatter, avec mots-clés en majuscules, indentation nette et blocs VALUES multi-valeurs clairs.
- Auto-réparation JSON : corrige automatiquement les virgules de fin, les guillemets simples et les guillemets de clé manquants pour des conversions résilientes.
- Logique de promotion des types : les types en conflit entre lignes sont promus au type compatible le plus large (INT + FLOAT devient FLOAT) pour que le DDL ne tronque jamais les données.
- Noms de table et de colonne personnalisés : le nom de la table devient le nom du fichier (p. ex. users.sql) ; les noms de colonne suivent les clés de l'objet JSON.
- Entrée flexible : collez du JSON, téléchargez un fichier .json/.txt ou chargez l'exemple intégré en un clic.
- Compteur de lignes et colonnes en direct : la barre d'état affiche le nombre total de lignes et de colonnes après la conversion pour une validation rapide.
- Copier et télécharger : copiez dans le presse-papiers en un clic ou enregistrez comme fichier .sql standard prêt à importer dans n'importe quelle base de données.
- 100% dans le navigateur : tout le parsing et la transformation se font en JavaScript côté client ; le JSON ne quitte jamais votre appareil.
FAQ
Comment convertir un tableau JSON en instructions SQL INSERT ?
Collez le tableau JSON dans l'éditeur de gauche et l'outil convertit chaque objet en instruction INSERT INTO. Les clés de l'objet deviennent les noms de colonnes et les valeurs sont automatiquement mises entre guillemets ou conservées comme nombres. Le SQL généré peut être copié et exécuté directement dans MySQL, PostgreSQL, SQLite ou tout autre client compatible.
L'outil peut-il générer des scripts DDL CREATE TABLE à partir de JSON ?
Oui. Activez "Générer CREATE TABLE" dans le panneau des paramètres. L'outil analyse chaque champ du JSON, déduit le type de données SQL approprié (VARCHAR, INT, BIGINT, FLOAT, BOOLEAN, TIMESTAMP, DATE, TEXT, etc.) et émet une instruction CREATE TABLE complète qui, avec les INSERT, forme un script d'initialisation prêt à exécuter.
Quels dialectes SQL sont pris en charge ?
L'outil prend en charge plus de 20 dialectes SQL majeurs, dont MySQL, MariaDB, PostgreSQL, SQLite, SQL Server (T-SQL), Oracle PL/SQL, DB2, BigQuery, Snowflake, Redshift, DuckDB, ClickHouse, Trino, Spark SQL, Hive, TiDB, SingleStoreDB et N1QL. Les guillemets d'identifiant (apostrophes inversées, guillemets doubles, crochets), les types de données (INT64, NVARCHAR, CLOB, etc.) et la représentation booléenne (TRUE/FALSE vs 1/0) sont adaptés automatiquement par dialecte.
Comment l'outil déduit-il les types SQL à partir des valeurs JSON ?
null correspond à SQL NULL ; true/false à BOOLEAN (1/0 ou BIT pour SQLite/DB2/SQL Server) ; les entiers à INT ou BIGINT selon la plage (promu automatiquement à BIGINT lorsque la valeur absolue dépasse 2 147 483 647) ; les flottants à FLOAT/DOUBLE/REAL selon le dialecte ; les chaînes au format ISO 8601 sont reconnues comme DATE et TIMESTAMP ; les chaînes courtes comme VARCHAR(255) ; les chaînes de plus de 255 caractères comme TEXT. Les types en conflit entre lignes sont promus automatiquement (par exemple, INT + FLOAT devient FLOAT).
Le SQL généré peut-il être exécuté directement dans ma base de données ?
Oui. Le SQL généré est conforme à la norme du dialecte choisi et peut être exécuté dans MySQL Workbench, Navicat, DBeaver, pgAdmin, SQL Server Management Studio, phpMyAdmin ou tout autre outil de gestion de base de données. Les fichiers téléchargés sont nommés d'après la table (par exemple users.sql) pour faciliter l'importation par lots.
Que se passe-t-il si mon JSON contient des erreurs de syntaxe ?
Si le JSON contient des virgules de fin, des guillemets manquants ou des guillemets simples au lieu de doubles, l'outil invoque automatiquement la fonction de réparation tryFixJSON et poursuit la conversion. Si la réparation échoue, le panneau de droite affiche l'emplacement exact de l'erreur. Pour les JSON profondément imbriqués ou très endommagés, utilisez d'abord l'outil JSON Formatter.
L'outil prend-il en charge les insertions par lots ? Combien de lignes par INSERT ?
Oui. Par défaut, chaque INSERT regroupe 100 lignes, configurable de 1 à 1000. Convertir 10 000 lignes JSON produit 100 instructions INSERT multi-valeurs. Par rapport aux insertions ligne par ligne, les performances d'importation sont généralement 10 à 100 fois supérieures sur MySQL, PostgreSQL et les moteurs similaires.
Mes données JSON sont-elles téléchargées sur un serveur ?
Non. Il s'agit d'une application purement côté client. Toute l'analyse JSON, l'inférence de types et la génération SQL s'exécutent dans le moteur JavaScript du navigateur ; rien n'est envoyé à un serveur. Les téléchargements de fichiers utilisent l'API native FileReader et toutes les données sont effacées de la mémoire au rechargement de la page. Vous pouvez traiter en toute sécurité des JSON contenant des données personnelles ou des secrets commerciaux.
Les chaînes de date ISO 8601 sont-elles détectées automatiquement ?
Oui. L'outil reconnaît deux motifs ISO 8601 : les chaînes avec le séparateur T (par exemple 2024-05-20T10:30:00) correspondent à TIMESTAMP ; les chaînes de date uniquement (par exemple 2024-05-20) correspondent à DATE. Les chaînes qui ne suivent pas ISO 8601 (par exemple 2024/05/20 ou May 20, 2024) sont traitées comme de simples valeurs VARCHAR.
Quelle taille de fichier JSON l'outil peut-il gérer ?
Il n'y a pas de limite stricte ; la limite pratique est la mémoire du navigateur. Les fichiers jusqu'à 10 Mo (des dizaines de milliers de lignes) fonctionnent sans problème. Les fichiers plus volumineux peuvent ralentir à mesure que la pression mémoire augmente. Pour de très grands ensembles de données, divisez-les en lots plus petits ou désactivez l'étape optionnelle d'embellissement dans le formateur SQL.
Le SQL généré est-il formaté automatiquement ?
Oui. L'outil utilise la bibliothèque sql-formatter pour embellir la sortie : les mots-clés sont en majuscules (SELECT, INSERT INTO, VALUES, CREATE TABLE), chaque enregistrement est sur sa propre ligne, l'indentation est cohérente et les lignes vides sont conservées pour la lisibilité. Le résultat est facile à lire dans n'importe quel client de base de données et facile à modifier manuellement.
Puis-je contrôler l'ordre des colonnes de l'INSERT généré ?
Par défaut, l'outil utilise l'ordre des clés dans le premier objet du tableau JSON, ce qui maintient la sortie multi-lignes alignée. Si différents objets ont des ordres de clés différents, l'outil fusionne et déduplique toutes les clés et remplit les valeurs manquantes avec NULL. Pour de meilleurs résultats, normalisez le JSON avec l'outil JSON Formatter avant la conversion.
Dépannage
Le panneau de droite affiche uniquement "No valid objects found in JSON".
Cause 1 : le niveau supérieur du JSON n'est ni un tableau ni un objet (par exemple une chaîne ou un nombre seul), il n'y a donc rien à convertir en lignes. Solution : enveloppez le JSON dans un tableau [{...}] ou un objet {...}. Cause 2 : le tableau contient des valeurs primitives ([1, 2, 3]) au lieu d'objets, il n'y a donc pas de noms de clé à mapper aux colonnes. Solution : chaque élément du tableau doit être un objet avec des paires clé-valeur. Cause 3 : le JSON n'a pas pu être analysé, tryFixJSON s'est exécuté, et le résultat de la réparation n'est toujours pas un objet. Solution : validez le JSON avec l'outil JSON Formatter pour trouver le problème de syntaxe.
Le SQL généré produit une erreur de syntaxe dans ma base de données.
Cause 1 : le mauvais dialecte est sélectionné (par exemple MySQL sélectionné mais la cible est PostgreSQL), le style de guillemets d'identifiant ne correspond donc pas. Solution : choisissez le bon dialecte dans le menu déroulant. Cause 2 : le nom de table ou de colonne entre en collision avec un mot réservé SQL (order, user, select, etc.). Solution : renommez la table dans les paramètres ou enveloppez manuellement le nom entre apostrophes inversées ou crochets. Cause 3 : la taille du lot est trop grande et dépasse max_allowed_packet de la base de données ou une limite similaire. Solution : réduisez la taille du lot (par exemple à 50) dans les paramètres.
Un champ de date a été détecté comme VARCHAR au lieu de DATE ou TIMESTAMP.
Cause : la chaîne de date n'est pas au format ISO 8601. L'outil ne reconnaît que YYYY-MM-DD (DATE) et YYYY-MM-DDTHH:mm:ss (TIMESTAMP). Formats courants qu'il ne reconnaîtra pas : YYYY/MM/DD, DD-MM-YYYY, "May 20 2024" et horodatages Unix comme 1715644800. Solution : convertissez d'abord la date en ISO 8601 dans le JSON, ou modifiez manuellement le type de colonne CREATE TABLE en DATE ou VARCHAR après la conversion.
Les booléens apparaissent comme 1/0 dans SQLite/DB2 mais je veux TRUE/FALSE.
Cause : SQLite, DB2 et SQL Server n'ont pas de type BOOLEAN natif, la norme du dialecte utilise donc 1/0 (ou BIT). Solution : option 1, acceptez 1/0 comme représentation standard (1 signifie TRUE, 0 signifie FALSE) ; option 2, convertissez la valeur dans la couche applicative (1 vers true, 0 vers false) ; option 3, post-traitez le SQL en remplaçant 1/0 par TRUE/FALSE et changez le type de colonne en INTEGER pour le lire comme booléen dans votre code. L'outil suit toujours la norme du dialecte et n'offre pas d'option non standard.
Le JSON contient des objets ou tableaux imbriqués. Quels types de colonnes sont produits ?
Les valeurs non primitives (objets et tableaux imbriqués) sont sérialisées en chaînes JSON et stockées comme TEXT. Par exemple {"tags": ["a", "b"], "profile": {"age": 30}} produit deux colonnes : tags TEXT et profile TEXT, contenant toutes deux du JSON sérialisé. À l'interrogation, vous pouvez utiliser JSON_EXTRACT (MySQL 5.7+) ou des fonctions JSON similaires pour extraire des champs imbriqués. Pour normaliser complètement les données imbriquées dans des tables relationnelles séparées, gérez cela dans la couche applicative ou utilisez un outil ETL dédié.
Les caractères chinois apparaissent corrompus après l'importation du fichier .sql téléchargé.
Cause : le fichier .sql est encodé en UTF-8, mais le client de base de données ou la base de données elle-même n'est pas configurée en UTF-8. Solution : option 1, définissez le jeu de caractères de la base de données sur utf8mb4 (MySQL) ou UTF8 (PostgreSQL). Option 2, spécifiez le jeu de caractères sur la connexion cliente (par exemple MySQL CLI avec --default-character-set=utf8mb4). Option 3, ouvrez le fichier .sql dans un éditeur de texte et confirmez que l'encodage est UTF-8 (pas GBK ou autre). L'outil produit toujours des fichiers .sql en UTF-8.
Glossaire
- JSON (JavaScript Object Notation)
- Format léger d'échange de données basé sur la syntaxe d'objets JavaScript mais indépendant de tout langage de programmation. Prend en charge six types de base : objet ({}), tableau ([]), chaîne, nombre, booléen et null. Largement utilisé pour les API REST, le transport frontend-backend, les fichiers de configuration et les journaux.
- SQL (Structured Query Language)
- Langage standard pour les bases de données relationnelles (MySQL, PostgreSQL, SQLite, SQL Server, Oracle, etc.). Comprend DDL (définition de données, p. ex. CREATE TABLE), DML (manipulation de données, p. ex. INSERT), DQL (requête de données, p. ex. SELECT) et DCL (contrôle des données).
- Instruction INSERT
- Instruction DML qui ajoute des lignes à une table ; la syntaxe est INSERT INTO table_name (col1, col2) VALUES (val1, val2). Prend en charge les tuples à valeur unique et les tuples multi-valeurs (un INSERT pour plusieurs lignes) ; ce dernier améliore considérablement les performances d'importation en masse.
- Instruction CREATE TABLE
- Instruction DDL qui crée une table en définissant son nom, ses colonnes, ses types de données et ses contraintes (NOT NULL, PRIMARY KEY, UNIQUE, DEFAULT, etc.). Le CREATE TABLE généré par cet outil omet les clés primaires, les clés étrangères et les index pour rester propre et prévisible.
- Dialecte SQL
- Les différences d'implémentation entre les fournisseurs de bases de données pour la norme SQL. MySQL utilise des apostrophes inversées, PostgreSQL utilise des guillemets doubles, SQL Server utilise des crochets ; SQLite n'a pas de BOOLEAN natif et utilise 1/0 ; Oracle utilise VARCHAR2 ; BigQuery utilise INT64 et STRING. Le même SQL logique peut avoir une syntaxe différente selon les dialectes.
- DDL (Data Definition Language)
- Sous-langage SQL qui comprend les instructions CREATE, ALTER et DROP, utilisé pour définir et modifier les structures de bases de données (tables, vues, index, contraintes, etc.). La sortie CREATE TABLE de cet outil est une instruction DDL.
- DML (Data Manipulation Language)
- Sous-langage SQL qui comprend les instructions INSERT, UPDATE et DELETE, utilisé pour manipuler les lignes de données dans les tables. La sortie INSERT INTO de cet outil est une instruction DML.
- Inférence de types
- Processus de déduction automatique du type d'une valeur à partir de sa forme littérale. L'outil inspecte le typeof de chaque valeur JSON (null, boolean, number, string) ainsi que sa forme spécifique (date ISO 8601, longueur de chaîne) pour la mapper au type SQL le plus approprié.
- Guillemet d'identifiant
- Caractères spéciaux qui entourent les noms de table et de colonne en SQL. MySQL utilise des apostrophes inversées comme `name`, PostgreSQL et le SQL standard utilisent des guillemets doubles comme "name", SQL Server utilise des crochets comme [name]. Les guillemets d'identifiant sont utilisés pour échapper les mots réservés et contrôler la sensibilité à la casse.
- Format de date ISO 8601
- Norme internationale pour représenter les dates et heures. Le format est YYYY-MM-DD pour les dates et YYYY-MM-DDTHH:mm:ss pour les dates avec heure. Les chaînes correspondant à ces motifs sont automatiquement mappées aux types SQL DATE et TIMESTAMP par cet outil.
- VARCHAR et TEXT
- Deux types SQL pour les chaînes de longueur variable. VARCHAR(n) a une limite de longueur (communément jusqu'à 65 535 octets) et convient aux chaînes courtes comme les noms, les e-mails et les titres. TEXT n'a pas de limite de longueur (ou une très grande) et convient au contenu long. Par défaut, cet outil mappe les chaînes de 255 caractères ou moins à VARCHAR(255) et les chaînes plus longues à TEXT.
- INT et BIGINT
- Deux types SQL pour les entiers. INT (INTEGER) est normalement un entier signé de 32 bits dans la plage -2 147 483 648 à 2 147 483 647. BIGINT est un entier signé de 64 bits avec une plage beaucoup plus large. L'outil promeut automatiquement à BIGINT les entiers dont la valeur absolue dépasse la plage INT.
- Type BOOLEAN
- Type SQL pour les valeurs de vérité. MySQL, PostgreSQL et BigQuery prennent en charge BOOLEAN nativement (stockent TRUE/FALSE). SQLite n'a pas de BOOLEAN natif et utilise 1/0 ou INTEGER. SQL Server utilise BIT. DB2 utilise SMALLINT. L'outil adapte la sortie automatiquement par dialecte.
- Clause IF NOT EXISTS
- Clause facultative sur CREATE TABLE qui ignore la création lorsque la table existe déjà, évitant les erreurs lors des exécutions répétées. MySQL, PostgreSQL, SQLite et BigQuery la prennent en charge ; Oracle PL/SQL et SQL Server T-SQL ne la prennent pas en charge. L'outil émet cette clause uniquement pour les dialectes qui la prennent en charge.
- Insertion par lots
- Technique qui combine plusieurs lignes dans une seule instruction INSERT en utilisant des tuples multi-valeurs, p. ex. VALUES (1,2), (3,4), (5,6). Par rapport aux insertions ligne par ligne, cela réduit la surcharge d'analyse et les allers-retours réseau et améliore généralement les performances d'importation de 10x à 100x. L'outil utilise par défaut 100 lignes par INSERT et prend en charge 1-1000.
- sql-formatter
- Embellisseur SQL JavaScript qui prend en charge plus de 20 dialectes. Il met les mots-clés en majuscules, applique une indentation cohérente et coupe les longues lignes. L'outil utilise cette bibliothèque comme dernière étape de son pipeline pour rendre le SQL généré plus facile à lire et à éditer.
Dialectes SQL pris en charge et différences clés
Les plus de 20 dialectes SQL pris en charge par l'outil, avec leurs guillemets d'identifiant, types d'entier et représentation booléenne :
| Dialecte | Guillemet d'identifiant | Type entier | Forme booléenne | IF NOT EXISTS |
|---|---|---|---|---|
| MySQL | apostrophes inv. ` | INT | TRUE | oui |
| MariaDB | apostrophes inv. ` | INT | TRUE | oui |
| TiDB | apostrophes inv. ` | INT | TRUE | oui |
| SingleStoreDB | apostrophes inv. ` | INT | TRUE | oui |
| PostgreSQL | guillemets doubles " | INTEGER | TRUE | oui |
| Redshift | guillemets doubles " | INTEGER | TRUE | oui |
| DuckDB | guillemets doubles " | INTEGER | TRUE | oui |
| Trino | guillemets doubles " | INTEGER | TRUE | oui |
| SQLite | guillemets doubles " | INTEGER | 1/0 | oui |
| BigQuery | apostrophes inv. ` | INT64 | TRUE | oui |
| Snowflake | guillemets doubles " | NUMBER | TRUE | oui |
| DB2 | guillemets doubles " | INTEGER | 1/0 | oui |
| DB2i | guillemets doubles " | INTEGER | 1/0 | oui |
| Oracle PL/SQL | guillemets doubles " | NUMBER | 1/0 | non |
| SQL Server T-SQL | crochets [] | INT | 1/0 | non |
| Transact-SQL | crochets [] | INT | 1/0 | non |
| Spark SQL | apostrophes inv. ` | INT | TRUE | oui |
| Hive | apostrophes inv. ` | INT | TRUE | oui |
| ClickHouse | apostrophes inv. ` | Int32 | 1/0 | oui |
| N1QL (Couchbase) | apostrophes inv. ` | NUMBER | TRUE | oui |
Règles de mappage des types JSON vers SQL
L'ensemble complet des règles utilisées par la fonction detectType pour mapper les valeurs JSON aux types SQL :
| Valeur JSON | Exemple | Type SQL déduit | Règle de détection |
|---|---|---|---|
null | null | NULL | JSON null correspond à SQL NULL |
boolean | true / false | BOOLEAN | Les dialectes avec BOOLEAN natif l'utilisent ; SQLite/DB2/SQL Server utilisent 1/0 ou BIT |
entier (32 bits) | 1, 100, -9999 | INT / INTEGER | |valeur| <= 2 147 483 647 -> INT |
entier (64 bits) | 9999999999, -1234567890 | BIGINT | |valeur| > 2 147 483 647 promu à BIGINT |
flottant | 3.14, -0.5, 1e10 | FLOAT / DOUBLE / REAL | Les flottants utilisent FLOAT/DOUBLE/REAL selon le dialecte |
ISO 8601 date-time | 2024-05-20T10:30:00 | TIMESTAMP | Correspond à /^\d{4}-\d{2}-\d{2}T/ -> TIMESTAMP |
ISO 8601 date | 2024-05-20 | DATE | Correspond à /^\d{4}-\d{2}-\d{2}/ -> DATE |
chaîne courte | Alice, Paris | VARCHAR(255) | longueur <= 255 -> VARCHAR(255) |
chaîne longue | plus de 255 caractères | TEXT | longueur > 255 -> TEXT (CLOB/NVARCHAR(MAX)/STRING selon le dialecte) |
Privacy & Security
Ce convertisseur JSON en SQL s'exécute entièrement dans votre navigateur. L'analyse JSON, l'inférence de types, la génération SQL et l'embellissement SQL s'exécutent en JavaScript côté client ; rien n'est envoyé à un serveur. Les téléchargements de fichiers utilisent l'API native FileReader et ne passent jamais par un service intermédiaire. L'outil n'utilise pas de cookies de suivi et ne collecte aucune donnée d'entrée ou d'utilisation. Toutes les entrées et sorties sont effacées de la mémoire dès que la page est fermée ou rechargée. Sûr à utiliser avec du JSON contenant des données personnelles, des secrets commerciaux ou tout autre contenu sensible.
Authoritative References
- MySQLSyntaxe INSERT MySQL - documentation officielle
- PostgreSQLSyntaxe INSERT PostgreSQL - documentation officielle
- SQLiteSyntaxe INSERT SQLite - documentation officielle
- MicrosoftSyntaxe INSERT SQL Server - documentation officielle
- MDNSpécification JSON - MDN Web Docs
- WikipediaNorme de date et heure ISO 8601 - Wikipedia
- GitHubsql-formatter sur GitHub
- Compression JSON
- CSV vers JSON
- JSON vers CSV
- JSON Diff
- JSON Escape / Unescape
- JSON Flatten
- Formatage JSON
- Générateur JSON
- Requête JSONPath
- Fusionner JSON
- Réparer JSON
- Validateur JSON Schema
- Trier JSON
- JSON Stringify
- JSON vers HTML
- JSON vers Java
- JSON to Markdown
- JSON en SQL
- JSON vers TOML
- JSON vers TypeScript
- XML vers JSON
- JSON vers XML
- YAML vers JSON
- JSON vers YAML
- JSON vers Python
- JSON vers Go
- JSON vers Rust
- JSON vers Swift
- JSON vers C#
- JSON vers C++
- JSON vers PHP