JSON in SQL
Convertitore online gratuito da JSON a SQL. Converte array JSON in istruzioni INSERT e genera opzionalmente script DDL CREATE TABLE. Compatibile con MySQL, PostgreSQL, SQLite, SQL Server e oltre 20 dialetti SQL con inferenza automatica dei tipi. Elaborazione 100% nel browser.
Raccomandazioni correlate
Informazioni su JSON in SQL: spostare dati JSON in database relazionali
JSON in SQL è il processo di conversione di dati in formato JSON (array o oggetti JSON) in script SQL che un database relazionale può eseguire, nello specifico istruzioni INSERT e CREATE TABLE. JSON (JavaScript Object Notation) è un formato leggero di scambio dati usato ovunque: API REST, trasporto frontend verso backend, file di configurazione, log. I database relazionali (MySQL, PostgreSQL, SQLite, SQL Server, Oracle, ecc.) sono la spina dorsale dell'archiviazione dati aziendale, ma richiedono strutture di tabella rigide e istruzioni SQL per memorizzare e interrogare i dati. Spostare dati da JSON a un database relazionale richiede quindi di trasformare il JSON in uno script SQL.
Al centro dello strumento, ogni oggetto di un array JSON viene convertito in una riga di dati. Un singolo oggetto viene trattato come una singola riga e ogni elemento di un array JSON diventa una riga. Le chiavi dell'oggetto diventano i nomi delle colonne e i valori vengono tradotti nel letterale SQL corrispondente. L'intera conversione viene eseguita localmente nel browser, senza backend.
L'inferenza dei tipi è la sfida tecnica centrale di JSON in SQL. JSON ha solo sei tipi primitivi (null, boolean, number, string, array, object), mentre SQL ne ha decine (INT, BIGINT, FLOAT, DOUBLE, VARCHAR, TEXT, DATE, TIMESTAMP, BOOLEAN, BIT, ecc.). La funzione detectType di questo strumento esamina la forma letterale di ogni valore: null viene mappato su SQL NULL; true/false su BOOLEAN; gli interi su INT (intervallo -2.147.483.648 a 2.147.483.647) o BIGINT; i float su FLOAT/DOUBLE/REAL a seconda del dialetto; le stringhe in formato ISO 8601 su DATE e TIMESTAMP; le stringhe corte su VARCHAR(255); le stringhe più lunghe di 255 caratteri su TEXT.
Lo strumento implementa un algoritmo di promozione dei tipi: quando il tipo esistente di una colonna è in conflitto con un nuovo valore, viene promosso al tipo più ampio che li copra entrambi (ad esempio, INT viene promosso a FLOAT). NULL non è incluso in questa decisione, quindi il tipo dedotto rimane stabile. Poiché il tipo di colonna finale viene deciso dopo l'elaborazione di tutte le righe, il risultato è il tipo globalmente ottimale per il set di dati.
Le differenze di dialetto sono centralizzate in DIALECT_CONFIG. MySQL racchiude gli identificatori tra apici inversi (`name`), PostgreSQL e l'SQL standard usano le virgolette doppie ("name"), SQL Server usa le parentesi quadre ([name]). SQLite non ha un tipo BOOLEAN nativo, quindi viene usato 1/0. BigQuery usa INT64 per gli interi e STRING per il testo. Snowflake usa NUMBER per gli interi e TIMESTAMP_NTZ per i timestamp. Oracle usa VARCHAR2 e NUMBER(1) per i booleani. DB2 memorizza il testo in CLOB. Lo strumento adatta le virgolette degli identificatori, i tipi di dati e la rappresentazione booleana al dialetto scelto dall'utente.
La generazione di CREATE TABLE si basa sull'inferenza dei tipi. Quando l'utente attiva "Genera CREATE TABLE" nelle impostazioni, lo strumento emette un'istruzione CREATE TABLE prima del blocco INSERT. Il nome della tabella proviene dall'input dell'utente (predefinito `users`); i nomi delle colonne provengono dalle chiavi dell'oggetto JSON; i tipi delle colonne provengono dai tipi SQL dedotti. Per i dialetti che supportano IF NOT EXISTS, la clausola viene aggiunta automaticamente per evitare errori alla ricreazione; per i dialetti che non la supportano (Oracle PL/SQL, SQL Server T-SQL) viene omessa per compatibilità. CREATE TABLE e INSERT formano insieme uno script di inizializzazione completo che può essere eseguito in un database vuoto con una sola esecuzione.
L'inserimento in batch è la chiave delle prestazioni. Convertire 10.000 righe di JSON in 10.000 istruzioni INSERT separate è dolorosamente lento. Lo strumento supporta una dimensione del lotto configurabile (predefinita 100, intervallo 1-1000) e unisce più righe in un INSERT con tuple multivalore (VALUES (1,2), (3,4), ...). Ciò riduce drasticamente il numero di istruzioni e offre prestazioni di importazione da 10 a 100 volte superiori sulla maggior parte dei motori. La dimensione del lotto deve essere regolata per ciascun database e server, poiché un lotto troppo grande può superare max_allowed_packet su MySQL.
La tolleranza agli errori JSON è una funzionalità pratica. Lo strumento include una routine di riparazione tryFixJSON che viene eseguita quando JSON.parse fallisce; se la riparazione riesce, l'utente viene avvisato e la conversione continua. Ciò migliora drasticamente il tasso di successo nella pratica ed evita avanti e indietro infiniti per piccoli errori. Tutta l'elaborazione è lato client: nulla viene mai inviato a un server, eliminando qualsiasi rischio di fuga e rendendo la conversione praticamente istantanea per dati di medie dimensioni (meno di 10 MB).
Casi d'uso
- Converti le risposte JSON delle API in istruzioni INSERT per importare dati in blocco in MySQL, PostgreSQL o altri database relazionali per l'analisi.
- Genera DDL CREATE TABLE da una configurazione JSON o dizionario dati durante l'inizializzazione dello schema di un nuovo progetto.
- Converti mock frontend o fixture di test in script SQL per popolare ambienti di sviluppo, staging o QA.
- Migrazione dati: trasforma esportazioni JSON da MongoDB, Elasticsearch o archivi documentali in script SQL per destinazioni relazionali.
- Pre-elaborazione ETL: normalizza payload JSON a monte in istruzioni INSERT standard che le pipeline a valle possono ingerire direttamente.
- Backup e ripristino: conserva i dati aziendali critici in formato JSON portatile e rigenera script SQL su richiesta per un ripristino rapido.
- Collaborazione tra team: concorda un contratto JSON e lascia che il backend generi con un clic sia il DDL dello schema che gli script INSERT di seed.
- Insegnamento e demo: guida gli studenti attraverso il modo in cui i dati JSON mappano le istruzioni SQL, illustrando l'inferenza dei tipi e la meccanica di inserimento in batch.
Come utilizzare
- Incolla un array o un oggetto JSON nell'editor di sinistra, fai clic su Carica per caricare un file .json/.txt, o fai clic su Esempio per caricare la demo integrata.
- Scegli il dialetto SQL di destinazione dal menu a discesa nella barra degli strumenti (MySQL, PostgreSQL, SQLite, SQL Server e oltre 20).
- Fai clic su Impostazioni per configurare il nome della tabella, se emettere CREATE TABLE e la dimensione del lotto di inserimento (1-1000 righe per INSERT).
- Fai clic su Converti (o usa la scorciatoia da tastiera) per analizzare il JSON, dedurre i tipi e renderizzare l'SQL nel pannello di destra.
- Ispeziona l'SQL generato e i totali di righe/colonne nella barra di stato per verificare l'integrità dei dati.
- Fai clic su Copia per mettere l'SQL negli appunti, o fai clic su Scarica per salvarlo come file .sql (ad esempio users.sql).
- Esegui l'SQL all'interno del tuo client database preferito (Navicat, DBeaver, pgAdmin, MySQL Workbench) per completare l'importazione dei dati.
Funzionalità
- Generazione di INSERT in batch: converte array JSON in istruzioni INSERT INTO standard con dimensione del lotto configurabile (1-1000 righe per istruzione).
- Output DDL CREATE TABLE: blocco DDL opzionale con tipi dedotti automaticamente (VARCHAR, INT, BIGINT, FLOAT, BOOLEAN, TIMESTAMP, DATE, TEXT).
- 20+ dialetti SQL: MySQL, PostgreSQL, SQLite, SQL Server, Oracle, DB2, BigQuery, Snowflake, Redshift, DuckDB, ClickHouse, Trino, Spark, Hive e altri.
- Inferenza intelligente dei tipi: rileva null, booleani, interi, float, date ISO 8601 e stringhe corte o lunghe e mappa ciascuna al miglior tipo SQL.
- Formattatore SQL integrato: alimentato da sql-formatter, con parole chiave in maiuscolo, indentazione ordinata e blocchi VALUES multivalore chiari.
- Auto-riparazione JSON: corregge automaticamente virgole finali, apici singoli e virgolette di chiave mancanti per conversioni resilienti.
- Logica di promozione dei tipi: i tipi in conflitto tra righe vengono promossi al tipo compatibile più ampio (INT + FLOAT diventa FLOAT) così che il DDL non tronchi mai i dati.
- Nomi di tabella e colonna personalizzati: il nome della tabella diventa il nome del file (es. users.sql); i nomi delle colonne seguono le chiavi dell'oggetto JSON.
- Input flessibile: incolla JSON, carica un file .json/.txt o carica l'esempio integrato con un clic.
- Conteggio righe e colonne in tempo reale: la barra di stato mostra il numero totale di righe e colonne dopo la conversione per una rapida validazione.
- Copia e download: copia negli appunti con un clic o salva come file .sql standard pronto per l'importazione in qualsiasi database.
- 100% nel browser: tutta l'analisi e la trasformazione avviene in JavaScript lato client; il JSON non lascia mai il tuo dispositivo.
Domande frequenti
Come converto un array JSON in istruzioni SQL INSERT?
Incolla l'array JSON nell'editor di sinistra e lo strumento converte ogni oggetto in un'istruzione INSERT INTO. Le chiavi dell'oggetto diventano i nomi delle colonne e i valori vengono automaticamente virgolettati o mantenuti come numeri. L'SQL generato può essere copiato ed eseguito direttamente in MySQL, PostgreSQL, SQLite o qualsiasi altro client compatibile.
Lo strumento può generare script DDL CREATE TABLE da JSON?
Sì. Attiva "Genera CREATE TABLE" nel pannello delle impostazioni. Lo strumento analizza ogni campo nel JSON, deduce il tipo di dato SQL appropriato (VARCHAR, INT, BIGINT, FLOAT, BOOLEAN, TIMESTAMP, DATE, TEXT, ecc.) ed emette un'istruzione CREATE TABLE completa che insieme agli INSERT forma uno script di inizializzazione pronto all'esecuzione.
Quali dialetti SQL sono supportati?
Lo strumento supporta oltre 20 dialetti SQL principali, tra cui MySQL, MariaDB, PostgreSQL, SQLite, SQL Server (T-SQL), Oracle PL/SQL, DB2, BigQuery, Snowflake, Redshift, DuckDB, ClickHouse, Trino, Spark SQL, Hive, TiDB, SingleStoreDB e N1QL. Le virgolette degli identificatori (apici inversi, virgolette doppie, parentesi quadre), i tipi di dati (INT64, NVARCHAR, CLOB, ecc.) e la rappresentazione booleana (TRUE/FALSE vs 1/0) vengono adattati automaticamente per dialetto.
Come deduce lo strumento i tipi SQL dai valori JSON?
null viene mappato su SQL NULL; true/false su BOOLEAN (1/0 o BIT per SQLite/DB2/SQL Server); gli interi su INT o BIGINT a seconda dell'intervallo (promosso automaticamente a BIGINT quando il valore assoluto supera 2.147.483.647); i float su FLOAT/DOUBLE/REAL per dialetto; le stringhe in formato ISO 8601 vengono riconosciute come DATE e TIMESTAMP; le stringhe corte come VARCHAR(255); le stringhe più lunghe di 255 caratteri come TEXT. I tipi in conflitto tra righe vengono promossi automaticamente (ad esempio, INT + FLOAT diventa FLOAT).
L'SQL generato può essere eseguito direttamente nel mio database?
Sì. L'SQL generato è pienamente conforme allo standard del dialetto scelto e può essere eseguito in MySQL Workbench, Navicat, DBeaver, pgAdmin, SQL Server Management Studio, phpMyAdmin o qualsiasi altro strumento di gestione database. I file scaricati sono denominati in base alla tabella (ad esempio users.sql) per facilitare l'importazione in batch.
Cosa succede se il mio JSON ha errori di sintassi?
Se il JSON contiene virgole finali, virgolette mancanti o apici singoli al posto di quelli doppi, lo strumento invoca automaticamente la funzione di riparazione tryFixJSON e prosegue la conversione. Se la riparazione non riesce, il pannello di destra mostra l'ubicazione esatta dell'errore. Per JSON profondamente annidati o molto danneggiati, esegui prima lo strumento JSON Formatter.
Lo strumento supporta l'inserimento in batch? Quante righe per INSERT?
Sì. Per impostazione predefinita ogni INSERT raggruppa 100 righe, configurabile da 1 a 1000. Convertire 10.000 righe JSON produce 100 istruzioni INSERT multivalore. Rispetto agli inserimenti riga per riga, le prestazioni di importazione sono tipicamente da 10 a 100 volte superiori su MySQL, PostgreSQL e motori simili.
I miei dati JSON vengono caricati su un server?
No. Questa è un'applicazione puramente lato client. Tutta l'analisi JSON, l'inferenza dei tipi e la generazione SQL avvengono nel motore JavaScript del browser; nulla viene inviato a un server. I caricamenti di file usano l'API nativa FileReader e tutti i dati vengono cancellati dalla memoria al ricaricamento della pagina. Puoi elaborare in sicurezza JSON contenenti dati personali o segreti aziendali.
Le stringhe di data ISO 8601 vengono rilevate automaticamente?
Sì. Lo strumento riconosce due pattern ISO 8601: le stringhe con il separatore T (ad esempio 2024-05-20T10:30:00) vengono mappate su TIMESTAMP; le stringhe di sola data (ad esempio 2024-05-20) vengono mappate su DATE. Le stringhe che non seguono ISO 8601 (ad esempio 2024/05/20 o May 20, 2024) vengono trattate come semplici valori VARCHAR.
Quanto è grande il file JSON che lo strumento può gestire?
Non c'è un limite rigido; il limite pratico è la memoria del browser. File fino a 10 MB (decine di migliaia di righe) funzionano senza problemi. File più grandi possono rallentare con l'aumentare della pressione di memoria. Per set di dati molto grandi, suddividi in batch più piccoli o disattiva il passaggio opzionale di abbellimento nel formattatore SQL.
L'SQL generato viene formattato automaticamente?
Sì. Lo strumento utilizza la libreria sql-formatter per abbellire l'output: le parole chiave sono in maiuscolo (SELECT, INSERT INTO, VALUES, CREATE TABLE), ogni record è su una propria riga, l'indentazione è coerente e le righe vuote sono mantenute per la leggibilità. Il risultato è facile da leggere in qualsiasi client database e facile da modificare manualmente in seguito.
Posso controllare l'ordine delle colonne dell'INSERT generato?
Per impostazione predefinita lo strumento utilizza l'ordine delle chiavi nel primo oggetto dell'array JSON, mantenendo allineato l'output multi-riga. Se oggetti diversi hanno ordini di chiavi diversi, lo strumento unisce e deduplica tutte le chiavi e riempie i valori mancanti con NULL. Per risultati migliori, normalizza il JSON con lo strumento JSON Formatter prima della conversione.
Risoluzione dei problemi
Il pannello di destra mostra solo "No valid objects found in JSON".
Causa 1: il livello superiore del JSON non è né un array né un oggetto (ad esempio una stringa o un numero sciolto), quindi non c'è nulla da convertire in righe. Soluzione: avvolgi il JSON in un array [{...}] o un oggetto {...}. Causa 2: l'array contiene valori primitivi ([1, 2, 3]) invece di oggetti, quindi non ci sono nomi di chiave da mappare alle colonne. Soluzione: ogni elemento dell'array deve essere un oggetto con coppie chiave-valore. Causa 3: il JSON non è stato analizzato, è stata eseguita tryFixJSON e il risultato della riparazione non è ancora un oggetto. Soluzione: valida il JSON con lo strumento JSON Formatter per trovare il problema di sintassi.
L'SQL generato genera un errore di sintassi nel mio database.
Causa 1: è selezionato il dialetto sbagliato (ad esempio MySQL selezionato ma il target è PostgreSQL), quindi lo stile delle virgolette dell'identificatore non corrisponde. Soluzione: scegli il dialetto corretto nel menu a discesa. Causa 2: il nome della tabella o della colonna è in collisione con una parola riservata SQL (order, user, select, ecc.). Soluzione: rinomina la tabella nelle impostazioni o racchiudi manualmente il nome tra apici inversi o parentesi quadre. Causa 3: la dimensione del lotto è troppo grande e supera il max_allowed_packet del database o un limite simile. Soluzione: riduci la dimensione del lotto (ad esempio a 50) nelle impostazioni.
Un campo data è stato rilevato come VARCHAR invece di DATE o TIMESTAMP.
Causa: la stringa di data non è in formato ISO 8601. Lo strumento riconosce solo YYYY-MM-DD (DATE) e YYYY-MM-DDTHH:mm:ss (TIMESTAMP). Formati comuni che non riconoscerà: YYYY/MM/DD, DD-MM-YYYY, "May 20 2024" e timestamp Unix come 1715644800. Soluzione: converti prima la data in ISO 8601 nel JSON, o modifica manualmente il tipo di colonna CREATE TABLE in DATE o VARCHAR dopo la conversione.
I booleani appaiono come 1/0 in SQLite/DB2 ma voglio TRUE/FALSE.
Causa: SQLite, DB2 e SQL Server non hanno un tipo BOOLEAN nativo, quindi lo standard del dialetto usa 1/0 (o BIT). Soluzione: opzione 1, accetta 1/0 come rappresentazione standard (1 significa TRUE, 0 significa FALSE); opzione 2, converti il valore nel livello applicativo (1 in true, 0 in false); opzione 3, post-elabora l'SQL sostituendo 1/0 con TRUE/FALSE e cambia il tipo di colonna in INTEGER per leggerlo come booleano nel tuo codice. Lo strumento segue sempre lo standard del dialetto e non offre un'opzione non standard.
Il JSON contiene oggetti o array annidati. Quali tipi di colonna vengono prodotti?
I valori non primitivi (oggetti e array annidati) vengono serializzati in stringhe JSON e memorizzati come TEXT. Ad esempio {"tags": ["a", "b"], "profile": {"age": 30}} produce due colonne: tags TEXT e profile TEXT, entrambe contenenti JSON serializzato. Al momento dell'interrogazione puoi usare JSON_EXTRACT (MySQL 5.7+) o funzioni JSON simili per estrarre campi annidati. Per normalizzare completamente i dati annidati in tabelle relazionali separate, gestiscilo nel livello applicativo o usa uno strumento ETL dedicato.
I caratteri cinesi appaiono illeggibili dopo l'importazione del file .sql scaricato.
Causa: il file .sql è codificato in UTF-8, ma il client del database o il database stesso non è configurato in UTF-8. Soluzione: opzione 1, imposta il set di caratteri del database su utf8mb4 (MySQL) o UTF8 (PostgreSQL). Opzione 2, specifica il set di caratteri sulla connessione client (ad esempio MySQL CLI con --default-character-set=utf8mb4). Opzione 3, apri il file .sql in un editor di testo e conferma che la codifica è UTF-8 (non GBK o altro). Lo strumento produce sempre file .sql in UTF-8.
Glossario
- JSON (JavaScript Object Notation)
- Formato leggero di scambio dati basato sulla sintassi degli oggetti JavaScript ma indipendente da qualsiasi linguaggio di programmazione. Supporta sei tipi di base: oggetto ({}), array ([]), stringa, numero, booleano e null. Ampiamente utilizzato per API REST, trasporto frontend-backend, file di configurazione e log.
- SQL (Structured Query Language)
- Linguaggio standard per database relazionali (MySQL, PostgreSQL, SQLite, SQL Server, Oracle, ecc.). Include DDL (definizione dati, es. CREATE TABLE), DML (manipolazione dati, es. INSERT), DQL (interrogazione dati, es. SELECT) e DCL (controllo dati).
- Istruzione INSERT
- Istruzione DML che aggiunge righe a una tabella; la sintassi è INSERT INTO table_name (col1, col2) VALUES (val1, val2). Supporta sia tuple a valore singolo sia tuple multivalore (un INSERT per molte righe); queste ultime migliorano drasticamente le prestazioni di importazione in batch.
- Istruzione CREATE TABLE
- Istruzione DDL che crea una tabella definendone nome, colonne, tipi di dati e vincoli (NOT NULL, PRIMARY KEY, UNIQUE, DEFAULT, ecc.). Il CREATE TABLE generato da questo strumento omette chiavi primarie, chiavi esterne e indici per rimanere pulito e prevedibile.
- Dialetto SQL
- Le differenze di implementazione tra i fornitori di database per lo standard SQL. MySQL usa gli apici inversi, PostgreSQL usa le virgolette doppie, SQL Server usa le parentesi quadre; SQLite non ha BOOLEAN nativo e usa 1/0; Oracle usa VARCHAR2; BigQuery usa INT64 e STRING. Lo stesso SQL logico può avere sintassi diversa tra dialetti.
- DDL (Data Definition Language)
- Sotto-linguaggio SQL che include le istruzioni CREATE, ALTER e DROP, utilizzato per definire e modificare le strutture del database (tabelle, viste, indici, vincoli, ecc.). L'output CREATE TABLE di questo strumento è un'istruzione DDL.
- DML (Data Manipulation Language)
- Sotto-linguaggio SQL che include le istruzioni INSERT, UPDATE e DELETE, utilizzato per manipolare le righe di dati nelle tabelle. L'output INSERT INTO di questo strumento è un'istruzione DML.
- Inferenza dei tipi
- Il processo di dedurre automaticamente il tipo di un valore dalla sua forma letterale. Lo strumento esamina il typeof di ogni valore JSON (null, boolean, number, string) insieme alla sua forma specifica (data ISO 8601, lunghezza stringa) per mapparlo al tipo SQL più appropriato.
- Virgolette dell'identificatore
- Caratteri speciali che racchiudono i nomi di tabelle e colonne in SQL. MySQL usa apici inversi come `name`, PostgreSQL e SQL standard usano virgolette doppie come "name", SQL Server usa parentesi quadre come [name]. Sono usate per far escape delle parole riservate e controllare la sensibilità alle maiuscole.
- Formato data ISO 8601
- Standard internazionale per rappresentare date e ore. Il formato è YYYY-MM-DD per le date e YYYY-MM-DDTHH:mm:ss per le date con ora. Le stringhe che corrispondono a questi pattern vengono automaticamente mappate ai tipi SQL DATE e TIMESTAMP da questo strumento.
- VARCHAR e TEXT
- Due tipi SQL per stringhe di lunghezza variabile. VARCHAR(n) ha un limite di lunghezza (comunemente fino a 65.535 byte) ed è adatto per stringhe corte come nomi, email e titoli. TEXT non ha limite di lunghezza (o ne ha uno molto grande) ed è adatto per contenuti lunghi. Per impostazione predefinita, questo strumento mappa stringhe di 255 caratteri o meno a VARCHAR(255) e stringhe più lunghe a TEXT.
- INT e BIGINT
- Due tipi SQL per gli interi. INT (INTEGER) è normalmente un intero con segno a 32 bit nell'intervallo da -2.147.483.648 a 2.147.483.647. BIGINT è un intero con segno a 64 bit con un intervallo molto più ampio. Lo strumento promuove automaticamente a BIGINT gli interi il cui valore assoluto supera l'intervallo di INT.
- Tipo BOOLEAN
- Tipo SQL per valori di verità. MySQL, PostgreSQL e BigQuery supportano BOOLEAN nativamente (memorizzano TRUE/FALSE). SQLite non ha BOOLEAN nativo e usa 1/0 o INTEGER. SQL Server usa BIT. DB2 usa SMALLINT. Lo strumento adatta l'output automaticamente per dialetto.
- Clausola IF NOT EXISTS
- Clausola opzionale su CREATE TABLE che salta la creazione quando la tabella esiste già, evitando errori nelle esecuzioni ripetute. MySQL, PostgreSQL, SQLite e BigQuery la supportano; Oracle PL/SQL e SQL Server T-SQL no. Lo strumento emette questa clausola solo per i dialetti che la supportano.
- Inserimento in batch
- Tecnica che combina molte righe in una singola istruzione INSERT usando tuple multivalore, es. VALUES (1,2), (3,4), (5,6). Rispetto agli inserimenti riga per riga, riduce l'overhead di analisi e i round-trip di rete e tipicamente migliora le prestazioni di importazione di 10x-100x. Lo strumento usa per impostazione predefinita 100 righe per INSERT e supporta 1-1000.
- sql-formatter
- Abbellitore SQL JavaScript che supporta oltre 20 dialetti. Mette le parole chiave in maiuscolo, applica indentazione coerente e spezza le righe lunghe. Lo strumento usa questa libreria come ultimo passaggio del suo pipeline per rendere l'SQL generato più facile da leggere e modificare.
Dialetti SQL supportati e differenze chiave
Gli oltre 20 dialetti SQL supportati dallo strumento, con le loro virgolette identificative, tipi di intero e rappresentazione booleana:
| Dialetto | Virgolette identificativo | Tipo intero | Forma booleana | IF NOT EXISTS |
|---|---|---|---|---|
| MySQL | apici inversi ` | INT | TRUE | sì |
| MariaDB | apici inversi ` | INT | TRUE | sì |
| TiDB | apici inversi ` | INT | TRUE | sì |
| SingleStoreDB | apici inversi ` | INT | TRUE | sì |
| PostgreSQL | virgolette doppie " | INTEGER | TRUE | sì |
| Redshift | virgolette doppie " | INTEGER | TRUE | sì |
| DuckDB | virgolette doppie " | INTEGER | TRUE | sì |
| Trino | virgolette doppie " | INTEGER | TRUE | sì |
| SQLite | virgolette doppie " | INTEGER | 1/0 | sì |
| BigQuery | apici inversi ` | INT64 | TRUE | sì |
| Snowflake | virgolette doppie " | NUMBER | TRUE | sì |
| DB2 | virgolette doppie " | INTEGER | 1/0 | sì |
| DB2i | virgolette doppie " | INTEGER | 1/0 | sì |
| Oracle PL/SQL | virgolette doppie " | NUMBER | 1/0 | no |
| SQL Server T-SQL | parentesi quadre [] | INT | 1/0 | no |
| Transact-SQL | parentesi quadre [] | INT | 1/0 | no |
| Spark SQL | apici inversi ` | INT | TRUE | sì |
| Hive | apici inversi ` | INT | TRUE | sì |
| ClickHouse | apici inversi ` | Int32 | 1/0 | sì |
| N1QL (Couchbase) | apici inversi ` | NUMBER | TRUE | sì |
Regole di mappatura dei tipi JSON in SQL
L'insieme completo di regole utilizzate dalla funzione detectType per mappare i valori JSON ai tipi SQL:
| Valore JSON | Esempio | Tipo SQL dedotto | Regola di rilevamento |
|---|---|---|---|
null | null | NULL | JSON null viene mappato su SQL NULL |
boolean | true / false | BOOLEAN | I dialetti con BOOLEAN nativo lo usano; SQLite/DB2/SQL Server usano 1/0 o BIT |
intero (32 bit) | 1, 100, -9999 | INT / INTEGER | |valore| <= 2.147.483.647 -> INT |
intero (64 bit) | 9999999999, -1234567890 | BIGINT | |valore| > 2.147.483.647 promosso a BIGINT |
float | 3.14, -0.5, 1e10 | FLOAT / DOUBLE / REAL | I float usano FLOAT/DOUBLE/REAL per dialetto |
ISO 8601 date-time | 2024-05-20T10:30:00 | TIMESTAMP | Corrisponde a /^\d{4}-\d{2}-\d{2}T/ -> TIMESTAMP |
ISO 8601 date | 2024-05-20 | DATE | Corrisponde a /^\d{4}-\d{2}-\d{2}/ -> DATE |
stringa corta | Alice, Roma | VARCHAR(255) | lunghezza <= 255 -> VARCHAR(255) |
stringa lunga | più di 255 caratteri | TEXT | lunghezza > 255 -> TEXT (CLOB/NVARCHAR(MAX)/STRING per dialetto) |
Privacy & Security
Questo convertitore da JSON a SQL viene eseguito interamente nel tuo browser. L'analisi JSON, l'inferenza dei tipi, la generazione SQL e l'abbellimento SQL vengono eseguiti in JavaScript lato client; nulla viene inviato a un server. I caricamenti di file usano l'API nativa FileReader e non passano mai attraverso un servizio intermedio. Lo strumento non usa cookie di tracciamento e non raccoglie dati di input o utilizzo. Tutti gli input e gli output vengono cancellati dalla memoria non appena la pagina viene chiusa o ricaricata. Sicuro da usare con JSON contenenti dati personali, segreti aziendali o qualsiasi altro contenuto sensibile.
Authoritative References
- MySQLSintassi INSERT MySQL - documentazione ufficiale
- PostgreSQLSintassi INSERT PostgreSQL - documentazione ufficiale
- SQLiteSintassi INSERT SQLite - documentazione ufficiale
- MicrosoftSintassi INSERT SQL Server - documentazione ufficiale
- MDNSpecifica JSON - MDN Web Docs
- WikipediaStandard di data e ora ISO 8601 - Wikipedia
- GitHubsql-formatter su GitHub
- Compressione JSON
- CSV in JSON
- JSON to CSV
- JSON Diff
- JSON Escape / Unescape
- Appiattimento JSON
- Formattatore JSON
- Generatore JSON
- Query JSONPath
- Unire JSON
- Riparare JSON
- Validatore di Schema JSON
- Ordinare JSON
- JSON Stringify
- JSON in HTML
- JSON in Java
- JSON to Markdown
- JSON in SQL
- JSON in TOML
- JSON in TypeScript
- XML in JSON
- JSON in XML
- YAML in JSON
- Da JSON a YAML
- JSON in Python
- JSON in Go
- JSON in Rust
- JSON in Swift
- JSON a C#
- JSON a C++
- JSON to PHP