JSON para SQL

Clique para converter JSON em instruções SQL INSERT

Conversor online gratuito de JSON para SQL. Converte arrays JSON em instruções INSERT e opcionalmente gera scripts DDL CREATE TABLE. Compatível com MySQL, PostgreSQL, SQLite, SQL Server e mais de 20 dialetos SQL com inferência automática de tipos. Processamento 100% no navegador.

Sugestões Relacionadas

Conversor de SQL

Formatador SQL

JSON para CSV

JSON para YAML

Formatador JSON

Consulta JSONPath

Sobre JSON para SQL: movendo dados JSON para bancos de dados relacionais

JSON para SQL é o processo de converter dados em formato JSON (arrays ou objetos JSON) em scripts SQL que um banco de dados relacional pode executar, especificamente instruções INSERT e CREATE TABLE. JSON (JavaScript Object Notation) é um formato leve de troca de dados usado em todo lugar: APIs REST, transporte frontend para backend, arquivos de configuração, logs. Bancos de dados relacionais (MySQL, PostgreSQL, SQLite, SQL Server, Oracle, etc.) são a espinha dorsal do armazenamento de dados empresarial, mas requerem estruturas de tabela rígidas e instruções SQL para armazenar e consultar dados. Mover dados de JSON para um banco de dados relacional requer, portanto, transformar o JSON em um script SQL.

No núcleo da ferramenta, cada objeto de um array JSON é convertido em uma linha de dados. Um único objeto é tratado como uma única linha e cada elemento de um array JSON se torna uma linha. As chaves do objeto se tornam os nomes das colunas e os valores são traduzidos para o literal SQL correspondente. Toda a conversão é executada localmente no navegador, sem backend.

A inferência de tipos é o desafio técnico central de JSON para SQL. JSON tem apenas seis tipos primitivos (null, boolean, number, string, array, object), enquanto SQL tem dezenas (INT, BIGINT, FLOAT, DOUBLE, VARCHAR, TEXT, DATE, TIMESTAMP, BOOLEAN, BIT, etc.). A função detectType desta ferramenta examina a forma literal de cada valor: null é mapeado para SQL NULL; true/false para BOOLEAN; inteiros para INT (faixa -2.147.483.648 a 2.147.483.647) ou BIGINT; floats para FLOAT/DOUBLE/REAL dependendo do dialeto; strings no formato ISO 8601 para DATE e TIMESTAMP; strings curtas para VARCHAR(255); strings maiores que 255 caracteres para TEXT.

A ferramenta implementa um algoritmo de promoção de tipos: quando o tipo existente de uma coluna entra em conflito com um novo valor, ele é promovido ao tipo mais amplo que cubra ambos (por exemplo, INT é promovido para FLOAT). NULL não é incluído nessa decisão, então o tipo deduzido permanece estável. Como o tipo de coluna final é decidido após o processamento de todas as linhas, o resultado é o tipo globalmente ótimo para o conjunto de dados.

As diferenças de dialeto são centralizadas em DIALECT_CONFIG. MySQL envolve os identificadores entre crases (`name`), PostgreSQL e o SQL padrão usam aspas duplas ("name"), SQL Server usa colchetes ([name]). SQLite não tem um tipo BOOLEAN nativo, então é usado 1/0. BigQuery usa INT64 para inteiros e STRING para texto. Snowflake usa NUMBER para inteiros e TIMESTAMP_NTZ para timestamps. Oracle usa VARCHAR2 e NUMBER(1) para booleanos. DB2 armazena texto em CLOB. A ferramenta adapta as aspas de identificador, os tipos de dados e a representação booleana ao dialeto escolhido pelo usuário.

A geração de CREATE TABLE se baseia na inferência de tipos. Quando o usuário ativa "Gerar CREATE TABLE" nas configurações, a ferramenta emite uma instrução CREATE TABLE antes do bloco INSERT. O nome da tabela vem da entrada do usuário (padrão `users`); os nomes das colunas vêm das chaves do objeto JSON; os tipos das colunas vêm dos tipos SQL deduzidos. Para dialetos que suportam IF NOT EXISTS, a cláusula é adicionada automaticamente para evitar erros na recriação; para dialetos que não suportam (Oracle PL/SQL, SQL Server T-SQL), ela é omitida por compatibilidade. CREATE TABLE e INSERT juntos formam um script de inicialização completo que pode ser executado em um banco de dados vazio em uma única execução.

A inserção em lote é a chave do desempenho. Converter 10.000 linhas de JSON em 10.000 instruções INSERT separadas é dolorosamente lento. A ferramenta suporta um tamanho de lote configurável (padrão 100, faixa 1-1000) e mescla várias linhas em um INSERT com tuplas multivalor (VALUES (1,2), (3,4), ...). Isso reduz drasticamente o número de instruções e oferece um desempenho de importação 10 a 100 vezes maior na maioria dos mecanismos. O tamanho do lote deve ser ajustado para cada banco de dados e servidor, pois um lote muito grande pode exceder o max_allowed_packet no MySQL.

A tolerância a erros JSON é um recurso prático. A ferramenta inclui uma rotina de reparo tryFixJSON que é executada quando JSON.parse falha; se o reparo for bem-sucedido, o usuário é notificado e a conversão continua. Isso melhora drasticamente a taxa de sucesso na prática e evita idas e vindas intermináveis por pequenos erros. Todo o processamento é do lado do cliente: nada é enviado a um servidor, eliminando qualquer risco de vazamento e tornando a conversão praticamente instantânea para dados de tamanho médio (menos de 10 MB).

Casos de uso

Converta respostas JSON de API em instruções INSERT para importar dados em massa no MySQL, PostgreSQL ou outros bancos de dados relacionais para análise.
Gere DDL CREATE TABLE a partir de uma configuração JSON ou dicionário de dados ao inicializar o esquema de um novo projeto.
Converta mocks de frontend ou fixtures de teste em scripts SQL para semear ambientes de desenvolvimento, staging ou QA.
Migração de dados: transforme exportações JSON de MongoDB, Elasticsearch ou armazenamentos de documentos em scripts SQL para destinos relacionais.
Pré-processamento ETL: normalize payloads JSON upstream em instruções INSERT padrão que os pipelines downstream podem ingerir diretamente.
Backup e recuperação: mantenha dados críticos de negócios em formato JSON portátil e regenere scripts SQL sob demanda para restauração rápida.
Colaboração entre equipes: combine um contrato JSON e deixe o backend gerar com um clique tanto o DDL de esquema quanto os scripts INSERT de seed.
Ensino e demos: guie os alunos por meio de como os dados JSON mapeiam para instruções SQL, ilustrando a inferência de tipos e a mecânica de inserção em lote.

Como Usar

Cole um array ou objeto JSON no editor à esquerda, clique em Upload para carregar um arquivo .json/.txt, ou clique em Amostra para carregar a demo integrada.
Escolha o dialeto SQL de destino no menu suspenso da barra de ferramentas (MySQL, PostgreSQL, SQLite, SQL Server e mais de 20).
Clique em Configurações para configurar o nome da tabela, se deve emitir CREATE TABLE e o tamanho do lote de inserção (1-1000 linhas por INSERT).
Clique em Converter (ou use o atalho de teclado) para analisar o JSON, deduzir tipos e renderizar o SQL no painel direito.
Inspecione o SQL gerado e os totais de linhas/colunas na barra de status para verificar a integridade dos dados.
Clique em Copiar para colocar o SQL na área de transferência, ou clique em Baixar para salvá-lo como arquivo .sql (por exemplo, users.sql).
Execute o SQL dentro do seu cliente de banco de dados preferido (Navicat, DBeaver, pgAdmin, MySQL Workbench) para completar a importação dos dados.

Recursos

Geração de INSERT em lote: converte arrays JSON em instruções INSERT INTO padrão com tamanho de lote configurável (1-1000 linhas por instrução).
Saída DDL CREATE TABLE: bloco DDL opcional com tipos auto-deduzidos (VARCHAR, INT, BIGINT, FLOAT, BOOLEAN, TIMESTAMP, DATE, TEXT).
20+ dialetos SQL: MySQL, PostgreSQL, SQLite, SQL Server, Oracle, DB2, BigQuery, Snowflake, Redshift, DuckDB, ClickHouse, Trino, Spark, Hive e mais.
Inferência inteligente de tipos: detecta null, booleanos, inteiros, floats, datas ISO 8601 e strings curtas ou longas e mapeia cada uma ao melhor tipo SQL.
Formatador SQL integrado: alimentado por sql-formatter, com palavras-chave em maiúsculas, indentação limpa e blocos VALUES multivalor claros.
Auto-reparo de JSON: corrige automaticamente vírgulas finais, aspas simples e aspas de chave ausentes para manter as conversões resilientes.
Lógica de promoção de tipos: tipos em conflito entre linhas são promovidos ao tipo compatível mais amplo (INT + FLOAT se torna FLOAT) para que o DDL nunca trunque dados.
Nomes de tabela e coluna personalizados: o nome da tabela se torna o nome do arquivo (p. ex., users.sql); os nomes das colunas seguem as chaves do objeto JSON.
Entrada flexível: cole JSON, carregue um arquivo .json/.txt ou carregue a amostra integrada com um clique.
Contagem de linhas e colunas ao vivo: a barra de status mostra o número total de linhas e colunas após a conversão para validação rápida.
Copiar e baixar: copie para a área de transferência com um clique ou salve como arquivo .sql padrão pronto para importar em qualquer banco de dados.
100% no navegador: toda a análise e transformação acontece em JavaScript do lado do cliente; o JSON nunca sai do seu dispositivo.

Perguntas frequentes

Como converto um array JSON em instruções SQL INSERT?

Cole o array JSON no editor à esquerda e a ferramenta converte cada objeto em uma instrução INSERT INTO. As chaves do objeto se tornam os nomes das colunas e os valores são automaticamente colocados entre aspas ou mantidos como números. O SQL gerado pode ser copiado e executado diretamente no MySQL, PostgreSQL, SQLite ou em qualquer cliente compatível.

A ferramenta pode gerar scripts DDL CREATE TABLE a partir do JSON?

Sim. Ative "Gerar CREATE TABLE" no painel de configurações. A ferramenta analisa cada campo do JSON, deduz o tipo de dado SQL apropriado (VARCHAR, INT, BIGINT, FLOAT, BOOLEAN, TIMESTAMP, DATE, TEXT, etc.) e emite uma instrução CREATE TABLE completa que, junto com os INSERTs, forma um script de inicialização pronto para executar.

Quais dialetos SQL são suportados?

A ferramenta suporta mais de 20 dialetos SQL principais, incluindo 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. As aspas de identificador (crase, aspas duplas, colchetes), os tipos de dados (INT64, NVARCHAR, CLOB, etc.) e a representação booleana (TRUE/FALSE vs 1/0) são adaptados automaticamente por dialeto.

Como a ferramenta deduz os tipos SQL a partir dos valores JSON?

null é mapeado para SQL NULL; true/false para BOOLEAN (1/0 ou BIT para SQLite/DB2/SQL Server); inteiros para INT ou BIGINT dependendo da faixa (promovido automaticamente para BIGINT quando o valor absoluto excede 2.147.483.647); floats para FLOAT/DOUBLE/REAL por dialeto; strings no formato ISO 8601 são reconhecidas como DATE e TIMESTAMP; strings curtas como VARCHAR(255); strings maiores que 255 caracteres como TEXT. Tipos em conflito entre linhas são promovidos automaticamente (por exemplo, INT + FLOAT se torna FLOAT).

O SQL gerado pode ser executado diretamente no meu banco de dados?

Sim. O SQL gerado é totalmente padrão para o dialeto escolhido e pode ser executado no MySQL Workbench, Navicat, DBeaver, pgAdmin, SQL Server Management Studio, phpMyAdmin ou qualquer outra ferramenta de gerenciamento de banco de dados. Os arquivos baixados são nomeados de acordo com a tabela (por exemplo, users.sql) para facilitar a importação em lote.

O que acontece se meu JSON tiver erros de sintaxe?

Se o JSON contiver vírgulas finais, aspas ausentes ou aspas simples em vez de duplas, a ferramenta invoca automaticamente a função de reparo tryFixJSON e continua a conversão. Se o reparo falhar, o painel direito mostra o local exato do erro. Para JSON profundamente aninhado ou muito danificado, execute primeiro a ferramenta JSON Formatter.

A ferramenta suporta inserção em lote? Quantas linhas por INSERT?

Sim. Por padrão, cada INSERT agrupa 100 linhas, configurável de 1 a 1000. Converter 10.000 linhas JSON produz 100 instruções INSERT multivalor. Comparado com inserções linha a linha, o desempenho de importação é tipicamente 10 a 100 vezes maior no MySQL, PostgreSQL e mecanismos similares.

Meus dados JSON são enviados para um servidor?

Não. Esta é uma aplicação puramente do lado do cliente. Toda a análise JSON, inferência de tipos e geração SQL acontecem no motor JavaScript do navegador; nada é enviado para um servidor. Os uploads de arquivos usam a API nativa FileReader e todos os dados são apagados da memória ao recarregar a página. Você pode processar com segurança JSON contendo dados pessoais ou segredos comerciais.

Strings de data ISO 8601 são detectadas automaticamente?

Sim. A ferramenta reconhece dois padrões ISO 8601: strings com o separador T (por exemplo 2024-05-20T10:30:00) são mapeadas para TIMESTAMP; strings apenas de data (por exemplo 2024-05-20) para DATE. Strings que não seguem ISO 8601 (por exemplo 2024/05/20 ou May 20, 2024) são tratadas como valores VARCHAR normais.

Qual o tamanho de arquivo JSON que a ferramenta pode manipular?

Não há um limite rígido; o limite prático é a memória do navegador. Arquivos de até 10 MB (dezenas de milhares de linhas) funcionam sem problemas. Arquivos maiores podem ficar lentos à medida que a pressão de memória aumenta. Para conjuntos de dados muito grandes, divida-os em lotes menores ou desative a etapa opcional de embelezamento no formatador SQL.

O SQL gerado é formatado automaticamente?

Sim. A ferramenta usa a biblioteca sql-formatter para embelezar a saída: as palavras-chave ficam em maiúsculas (SELECT, INSERT INTO, VALUES, CREATE TABLE), cada registro fica em sua própria linha, a indentação é consistente e as linhas em branco são preservadas para legibilidade. O resultado é fácil de ler em qualquer cliente de banco de dados e fácil de editar manualmente depois.

Posso controlar a ordem das colunas do INSERT gerado?

Por padrão, a ferramenta usa a ordem das chaves no primeiro objeto do array JSON, mantendo a saída multilinha alinhada. Se objetos diferentes tiverem ordens de chaves diferentes, a ferramenta mescla e deduplica todas as chaves e preenche os valores ausentes com NULL. Para melhores resultados, normalize o JSON com a ferramenta JSON Formatter antes da conversão.

Solução de Problemas

O painel direito mostra apenas "No valid objects found in JSON".

Causa 1: o nível superior do JSON não é nem um array nem um objeto (por exemplo, uma string ou número solto), portanto não há nada para converter em linhas. Solução: envolva o JSON em um array [{...}] ou objeto {...}. Causa 2: o array contém valores primitivos ([1, 2, 3]) em vez de objetos, então não há nomes de chave para mapear para colunas. Solução: cada elemento do array deve ser um objeto com pares chave-valor. Causa 3: o JSON não pôde ser analisado, tryFixJSON foi executado e o resultado do reparo ainda não é um objeto. Solução: valide o JSON com a ferramenta JSON Formatter para encontrar o problema de sintaxe.

O SQL gerado gera um erro de sintaxe no meu banco de dados.

Causa 1: o dialeto errado está selecionado (por exemplo, MySQL selecionado mas o destino é PostgreSQL), então o estilo de aspas do identificador não corresponde. Solução: escolha o dialeto correto no menu suspenso. Causa 2: o nome da tabela ou coluna colide com uma palavra reservada SQL (order, user, select, etc.). Solução: renomeie a tabela nas configurações ou envolva manualmente o nome entre crases ou colchetes. Causa 3: o tamanho do lote é muito grande e excede o max_allowed_packet do banco de dados ou um limite similar. Solução: reduza o tamanho do lote (por exemplo, para 50) nas configurações.

Um campo de data foi detectado como VARCHAR em vez de DATE ou TIMESTAMP.

Causa: a string de data não está no formato ISO 8601. A ferramenta só reconhece YYYY-MM-DD (DATE) e YYYY-MM-DDTHH:mm:ss (TIMESTAMP). Formatos comuns que ela não reconhecerá: YYYY/MM/DD, DD-MM-YYYY, "May 20 2024" e timestamps Unix como 1715644800. Solução: converta a data para ISO 8601 no JSON primeiro, ou edite manualmente o tipo de coluna CREATE TABLE para DATE ou VARCHAR após a conversão.

Os booleanos aparecem como 1/0 no SQLite/DB2 mas eu quero TRUE/FALSE.

Causa: SQLite, DB2 e SQL Server não têm um tipo BOOLEAN nativo, então o padrão do dialeto usa 1/0 (ou BIT). Solução: opção 1, aceite 1/0 como representação padrão (1 significa TRUE, 0 significa FALSE); opção 2, converta o valor na camada de aplicação (1 para true, 0 para false); opção 3, pós-processe o SQL substituindo 1/0 por TRUE/FALSE e mude o tipo de coluna para INTEGER para lê-lo como booleano no seu código. A ferramenta sempre segue o padrão do dialeto e não oferece uma opção não padrão.

O JSON contém objetos ou arrays aninhados. Quais tipos de coluna são produzidos?

Valores não primitivos (objetos e arrays aninhados) são serializados em strings JSON e armazenados como TEXT. Por exemplo {"tags": ["a", "b"], "profile": {"age": 30}} produz duas colunas: tags TEXT e profile TEXT, ambas contendo JSON serializado. Ao consultar, você pode usar JSON_EXTRACT (MySQL 5.7+) ou funções JSON semelhantes para extrair campos aninhados. Para normalizar completamente os dados aninhados em tabelas relacionais separadas, gerencie isso na camada de aplicação ou use uma ferramenta ETL dedicada.

Os caracteres chineses aparecem ilegíveis após importar o arquivo .sql baixado.

Causa: o arquivo .sql é codificado em UTF-8, mas o cliente do banco de dados ou o próprio banco de dados não está configurado em UTF-8. Solução: opção 1, defina o conjunto de caracteres do banco de dados como utf8mb4 (MySQL) ou UTF8 (PostgreSQL). Opção 2, especifique o conjunto de caracteres na conexão do cliente (por exemplo, MySQL CLI com --default-character-set=utf8mb4). Opção 3, abra o arquivo .sql em um editor de texto e confirme que a codificação é UTF-8 (não GBK ou outra). A ferramenta sempre produz arquivos .sql em UTF-8.

Glossário

JSON (JavaScript Object Notation): Formato leve de troca de dados baseado na sintaxe de objetos JavaScript, mas independente de qualquer linguagem de programação. Suporta seis tipos básicos: objeto ({}), array ([]), string, número, booleano e null. Amplamente usado em APIs REST, transporte frontend-backend, arquivos de configuração e logs.
SQL (Structured Query Language): A linguagem padrão para bancos de dados relacionais (MySQL, PostgreSQL, SQLite, SQL Server, Oracle, etc.). Inclui DDL (definição de dados, p. ex., CREATE TABLE), DML (manipulação de dados, p. ex., INSERT), DQL (consulta de dados, p. ex., SELECT) e DCL (controle de dados).
Instrução INSERT: Instrução DML que adiciona linhas a uma tabela; a sintaxe é INSERT INTO table_name (col1, col2) VALUES (val1, val2). Suporta tanto tuplas de valor único quanto tuplas multivalor (um INSERT para muitas linhas); esta última melhora drasticamente o desempenho da importação em lote.
Instrução CREATE TABLE: Instrução DDL que cria uma tabela definindo seu nome, colunas, tipos de dados e restrições (NOT NULL, PRIMARY KEY, UNIQUE, DEFAULT, etc.). O CREATE TABLE gerado por esta ferramenta omite chaves primárias, chaves estrangeiras e índices para permanecer limpo e previsível.
Dialeto SQL: As diferenças de implementação entre fornecedores de banco de dados para o padrão SQL. MySQL usa crases, PostgreSQL usa aspas duplas, SQL Server usa colchetes; SQLite não tem BOOLEAN nativo e usa 1/0; Oracle usa VARCHAR2; BigQuery usa INT64 e STRING. O mesmo SQL lógico pode ter sintaxe diferente entre dialetos.
DDL (Data Definition Language): Sub-linguagem SQL que inclui as instruções CREATE, ALTER e DROP, usada para definir e modificar estruturas de banco de dados (tabelas, views, índices, restrições, etc.). A saída CREATE TABLE desta ferramenta é uma instrução DDL.
DML (Data Manipulation Language): Sub-linguagem SQL que inclui as instruções INSERT, UPDATE e DELETE, usada para manipular as linhas de dados nas tabelas. A saída INSERT INTO desta ferramenta é uma instrução DML.
Inferência de tipos: O processo de deduzir automaticamente o tipo de um valor a partir de sua forma literal. A ferramenta inspeciona o typeof de cada valor JSON (null, boolean, number, string) junto com sua forma específica (data ISO 8601, comprimento de string) para mapeá-lo ao tipo SQL mais apropriado.
Aspa de identificador: Caracteres especiais que envolvem os nomes de tabelas e colunas em SQL. MySQL usa crases como `name`, PostgreSQL e SQL padrão usam aspas duplas como "name", SQL Server usa colchetes como [name]. São usadas para escapar palavras reservadas e controlar a sensibilidade a maiúsculas/minúsculas.
Formato de data ISO 8601: Padrão internacional para representar datas e horas. O formato é YYYY-MM-DD para datas e YYYY-MM-DDTHH:mm:ss para datas com hora. Strings que correspondam a esses padrões são automaticamente mapeadas para os tipos SQL DATE e TIMESTAMP por esta ferramenta.
VARCHAR e TEXT: Dois tipos SQL para strings de comprimento variável. VARCHAR(n) tem um limite de comprimento (comumente até 65.535 bytes) e é adequado para strings curtas como nomes, e-mails e títulos. TEXT não tem limite de comprimento (ou tem um muito grande) e é adequado para conteúdo longo. Por padrão, esta ferramenta mapeia strings de 255 caracteres ou menos para VARCHAR(255) e strings mais longas para TEXT.
INT e BIGINT: Dois tipos SQL para inteiros. INT (INTEGER) é normalmente um inteiro de 32 bits com sinal na faixa de -2.147.483.648 a 2.147.483.647. BIGINT é um inteiro de 64 bits com sinal com uma faixa muito maior. A ferramenta promove automaticamente para BIGINT os inteiros cujo valor absoluto excede a faixa do INT.
Tipo BOOLEAN: Tipo SQL para valores de verdade. MySQL, PostgreSQL e BigQuery suportam BOOLEAN nativamente (armazenam TRUE/FALSE). SQLite não tem BOOLEAN nativo e usa 1/0 ou INTEGER. SQL Server usa BIT. DB2 usa SMALLINT. A ferramenta adapta a saída automaticamente por dialeto.
Cláusula IF NOT EXISTS: Cláusula opcional em CREATE TABLE que pula a criação quando a tabela já existe, evitando erros em execuções repetidas. MySQL, PostgreSQL, SQLite e BigQuery suportam; Oracle PL/SQL e SQL Server T-SQL não suportam. A ferramenta emite essa cláusula apenas para os dialetos que suportam.
Inserção em lote: Técnica que combina várias linhas em uma única instrução INSERT usando tuplas multivalor, p. ex., VALUES (1,2), (3,4), (5,6). Comparado com inserções linha a linha, isso reduz a sobrecarga de análise e as idas e vindas de rede e tipicamente melhora o desempenho de importação em 10x-100x. A ferramenta usa por padrão 100 linhas por INSERT e suporta 1-1000.
sql-formatter: Embelezador de SQL em JavaScript que suporta mais de 20 dialetos. Coloca as palavras-chave em maiúsculas, aplica indentação consistente e quebra linhas longas. A ferramenta usa esta biblioteca como o último passo de seu pipeline para tornar o SQL gerado mais fácil de ler e editar.

Dialetos SQL suportados e diferenças principais

Os mais de 20 dialetos SQL suportados pela ferramenta, com suas aspas de identificador, tipos de inteiro e representação booleana:

Dialeto	Aspa de identificador	Tipo inteiro	Forma booleana	IF NOT EXISTS
MySQL	crases `	`INT`	`TRUE`	sim
MariaDB	crases `	`INT`	`TRUE`	sim
TiDB	crases `	`INT`	`TRUE`	sim
SingleStoreDB	crases `	`INT`	`TRUE`	sim
PostgreSQL	`aspas duplas "`	`INTEGER`	`TRUE`	sim
Redshift	`aspas duplas "`	`INTEGER`	`TRUE`	sim
DuckDB	`aspas duplas "`	`INTEGER`	`TRUE`	sim
Trino	`aspas duplas "`	`INTEGER`	`TRUE`	sim
SQLite	`aspas duplas "`	`INTEGER`	`1/0`	sim
BigQuery	crases `	`INT64`	`TRUE`	sim
Snowflake	`aspas duplas "`	`NUMBER`	`TRUE`	sim
DB2	`aspas duplas "`	`INTEGER`	`1/0`	sim
DB2i	`aspas duplas "`	`INTEGER`	`1/0`	sim
Oracle PL/SQL	`aspas duplas "`	`NUMBER`	`1/0`	não
SQL Server T-SQL	`colchetes []`	`INT`	`1/0`	não
Transact-SQL	`colchetes []`	`INT`	`1/0`	não
Spark SQL	crases `	`INT`	`TRUE`	sim
Hive	crases `	`INT`	`TRUE`	sim
ClickHouse	crases `	`Int32`	`1/0`	sim
N1QL (Couchbase)	crases `	`NUMBER`	`TRUE`	sim

Regras de mapeamento de tipos JSON para SQL

O conjunto completo de regras usadas pela função detectType para mapear valores JSON para tipos SQL:

Valor JSON	Exemplo	Tipo SQL deduzido	Regra de detecção
`null`	`null`	`NULL`	JSON null é mapeado para SQL NULL
`boolean`	`true / false`	`BOOLEAN`	Dialetos com BOOLEAN nativo o usam; SQLite/DB2/SQL Server usam 1/0 ou BIT
`inteiro (32 bits)`	`1, 100, -9999`	`INT / INTEGER`	\|valor\| <= 2.147.483.647 -> INT
`inteiro (64 bits)`	`9999999999, -1234567890`	`BIGINT`	\|valor\| > 2.147.483.647 promovido para BIGINT
`float`	`3.14, -0.5, 1e10`	`FLOAT / DOUBLE / REAL`	Floats usam FLOAT/DOUBLE/REAL por dialeto
`ISO 8601 date-time`	`2024-05-20T10:30:00`	`TIMESTAMP`	Corresponde a /^\d{4}-\d{2}-\d{2}T/ -> TIMESTAMP
`ISO 8601 date`	`2024-05-20`	`DATE`	Corresponde a /^\d{4}-\d{2}-\d{2}/ -> DATE
`string curta`	`Alice, São Paulo`	`VARCHAR(255)`	comprimento <= 255 -> VARCHAR(255)
`string longa`	`mais de 255 caracteres`	`TEXT`	comprimento > 255 -> TEXT (CLOB/NVARCHAR(MAX)/STRING por dialeto)

Privacy & Security

Este conversor de JSON para SQL é executado inteiramente no seu navegador. A análise JSON, a inferência de tipos, a geração SQL e o embelezamento SQL são executados em JavaScript do lado do cliente; nada é enviado para um servidor. Os uploads de arquivos usam a API nativa FileReader e nunca passam por um serviço intermediário. A ferramenta não usa cookies de rastreamento e não coleta dados de entrada ou uso. Todas as entradas e saídas são apagadas da memória assim que a página é fechada ou recarregada. Seguro para usar com JSON que contenha dados pessoais, segredos comerciais ou qualquer outro conteúdo sensível.

Authoritative References

MySQLSintaxe INSERT do MySQL - documentação oficial
PostgreSQLSintaxe INSERT do PostgreSQL - documentação oficial
SQLiteSintaxe INSERT do SQLite - documentação oficial
MicrosoftSintaxe INSERT do SQL Server - documentação oficial
MDNEspecificação JSON - MDN Web Docs
WikipediaPadrão de data e hora ISO 8601 - Wikipedia
GitHubsql-formatter no GitHub