La respuesta corta
Una base de datos no puede leer un .xlsx por sí sola. Algo tiene que leer la hoja, decidir el tipo de cada columna, crear la tabla e insertar las filas. Puedes dejar que lo haga el asistente de importación de tu base de datos, cargar un CSV con un comando masivo o generar SQL plano que cualquier cliente pueda ejecutar.
El SQL generado es la opción más portable y la más fácil de revisar, porque ves exactamente qué se va a crear antes de tocar la base de datos. En el convertidor de abajo, abre el .xlsx o el .csv (o pega celdas copiadas de Excel), elige la Base de datos, escribe el Nombre de la tabla y copia o descarga el script. Los tipos de columna se detectan a partir de los datos, y los códigos de barras o códigos con ceros a la izquierda quedan como texto.
Pruébalo aquí: Excel a SQL
Abrir la herramienta completaPrepara la hoja antes
La mayoría de las importaciones fallidas se deben a la hoja de cálculo, no a la base de datos. Las hojas se hacen para personas; una tabla necesita un rectángulo limpio de datos. Dedica dos minutos a esto antes de importar:
- Una sola fila de encabezado con nombres de columna distintos. Quita los títulos encima de la tabla, las celdas de encabezado combinadas y las segundas filas de encabezado.
- Una fila por registro. Borra las filas de totales y subtotales, las filas vacías de separación y las notas debajo de los datos.
- Un tipo de valor por columna. Una columna Precio no debería tener el texto a consultar en algunas filas; deja la celda vacía, que se convierte en NULL.
- Nada de celdas combinadas dentro de los datos. Sepáralas y escribe el valor en cada fila a la que corresponde.
- Las fórmulas no son problema: se usa el último valor calculado guardado en el archivo. Asegúrate de que el libro se recalculó y se guardó después del último cambio.
- Cada tabla en su propia hoja. Si el libro tiene varias hojas, el convertidor muestra un selector de Hoja.
Métodos comparados
| Método | Ideal para | Ojo con |
|---|---|---|
| SQL generado (esta página) | Hasta decenas de miles de filas, cualquier base de datos, script revisable | Archivos enormes generan scripts enormes |
| SQL Server Import and Export Wizard | Importaciones habituales a SQL Server | Leer .xlsx requiere Microsoft Access Database Engine; las versiones de 32 y 64 bits deben coincidir |
| SSMS Import Flat File | CSV a SQL Server | Revisa los tipos que adivina antes de terminar |
| BULK INSERT (SQL Server), LOAD DATA (MySQL), COPY (PostgreSQL) | Millones de filas desde CSV | Permisos de archivo en el servidor, opciones de separador y codificación |
| MySQL Workbench Table Data Import Wizard | CSV o JSON a MySQL | Lento con archivos grandes |
| Importar/Exportar de pgAdmin | CSV a una tabla de PostgreSQL que ya existe | La tabla debe existir antes |
| El comando .import del shell sqlite3 (modo csv) | CSV a SQLite | Si la tabla no existe, las columnas se crean como TEXT |
Paso a paso con SQL generado
- Abre el archivo o pega las celdas. La primera fila se convierte en los nombres de columna; desactiva La primera fila es el encabezado si tus datos no lo tienen.
- Elige la Base de datos: SQL Server, MySQL, PostgreSQL o SQLite. Las comillas, los tipos y el escape cambian según cuál sea.
- Escribe el Nombre de la tabla. Con Simplificar nombres activado, Nombre del producto pasa a nombre_del_producto, lo que te ahorra poner comillas en cada consulta posterior.
- Elige Filas por INSERT. 100 es un valor seguro; los lotes grandes importan más rápido. SQL Server acepta como máximo 1000 filas en una lista VALUES, así que con SQL Server la herramienta nunca supera esa cifra.
- Decide los extras: CREATE TABLE escribe la definición de la tabla, Eliminar la tabla antes borra una tabla existente con el mismo nombre (úsalo solo con tablas que quieras reemplazar) y Usar una transacción hace que la importación sea todo o nada.
- Copia el SQL o descarga el archivo .sql y ejecútalo en tu cliente de base de datos.
Los tipos de columna que elige el convertidor
Cada columna recibe el tipo más ajustado que admite todos sus valores. Las columnas de texto reciben una longitud redondeada hacia arriba a partir del valor más largo (por ejemplo VARCHAR(50) para un máximo de 37 caracteres), y siempre puedes ampliarla después.
| Datos de la columna | SQL Server | MySQL | PostgreSQL | SQLite |
|---|---|---|---|---|
| Números enteros | INT o BIGINT | INT o BIGINT | INTEGER o BIGINT | INTEGER |
| Decimales | DECIMAL(p, s) | DECIMAL(p, s) | NUMERIC(p, s) | REAL |
| true o false | BIT | TINYINT(1) | BOOLEAN | INTEGER |
| Fechas | DATE | DATE | DATE | TEXT |
| Fecha y hora | DATETIME2 | DATETIME | TIMESTAMP | TEXT |
| Texto, códigos con ceros iniciales | NVARCHAR(n) | VARCHAR(n) | VARCHAR(n) | TEXT |
Problemas habituales y cómo evitarlos
- Las fechas llegan como números tipo 45000. Excel guarda las fechas como un recuento de días (45000 es el 15 de marzo de 2023). Al leer un .xlsx con el convertidor, las celdas de fecha vuelven a ser fechas reales; con otras herramientas puede que tengas que dar formato de fecha a la columna antes.
- Desaparecen los ceros iniciales. Códigos de barras, códigos postales y códigos de producto como 00123 tienen que ser texto. El convertidor deja como texto las columnas cuyos valores empiezan por cero, y los números de más de 15 dígitos también quedan como texto.
- Las tildes y la ñ se convierten en signos de interrogación en SQL Server. El texto Unicode necesita columnas NVARCHAR y el prefijo N en los literales; el script generado para SQL Server usa las dos cosas. En MySQL, usa una tabla utf8mb4.
- Números con coma decimal. En CSV separados por punto y coma, valores como 1.499,90 se leen como 1499.90. En archivos separados por comas la coma es el separador de columnas, así que esos valores tienen que ir entre comillas.
- Celdas vacías. Se convierten en NULL y la columna se crea admitiendo nulos. Si prefieres texto vacío, cámbialo después de importar.
- Comillas dentro del texto. Un apóstrofo como el de O'Higgins rompería un INSERT escrito a mano; los valores generados se escapan, y en MySQL también las barras invertidas.
Cuándo usar un cargador masivo
Los scripts de INSERT son perfectos para unos miles o decenas de miles de filas: se pueden leer, guardar en control de versiones y ejecutar en cualquier sitio. Con cientos de miles o millones de filas, el script crece muchísimo y ejecutarlo es más lento que una carga masiva.
En ese caso guarda la hoja como CSV UTF-8 y usa el comando masivo de tu base de datos: BULK INSERT en SQL Server, LOAD DATA LOCAL INFILE en MySQL, COPY o el \copy de psql en PostgreSQL. Un camino intermedio útil es dejar que el convertidor escriba solo la sentencia CREATE TABLE a partir de una muestra de los datos, para tener tipos de columna sensatos, y luego cargar el CSV completo en esa tabla con el comando masivo.