logo
GeekFormat

Conversor de SQL

El conversor de SQL en línea de GeekFormat transforma con un clic las sentencias SQL INSERT y los scripts CREATE TABLE a JSON, CSV, TSV, XML, YAML, tablas HTML, tablas Markdown, JSON Lines y muchos otros formatos. Admite múltiples sentencias INSERT y el análisis por lotes de tuplas multivalor, reconoce automáticamente números, cadenas, NULL, booleanos y literales hexadecimales, y es compatible con los estilos de comillas de identificador de MySQL, PostgreSQL, SQLite y SQL Server. Los datos de varias tablas pueden exportarse por separado o combinarse. También permite reconstruir sentencias INSERT y cambiar de dialecto. El procesamiento es totalmente local en el navegador, ningún dato sale del dispositivo.

Relacionado

Sobre la conversión SQL: transformar scripts SQL a JSON/CSV/XML y otros formatos

La conversión SQL (SQL Conversion) consiste en extraer datos de un script SQL y reorganizarlos en otros formatos de datos como JSON, CSV, XML, YAML, HTML o Markdown. SQL (Structured Query Language, lenguaje de consulta estructurado) es el lenguaje de consulta estándar de las bases de datos relacionales. Las herramientas de exportación de bases de datos (mysqldump, pg_dump) suelen producir los datos en forma de sentencias INSERT dentro de un script SQL. Este formato, aunque práctico para importar a bases de datos, es incómodo para la lectura por programas, el análisis de datos o el intercambio entre sistemas, por lo que es necesario convertirlo a formatos más universales.

Los scripts habituales de exportación de datos SQL contienen dos tipos de sentencias: CREATE TABLE define la estructura de la tabla (nombres de columnas, tipos de datos, restricciones), e INSERT INTO ... VALUES (...) inserta los datos propiamente dichos. Esta herramienta analiza ambos tipos de sentencias: extrae las definiciones de columnas y la información de tipos de CREATE TABLE, y las filas de datos reales de INSERT, y luego reorganiza la salida en el formato elegido por el usuario. Todo el proceso de análisis se realiza localmente en el navegador, sin depender de ningún servicio backend.

¿Por qué es necesario convertir SQL a otros formatos? SQL, aunque universal, resulta poco práctico en los siguientes escenarios: primero, un programa frontend lee JSON mucho más fácilmente que SQL, sin necesidad de integrar un analizador SQL; segundo, las hojas de cálculo como Excel o Google Sheets admiten de forma nativa CSV, no SQL; tercero, YAML y Markdown son más legibles que SQL en escenarios de configuración y documentación; cuarto, el intercambio de datos entre sistemas suele emplear XML o JSON como formato neutro. Una vez convertido a estos formatos universales, los datos pueden consumirse directamente por más herramientas y lenguajes.

El analizador SQL de esta herramienta está escrito a mano y se centra en las sentencias INSERT y CREATE TABLE. Para INSERT admite tanto tuplas de valor único (INSERT INTO t (a,b) VALUES (1,2)) como tuplas multivalor (INSERT INTO t (a,b) VALUES (1,2), (3,4), (5,6)), mapeando automáticamente los datos a los nombres de columna. Para CREATE TABLE analiza definiciones de columnas, tipos de datos (VARCHAR(255), INT, DECIMAL(10,2) etc., con longitud entre paréntesis), y restricciones y cláusulas como NOT NULL, PRIMARY KEY, IF NOT EXISTS, tratando correctamente los paréntesis anidados para evitar divisiones erróneas.

El reconocimiento de tipos es clave para la conversión SQL. La herramienta determina automáticamente el tipo a partir de la forma literal del valor: las cadenas con comillas simples o dobles son cadenas; NULL (sin distinguir mayúsculas/minúsculas) es el valor nulo; TRUE/FALSE son booleanos; 0x..., X'...', B'...' son literales hexadecimales; y los números puros (con signo, separador decimal, notación científica) son números. Este reconocimiento automático de tipos garantiza que JSON, CSV y otros formatos conserven la semántica de los datos originales (por ejemplo el número 1 y no la cadena "1"), para que los programas posteriores procesen los valores correctamente.

Las diferencias en los estilos de comillas de identificador entre dialectos son una trampa habitual del análisis SQL. MySQL usa por defecto el acento grave (`) para rodear identificadores (nombres de tablas y columnas), PostgreSQL las comillas dobles ("), SQL Server/T-SQL los corchetes ([]), y SQL estándar también comillas dobles. La función unquoteIdentifier de esta herramienta reconoce y elimina automáticamente estas comillas, tratando también los escapados internos (por ejemplo `` → `, "" → "). En el modo de reconstrucción SQL, INSERT puede regenerarse con el estilo de comillas del dialecto destino elegido.

El escapado de cadenas SQL es otro punto técnico esencial. El estándar SQL establece que las comillas simples dentro de una cadena se escapan duplicándolas ('It''s' representa It's). MySQL admite además el escapado con barra invertida (\n, \t, \', \", \\, \0, \Z). El analizador de cadenas de esta herramienta trata ambos mecanismos de escapado y restituye correctamente el contenido original. En la conversión a CSV, los campos con coma, comilla o salto de línea se reescapan conforme a RFC 4180; en la conversión a XML/HTML, los caracteres especiales &, <, >, ", ' se escapan.

El procesamiento puramente frontend es un principio de diseño fundamental de esta herramienta. Todos los pasos de análisis SQL y conversión de datos se ejecutan en el motor JavaScript del navegador, sin enviar ningún dato a un servidor. Esto significa que incluso si el script SQL contiene información personal, datos comerciales sensibles o la estructura interna de una base de datos, nada se filtra al exterior. Este enfoque es especialmente adecuado para exports de bases de datos de producción, sin preocupaciones de cumplimiento normativo. Al mismo tiempo, el procesamiento frontend elimina la latencia de red; la velocidad de conversión solo está limitada por la CPU y la memoria del dispositivo.

Comparado con las herramientas tradicionales de conversión SQL en línea de comandos (sql2csv, sqlparser), esta herramienta ofrece varias ventajas: no requiere instalación ni configuración de entorno, se usa directamente desde la página web; interfaz visual con vista previa en tiempo real del resultado; cambio con un clic entre varios formatos de salida; datos de ejemplo y documentación integrados; diseño responsive móvil utilizable desde cualquier lugar. A cambio, la herramienta se centra en la extracción de datos y no trata diferencias complejas entre dialectos (operadores JSONB de PostgreSQL, ON DUPLICATE KEY UPDATE de MySQL) ni funciones avanzadas (procedimientos almacenados, funciones, disparadores). Para este tipo de necesidades, utilice herramientas nativas de base de datos o plataformas ETL especializadas.

Al usar la herramienta de conversión SQL conviene tener en cuenta algunas buenas prácticas: primero, antes de convertir, comprobar que el script SQL contiene datos completos (sentencias INSERT) y no solo consultas (SELECT), ya que SELECT no se analiza; segundo, para scripts SQL con varias tablas, activar «Salida separada por tablas» para conservar la información de estructura; tercero, para SQL con caracteres chinos, activar «Incluir BOM» en la salida CSV para que Excel reconozca la codificación; cuarto, para dumps SQL grandes, desactivar «salida formateada» para reducir el volumen de salida; quinto, para migrar entre bases de datos, usar el modo «Reconstrucción SQL» para cambiar de dialecto, teniendo en cuenta que los tipos complejos (arrays de PostgreSQL, JSONB) pueden requerir ajustes manuales.

Casos de uso

  • Convertir a JSON los scripts SQL exportados por mysqldump o pg_dump, para importar datos vía API o consumirlos en el frontend
  • Convertir sentencias INSERT de base de datos en archivos CSV, para importarlos en Excel/WPS/Google Sheets y realizar análisis de datos o informes
  • Extraer datos de scripts de copia de seguridad SQL a XML, para el intercambio de datos entre sistemas o la integración con interfaces SOAP
  • Convertir datos SQL al formato de configuración YAML, para escenarios de configuración de Ansible, Docker Compose, Kubernetes, etc.
  • Convertir resultados de consultas SQL (exportados como INSERT) en tablas HTML, para incrustarlos directamente en páginas web
  • Convertir datos SQL en tablas Markdown, para pegarlas en README, sitios de documentación o blogs técnicos
  • Extraer datos de scripts completos CREATE TABLE + INSERT y convertirlos a JSON Lines para la indexación masiva en Elasticsearch
  • Al migrar bases de datos, reconstruir scripts INSERT de MySQL en dialecto PostgreSQL para facilitar la importación entre bases de datos
  • Gestión de datos de prueba: convertir datos semilla SQL a configuración JSON, fácil de leer y versionar por los programas
  • Demostraciones didácticas: convertir sentencias SQL a varios formatos y compararlas, para ayudar a los estudiantes a comprender las diferencias entre representaciones de datos
  • Preprocesamiento ETL: convertir dumps SQL ascendentes a JSON/CSV estructurado como entrada de pipelines ETL descendentes
  • Análisis de datos: extraer datos clave de exports SQL a CSV, para analizarlos con pandas, R y otras herramientas estadísticas
  • Entrega al cliente: convertir exports de base de datos a los formatos JSON o CSV, más universales, para que los no técnicos puedan consultarlos
  • Archivado de datos: convertir los scripts INSERT de bases de datos históricas a YAML o Markdown, más legibles para archivo

Cómo Usar

  1. Pegue el script SQL en el cuadro de entrada de la izquierda, o haga clic en el botón «Cargar SQL» para seleccionar un archivo .sql/.txt
  2. Haga clic en el botón «Ejemplo» para cargar un ejemplo SQL integrado (con CREATE TABLE y varios INSERT de tablas)
  3. Seleccione el formato destino (JSON, CSV, XML, YAML y otros 5) en el menú desplegable de formato en la parte superior del panel de salida a la derecha
  4. Haga clic en «Ajustes» para configurar las opciones de conversión: salida formateada, incluir BOM, salida separada por tablas, separador CSV, nombre de clave raíz JSON, dialecto SQL, etc.
  5. Haga clic en «Convertir» para ejecutar la conversión. El resultado se muestra en el panel derecho, la barra de estado inferior indica el número de tablas, filas, sentencias INSERT y otras estadísticas
  6. Haga clic en «Copiar» para copiar el resultado al portapapeles, o en «Descargar» para guardarlo como archivo en el formato correspondiente (por ejemplo result.json, result.csv)
  7. Al cambiar de formato de salida se reconvierte automáticamente, sin necesidad de pulsar de nuevo el botón Convertir

Características

  • Nueve formatos de salida: JSON, JSON Lines, CSV, TSV, XML, YAML, tabla HTML, tabla Markdown, reconstrucción SQL — cambie de formato con un clic y la reconversión es automática
  • Análisis de sentencias INSERT: reconocimiento automático de la sintaxis INSERT INTO ... VALUES (...), compatibilidad con tuplas únicas y multivalor (varias filas de datos en una sola sentencia INSERT)
  • Reconocimiento de CREATE TABLE: analiza sentencias CREATE TABLE para extraer definiciones de columnas, tipos de datos, NOT NULL, PRIMARY KEY y otras restricciones, con el fin de inferir tipos de campo
  • Procesamiento de varias tablas: cuando un script contiene varias tablas, la salida puede ser por tabla (con marcadores de separación por nombre de tabla) o combinada, agregando automáticamente las columnas y filas de cada tabla
  • Reconocimiento automático de tipos: identificación inteligente de números (enteros/de coma flotante), cadenas, NULL, booleanos (TRUE/FALSE) y literales hexadecimales (0x..., X'...', B'...'), conservando la semántica de tipo original
  • Compatibilidad con varios dialectos: reconoce los acentos graves de MySQL (`), las comillas dobles de PostgreSQL ("), los corchetes de SQL Server ([]) y las comillas estándar, y elimina automáticamente las comillas de identificador
  • Escapado de cadenas SQL: trata el escapado estándar SQL ('' → ') y el escapado con barra invertida de MySQL (\n, \r, \t, \0, \', \") para restituir correctamente las cadenas con caracteres especiales
  • Reconstrucción de dialecto SQL: las sentencias INSERT pueden regenerarse en los dialectos MySQL, PostgreSQL, SQLite o SQL estándar, con nombre de tabla personalizado y generación opcional de CREATE TABLE
  • Configuración flexible de CSV: separador a elección (coma/punto y coma/Tabulación/Barra vertical), cabecera BOM UTF-8 opcional (compatible con Excel), sangría opcional, conforme al estándar RFC 4180
  • Múltiples estructuras JSON: tres estructuras de salida JSON a elegir — agrupadas por tabla (clave raíz tables), datos puros (clave raíz data) o array puro (sin clave raíz), adaptadas a distintos escenarios de consumo
  • Estadísticas en tiempo real: tras la conversión, se muestran en tiempo real el número de tablas, el número total de filas, el número de sentencias INSERT y el número de caracteres de salida, para verificar la integridad del resultado
  • Carga y descarga de archivos: permite cargar archivos .sql/.txt/.csv/.tsv/.json para su análisis directo y descargar el resultado como archivo en el formato correspondiente (.json, .csv, .yaml)
  • Gestión del historial: panel lateral integrado a la izquierda que guarda automáticamente las últimas entradas SQL convertidas, para recargar rápidamente scripts anteriores
  • Diseño responsive para móvil: en smartphones cambia automáticamente a un diseño de pestañas entrada/resultado, en escritorio usa un panel doble redimensionable, todas las interacciones también están disponibles en móvil
  • Procesamiento totalmente local en el navegador: todos los pasos de análisis y conversión se ejecutan en el JavaScript del navegador, sin ninguna petición al servidor. Los datos SQL no salen del dispositivo — ideal para exports de base de datos con información sensible

Preguntas Frecuentes

¿A qué formatos se puede convertir SQL?

Esta herramienta admite nueve formatos de salida: JSON (array estructurado), JSON Lines (un objeto JSON por línea), CSV (separado por comas), TSV (separado por tabulaciones), XML (documento XML estándar con etiquetas), YAML (formato de configuración), tabla HTML (con estilos, visualizable directamente en el navegador), tabla Markdown (sintaxis de documentación) y reconstrucción SQL (regeneración de sentencias INSERT con dialecto a elegir). Basta un clic en el menú desplegable de formato de la derecha para alternar y reconvertir automáticamente.

¿Qué sentencias SQL se admiten?

Principalmente se analizan las sentencias INSERT INTO ... VALUES (...) para extraer datos, y se reconocen las sentencias CREATE TABLE para obtener definiciones de columnas e información de tipos. Admite INSERT únicos, INSERT con tuplas múltiples (varias filas en una sola sentencia), varias sentencias INSERT y INSERT distribuidas en varias tablas. Los comentarios (-- una línea, /* */ varias líneas, # MySQL una línea) se eliminan automáticamente y no afectan al análisis.

¿Qué dialectos de base de datos se admiten?

Durante el análisis son compatibles los estilos de comillas de identificador de MySQL (acento grave `), PostgreSQL (comillas dobles "), SQL Server (corchetes []) y SQL estándar, y se eliminan automáticamente para restituir los nombres originales de columnas y tablas. En el modo de reconstrucción SQL, INSERT puede regenerarse en los dialectos MySQL, PostgreSQL, SQLite o SQL estándar; las comillas y la representación de booleanos varían según el dialecto.

¿Cómo se gestionan varias tablas en un script SQL?

La herramienta agrega automáticamente los datos INSERT por nombre de tabla. Cuando se activa «Salida separada por tablas» en los ajustes, los formatos tabulares como CSV/HTML/Markdown se emiten por segmentos (con marca de nombre de tabla), y los formatos estructurados como JSON/XML se agrupan por nombre de tabla. Si la opción está desactivada, CSV solo produce los datos de la primera tabla, y JSON puede emitirse sin clave raíz como array puro.

¿Cómo se tratan NULL, los booleanos y los caracteres especiales en SQL?

La herramienta reconoce automáticamente NULL (sin distinguir mayúsculas/minúsculas), los booleanos TRUE/FALSE, los literales hexadecimales (0x..., X'...', B'...'), los enteros y los números de coma flotante. Las cadenas se tratan con el escapado estándar SQL ('' → ') y el escapado con barra invertida de MySQL (\n, \t, \' etc.) para restituir correctamente el contenido original con saltos de línea, comillas y caracteres especiales. En la salida CSV, los campos que contienen coma, comilla o salto de línea se rodean de comillas y se escapan conforme al estándar RFC 4180.

¿Cuál es la estructura del JSON convertido?

La salida JSON admite tres estructuras: «clave raíz tables» (agrupada por nombre de tabla, recomendada para varias tablas), «clave raíz data» (encapsulación unificada), «sin clave raíz» (array puro, adecuado para una sola tabla o procesamiento en flujo). Por ejemplo, una tabla única users se convierte en [{"id":1,"name":"Alice"},...], varias tablas se agrupan por nombre en {"users":[...],"orders":[...]}. Seleccionable en los ajustes.

¿Los archivos SQL cargados se guardan en el servidor?

No. Esta herramienta es una aplicación puramente frontend. Todos los pasos de análisis y conversión se ejecutan localmente en el JavaScript del navegador, sin enviar el contenido SQL ni los resultados a ningún servidor. Los archivos cargados se leen directamente en el navegador mediante FileReader y se eliminan automáticamente al cerrar la página. Adecuado para exports de base de datos con datos personales o sensibles.

¿Se admiten los identificadores con corchetes de SQL Server?

Sí. La herramienta reconoce los identificadores con corchetes de SQL Server/T-SQL (por ejemplo [users], [order details]) y elimina automáticamente los corchetes para restituir los nombres originales. También admite los acentos graves de MySQL y las comillas dobles de PostgreSQL. En el modo de reconstrucción SQL, la elección del dialecto determina el estilo de comillas usado para regenerar INSERT.

¿Por qué la conversión de mi script SQL no produce ningún dato?

Compruebe si el SQL contiene sentencias INSERT INTO ... VALUES (...). Esta herramienta solo analiza sentencias INSERT para extraer datos; las consultas SELECT no generan salida. Si solo hay sentencias CREATE TABLE, se muestra la advertencia «Solo se ha detectado CREATE TABLE, no hay filas de datos que convertir». Asegúrese de que el script SQL es un export de datos (dump) y no consultas.

¿Se admiten procedimientos almacenados, funciones y disparadores?

No. Esta herramienta se centra en la extracción de datos y solo analiza sentencias INSERT y CREATE TABLE. Los procedimientos almacenados (CREATE PROCEDURE), funciones (CREATE FUNCTION), disparadores (CREATE TRIGGER) y vistas (CREATE VIEW) no se analizan. Para migrar estos objetos, use herramientas nativas como pg_dump o mysqldump.

¿Los caracteres chinos se muestran correctamente en el archivo CSV convertido al abrirlo en Excel?

Sí. Al activar la opción «Incluir BOM» en los ajustes, el archivo CSV lleva una cabecera BOM UTF-8 (\uFEFF), y Excel reconoce correctamente la codificación y muestra los caracteres no ASCII como el chino de forma correcta. Sin BOM, algunas versiones de Excel pueden mostrar el chino UTF-8 como caracteres erróneos. Las hojas de cálculo modernas como Google Sheets o WPS suelen reconocer la codificación correctamente incluso sin BOM.

¿Se pueden reconstruir sentencias INSERT a partir de un script SQL?

Sí. Con el formato de salida «Reconstrucción SQL» puede regenerar sentencias INSERT. Puede elegir el dialecto destino (MySQL/PostgreSQL/SQLite/SQL estándar), personalizar el nombre de tabla y generar opcionalmente una sentencia CREATE TABLE (los tipos de columna INT/BIGINT/FLOAT/VARCHAR/TEXT/BOOLEAN se deducen automáticamente a partir de los datos). Ideal para reconvertir un script MySQL al dialecto PostgreSQL o para reimportar tras modificar el nombre de tabla.

¿Cuál es la diferencia entre JSON Lines y JSON? ¿Cuándo usar JSON Lines?

La salida JSON es un array JSON completo ([{...},{...}]), adecuado para programas que cargan todo en memoria. JSON Lines (también llamado NDJSON) contiene un objeto JSON independiente por línea, adecuado para procesamiento en flujo, importación de grandes volúmenes, API bulk de Elasticsearch, análisis de logs, etc., donde la lectura línea a línea reduce el consumo de memoria. La herramienta permite alternar libremente entre ambos formatos.

¿Se conserva el orden original de las columnas en el resultado?

Sí. La herramienta mantiene los nombres de columna en el orden especificado en la sentencia INSERT. Si INSERT no indica explícitamente los nombres de columna (por ejemplo INSERT INTO t VALUES (...)), se generan nombres de columna de reemplazo como col_1, col_2, etc., en función del número de valores de la primera fila. El orden de columnas de cada tabla se conserva de forma independiente y se presenta por tabla en la exportación combinada.

¿Qué tamaño de archivo SQL se admite?

Teóricamente no hay un límite estricto; el límite lo marca la memoria del navegador. Los dumps SQL de algunas decenas de MB suelen procesarse con fluidez, mientras que los archivos muy grandes (varios cientos de MB) pueden ralentizarse por falta de memoria del navegador. Para archivos muy grandes se recomienda dividirlos en varios archivos más pequeños y convertirlos por lotes, o desactivar «salida formateada» para reducir el consumo de memoria. El análisis se realiza localmente en el navegador y no está limitado por la transferencia por red.

Solución de problemas

¿No hay datos de salida tras la conversión?

Causa 1: el script SQL solo contiene consultas SELECT. Esta herramienta solo analiza sentencias INSERT para extraer datos y no ejecuta consultas. Solución: use mysqldump/pg_dump para exportar los datos como sentencias INSERT. Causa 2: el script SQL solo tiene CREATE TABLE sin filas de datos; en ese caso se muestra una advertencia. Causa 3: la sintaxis INSERT no es estándar (por ejemplo falta la palabra clave VALUES); compruebe la sintaxis SQL. Causa 4: todo el contenido SQL está comentado (-- o /* */); verifique si se han dejado marcadores de comentario por error.

¿Los caracteres chinos del CSV se ven como caracteres erróneos en Excel?

Excel reconoce por defecto el CSV en codificación GBK, por lo que el chino en UTF-8 aparece como caracteres erróneos. Solución: active la opción «Incluir BOM» en los ajustes. El archivo CSV resultante llevará una cabecera BOM UTF-8 (\uFEFF), y Excel reconocerá correctamente la codificación UTF-8. Si ya ha exportado un CSV sin BOM, puede volver a guardarlo como «UTF-8 con BOM» en un editor de texto antes de abrirlo en Excel, o abrirlo directamente con Google Sheets, WPS u otra hoja de cálculo moderna.

¿Los números se convierten en cadenas en el JSON?

Causa: el número está rodeado de comillas en el SQL (por ejemplo '123' en lugar de 123), la herramienta lo analiza como cadena. Solución: compruebe si los números están entre comillas en el script SQL y elimínelas. Si los datos originales son así (por ejemplo códigos postales a menudo guardados como cadena), se trata del comportamiento esperado, ya que la semántica de cadena evita la pérdida de ceros a la izquierda (01234 no se convierte en 1234).

¿Error al convertir cadenas con caracteres especiales?

Causa: los caracteres especiales (salto de línea, comilla, barra invertida) de la cadena SQL no están correctamente escapados. Esta herramienta admite el escapado estándar SQL ('' → ') y el escapado con barra invertida de MySQL (\n, \' etc.). Sin embargo, si el SQL original usa un escapado no estándar (por ejemplo cadenas E'...' de PostgreSQL), la restitución puede fallar. Solución: compruebe la conformidad del escapado SQL y ajústelo manualmente en un editor de texto antes de convertir si es necesario.

Al convertir un SQL con varias tablas, ¿solo se ve la primera?

Causa: la opción «Salida separada por tablas» no está activada; los formatos tabulares como CSV/HTML/Markdown producen por defecto solo la primera tabla. Solución: active «Salida separada por tablas» en los ajustes. El CSV se emitirá por segmentos por tabla (con marcador # Table: nombre de tabla), y el JSON se agrupará por nombre de tabla ({nombre_tabla1:[...],nombre_tabla2:[...]}). Nota: el formato JSON Lines no distingue tablas; todas las filas se combinan.

Tras la reconstrucción SQL, ¿las comillas de los nombres de tablas o columnas son incorrectas?

Causa: al reconstruir se ha elegido el dialecto equivocado. Los dialectos usan estilos de comillas distintos (acento grave MySQL, comillas dobles PostgreSQL, corchetes SQL Server). Solución: seleccione el dialecto SQL destino en los ajustes; la herramienta regenera INSERT con el estilo de comillas correspondiente. Por ejemplo, al elegir PostgreSQL el nombre de tabla se convierte en "users"; al elegir MySQL, en `users`.

Glosario

SQL (Structured Query Language)
Lenguaje de consulta estructurado, lenguaje estándar de consulta y operación en bases de datos relacionales (MySQL, PostgreSQL, Oracle, SQL Server, SQLite). Incluye sublenguajes como DDL (definición de datos), DML (manipulación de datos), DQL (consulta de datos) y DCL (control de datos).
Sentencia INSERT
Sentencia SQL para insertar datos en una tabla, sintaxis INSERT INTO table (cols) VALUES (vals). Admite tuplas únicas y múltiples para la inserción por lotes. Esta herramienta analiza principalmente sentencias INSERT para extraer datos.
Sentencia CREATE TABLE
Sentencia DDL de SQL para crear una tabla. Define nombres de columnas, tipos de datos y restricciones (NOT NULL, PRIMARY KEY, UNIQUE, etc.). Esta herramienta puede analizar CREATE TABLE para extraer las definiciones de columnas.
Tupla VALUES
Lista de valores entre paréntesis tras la palabra clave VALUES en una sentencia INSERT, por ejemplo (1, 'Alice', TRUE). Una sentencia INSERT puede contener varias tuplas para inserción por lotes: VALUES (1,'A'), (2,'B'), (3,'C').
Dialecto SQL
Diferencias de extensión de los fabricantes de bases de datos respecto al estándar SQL, por ejemplo comillas de identificador (acento grave MySQL, comillas dobles PostgreSQL, corchetes SQL Server), booleanos (TRUE/1), columnas autonuméricas (AUTO_INCREMENT/SERIAL), etc.
Comillas de identificador
Caracteres especiales en SQL que rodean los nombres de tablas y columnas. MySQL usa el acento grave `name`, PostgreSQL y SQL estándar las comillas dobles "name", SQL Server los corchetes [name]. Sirven para escapar palabras reservadas o en escenarios sensibles a mayúsculas/minúsculas.
Escapado SQL
Mecanismo para representar caracteres especiales en cadenas SQL. El estándar SQL usa la duplicación de comillas simples ('') para una comilla simple; MySQL admite además el escapado con barra invertida (\n, \t, \', \\). Esta herramienta sabe restituir ambos mecanismos de escapado.
Valor NULL
Valor especial en SQL que representa un dato ausente o desconocido, sin distinguir mayúsculas/minúsculas (NULL/null/Null). NULL no es igual a la cadena vacía ni a 0. En JSON, NULL se mapea a null; en CSV, generalmente se deja en blanco.
Literal hexadecimal
Sintaxis literal en SQL para representar datos binarios. MySQL admite las formas 0x... y X'...', PostgreSQL X'...' y B'...' (binario). Esta herramienta conserva los literales hexadecimales tal cual.
JSON Lines (NDJSON)
Formato de texto con un objeto JSON independiente por línea, extensión .jsonl. Adecuado para procesamiento en flujo, importación de grandes volúmenes y API bulk de Elasticsearch, más ahorrador de memoria que un array JSON completo.
RFC 4180
Estándar internacional del formato CSV (Common Format and MIME Type for Comma-Separated Values Files) que define las reglas de separación de campos, escapado con comillas y tratamiento de saltos de línea. La salida CSV de esta herramienta es conforme a este estándar.
BOM (Byte Order Mark)
Marca de orden de bytes, carácter U+FEFF. Un BOM al inicio de un archivo UTF-8 ayuda a programas como Excel a reconocer la codificación y evita la visualización errónea de caracteres chinos. La salida CSV de esta herramienta puede incluir opcionalmente un BOM.
SQL Dump
Archivo de script SQL exportado desde una base de datos, generalmente producido por herramientas como mysqldump o pg_dump, que contiene sentencias CREATE TABLE e INSERT para copias de seguridad y migraciones de base de datos.
DDL (Data Definition Language)
Lenguaje de definición de datos, subconjunto de SQL que incluye sentencias como CREATE, ALTER, DROP, utilizado para definir y modificar la estructura de una base de datos (tablas, vistas, índices, etc.).

Comparación de los formatos de salida admitidos

Comparación de las características y casos de uso de los nueve formatos de salida:

FormatoExtensiónCaracterísticaCaso de uso ideal
JSON.jsonArray estructurado, tipos conservadosAPI, lectura por programa, datos frontend
JSON Lines.jsonlUn objeto JSON por líneaProcesamiento en flujo, Elasticsearch, big data
CSV.csvTabla separada por comas, RFC 4180Excel, análisis de datos, informes
TSV.tsvTabla separada por tabulacionesPegar en hoja de cálculo, bioinformática
XML.xmlDocumento estructurado con etiquetas y atributosInterfaces SOAP, archivos de config, sistemas Java
YAML.yamlFormato de configuración más legibleAnsible, K8s, configuración CI/CD
HTML.htmlTabla con estilos, visualizable en el navegadorVisualización web, correos, informes
Markdown.mdSintaxis de tabla MarkdownREADME, sitios de doc, blogs técnicos
Reconstrucción SQL.sqlINSERT regenerado, dialecto modificableMigración entre bases, cambio de nombre de tabla

Reglas de reconocimiento de tipos de valores SQL

Reglas de reconocimiento de tipos al analizar valores SQL (según la forma literal):

Literal SQLTipo reconocidoSalida JSONSalida CSV
123Entero123123
-45Entero negativo-45-45
3.14Coma flotante3.143.14
1e10Notación científica1000000000010000000000
'hello'Cadena"hello"hello
NULLValor nulonull(vacío)
TRUEBooleano verdaderotrueTRUE
FALSEBooleano falsofalseFALSE
0xFFHexadecimal"0xFF"0xFF
X'4142'Hexadecimal"X'4142'"X'4142'

Estilos de comillas de identificador en los distintos dialectos de base de datos

Diferencias en las comillas de identificador (nombres de tablas y columnas) entre las principales bases de datos:

Base de datosEstilo de comillasEjemploNota
MySQL/MariaDBAcento grave ``users`Activado por defecto, distingue palabras reservadas
PostgreSQLComillas dobles ""users"Sensible a mayúsculas/minúsculas, estilo SQL estándar
SQLiteComillas dobles "/Acento grave`/Corchetes[]"users" / [users]Compatible con varios estilos
SQL ServerCorchetes [][users]Estilo por defecto T-SQL
OracleComillas dobles ""users"Fuerza mayúsculas, comillas para conservar minúsculas
SQL estándarComillas dobles ""users"Estándar ANSI SQL

Privacy & Security

Todas las operaciones de este conversor SQL se realizan íntegramente de forma local en su navegador: el análisis SQL, la extracción de datos y la conversión de formato se ejecutan en el lado cliente en el JavaScript del navegador, sin que ningún contenido SQL, archivo cargado o resultado de conversión se envíe por red a un servidor. Las cargas de archivos se leen directamente en memoria mediante la API FileReader nativa del navegador, sin servicios intermedios. No se usan cookies de seguimiento, no se recopila ninguna entrada de usuario ni dato de uso. Al cerrar o recargar la página, todas las entradas y salidas se borran automáticamente de la memoria (el historial solo se conserva localmente en el localStorage del navegador). Adecuado para scripts de exportación de base de datos con información personal o comercial sensible.

Authoritative References