Convertidor de Excel a SQL
Sube un archivo Excel para convertirlo en sentencias SQL INSERT
Arrastra un archivo Excel aquí o haz clic para seleccionar
¿Qué es Excel a SQL?
Excel a SQL es una herramienta en línea de conversión de formatos de datos que convierte archivos Excel (.xlsx/.xls) en sentencias SQL INSERT para facilitar la importación a bases de datos.
Excel es el formato de hoja de cálculo más utilizado, ampliamente empleado para almacenamiento y análisis de datos. SQL es el lenguaje de consulta estándar para bases de datos relacionales, y las sentencias INSERT se utilizan para insertar datos en tablas de bases de datos.
Con esta herramienta, puedes convertir rápidamente datos de hojas de cálculo Excel en sentencias SQL ejecutables, con soporte para selección de múltiples hojas, nombres de tabla personalizados y estilos de comillas para facilitar las operaciones de migración e importación de datos.
Cómo usar
Cómo usar
- Sube un archivo Excel (formato .xlsx o .xls).
- Si existen varias hojas, selecciona la hoja a convertir.
- Establece el nombre de la tabla (por defecto es table_name).
- Elige si deseas usar la primera fila como nombres de campos.
- Las sentencias SQL INSERT se generan automáticamente, cópialas con un solo clic.
Comprobaciones de generación SQL
- Inspecciona los nombres de columnas, tipos de datos, comillas y manejo de NULL antes de ejecutar el SQL generado en una base de datos real.
- Para importaciones en producción, prueba primero en una tabla temporal y conserva una copia de seguridad de la hoja de cálculo original.
Casos de uso
Principio técnico
La página analiza el libro subido con SheetJS: XLSX.read(arrayBuffer, {type: 'array'}) devuelve un objeto workbook cuya hoja tiene celdas indexadas por claves A1, luego XLSX.utils.sheet_to_json(sheet, {header: 1, defval: null}) recorre el rango acotado !ref en un array de arrays. La primera fila no vacía (cuando la opción de primera fila como encabezado está activa) se toma como nombres de columna; de lo contrario se sintetizan col1, col2, col3 al estilo SheetJS. Cada fila restante se emite como una sentencia SQL de la forma INSERT INTO `tabla` (`c1`, `c2`, ...) VALUES (v1, v2, ...);, opcionalmente precedida por CREATE TABLE `tabla` (`c1` VARCHAR(255), ...);. El estilo de comillas de identificadores varía según el dialecto SQL y está gobernado por el estándar SQL:1992 y la desviación de cada fabricante: SQL estándar y PostgreSQL comillas dobles ("col"), MySQL y MariaDB usan acentos graves (`col`) por defecto y solo aceptan comillas dobles cuando el modo SQL ANSI_QUOTES está activado, SQLite acepta tanto acentos graves como comillas dobles (y, por compatibilidad con versiones anteriores, trata los identificadores entre comillas dobles que no se resuelven como literales de cadena, un problema conocido documentado en la página de peculiaridades de SQLite), SQL Server y Sybase usan corchetes ([col]). El entrecomillado de valores sigue las reglas de literales de cadena SQL: las comillas simples envuelven el literal y se escapan duplicándolas ('O''Brien'), según ISO/IEC 9075. Las celdas vacías se asignan al literal sin comillas NULL, no a la cadena vacía ''; las celdas numéricas con cell.t === 'n' se emiten sin comillas; los booleanos se convierten en 1/0 o TRUE/FALSE según el dialecto; las fechas requieren manejo explícito. Las celdas de fecha necesitan atención especial porque SheetJS conserva el número serial subyacente: Excel almacena fechas como días desde 1900-01-01 con el error histórico del año bisiesto de 1900-02-29 que desplaza las fechas anteriores a marzo de 1900 un día, y el sistema Excel para Mac de 1904 usa 1904-01-01 como época. La conversión a ISO 8601 (YYYY-MM-DD HH:mm:ss, el formato que aceptan tanto MySQL DATETIME como PostgreSQL TIMESTAMP) es (serial - 25569) * 86400000 ms desde la época Unix, formateada en UTC. La inferencia de tipos es puramente léxica y superficial: una columna cuya primera celda no vacía es un número entero se convierte en INT, decimal en DECIMAL(10,2), texto en VARCHAR(255), y una columna que empieza con 2024-01-01 puede exportarse como cadena a menos que la celda original tenga cell.t === 'd'. Las inserciones masivas se emiten como un INSERT por fila, que es lento a gran escala; combinar 100-500 filas en un solo INSERT INTO t VALUES (...), (...), ...; reduce los viajes de red en ~100x, y envolver el script en BEGIN; ... COMMIT; convierte la importación en una transacción atómica que retrocede en la primera fila fallida.
- Comillas de identificadores por dialecto: MySQL/MariaDB `col` (acentos graves, o "col" con ANSI_QUOTES activado); PostgreSQL y SQL estándar "col"; SQL Server [col]; SQLite acepta ambos (pero "col" recurre silenciosamente a un literal de cadena cuando col no es un identificador conocido).
- Escape de literales de cadena (ISO/IEC 9075): envolver con comillas simples y doblar las comillas simples internas (O'Brien -> 'O''Brien'); nunca usar barras invertidas en bruto, ya que PostgreSQL standard_conforming_strings está activado por defecto desde la versión 9.1.
- Número serial de fecha de Excel: días desde 1900-01-01 con el error de 1900-02-29 (o 1904-01-01 si workbook.date1904 es true); cadena ISO 8601 = new Date((serial - 25569) * 86400000).toISOString().
- La inferencia de tipos es léxica: enteros -> INT, decimales -> DECIMAL(10,2), texto -> VARCHAR(255); las fechas que parecen fechas pero no tienen el tipo cell.t === 'd' se exportan como cadenas; las celdas monetarias con separador de miles se exportan con el separador dentro de la cadena.
- Manejo de NULL: una celda vacía de Excel se convierte en el literal sin comillas NULL, no en '' — la diferencia importa para columnas NOT NULL y para COUNT(col) que omite NULL pero cuenta ''.
- Inserción masiva: combinar 100-500 filas en un solo INSERT INTO t VALUES (...),(...),...; reduce los viajes de red en ~100x comparado con un INSERT por fila; max_allowed_packet de MySQL (64 MB por defecto) limita el tamaño de cada sentencia.
- Envuelve el script generado en BEGIN;...COMMIT; (PostgreSQL/SQLite) o START TRANSACTION;...COMMIT; (MySQL InnoDB) para que una sola fila fallida retroceda todo el lote; las tablas MyISAM ignoran la transacción y hacen commit parcial.
Ejemplos
Hoja Excel → sentencias INSERT
Hoja "users" (3 filas):
id | name | email | age
1 | Alice | alice@mail.com | 28
2 | Bob | bob@mail.com | 34
SQL generado:
INSERT INTO users (id, name, email, age) VALUES (1, 'Alice', 'alice@mail.com', 28);
INSERT INTO users (id, name, email, age) VALUES (2, 'Bob', 'bob@mail.com', 34);Único INSERT con varias filas (importación más rápida)
Usa la opción "combinar filas" para cargas masivas:
INSERT INTO products (sku, name, price) VALUES
('A001', 'USB-C Cable', 9.90),
('A002', 'HDMI Adapter', 14.50),
('A003', 'Mouse Pad', 4.25);
Reduce 3 viajes de ida y vuelta a 1: más seguro para lotes de 100-500 filas.Escape de comillas en nombres con apóstrofo
Celda origen: O'Brien
SQL generado (comillas simples duplicadas):
INSERT INTO customers (id, name) VALUES (42, 'O''Brien');
Manejo de NULL: una celda Excel vacía se convierte en NULL literal, no en '':
INSERT INTO customers (id, phone) VALUES (43, NULL);Envolver la importación en una transacción
BEGIN;
INSERT INTO orders (id, customer_id, total, created_at) VALUES (1001, 7, 199.50, '2026-06-01');
INSERT INTO orders (id, customer_id, total, created_at) VALUES (1002, 7, 42.00, '2026-06-02');
INSERT INTO orders (id, customer_id, total, created_at) VALUES (1003, 9, 78.30, '2026-06-03');
COMMIT;
Si alguna fila falla, todo el lote se revierte.Preguntas frecuentes
¿Se sube la hoja de cálculo a algún servidor?
No. El archivo se procesa en tu navegador con SheetJS y el SQL se genera localmente. Nada se envía a un servidor, así que incluso los datos sensibles permanecen en tu dispositivo.
¿Qué tipo de SQL produce?
Una sentencia CREATE TABLE seguida de filas INSERT INTO individuales (una sentencia por fila). El SQL generado usa el nombre de tabla que indicaste y el estilo de comillas que elegiste (simples, dobles o backtick).
¿Cómo se infieren los tipos de columna?
La página muestrea cada columna y elige el tipo más estrecho que encaje: INTEGER, DECIMAL, VARCHAR(N), BOOLEAN o DATE/DATETIME. Puedes sobrescribirlos antes de generar el SQL. Las columnas con tipos mezclados caen a VARCHAR.
¿Qué pasa con las fechas de Excel?
Excel guarda las fechas como números seriales. La página las imprime tal y como vienen en la hoja. Revisa el SQL generado y ajusta los literales de fecha para que coincidan con el formato de tu base de datos destino si hace falta.
¿Cómo se escapan los caracteres especiales y las comillas?
Las comillas simples se duplican (Smith's → Smith''s). Las barras invertidas y el Unicode pasan tal cual; esto se ajusta al estándar de cadenas de PostgreSQL. Si tu destino es MySQL con NO_BACKSLASH_ESCAPES desactivado, puede que tengas que escapar las barras a mano.
¿Funcionará el resultado en MySQL, PostgreSQL, SQLite y MSSQL?
Los INSERT básicos funcionan en los cuatro. La sentencia CREATE TABLE usa tipos portables (INT, VARCHAR, DECIMAL, DATE). Para tipos específicos del dialecto (SERIAL, AUTO_INCREMENT, IDENTITY) edita el CREATE para adaptarlo a tu destino.
¿Se evalúan las fórmulas?
No. Se usa el valor cacheado que Excel guardó. Abre el libro original, recalcula, guarda y vuelve a subirlo si necesitas valores de fórmula actualizados.