JSON a SQL

Haz clic para convertir JSON en instrucciones SQL INSERT

Conversor online gratuito de JSON a SQL. Convierte matrices JSON en sentencias INSERT y genera opcionalmente scripts DDL CREATE TABLE. Compatible con MySQL, PostgreSQL, SQLite, SQL Server y más de 20 dialectos SQL con inferencia automática de tipos. Procesamiento 100% en el navegador.

Relacionado

Conversor de SQL

Formateador de SQL

JSON a CSV

JSON a YAML

Formateo JSON

Consulta JSONPath

Acerca de JSON a SQL: Mover datos JSON a bases de datos relacionales

JSON a SQL es el proceso de convertir datos en formato JSON (matrices u objetos JSON) en scripts SQL que una base de datos relacional pueda ejecutar, específicamente sentencias INSERT y CREATE TABLE. JSON (JavaScript Object Notation) es un formato ligero de intercambio de datos utilizado en todas partes: APIs REST, transporte frontend a backend, archivos de configuración, registros. Las bases de datos relacionales (MySQL, PostgreSQL, SQLite, SQL Server, Oracle, etc.) son la columna vertebral del almacenamiento de datos empresariales, pero requieren estructuras de tabla estrictas y sentencias SQL para almacenar y consultar datos. Mover datos de JSON a una base de datos relacional requiere convertir el JSON en un script SQL.

En su núcleo, la herramienta convierte cada objeto de una matriz JSON en una fila de datos. Un objeto individual se trata como una sola fila y cada elemento de una matriz JSON se convierte en una fila. Las claves del objeto se convierten en nombres de columna y los valores se traducen al literal SQL correspondiente. Toda la conversión se ejecuta localmente en el navegador, sin backend.

La inferencia de tipos es el desafío técnico central de JSON a SQL. JSON solo tiene seis tipos primitivos (null, boolean, number, string, array, object), mientras que SQL tiene docenas (INT, BIGINT, FLOAT, DOUBLE, VARCHAR, TEXT, DATE, TIMESTAMP, BOOLEAN, BIT, etc.). La función detectType de esta herramienta examina la forma literal de cada valor: null se asigna a SQL NULL; true/false a BOOLEAN; los enteros a INT (rango -2.147.483.648 a 2.147.483.647) o BIGINT; los flotantes a FLOAT/DOUBLE/REAL según el dialecto; las cadenas con formato ISO 8601 se asignan a DATE y TIMESTAMP; las cadenas cortas a VARCHAR(255); las cadenas de más de 255 caracteres a TEXT.

La herramienta implementa un algoritmo de promoción de tipos: cuando el tipo existente de una columna entra en conflicto con un nuevo valor, se promueve al tipo más amplio que cubra ambos (por ejemplo, INT se promueve a FLOAT). NULL no se incluye en esta decisión, por lo que el tipo inferido se mantiene estable. Como el tipo de columna final se decide después de procesar todas las filas, el resultado es el tipo globalmente óptimo para el conjunto de datos.

Las diferencias de dialecto se centralizan en DIALECT_CONFIG. MySQL envuelve los identificadores entre acentos graves (`name`), PostgreSQL y el SQL estándar usan comillas dobles ("name"), SQL Server usa corchetes ([name]). SQLite no tiene un tipo BOOLEAN nativo, por lo que se usa 1/0. BigQuery usa INT64 para enteros y STRING para texto. Snowflake usa NUMBER para enteros y TIMESTAMP_NTZ para fechas. Oracle usa VARCHAR2 y NUMBER(1) para booleanos. DB2 almacena texto en CLOB. La herramienta adapta las comillas de identificador, los tipos de datos y la representación booleana a cualquier dialecto que el usuario seleccione.

La generación de CREATE TABLE se basa en la inferencia de tipos. Cuando el usuario activa "Generar CREATE TABLE" en los ajustes, la herramienta emite una sentencia CREATE TABLE antes del bloque INSERT. El nombre de la tabla proviene de la entrada del usuario (por defecto `users`); los nombres de columna provienen de las claves del objeto JSON; los tipos de columna provienen de los tipos SQL inferidos. Para los dialectos que admiten IF NOT EXISTS, la cláusula se agrega automáticamente para evitar errores al volver a crear la tabla; para los dialectos que no la admiten (Oracle PL/SQL, SQL Server T-SQL) se omite por compatibilidad. CREATE TABLE e INSERT juntos forman un script de inicialización completo que se puede ejecutar en una base de datos vacía con una sola ejecución.

La inserción por lotes es la clave del rendimiento. Convertir 10.000 filas de JSON en 10.000 sentencias INSERT separadas es dolorosamente lento. La herramienta admite un tamaño de lote configurable (por defecto 100, rango 1-1000) y combina varias filas en un INSERT con tuplas multivalor (VALUES (1,2), (3,4), ...). Esto reduce drásticamente el número de sentencias y ofrece un rendimiento de importación de 10 a 100 veces mayor en la mayoría de los motores. El tamaño del lote debe ajustarse para cada base de datos y servidor, ya que un lote demasiado grande puede superar max_allowed_packet en MySQL.

La tolerancia a errores JSON es una característica práctica. La herramienta incluye una rutina de reparación tryFixJSON que se ejecuta cuando JSON.parse falla; si la reparación tiene éxito, se notifica al usuario y la conversión continúa. Esto mejora drásticamente la tasa de éxito en la práctica y evita interminables idas y venidas por pequeños errores. Todo el procesamiento es del lado del cliente: no se envía nada a ningún servidor, lo que elimina cualquier riesgo de fuga y hace que la conversión sea prácticamente instantánea para datos de tamaño medio (menos de 10 MB).

Casos de uso

Convierte JSON de respuestas de API en sentencias INSERT para importar datos de forma masiva a MySQL, PostgreSQL u otras bases de datos relacionales para análisis.
Genera DDL CREATE TABLE a partir de una configuración JSON o diccionario de datos al inicializar el esquema de un nuevo proyecto.
Convierte mocks de frontend o fixtures de prueba en scripts SQL para sembrar entornos de desarrollo, staging o QA.
Migración de datos: convierte exportaciones JSON de MongoDB, Elasticsearch o almacenes de documentos en scripts SQL para destinos relacionales.
Preprocesamiento ETL: normaliza cargas JSON upstream en sentencias INSERT estándar que las pipelines downstream pueden ingerir directamente.
Respaldo y recuperación: mantén datos críticos del negocio en formato JSON portable y regenera scripts SQL bajo demanda para una restauración rápida.
Colaboración entre equipos: acuerda un contrato JSON y deja que el backend genere con un clic tanto el DDL de esquema como los scripts INSERT semilla.
Enseñanza y demos: guía a los estudiantes a través de cómo los datos JSON se asignan a sentencias SQL, ilustrando la inferencia de tipos y la mecánica de inserción por lotes.

Cómo Usar

Pega una matriz u objeto JSON en el editor izquierdo, haz clic en Subir para cargar un archivo .json/.txt, o haz clic en Muestra para cargar la demo integrada.
Elige el dialecto SQL de destino en el menú desplegable de la barra de herramientas (MySQL, PostgreSQL, SQLite, SQL Server y más de 20).
Haz clic en Configuración para configurar el nombre de la tabla, si se emite CREATE TABLE y el tamaño de lote de inserción (1-1000 filas por INSERT).
Haz clic en Convertir (o usa el atajo de teclado) para analizar el JSON, inferir tipos y renderizar el SQL en el panel derecho.
Inspecciona el SQL generado y los totales de filas/columnas en la barra de estado para verificar la integridad de los datos.
Haz clic en Copiar para poner el SQL en el portapapeles, o haz clic en Descargar para guardarlo como un archivo .sql (por ejemplo users.sql).
Ejecuta el SQL dentro de tu cliente de base de datos preferido (Navicat, DBeaver, pgAdmin, MySQL Workbench) para completar la importación de datos.

Características

Generación masiva de INSERT: convierte matrices JSON en sentencias INSERT INTO estándar con tamaño de lote configurable (1-1000 filas por sentencia).
Salida DDL CREATE TABLE: bloque DDL opcional con tipos auto-inferidos (VARCHAR, INT, BIGINT, FLOAT, BOOLEAN, TIMESTAMP, DATE, TEXT).
20+ dialectos SQL: MySQL, PostgreSQL, SQLite, SQL Server, Oracle, DB2, BigQuery, Snowflake, Redshift, DuckDB, ClickHouse, Trino, Spark, Hive y más.
Inferencia inteligente de tipos: detecta null, booleanos, enteros, flotantes, fechas ISO 8601 y cadenas cortas o largas y asigna cada una al mejor tipo SQL.
Formateador SQL integrado: impulsado por sql-formatter, con palabras clave en mayúsculas, sangría limpia y bloques VALUES multivalor claros.
Auto-reparación de JSON: corrige automáticamente comas finales, comillas simples y comillas de clave faltantes para mantener la conversión resiliente.
Lógica de promoción de tipos: los tipos en conflicto entre filas se promueven al tipo compatible más amplio (INT + FLOAT se convierte en FLOAT) para que el DDL nunca trunque datos.
Nombres de tabla y columna personalizados: el nombre de la tabla se convierte en el nombre del archivo (p. ej., users.sql); los nombres de columna siguen las claves del objeto JSON.
Entrada flexible: pega JSON, sube un archivo .json/.txt o carga la muestra integrada con un solo clic.
Recuento de filas y columnas en vivo: la barra de estado muestra el número total de filas y columnas después de la conversión para una validación rápida.
Copiar y descargar: copia al portapapeles con un clic o guarda como archivo .sql estándar listo para importar a cualquier base de datos.
100% en el navegador: todo el análisis y la transformación ocurren en JavaScript del lado del cliente; el JSON nunca sale de tu dispositivo.

Preguntas Frecuentes

¿Cómo convierto una matriz JSON en sentencias SQL INSERT?

Pega la matriz JSON en el editor izquierdo y la herramienta convierte cada objeto en una sentencia INSERT INTO. Las claves del objeto se convierten en nombres de columna y los valores se entrecomillan automáticamente o se mantienen como números. El SQL generado se puede copiar y ejecutar directamente en MySQL, PostgreSQL, SQLite o cualquier cliente compatible.

¿Puede la herramienta generar scripts DDL CREATE TABLE desde JSON?

Sí. Activa "Generar CREATE TABLE" en el panel de ajustes. La herramienta analiza cada campo del JSON, infiere el tipo de dato SQL adecuado (VARCHAR, INT, BIGINT, FLOAT, BOOLEAN, TIMESTAMP, DATE, TEXT, etc.) y emite una sentencia CREATE TABLE completa que junto con los INSERT forma un script de inicialización listo para ejecutar.

¿Qué dialectos SQL son compatibles?

La herramienta soporta más de 20 dialectos SQL principales, incluyendo MySQL, MariaDB, PostgreSQL, SQLite, SQL Server (T-SQL), Oracle PL/SQL, DB2, BigQuery, Snowflake, Redshift, DuckDB, ClickHouse, Trino, Spark SQL, Hive, TiDB, SingleStoreDB y N1QL. Las comillas de identificador (acento grave, comillas dobles, corchetes), los tipos de datos (INT64, NVARCHAR, CLOB, etc.) y la representación booleana (TRUE/FALSE vs 1/0) se adaptan automáticamente por dialecto.

¿Cómo infiere la herramienta los tipos SQL a partir de los valores JSON?

null se asigna a SQL NULL; true/false a BOOLEAN (1/0 o BIT en SQLite/DB2/SQL Server); los enteros a INT o BIGINT según el rango (se promueve automáticamente a BIGINT cuando el valor absoluto supera 2.147.483.647); los flotantes a FLOAT/DOUBLE/REAL según el dialecto; las cadenas con formato ISO 8601 se reconocen como DATE y TIMESTAMP; las cadenas cortas como VARCHAR(255); las cadenas de más de 255 caracteres como TEXT. Los tipos en conflicto entre filas se promueven automáticamente (por ejemplo, INT + FLOAT se convierte en FLOAT).

¿El SQL generado se puede ejecutar directamente en mi base de datos?

Sí. El SQL generado cumple con el estándar del dialecto elegido y se puede ejecutar en MySQL Workbench, Navicat, DBeaver, pgAdmin, SQL Server Management Studio, phpMyAdmin o cualquier otra herramienta de gestión de bases de datos. Los archivos descargados se nombran según la tabla (por ejemplo, users.sql) para facilitar la importación por lotes.

¿Qué pasa si mi JSON tiene errores de sintaxis?

Si el JSON contiene comas finales, comillas faltantes o comillas simples en lugar de dobles, la herramienta invoca automáticamente la función de reparación tryFixJSON y continúa la conversión. Si la reparación no funciona, el panel derecho muestra la ubicación exacta del error. Para JSON profundamente anidados o muy dañados, usa primero la herramienta JSON Formatter.

¿La herramienta admite inserciones por lotes? ¿Cuántas filas por INSERT?

Sí. Por defecto cada INSERT agrupa 100 filas, configurable de 1 a 1000. Convertir 10.000 filas JSON produce 100 sentencias INSERT multivalor. Comparado con inserciones fila a fila, el rendimiento de importación suele ser de 10 a 100 veces mayor en MySQL, PostgreSQL y motores similares.

¿Se suben mis datos JSON a un servidor?

No. Esta es una aplicación puramente del lado del cliente. Todo el análisis JSON, la inferencia de tipos y la generación de SQL ocurren en el motor JavaScript del navegador; no se envía nada a ningún servidor. Las cargas de archivos usan la API nativa FileReader y todos los datos se borran de la memoria al recargar la página. Puedes procesar con seguridad JSON con datos personales o secretos comerciales.

¿Las cadenas de fecha ISO 8601 se detectan automáticamente?

Sí. La herramienta reconoce dos patrones ISO 8601: las cadenas con el separador T (por ejemplo 2024-05-20T10:30:00) se asignan a TIMESTAMP; las cadenas solo de fecha (por ejemplo 2024-05-20) se asignan a DATE. Las cadenas que no siguen ISO 8601 (por ejemplo 2024/05/20 o May 20, 2024) se tratan como valores VARCHAR normales.

¿Qué tamaño de archivo JSON puede manejar la herramienta?

No hay un límite estricto; el límite práctico es la memoria del navegador. Archivos de hasta 10 MB (decenas de miles de filas) funcionan sin problemas. Archivos más grandes pueden volverse lentos a medida que aumenta la presión de memoria. Para conjuntos de datos muy grandes, divídelos en lotes más pequeños o desactiva el paso opcional de embellecimiento en el formateador SQL.

¿El SQL generado se formatea automáticamente?

Sí. La herramienta usa la biblioteca sql-formatter para embellecer la salida: las palabras clave se ponen en mayúsculas (SELECT, INSERT INTO, VALUES, CREATE TABLE), cada registro se ubica en su propia línea, la sangría es consistente y se preservan las líneas en blanco para mayor legibilidad. El resultado es fácil de leer en cualquier cliente de base de datos y fácil de editar manualmente después.

¿Puedo controlar el orden de las columnas del INSERT generado?

Por defecto la herramienta usa el orden de las claves en el primer objeto de la matriz JSON, lo que mantiene alineada la salida de varias filas. Si diferentes objetos tienen distintos órdenes de claves, la herramienta combina y deduplica todas las claves y rellena los valores faltantes con NULL. Para mejores resultados, normaliza el JSON con la herramienta JSON Formatter antes de la conversión.

Solución de problemas

El panel derecho solo muestra "No valid objects found in JSON".

Causa 1: el nivel superior del JSON no es ni una matriz ni un objeto (por ejemplo, una cadena o número sueltos), por lo que no hay nada que convertir en filas. Solución: envuelve el JSON en una matriz [{...}] u objeto {...}. Causa 2: la matriz contiene valores primitivos ([1, 2, 3]) en lugar de objetos, por lo que no hay nombres de clave para asignar a columnas. Solución: cada elemento de la matriz debe ser un objeto con pares clave-valor. Causa 3: el JSON no se pudo analizar, se ejecutó tryFixJSON y el resultado de la reparación sigue sin ser un objeto. Solución: valida el JSON con la herramienta JSON Formatter para encontrar el problema de sintaxis.

El SQL generado produce un error de sintaxis en mi base de datos.

Causa 1: se seleccionó el dialecto incorrecto (por ejemplo, MySQL seleccionado pero el destino es PostgreSQL), por lo que el estilo de comillas del identificador no coincide. Solución: elige el dialecto correcto en el menú desplegable. Causa 2: el nombre de la tabla o columna coincide con una palabra reservada SQL (order, user, select, etc.). Solución: renombra la tabla en los ajustes o envuelve manualmente el nombre entre acentos graves o corchetes. Causa 3: el tamaño del lote es demasiado grande y excede max_allowed_packet de la base de datos o un límite similar. Solución: reduce el tamaño del lote (por ejemplo, a 50) en los ajustes.

Un campo de fecha se detectó como VARCHAR en lugar de DATE o TIMESTAMP.

Causa: la cadena de fecha no está en formato ISO 8601. La herramienta solo reconoce YYYY-MM-DD (DATE) e YYYY-MM-DDTHH:mm:ss (TIMESTAMP). Formatos comunes que no reconocerá: YYYY/MM/DD, DD-MM-YYYY, "May 20 2024" y marcas de tiempo Unix como 1715644800. Solución: convierte la fecha a ISO 8601 en el JSON primero, o edita manualmente el tipo de columna CREATE TABLE a DATE o VARCHAR después de la conversión.

Los booleanos aparecen como 1/0 en SQLite/DB2 pero quiero TRUE/FALSE.

Causa: SQLite, DB2 y SQL Server no tienen un tipo BOOLEAN nativo, por lo que el estándar del dialecto usa 1/0 (o BIT). Solución: opción 1, acepta 1/0 como representación estándar (1 significa TRUE, 0 significa FALSE); opción 2, convierte el valor en la capa de aplicación (1 a true, 0 a false); opción 3, postprocesa el SQL reemplazando 1/0 con TRUE/FALSE y cambia el tipo de columna a INTEGER para leerlo como booleano en tu código. La herramienta siempre sigue el estándar del dialecto y no ofrece una opción no estándar.

El JSON contiene objetos o matrices anidadas. ¿Qué tipos de columna se producen?

Los valores no primitivos (objetos y matrices anidadas) se serializan a cadenas JSON y se almacenan como TEXT. Por ejemplo {"tags": ["a", "b"], "profile": {"age": 30}} produce dos columnas: tags TEXT y profile TEXT, ambas con JSON serializado. Al consultar puedes usar JSON_EXTRACT (MySQL 5.7+) o funciones JSON similares para extraer campos anidados. Para normalizar completamente los datos anidados en tablas relacionales separadas, manéjalo en la capa de aplicación o usa una herramienta ETL dedicada.

Los caracteres chinos se ven corruptos después de importar el archivo .sql descargado.

Causa: el archivo .sql está codificado en UTF-8, pero el cliente de la base de datos o la propia base de datos no está configurada en UTF-8. Solución: opción 1, establece el juego de caracteres de la base de datos en utf8mb4 (MySQL) o UTF8 (PostgreSQL). Opción 2, especifica el juego de caracteres en la conexión del cliente (por ejemplo, MySQL CLI con --default-character-set=utf8mb4). Opción 3, abre el archivo .sql en un editor de texto y confirma que la codificación es UTF-8 (no GBK u otra). La herramienta siempre produce archivos .sql en UTF-8.

Glosario

JSON (JavaScript Object Notation): Formato ligero de intercambio de datos basado en la sintaxis de objetos de JavaScript pero independiente de cualquier lenguaje de programación. Admite seis tipos básicos: objeto ({}), array ([]), cadena, número, booleano y null. Ampliamente utilizado en APIs REST, transporte frontend-backend, archivos de configuración y registros.
SQL (Structured Query Language): Lenguaje estándar para bases de datos relacionales (MySQL, PostgreSQL, SQLite, SQL Server, Oracle, etc.). Incluye DDL (definición de datos, p. ej., CREATE TABLE), DML (manipulación de datos, p. ej., INSERT), DQL (consulta de datos, p. ej., SELECT) y DCL (control de datos).
Sentencia INSERT: Sentencia DML que añade filas a una tabla; la sintaxis es INSERT INTO table_name (col1, col2) VALUES (val1, val2). Admite tuplas de un solo valor y tuplas multivalor (un INSERT para muchas filas); esta última mejora drásticamente el rendimiento de la importación masiva.
Sentencia CREATE TABLE: Sentencia DDL que crea una tabla definiendo su nombre, columnas, tipos de datos y restricciones (NOT NULL, PRIMARY KEY, UNIQUE, DEFAULT, etc.). El CREATE TABLE generado por esta herramienta omite claves primarias, claves foráneas e índices para mantenerse limpio y predecible.
Dialecto SQL: Las diferencias de implementación entre proveedores de bases de datos para el estándar SQL. MySQL usa acentos graves, PostgreSQL usa comillas dobles, SQL Server usa corchetes; SQLite no tiene BOOLEAN nativo y usa 1/0; Oracle usa VARCHAR2; BigQuery usa INT64 y STRING. La misma SQL lógica puede tener sintaxis diferente entre dialectos.
DDL (Data Definition Language): Sublenguaje SQL que incluye sentencias CREATE, ALTER y DROP, utilizado para definir y modificar estructuras de bases de datos (tablas, vistas, índices, restricciones, etc.). La salida CREATE TABLE de esta herramienta es una sentencia DDL.
DML (Data Manipulation Language): Sublenguaje SQL que incluye sentencias INSERT, UPDATE y DELETE, utilizado para manipular las filas de datos en las tablas. La salida INSERT INTO de esta herramienta es una sentencia DML.
Inferencia de tipos: Proceso de deducir automáticamente el tipo de un valor a partir de su forma literal. La herramienta inspecciona el typeof de cada valor JSON (null, boolean, number, string) junto con su forma específica (fecha ISO 8601, longitud de cadena) para asignarlo al tipo SQL más apropiado.
Comilla de identificador: Caracteres especiales que envuelven los nombres de tablas y columnas en SQL. MySQL usa acentos graves como `name`, PostgreSQL y SQL estándar usan comillas dobles como "name", SQL Server usa corchetes como [name]. Se utilizan para escapar palabras reservadas y controlar el uso de mayúsculas/minúsculas.
Formato de fecha ISO 8601: Estándar internacional para representar fechas y horas. El formato es YYYY-MM-DD para fechas e YYYY-MM-DDTHH:mm:ss para fechas con hora. Las cadenas que coincidan con estos patrones se asignan automáticamente a los tipos SQL DATE y TIMESTAMP por esta herramienta.
VARCHAR y TEXT: Dos tipos SQL para cadenas de longitud variable. VARCHAR(n) tiene un límite de longitud (comúnmente hasta 65.535 bytes) y es adecuado para cadenas cortas como nombres, correos y títulos. TEXT no tiene límite de longitud (o uno muy grande) y es adecuado para contenido largo. Por defecto, esta herramienta asigna cadenas de 255 caracteres o menos a VARCHAR(255) y las más largas a TEXT.
INT y BIGINT: Dos tipos SQL para enteros. INT (INTEGER) normalmente es un entero de 32 bits con signo en el rango -2.147.483.648 a 2.147.483.647. BIGINT es un entero de 64 bits con signo con un rango mucho mayor. La herramienta promueve automáticamente a BIGINT los enteros cuyo valor absoluto exceda el rango de INT.
Tipo BOOLEAN: Tipo SQL para valores de verdad. MySQL, PostgreSQL y BigQuery admiten BOOLEAN de forma nativa (almacenan TRUE/FALSE). SQLite no tiene BOOLEAN nativo y usa 1/0 o INTEGER. SQL Server usa BIT. DB2 usa SMALLINT. La herramienta adapta la salida automáticamente por dialecto.
Cláusula IF NOT EXISTS: Cláusula opcional en CREATE TABLE que omite la creación cuando la tabla ya existe, evitando errores en ejecuciones repetidas. MySQL, PostgreSQL, SQLite y BigQuery la admiten; Oracle PL/SQL y SQL Server T-SQL no. La herramienta emite esta cláusula solo para los dialectos que la admiten.
Inserción por lotes: Técnica que combina muchas filas en una sola sentencia INSERT usando tuplas multivalor, p. ej., VALUES (1,2), (3,4), (5,6). Comparado con inserciones fila a fila, esto reduce la sobrecarga de análisis y los viajes de red y típicamente mejora el rendimiento de importación entre 10x y 100x. La herramienta usa por defecto 100 filas por INSERT y admite 1-1000.
sql-formatter: Embellecedor de SQL en JavaScript que admite más de 20 dialectos. Pone las palabras clave en mayúsculas, aplica sangría consistente y divide líneas largas. La herramienta usa esta biblioteca como último paso de su pipeline para que el SQL generado sea más fácil de leer y editar.

Dialectos SQL compatibles y diferencias clave

Los más de 20 dialectos SQL compatibles con la herramienta, con sus comillas de identificador, tipos de entero y representación booleana:

Dialecto	Comilla de identificador	Tipo entero	Forma booleana	IF NOT EXISTS
MySQL	acentos graves `	`INT`	`TRUE`	sí
MariaDB	acentos graves `	`INT`	`TRUE`	sí
TiDB	acentos graves `	`INT`	`TRUE`	sí
SingleStoreDB	acentos graves `	`INT`	`TRUE`	sí
PostgreSQL	`comillas dobles "`	`INTEGER`	`TRUE`	sí
Redshift	`comillas dobles "`	`INTEGER`	`TRUE`	sí
DuckDB	`comillas dobles "`	`INTEGER`	`TRUE`	sí
Trino	`comillas dobles "`	`INTEGER`	`TRUE`	sí
SQLite	`comillas dobles "`	`INTEGER`	`1/0`	sí
BigQuery	acentos graves `	`INT64`	`TRUE`	sí
Snowflake	`comillas dobles "`	`NUMBER`	`TRUE`	sí
DB2	`comillas dobles "`	`INTEGER`	`1/0`	sí
DB2i	`comillas dobles "`	`INTEGER`	`1/0`	sí
Oracle PL/SQL	`comillas dobles "`	`NUMBER`	`1/0`	no
SQL Server T-SQL	`corchetes []`	`INT`	`1/0`	no
Transact-SQL	`corchetes []`	`INT`	`1/0`	no
Spark SQL	acentos graves `	`INT`	`TRUE`	sí
Hive	acentos graves `	`INT`	`TRUE`	sí
ClickHouse	acentos graves `	`Int32`	`1/0`	sí
N1QL (Couchbase)	acentos graves `	`NUMBER`	`TRUE`	sí

Reglas de mapeo de tipos JSON a SQL

El conjunto completo de reglas utilizadas por la función detectType para asignar valores JSON a tipos SQL:

Valor JSON	Ejemplo	Tipo SQL inferido	Regla de detección
`null`	`null`	`NULL`	JSON null se asigna a SQL NULL
`boolean`	`true / false`	`BOOLEAN`	Los dialectos con BOOLEAN nativo lo usan; SQLite/DB2/SQL Server usan 1/0 o BIT
`entero (32 bits)`	`1, 100, -9999`	`INT / INTEGER`	\|valor\| <= 2.147.483.647 -> INT
`entero (64 bits)`	`9999999999, -1234567890`	`BIGINT`	\|valor\| > 2.147.483.647 se promueve a BIGINT
`flotante`	`3.14, -0.5, 1e10`	`FLOAT / DOUBLE / REAL`	Los flotantes usan FLOAT/DOUBLE/REAL según el dialecto
`ISO 8601 date-time`	`2024-05-20T10:30:00`	`TIMESTAMP`	Coincide con /^\d{4}-\d{2}-\d{2}T/ -> TIMESTAMP
`ISO 8601 date`	`2024-05-20`	`DATE`	Coincide con /^\d{4}-\d{2}-\d{2}/ -> DATE
`cadena corta`	`Alice, Madrid`	`VARCHAR(255)`	longitud <= 255 -> VARCHAR(255)
`cadena larga`	`más de 255 caracteres`	`TEXT`	longitud > 255 -> TEXT (CLOB/NVARCHAR(MAX)/STRING según el dialecto)

Privacy & Security

Este conversor de JSON a SQL se ejecuta completamente en tu navegador. El análisis JSON, la inferencia de tipos, la generación de SQL y el embellecimiento de SQL se ejecutan en JavaScript del lado del cliente; nada se envía a ningún servidor. Las cargas de archivos usan la API nativa FileReader y nunca pasan por un servicio intermedio. La herramienta no usa cookies de seguimiento y no recopila datos de entrada o uso. Todas las entradas y salidas se borran de la memoria en cuanto se cierra o recarga la página. Segura de usar con JSON que contenga datos personales, secretos comerciales o cualquier otro contenido sensible.