JSON a SQL - Generar CREATE TABLE e INSERT Online
Convierte datos JSON a sentencias CREATE TABLE e INSERT INTO para MySQL, PostgreSQL, SQLite y SQL Server — 100% en tu navegador.
Preguntas frecuentes
¿Qué es un convertidor de JSON a SQL?
Un convertidor de JSON a SQL es una herramienta que transforma datos JSON en sentencias SQL. Genera sentencias CREATE TABLE (DDL) que definen el esquema de la base de datos basándose en la estructura y los tipos encontrados en su JSON, y sentencias INSERT INTO (DML) que llenan la tabla con datos. La herramienta infiere automáticamente los tipos de columna SQL a partir de los valores JSON: las cadenas se convierten en VARCHAR o TEXT, los números en INT o FLOAT, los booleanos en BOOLEAN o BIT dependiendo del dialecto de la base de datos, y los objetos anidados se almacenan como columnas JSON.
¿Cómo convierto JSON a sentencias SQL?
Pegue sus datos JSON (un objeto único o un array de objetos) en el campo de entrada. Seleccione su dialecto SQL de destino (MySQL, PostgreSQL, SQLite o SQL Server), ingrese un nombre de tabla y elija su modo de salida (CREATE TABLE + INSERT, solo CREATE o solo INSERT). La herramienta genera instantáneamente el SQL correspondiente en el panel de salida. Puede personalizar opciones como el modo de INSERT por lotes, la selección de clave primaria y el manejo de JSON anidado antes de copiar el resultado a su portapapeles.
¿Cómo funciona la inferencia de tipos?
La herramienta analiza todos los valores en cada campo JSON en todas las filas para determinar el mejor tipo de columna SQL. Las cadenas se mapean a VARCHAR(255) o TEXT según la longitud, los enteros a INT o BIGINT según la magnitud, los decimales a FLOAT, los booleanos al tipo booleano específico del dialecto (BOOLEAN para PostgreSQL, TINYINT(1) para MySQL, BIT para SQL Server), y los valores nulos hacen la columna nullable. Las cadenas de fecha ISO 8601 como '2026-03-20' se detectan y mapean a tipos DATE o TIMESTAMP. Los objetos y arrays anidados se almacenan como columnas JSON/JSONB.
¿Cuáles son las diferencias entre los dialectos SQL?
Cada dialecto SQL tiene una sintaxis única para identificadores, tipos de datos y características. MySQL usa acentos graves para citar (por ejemplo, `column_name`), PostgreSQL usa comillas dobles, SQLite usa comillas dobles y SQL Server usa corchetes ([column_name]). Los tipos booleanos difieren: PostgreSQL tiene BOOLEAN nativo, MySQL usa TINYINT(1) y SQL Server usa BIT. La sintaxis de auto-incremento varía: MySQL usa AUTO_INCREMENT, PostgreSQL usa SERIAL, SQLite usa AUTOINCREMENT y SQL Server usa IDENTITY(1,1). El almacenamiento JSON también difiere: PostgreSQL tiene JSONB, MySQL tiene JSON, mientras que SQLite y SQL Server usan TEXT/NVARCHAR(MAX).
¿Están seguros mis datos al usar esta herramienta?
Sí, completamente. Esta herramienta procesa todo en su navegador usando JavaScript del lado del cliente. Sus datos JSON nunca salen de su computadora — no hay cargas al servidor, no hay llamadas API y no hay almacenamiento de datos. Esto lo hace seguro para usar con datos de bases de datos de producción, respuestas de API que contengan información sensible y cualquier dato confidencial que necesite convertir a SQL.
¿Cómo maneja la herramienta los objetos y arrays JSON anidados?
La herramienta ofrece dos estrategias para JSON anidado. La estrategia predeterminada 'columna JSON' almacena objetos y arrays anidados como columnas JSON/JSONB en la base de datos, preservando la estructura original. La estrategia 'Aplanar' normaliza los datos creando tablas relacionadas separadas con relaciones de clave foránea — los objetos anidados se convierten en columnas aplanadas con nombres prefijados, y los arrays de objetos crean tablas hijas. Elija columnas JSON para almacenamiento rápido y consultas flexibles, o aplanamiento para un diseño de esquema relacional completamente normalizado.
¿Qué es el modo de INSERT por lotes?
El modo de INSERT por lotes combina múltiples filas en una sola sentencia INSERT usando sintaxis de valores múltiples: INSERT INTO table VALUES (...), (...), (...). Esto es significativamente más rápido que las sentencias INSERT individuales al importar grandes conjuntos de datos porque reduce el número de viajes de ida y vuelta a la base de datos. Puede configurar el tamaño del lote (predeterminado: 100 filas por sentencia) para equilibrar entre el tamaño de la sentencia y el rendimiento. Todas las bases de datos principales soportan esta sintaxis.
Ejemplos de código
// JSON to SQL converter
function jsonToSql(jsonStr, options = {}) {
const {
tableName = 'my_table',
dialect = 'mysql',
includeCreate = true,
includeInsert = true,
} = options;
const data = JSON.parse(jsonStr);
const rows = Array.isArray(data) ? data : [data];
if (rows.length === 0) return '';
// Collect all column names
const columns = [...new Set(rows.flatMap(Object.keys))];
// Infer types from all rows
const types = {};
for (const col of columns) {
for (const row of rows) {
const val = row[col];
if (val === null || val === undefined) continue;
if (typeof val === 'boolean') types[col] = 'BOOLEAN';
else if (typeof val === 'number') {
types[col] = Number.isInteger(val) ? 'INT' : 'FLOAT';
} else if (typeof val === 'object') types[col] = 'JSON';
else types[col] = 'VARCHAR(255)';
}
if (!types[col]) types[col] = 'VARCHAR(255)';
}
const quote = dialect === 'mysql' ? (n) => `\`${n}\``
: dialect === 'sqlserver' ? (n) => `[${n}]`
: (n) => `"${n}"`;
const parts = [];
if (includeCreate) {
const colDefs = columns.map(c => ` ${quote(c)} ${types[c]}`);
parts.push(`CREATE TABLE ${quote(tableName)} (\n${colDefs.join(',\n')}\n);`);
}
if (includeInsert) {
for (const row of rows) {
const vals = columns.map(c => {
const v = row[c];
if (v === null || v === undefined) return 'NULL';
if (typeof v === 'boolean') return v ? 'TRUE' : 'FALSE';
if (typeof v === 'number') return String(v);
if (typeof v === 'object') return `'${JSON.stringify(v).replace(/'/g, "''")}'`;
return `'${String(v).replace(/'/g, "''")}'`;
});
parts.push(
`INSERT INTO ${quote(tableName)} (${columns.map(quote).join(', ')}) VALUES (${vals.join(', ')});`
);
}
}
return parts.join('\n\n');
}
// Example usage
const json = '[{"id":1,"name":"Alice","active":true},{"id":2,"name":"Bob","active":false}]';
console.log(jsonToSql(json, { tableName: 'users', dialect: 'postgresql' }));