Ir a la documentación

DEL ESQUEMA AL DIAGRAMA

SQL a ERD: guía

Convierte tu esquema de base de datos en un diagrama. Aprende el SQL compatible, previsualiza datos y consulta tu modelo.

SQL DDL → Diagrama ERAbrir SQL a ERD
PRIMEROS PASOS

Contrato de sintaxis SQL listo para IA

Utilice esta página como un contrato compacto al pedir a una IA que escriba o edite SQL para Erd Go. Prefiera los patrones de sintaxis a continuación, mantenga las sentencias completas y terminadas en punto y coma, y evite objetos de base de datos no admitidos a menos que solo necesite SQL sin procesar fuera de Erd Go. La sintaxis de SQLite, PostgreSQL, MySQL y MSSQL es compatible en el subconjunto compartido a continuación. La conversión de SQL a ERD se ejecuta completamente en el navegador, y sus motores de análisis y vista previa están bloqueados por miles de pruebas unitarias y de integración que cubren esquemas de producción del mundo real (SaaS, banca, social, análisis, EHR).

SQLite

Reglas de rowid INTEGER PRIMARY KEY, columnas sin tipo, AUTOINCREMENT, WITHOUT ROWID, tablas STRICT validadas, acciones FK y reproducción de migraciones

PostgreSQL

Tipos ENUM y compuestos, arrays, JSONB, SERIAL, columnas de identidad, NULLS NOT DISTINCT, índices de expresión, identidad de esquema y sensibilidad a mayúsculas en nombres entre comillas

MySQL

AUTO_INCREMENT, ENUM y SET en línea, comillas invertidas (backticks), COMMENT, UNSIGNED/SIGNED, índices en línea, CHANGE/MODIFY COLUMN y ubicación FIRST/AFTER

MSSQL

IDENTITY, NVARCHAR(MAX), nombres entre corchetes, índices agrupados, lotes GO, ALTER COLUMN, columnas calculadas, valores predeterminados con nombre y períodos temporales

DDL

CREATE TYPE, CREATE TABLE, reproducción de migración ALTER TABLE, CREATE INDEX y sentencias DROP seguras para la forma del esquema

DML / SELECT

INSERT, UPDATE, DELETE para vista previa de datos, además de sintaxis SELECT de solo lectura para joins, CTEs, agregados, funciones de ventana e informes

Inicio rápido

Utilice esto como respuesta de modelo al pedir a una IA SQL compatible con Erd Go: tipos personalizados primero, tablas después, restricciones de relación después de las tablas cuando sea útil, luego DML de muestra. Mantenga las consultas SELECT de solo lectura separadas.

PostgreSQL / Inicio rápido con PostgreSQL
-- Define custom types
CREATE TYPE status_enum AS ENUM (
  'active', 'inactive', 'suspended'
);

-- Create tables with constraints
CREATE TABLE departments (
  id SERIAL PRIMARY KEY,
  name VARCHAR(100) NOT NULL UNIQUE
);

CREATE TABLE employees (
  id SERIAL PRIMARY KEY,
  name VARCHAR(100) NOT NULL,
  email TEXT UNIQUE NOT NULL,
  status status_enum DEFAULT 'active',
  department_id INTEGER,
  salary NUMERIC(10, 2) DEFAULT 0
);

-- Add constraints via ALTER TABLE
ALTER TABLE employees
  ADD CONSTRAINT fk_dept
  FOREIGN KEY (department_id)
  REFERENCES departments(id);

-- Add sample data after schema DDL
INSERT INTO departments (id, name) VALUES
  (1, 'Engineering'),
  (2, 'Design');

INSERT INTO employees (id, name, email, status, department_id, salary) VALUES
  (1, 'Alice', '[email protected]', 'active', 1, 1500.00),
  (2, 'Bob', '[email protected]', 'inactive', 2, 1200.00);

UPDATE employees
  SET status = 'active'
  WHERE id = 2;
Sintaxis del esquema: Las relaciones se pueden declarar en línea REFERENCES o ALTER TABLE ADD FOREIGN KEY. Ambas formas aportan los mismos metadatos de relación.
Sintaxis DML: Poner INSERT, UPDATE, y DELETE después del DDL del esquema. El script se evalúa de arriba a abajo, por lo que las filas de muestra deben hacer referencia a tablas y tipos que ya existen.
Sintaxis de SELECT: Mantenga las consultas de informes de solo lectura separadas de los scripts de mutación. Solo deben hacer referencia a las tablas y filas producidas por el script de esquema/DML.
SQL / Ejemplo
SELECT e.name, d.name AS department, e.salary
FROM employees e
JOIN departments d ON d.id = e.department_id
WHERE e.status = 'active'
ORDER BY e.salary DESC;

Pestañas de SQL e importación de archivos

Inicia un nuevo archivo SQL con un ejemplo, una pestaña de Esquema en blanco o Importar archivos SQL. El ejemplo separa el esquema y los datos en pestañas. Agregar pestaña SQL crea otra pestaña de editor; haz doble clic en su título para renombrarla.

Las pestañas activas se compilan juntas en su orden visible para el ERD, la Vista de Datos, la Vista de Consulta y las solicitudes de IA. Una pestaña inactiva sigue siendo un borrador guardado y se excluye de esos flujos de trabajo. Coloca los tipos y las tablas antes de las sentencias que dependan de ellos.

Importar archivos SQL acepta múltiples archivos de texto SQL y revisa los problemas de análisis juntos antes de la importación. Esto ayuda a resolver referencias entre archivos. Use el orden de las pestañas para mantener las dependencias y los pasos de migración de manera intencional.

Use las teclas de flecha y Inicio/Fin en la barra de pestañas para cambiar de pestaña, Alt+Izquierda/Derecha para reordenarlas y Shift+Alt+F para formatear SQL en el editor.

Abra el Explorador SQL junto a las pestañas para obtener un árbol de carpetas redimensionable. Cree carpetas anidadas y archivos SQL, seleccione un archivo para abrirlo y organícelo arrastrando y soltando. La ventana emergente de acción de fila admite Renombrar y Eliminar archivo; haga clic fuera para descartarla. Eliminar el último archivo mantiene abierto un archivo SQL en blanco. Las carpetas no cambian el orden de ejecución. Eliminar una carpeta mantiene sus archivos y subcarpetas en el padre. Guardar conserva el árbol de carpetas y la preferencia del panel.

Editar y revisar el diagrama

SQL es la fuente del significado del esquema. Use Agregar tabla para construir una tabla, o seleccione acciones de tabla y columna en el lienzo para editar columnas y conexiones. Las ediciones del esquema en el lienzo actualizan las pestañas de SQL propietarias, así como el diagrama.

Eliminar una columna muestra una vista previa de las conexiones, claves, índices y SQL dependiente afectados. Revise la eliminación o cascada antes de confirmar. Las migraciones complejas o las sentencias dependientes no admitidas pueden requerir la edición directa de SQL.

Use la puntuación de salud del ERD para inspeccionar hallazgos estructurales y optar por sugerencias de relaciones. Las relaciones sugeridas necesitan revisión; no reemplazan las claves foráneas declaradas ni establecen reglas de negocio automáticamente.

Organice las tablas con el Modo de diseño, zoom o Ajustar a la pantalla, busque tablas con el Navegador de tablas y use Colores de tabla o el minimapa para navegar por un diagrama grande. Pase el cursor o enfoque un control de la barra de herramientas para ver su texto de ayuda.

Seleccione una tabla y abra el Selector de color para ajustes preestablecidos sólidos o de degradado. Ingrese un valor hexadecimal o elija Personalizado junto a él para usar el selector de color nativo. Ambos controles permanecen sincronizados; Guardar conserva el color de la tabla.

Cuando las herramientas de tabla están configuradas solo para pasar el ratón, "Añadir columna" aparece cuando pasa el ratón sobre la última fila visible o enfoca el botón con el teclado. Las herramientas siempre visibles lo mantienen mostrado.

Elija Grupos de tablas en la barra de herramientas del lienzo SQL, luego Nuevo grupo. Asigne al grupo un nombre y color, seleccione sus tablas y elija Crear grupo. Una tabla seleccionada comienza marcada. Una tabla pertenece a un solo grupo; el formulario muestra cuándo su selección moverá una tabla fuera de otro grupo. Se admiten hasta 50 grupos, con nombres de hasta 160 caracteres.

Haga clic en el encabezado de un grupo para editar su nombre, color o miembros. Arrastre el encabezado para mover sus tablas juntas; suelte para aplicar el movimiento. Escape, la cancelación del puntero o la pérdida del foco de la ventana cancelan la vista previa. Desagrupar tablas elimina el marco manteniendo las tablas, sus posiciones, SQL y relaciones.

Los marcos de grupo siguen a las tarjetas de tablas en vivo y aparecen en Ajustar a la pantalla, el minimapa y las exportaciones de imágenes de la vista actual o del diagrama completo. Los grupos son un estado visual opcional guardado con el documento SQL. Los archivos más antiguos mantienen su diseño existente, y los nombres de tablas que faltan temporalmente permanecen en su grupo hasta que regresan al SQL analizado. Los grupos de tablas pertenecen a SQL a ERD; los paquetes de Diagrama de clases utilizan un modelo separado.

Revisión de IA dentro del editor SQL

  1. Ingrese un cambio específico en Ask AI para editar SQL y elija un modelo disponible. Set Gemini API key está disponible cuando desee usar su propia clave de Gemini.
  2. Revise los cambios propuestos y la vista previa temporal del diagrama. La solicitud utiliza la instantánea de la pestaña activa capturada cuando se envió; una respuesta no se guarda automáticamente.
  3. Acepta o rechaza cambios individuales, o usa las acciones para los cambios restantes. Navega por los cambios de código con F7 y Shift+F7. Las pestañas inactivas protegidas siguen siendo borradores.
  4. Inspeccione el SQL aceptado y luego guarde el documento. Copiar el prompt de IA en esta guía también le permite utilizar la documentación con un asistente fuera de la aplicación.

Datos, consultas, exportaciones y archivos guardados

Use los botones ERD, Datos y Consulta para cambiar de banco de trabajo. La vista de Datos materializa el DDL y DML soportados en el navegador y expone tablas, filas, tipos y un registro de ejecución. Cambie el tamaño de las columnas de la cuadrícula arrastrando sus bordes o haga doble clic para ajustar. Haga doble clic en una celda de Datos o presione Intro para editar; los campos booleanos y de enumeración ofrecen valores válidos. Añadir fila sigue los valores predeterminados de su esquema. Importe CSV, TSV, TXT o XLSX con una vista previa de mapeo de columnas. NULL y el texto vacío permanecen distintos. Las ediciones validadas se convierten en SQL en una pestaña de ediciones de Datos y pueden deshacerse. Descargue filas de tabla o resultados de Consulta como CSV.

Guardar recuerda el banco de trabajo de ERD, Datos o Consulta seleccionado; al volver a abrir se restaura, incluyendo Datos/Consulta en teléfonos. Los archivos más antiguos comienzan en ERD. Los editores nativos de fecha/hora conservan los valores admitidos, mientras que las marcas de tiempo con fracciones o desplazamientos de zona horaria permanecen editables como texto. Las identidades generadas por la base de datos permanecen como solo lectura.

La vista de consulta ejecuta consultas SELECT de solo lectura contra las tablas actuales en memoria. Admite la sintaxis documentada a continuación; no se conecta a una base de datos externa. El texto de la consulta se guarda con el contexto del documento SQL.

Guardar también recuerda la tabla de Datos seleccionada. Al volver a abrir se restaura, con la primera tabla como alternativa si no está disponible. Los campos del esquema alinean nombres, tipos y reglas; pase el cursor sobre una insignia de regla para ver su explicación. Ir a SQL junto al encabezado de la tabla abre su pestaña de SQL definitoria y revela la sentencia CREATE TABLE, volviendo a abrir el panel de SQL cuando está oculto mientras mantiene la selección de Datos y los borradores. Los resultados de la Consulta combinan recuentos, tiempos, Ajustar, Copiar y CSV en un solo encabezado.

Arrastra el divisor delgado entre el editor de Consulta y los resultados, o entre el esquema de Datos y las filas, para cambiar el tamaño de los paneles. Las teclas de flecha cambian el tamaño de un divisor enfocado, Escape cancela un arrastre y el doble clic lo restablece. Estos tamaños de panel permanecen como preferencias temporales del espacio de trabajo.

Generar datos de muestra utiliza sus tipos de columna, nombres, relaciones y restricciones. El idioma de muestra controla los nombres además de frases naturales de productos/descripciones en 17 idiomas. Revise los generadores y rangos sugeridos, previsualice el resultado, luego inserte explícitamente una pestaña de Datos de muestra separada. Los booleanos se muestran como true/false; los IDs permanecen numéricos. La generación nunca reemplaza las filas existentes.

Elija Exportar ERD para seleccionar PNG, SVG basado en imágenes o PDF con tamaño HD, 2K o 4K. Las imágenes exportadas no reemplazan a un documento guardado editable.

Inicie sesión y utilice Guardar SQL y ERD para guardar el contexto del SQL y el diagrama, incluyendo pestañas, ediciones de cuadrícula aplicadas, texto de consulta y diseño. Guardar verifica primero una celda activa o un borrador de nueva fila; los datos no válidos permanecen visibles para su corrección. Las vistas previas de importación necesitan su acción de Importar explícita. Abra los archivos guardados desde la lista de archivos y utilice Compartir en un documento guardado de su propiedad para configurar el acceso público y distribuir su enlace de solo lectura.

Los documentos de SQL, Prisma y Constructor se abren en sus propias herramientas. Prisma y Constructor tienen listas de archivos separadas y guardado solo en la nube. Los avisos de cambios no guardados protegen los documentos editados al salir de un espacio de trabajo; guarde sus cambios antes de compartir o cambiar de lugar.

Solucionar problemas del espacio de trabajo SQL

Solucionar problemas del espacio de trabajo SQL
SíntomaQué verificar
Falta una tablaCompruebe los diagnósticos de análisis, las pestañas activas y el orden de las sentencias. Un DROP o un cambio de nombre posterior pueden cambiar el diagrama final.
Falta una relaciónCompruebe que existan tanto las tablas como las columnas, que el recuento de columnas de clave foránea coincida y que la clave referenciada sea globalmente única. Califique con el esquema los nombres ambiguos.
La vista de Datos no muestra filasPonga INSERT después de su CREATE TABLE en una pestaña activa. Inspeccione el registro de ejecución para ver filas rechazadas o una reversión de transacción.
Los resultados de la consulta ya no coinciden con el SQLEjecute la consulta de nuevo después de cambiar el esquema o los datos; use las tablas actuales en memoria.
Añadir tabla sugiere un dialecto diferenteLa sintaxis del área de trabajo activa detectada tiene prioridad sobre la alternativa seleccionada manualmente. Revise el indicador de lenguaje SQL y los valores predeterminados específicos de la tabla.
Un archivo guardado no se puede editarCompruebe el inicio de sesión y la propiedad. Un enlace público otorga acceso de solo lectura; utilice Reintentar o Abrir archivos para errores de carga recuperables.

Flujo de trabajo de sintaxis de IA

Al usar un asistente de IA, pídale que genere SQL en este orden. Esto mantiene el resultado fácil de analizar, fácil de diagramar y fácil de previsualizar con filas de muestra o consultas de solo lectura.

1. Definir los dominios primero

Ponga las definiciones de enum/composite de CREATE TYPE antes de las tablas que hacen referencia a ellas. Prefiera nombres explícitos sobre tipos en línea ad hoc cuando se comparte un dominio.

2. Crear tablas base

Utilice CREATE TABLE para columnas, claves primarias, unicidad, valores predeterminados, comprobaciones, columnas generadas y claves foráneas en línea.

3. Reproducir migraciones

Utilice ALTER TABLE para restricciones añadidas, cambios de nombre, columnas eliminadas, cambios en el tipo/nulidad de columnas y claves foráneas circulares.

4. Añadir datos y consultas al final

Ponga INSERT/UPDATE/DELETE después de todo DDL. Mantenga las consultas SELECT separadas de la mutación de esquema cuando desee conjuntos de resultados.

Consejo de prompt de IA: Solicite un script SQL completo terminado en punto y coma. Dígale a la IA que evite objetos no compatibles como procedimientos almacenados, disparadores, CTE recursivos en consultas SELECT de solo lectura y ALTER TYPE. Los índices de expresión se conservan con una advertencia; solicite claves de columna simples cuando necesite insignias de índice ERD.

Sintaxis DDL y DML

Estas formas de declaración son seguras para scripts de esquema generados por IA y datos de muestra. La misma sintaxis impulsa la estructura del ERD y las filas de vista previa en memoria, así que mantenga DDL antes de DML y evite efectos secundarios externos específicos de la base de datos.

Sentencias admitidas

SQL / Ejemplo
-- Schema statements
CREATE TYPE type_name AS ENUM (...);
CREATE TYPE type_name AS (...);
CREATE TABLE table_name (...);
CREATE OR REPLACE TABLE table_name (...);
CREATE VIEW view_name AS SELECT ...;
CREATE OR REPLACE VIEW view_name AS SELECT ...;
CREATE OR ALTER VIEW view_name AS SELECT ...;
ALTER TABLE table_name ADD ...;
ALTER TABLE table_name DROP COLUMN column_name;
ALTER TABLE table_name RENAME COLUMN old_name TO new_name;
CREATE INDEX index_name ON table_name (column_name);
DROP INDEX index_name;
TRUNCATE TABLE table_name;
DROP TABLE [IF EXISTS] table_name;
DROP VIEW [IF EXISTS] view_name;
DROP TYPE [IF EXISTS] type_name;

-- Data statements
INSERT INTO table_name [(col1, col2, ...)] VALUES (...), (...);
UPDATE table_name SET col1 = value WHERE condition;
DELETE FROM table_name WHERE condition;
Soporte para WHERE: =, !=, <>, >, <, >=, <=, LIKE, NOT LIKE, IN, NOT IN, BETWEEN, NOT BETWEEN, IS NULL, IS NOT NULL, más AND / OR combinaciones. Las comparaciones NULL siguen la lógica UNKNOWN estándar de SQL — col = NULL nunca coincide; use col IS NULL en su lugar. Los objetivos de asignación desconocidos, las referencias de columna a la derecha y las columnas de filtro rechazan la mutación completa antes de cualquier cambio de fila.

Vista previa de la semántica para DML generado por IA

Generar datos de muestra localmente: En la Vista de Datos, elija Generar datos de ejemplo, elija la detección automática o un dialecto SQL, un diccionario de nombres de 26 países o inglés general, un porcentaje opcional de valores nulos y recuentos de filas de tabla, y expanda una tabla para personalizar sus generadores, rangos o valores permitidos. Obtenga una vista previa primero, luego copie/descargue el SQL o inserte uno nuevo Datos de muestra pestaña. No se necesita ninguna clave de IA ni solicitud de datos externos. Si reemplazó el esquema integrado, primero desactive su antigua pestaña de Datos de muestra de comercio. La generación conserva las filas existentes, copia tuplas completas de claves foráneas con cobertura parental equilibrada y valida las restricciones y tipos escalares admitidos. Las restricciones CHECK hechas completamente de IS NULL / IS NOT NULL, AND, OR y paréntesis tienen prioridad sobre el porcentaje opcional de NULL, incluyendo referencias exclusivas de publicaciones/videos. El catálogo tiene más de 4,200 entradas integradas, incluyendo más de 2,600 nombres con ortografía nativa y direcciones de correo electrónico ASCII, además de empresas, productos, trabajos, calles, descripciones en lenguaje natural y ejemplos de ubicación en más de 40 países, junto con monedas, direcciones IP, SKU, estados, colores, fechas y JSON. Los lotes admiten hasta 5,000 filas por tabla, 10,000 filas y 150,000 celdas en total, y 5 MB de SQL. Los ciclos de relación vacíos requeridos, los dominios únicos agotados, los nombres de tabla que colisionan entre esquemas y los tipos complejos requeridos no admitidos necesitan ajustes antes de que la generación pueda finalizar. Los valores complejos anulables y las referencias de ruptura de ciclo pueden convertirse en NULL con una nota de vista previa. Las semillas repiten los valores de diccionario generados; los valores predeterminados de la base de datos siguen su comportamiento normal. Finalice primero la revisión de IA y vuelva a abrir el generador si el espacio de trabajo SQL cambia.

Las filas se reproducen desde cero

Las sentencias DDL y DML se aplican juntas en el orden de origen; cada sentencia de datos utiliza el esquema activo en ese momento.

Los tipos permanecen inspeccionables

Los enums con nombre y los tipos compuestos creados con CREATE TYPE permanecen como parte del esquema analizado.

Se aplican restricciones

PK, FK, NOT NULL, UNIQUE, DEFAULT, CHECK, columnas generadas y dominios enum afectan a las filas de vista previa.

Los errores deben ser corregibles

Prefiera listas explícitas de columnas y cláusulas WHERE concretas para que los diagnósticos puedan señalar la tabla o columna exacta.

No pida a la IA que confíe en: independiente SELECT conjuntos de resultados en el esquema principal/script DML, cuerpos procedimentales no soportados o llamadas a bases de datos externas. CREATE VIEW, CREATE OR REPLACE VIEW, y MSSQL CREATE OR ALTER VIEW se materializan a partir de su SELECT resultado para vista previa; mantén las consultas ad hoc de solo lectura separadas.

Transacciones en la vista de datos

La vista de Datos admite BEGIN, COMMIT, ROLLBACK, SAVEPOINT, ROLLBACK TO y RELEASE en la vista previa en memoria. Estas sentencias afectan a las filas de la vista previa; nunca se aplican a una base de datos externa.

SQLite, PostgreSQL y SQL Server conservan el DDL transaccional en la vista previa. El DDL de MySQL confirma la transacción activa. SQLite PRAGMA foreign_keys y MySQL SET FOREIGN_KEY_CHECKS afectan la validación de DML posterior.

El renderizador ERD ignora los envoltorios de transacciones y representa las sentencias de esquema en el orden de origen. Por lo tanto, una reversión de transacción en la Vista de datos puede producir un conjunto de tablas diferente al del diagrama. Verifique cada banco de trabajo para ver el comportamiento que está probando.

SQL / Vista previa de la transacción
CREATE TABLE preview_items (
  id INTEGER PRIMARY KEY,
  label TEXT NOT NULL
);
INSERT INTO preview_items (id, label) VALUES (1, 'Before transaction');

BEGIN;
INSERT INTO preview_items (id, label) VALUES (2, 'Keep this row');
SAVEPOINT before_trial;
INSERT INTO preview_items (id, label) VALUES (3, 'Undo this row');
ROLLBACK TO before_trial;
RELEASE before_trial;
COMMIT;
En este ejemplo, la Vista de datos conserva los elementos 1 y 2. El elemento 3 se elimina mediante ROLLBACK TO antes de COMMIT. La Vista de consulta lee esas filas de vista previa finales.

Sintaxis de consulta SELECT

Pida a la IA que mantenga las consultas de informes de solo lectura como SELECT sentencias. Estas pueden hacer referencia a las tablas y filas producidas por el esquema/script DML y son útiles para uniones, filtros, totales y conjuntos de resultados con formato de informe sin requerir una base de datos activa.

Forma de consulta admitida

SQL / Ejemplo
WITH dept_totals AS (
  SELECT department_id, COUNT(*) AS employee_count, SUM(salary) AS payroll
  FROM employees
  GROUP BY department_id
)
SELECT d.name,
       dt.employee_count,
       dt.payroll
FROM dept_totals dt
JOIN departments d ON d.id = dt.department_id
WHERE dt.employee_count >= 1
ORDER BY dt.payroll DESC
LIMIT 10;

Solo SELECT

El editor de consultas acepta sentencias SELECT, incluyendo SELECT sin FROM y WITH CTEs que se resuelven en SELECT.

Joins y filtros

Joins INNER, LEFT, RIGHT, FULL y CROSS, condiciones WHERE, subconsultas EXISTS, IN, BETWEEN, LIKE, ILIKE y comprobaciones de NULL.

Agregados

GROUP BY, HAVING, COUNT, SUM, AVG, MIN, MAX, ARRAY_AGG, GROUP_CONCAT, STRING_AGG y variantes DISTINCT.

Ordenamiento y paginación

ORDER BY nombres u ordinales, ASC/DESC, NULLS FIRST/LAST, LIMIT/OFFSET, TOP, y FETCH FIRST.

Soporte avanzado de SELECT

CTEs y tablas derivadas

Se admiten cláusulas WITH, SELECT anidados en FROM, subconsultas escalares, EXISTS, NOT EXISTS, IN y NOT IN.

Operadores de conjuntos

UNION, UNION ALL, INTERSECT y EXCEPT pueden combinar conjuntos de resultados compatibles.

Funciones de ventana

ROW_NUMBER, RANK, DENSE_RANK, NTILE, LAG, LEAD, FIRST_VALUE y LAST_VALUE con OVER y PARTITION BY. Las ventanas ordenadas utilizan el marco predeterminado de SQL consciente de pares, y NTILE asigna primero los depósitos más grandes.

Ayudantes de dialecto

Las funciones comunes de SQLite, PostgreSQL, MySQL y MSSQL se normalizan para la vista previa, incluidos los ayudantes de JSON y fecha/cadena.

De solo lectura por diseño: Mantener INSERT, UPDATE, DELETE, CREATE, ALTER, y DROP sentencias en el esquema/script DML. La sintaxis de consulta debe permanecer SELECT-solo.

Diagnósticos y errores

Los diagnósticos de sintaxis muestran problemas de análisis de esquema, ejecución de DDL/DML y SELECT de solo lectura con mensajes claros. Los errores de análisis incluyen posiciones de línea/columna cuando es posible, y los mensajes de ejecución señalan la tabla, columna o forma de sentencia que necesita corrección.

Errores de análisis de esquema

El analizador de esquemas (SQLite, PostgreSQL, MySQL y MSSQL) informa problemas con dos niveles de gravedad: error evita que una sola sentencia contribuya al esquema; advertencia mantiene una sintaxis válida pero marca algo que el usuario debería saber.

SQL / Ejemplo
// Every entry the editor receives has this shape:
{
  message:  "Column 'a' missing data type",
  severity: "error" | "warning",
  position: { line: 1, column: 17, index: 16 },
  token?:   { type, value, raw }   // present for parser-side errors
}

Errores del analizador

Listas de columnas PRIMARY KEY / UNIQUE / FOREIGN KEY vacías, tipos de datos requeridos faltantes (incluyendo columnas STRICT de SQLite), paréntesis no coincidentes, comas inesperadas y restricciones mal formadas.

Advertencias del tokenizador

Cadenas sin cerrar, comentarios de bloque sin cerrar, paréntesis no coincidentes y expresiones CHECK sospechosas entre líneas.

Advertencias de claves foráneas

Las FK que apuntan a una tabla desconocida, columna desconocida, hoja de esquema ambigua o destino que no es PK/no es UNIQUE se eliminan del diagrama con una advertencia descriptiva.

Diagnósticos agrupados

Las advertencias se agrupan por causa, incluyendo Relación eliminada, Tabla desconocida, Columna desconocida, Destino de FK no único, Advertencias y Errores de análisis.

SQL vacío

La entrada vacía es válida y produce un esquema vacío. Solo las entradas no textuales inválidas lanzan errores.

Registro de ejecución DDL/DML

Cada sentencia DDL o DML ejecutada añade una entrada estructurada al registro de ejecución en memoria. El flujo de mensajes preserva el orden cronológico y clasifica cada sentencia como error, advertencia, o éxito.

SQL / Ejemplo
// Each log entry is:
{
  type:      "success" | "warning" | "error",
  message:   "Inserted 3 row(s) into \"users\"",
  timestamp: 1734567890123  // ms since epoch, monotonic
}
SQL / Ejemplo
-- Examples ────────────────────────────────────────────────
-- success
CREATE TABLE users (id INT PRIMARY KEY);
-- → success: Table "users" created with 1 columns

-- warning (no WHERE clause)
UPDATE users SET id = 99;
-- → warning: UPDATE "users": no WHERE clause — all 2 row(s) will be affected
-- → success: Updated 2 row(s) in "users"

-- error (unknown table)
INSERT INTO ghost VALUES (1);
-- → error: INSERT INTO "ghost": table does not exist
Siempre procesable. Cada error y advertencia cita el nombre de la tabla/columna infractora, para que pueda identificar el problema sin volver a leer el script.

Diagnósticos comunes

SQL / Ejemplo
error    : INSERT INTO "x": unknown column(s): foo
warning  : INSERT INTO "x" row 3: expected 4 values but got 3
warning  : UPDATE "x": setting NOT NULL column "name" to NULL
warning  : DELETE FROM "x": no WHERE clause — all 1200 row(s) will be removed
error    : DROP: table "ghost" does not exist
warning  : ALTER "x": column "old_col" does not exist
warning  : Relation dropped: foreign key 'posts.user_id' references column
           'users.no_such' which does not exist on table 'users'.
warning  : Relation dropped: foreign key 'events.email' references 'users.email',
           but the target is only partial-unique, not globally unique.
Resistente a fallos. El análisis sintáctico del esquema, la ejecución de DDL/DML y la ejecución de SELECT recuperan el SQL malformado en errores visibles para que pueda seguir refinando el mismo script.

CREATE TYPE

Defina tipos de datos personalizados para su reutilización en el esquema de su base de datos. Los tipos enum y compuestos con nombre deben aparecer antes de las tablas que los referencian, incluidas las referencias cualificadas por esquema.

1.1. Tipo compuesto

Defina tipos compuestos personalizados con múltiples campos de varios tipos de datos.

SQL / Ejemplo
CREATE TYPE type_name AS (
  field1 data_type1,
  field2 data_type2,
  ...
);

Ejemplo:

SQL / Ejemplo
CREATE TYPE address_type AS (
  street VARCHAR(100),
  city TEXT,
  postal_code INTEGER
);

CREATE TYPE coordinates AS (
  latitude DECIMAL(10, 8),
  longitude DECIMAL(11, 8)
);
Tipos de datos admitidos: INTEGER, BIGINT, SMALLINT, TEXT, VARCHAR(n), CHAR(n), DECIMAL(p,s), NUMERIC, BOOLEAN, DATE, TIME, TIMESTAMP, FLOAT, REAL, DOUBLE PRECISION, UUID, JSON, JSONB, BYTEA, MONEY y más.

1.2. Tipo Enum

Cree tipos enumerados con valores predefinidos para una mejor integridad de Datos y legibilidad.

SQL / Ejemplo
CREATE TYPE enum_name AS ENUM (
  'value1',
  'value2',
  ...
);

Ejemplo:

SQL / Ejemplo
CREATE TYPE status_enum AS ENUM (
  'pending',
  'active',
  'completed',
  'cancelled'
);

CREATE TYPE priority_level AS ENUM (
  'low', 'medium', 'high', 'critical'
);
Importante: Los valores de Enum deben estar encerrados entre comillas simples ('value'), no comillas dobles.

1.3. Tipos cualificados por esquema

Los tipos definidos por el usuario se resuelven con la misma conciencia de esquema que las tablas. Si dos esquemas definen el mismo nombre de hoja, el ERD los mantiene distintos; si un tipo es único, el nombre para mostrar permanece simple.

SQL / Ejemplo
CREATE TYPE s1.status AS ENUM ('draft', 'active');
CREATE TYPE s2.status AS ENUM ('queued', 'done');

CREATE TABLE s1.items (
  id    INT PRIMARY KEY,
  state s1.status
);

CREATE TABLE s2.items (
  id    INT PRIMARY KEY,
  state s2.status
);
Regla de resolución: s1.status nunca se resuelve en s2.status solo porque ambos comparten el nombre de la hoja status. Los nombres de tipos cualificados son estrictos, mientras que los nombres no cualificados se resuelven solo cuando no hay ambigüedad.

CREATE TABLE

Defina tablas de base de datos con columnas, tipos de datos y restricciones.

2.1. Estructura básica de la tabla

La sintaxis general para crear una tabla:

SQL / Ejemplo
CREATE TABLE table_name (
  column_name data_type [constraints],
  ...
  -- table-level constraints (optional)
);

-- Also supports:
CREATE TABLE IF NOT EXISTS table_name ( ... );
CREATE TABLE schema_name.table_name ( ... );
Nota: Los nombres de tablas y columnas pueden usar comillas dobles ("name"), comillas invertidas (\`name\`), o corchetes ([name]) para escapar caracteres especiales o palabras clave reservadas.

2.2. Definiciones a nivel de columna

Cada columna puede incluir varias restricciones y propiedades:

SQL / Ejemplo
CREATE TABLE users (
  id INTEGER PRIMARY KEY,
  username VARCHAR(50) UNIQUE NOT NULL,
  email TEXT NOT NULL CHECK (email LIKE '%@%'),
  status VARCHAR(20) DEFAULT 'active',
  created_at TIMESTAMP DEFAULT now(),
  department_id INTEGER REFERENCES departments(id)
);

PRIMARY KEY

Identifica de forma única cada fila

UNIQUE

Asegura que los valores de la columna sean distintos

NOT NULL

Previene valores nulos

DEFAULT

Establece valores predeterminados (literales o funciones)

CHECK

Valida datos con expresiones booleanas

REFERENCES

Crea relaciones de clave foránea

Soporte de valores DEFAULT:
  • Literales: números (123), cadenas ('text')
  • Funciones de PostgreSQL: now(), CURRENT_TIMESTAMP, CURRENT_DATE, nextval('seq'::regclass)
  • Funciones de MSSQL: GETDATE(), NEWID()
REFERENCES (en línea): Reconoce REFERENCES table(column), calificado por esquema REFERENCES schema.table(column), columnas de destino omitidas como REFERENCES departments, y acciones de FK como ON DELETE CASCADE, ON UPDATE SET NULL, MATCH FULL, y DEFERRABLE INITIALLY DEFERRED.

2.3. Columnas generadas / calculadas

Referencia rápida. Vea el dedicado Columnas calculadas sección a continuación para el desglose completo por dialecto, incluida la forma bare-AS de MSSQL.

SQL / Ejemplo
CREATE TABLE products (
  id SERIAL PRIMARY KEY,
  price NUMERIC(10, 2),
  quantity INTEGER,

  -- PostgreSQL / MySQL: parenthesized expression
  total NUMERIC GENERATED ALWAYS AS (price * quantity) STORED,

  -- MySQL VIRTUAL column
  discount NUMERIC GENERATED ALWAYS AS (price * 0.1) VIRTUAL
);

2.4. Tipos ENUM en línea

Puede declarar un ENUM directamente en una definición de columna (estilo MySQL). El analizador lo registrará como un enum con nombre y reemplazará el tipo de columna automáticamente.

SQL / Ejemplo
CREATE TABLE tasks (
  id INTEGER PRIMARY KEY,
  status ENUM('todo', 'doing', 'done'),
  priority ENUM('low', 'medium', 'high')
);
Cómo funciona: Los ENUM en línea se registran automáticamente como tipos con nombre. El primer nombre simple utiliza column_enum (por ejemplo, status_enum); las tablas posteriores con una definición diferente para el mismo nombre de columna obtienen un nombre calificado por la tabla como tasks_status_enum para que los dominios nunca colapsen accidentalmente.
Consejo: Si necesita enumeraciones compartidas o nombres personalizados, defínalos explícitamente con CREATE TYPE ... AS ENUM en su lugar.

2.5. Restricciones a nivel de tabla

Defina restricciones al final del cuerpo de la tabla. Útil para claves compuestas y restricciones de varias columnas:

SQL / Ejemplo
-- Syntax:
[CONSTRAINT name] PRIMARY KEY (col1, col2, ...)

[CONSTRAINT name] FOREIGN KEY (col1, col2, ...)
  REFERENCES ref_table(ref_col1, ref_col2, ...)
  [MATCH FULL|PARTIAL|SIMPLE]
  [ON DELETE CASCADE|RESTRICT|SET NULL|SET DEFAULT|NO ACTION]
  [ON UPDATE CASCADE|RESTRICT|SET NULL|SET DEFAULT|NO ACTION]
  [DEFERRABLE|NOT DEFERRABLE] [INITIALLY DEFERRED|IMMEDIATE]

[CONSTRAINT name] UNIQUE (col1, col2, ...)

[CONSTRAINT name] CHECK (expression)

Ejemplo:

SQL / Ejemplo
CREATE TABLE order_items (
  order_id INTEGER,
  product_id INTEGER,
  quantity INTEGER CHECK (quantity > 0),
  unit_price NUMERIC(10, 2),

  CONSTRAINT pk_order_items
    PRIMARY KEY (order_id, product_id),
  CONSTRAINT fk_order
    FOREIGN KEY (order_id) REFERENCES orders(id),
  CONSTRAINT fk_product
    FOREIGN KEY (product_id) REFERENCES products(id),
  CONSTRAINT uq_order_product
    UNIQUE (order_id, product_id),
  CONSTRAINT chk_price
    CHECK (unit_price >= 0)
);
Restricciones admitidas: PRIMARY KEY, FOREIGN KEY, UNIQUE y CHECK son compatibles a nivel de tabla. El nombre de la restricción (CONSTRAINT name) es opcional.
Corrección de claves foráneas: Si REFERENCES ref_table omite la lista de columnas de destino, Erd Go la resuelve a la clave primaria de la tabla referenciada, incluyendo claves primarias compuestas. Si especifica las columnas de destino explícitamente, deben estar respaldadas por una PRIMARY KEY, una restricción UNIQUE o global CREATE UNIQUE INDEX; los índices únicos filtrados / parciales no cuentan como destinos de FK. Las relaciones no válidas se descartan con una advertencia.

2.6. Nombres de columnas con palabras reservadas

Palabras como key, index, value, y name están reservados en algunos dialectos pero se usan comúnmente como nombres de columna en otros. El analizador desambigua automáticamente cuando el siguiente token es un tipo de datos conocido, por lo que el uso sin comillas funciona:

SQL / Ejemplo
CREATE TABLE feature_flags (
  id        BIGSERIAL PRIMARY KEY,
  org_id    BIGINT NOT NULL,
  key       VARCHAR(128) NOT NULL,   -- 'key' as column name → OK
  index     INT,                     -- 'index' as column name → OK
  value     TEXT,                    -- 'value' as column name → OK
  enabled   BOOLEAN NOT NULL DEFAULT FALSE,
  UNIQUE (org_id, key)
);

-- The MySQL "KEY ... (cols)" index form is still recognized correctly
CREATE TABLE posts (
  id   INT PRIMARY KEY,
  body TEXT,
  KEY idx_body (body),                 -- treated as index, adds IDX badge
  FULLTEXT KEY ft_body (body)          -- treated as fulltext index badge
);
Regla de desambiguación: KEY / INDEX / FULLTEXT / SPATIAL seguido de una palabra clave de tipo de datos (VARCHAR, INT, …) es un columna. Seguido de un identificador y una lista de columnas entre paréntesis, es un índice. Para absoluta seguridad, ponga la columna entre comillas con "key", `key`, o [key].

Columnas de identidad / autoincremento

Utilice la sintaxis de identidad nativa para el dialecto seleccionado. Todas las formas admitidas producen una columna de clave primaria con el AUTO_INCREMENT marcador, pero SQLite tiene una regla estricta: AUTOINCREMENT requiere un único INTEGER PRIMARY KEY columna.

SQLite

SQL / Ejemplo
-- Rowid alias; auto assigns a value when omitted
CREATE TABLE users (
  id INTEGER PRIMARY KEY,
  email TEXT NOT NULL UNIQUE
);

-- AUTOINCREMENT prevents rowid reuse after DELETE
CREATE TABLE events (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  name TEXT NOT NULL
);

-- Invalid for SQLite AUTOINCREMENT:
-- 1. BIGINT PRIMARY KEY AUTOINCREMENT
-- 2. INT PRIMARY KEY AUTOINCREMENT
-- 3. AUTOINCREMENT on a composite primary key
Regla de SQLite: usar exactamente INTEGER PRIMARY KEY AUTOINCREMENT. No use BIGINT, INT, o una clave primaria compuesta con AUTOINCREMENT.

PostgreSQL

SQL / Ejemplo
-- Classic SERIAL family
CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  big_id BIGSERIAL,
  small_id SMALLSERIAL
);

-- Modern SQL-standard identity columns
CREATE TABLE events (
  id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  name TEXT
);

CREATE TABLE invoices (
  id BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY
);
Importante: GENERATED ALWAYS AS IDENTITY es un identidad columna (auto-incremento), distinta de GENERATED ALWAYS AS (expression) que es un calculado columna. El analizador los mantiene separados automáticamente.

MySQL

SQL / Ejemplo
CREATE TABLE users (
  id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
  email VARCHAR(255) NOT NULL UNIQUE
) ENGINE=InnoDB;

MSSQL / SQL Server

SQL / Ejemplo
-- IDENTITY(seed, increment)
CREATE TABLE [dbo].[Customers] (
  [CustomerID] BIGINT IDENTITY(1,1) NOT NULL CONSTRAINT pk_customer PRIMARY KEY,
  [Email] NVARCHAR(255) NOT NULL
);

-- Bare IDENTITY (defaults to (1,1))
CREATE TABLE [dbo].[Orders] (
  [OrderID] INT IDENTITY NOT NULL PRIMARY KEY
);
Salida ERD: Cada formulario anterior aparece de forma idéntica en el diagrama: icono de llave PK más AUTO_INCREMENT etiqueta, para que pueda mezclar dialectos en un esquema sin perder la sugerencia de autoincremento.

Columnas calculadas (por dialecto)

Una columna calculada deriva su valor de una expresión sobre otras columnas en la misma fila. Compatible con los cuatro dialectos con sus respectivas sintaxis.

PostgreSQL y MySQL — GENERATED ALWAYS AS

SQL / Ejemplo
CREATE TABLE products (
  id SERIAL PRIMARY KEY,
  price NUMERIC(10,2),
  qty INTEGER,
  total NUMERIC GENERATED ALWAYS AS (price * qty) STORED,
  discount NUMERIC GENERATED ALWAYS AS (price * 0.1) VIRTUAL
);

-- Complex expressions, including CASE
CREATE TABLE orders (
  id BIGSERIAL PRIMARY KEY,
  qty INT,
  flag INT GENERATED ALWAYS AS (CASE WHEN qty > 100 THEN 1 ELSE 0 END) STORED
);
Modos de base de datos: En una base de datos nativa, STORED almacena el valor calculado y VIRTUAL lo calcula al leer. Erd Go mantiene los valores de vista previa en la memoria; el ERD preserva cada modo como metadatos de columna.

MSSQL / SQL Server — columna AS expresión [PERSISTED]

MSSQL tiene su propia sintaxis: column_name AS expression, opcionalmente seguido de PERSISTED (y opcionalmente NOT NULL). Ambos entre paréntesis y desnudo se admiten formas de expresión.

SQL / Ejemplo
CREATE TABLE [dbo].[Customers] (
  [CustomerID] BIGINT IDENTITY(1,1) NOT NULL CONSTRAINT pk_c PRIMARY KEY,
  [FirstName] NVARCHAR(50) NOT NULL,
  [LastName]  NVARCHAR(50) NOT NULL,

  -- Parenthesized form
  [FullName] AS ([FirstName] + ' ' + [LastName]) PERSISTED,

  -- Bare form (no parens) — also accepted
  [Initials] AS LEFT([FirstName], 1) + LEFT([LastName], 1)
);

CREATE TABLE [dbo].[Loans] (
  [LoanID] BIGINT IDENTITY(1,1) NOT NULL PRIMARY KEY,
  [StartDate] DATE NOT NULL,
  [TermMonths] INT NOT NULL,

  -- Function call in a bare AS expression
  [MaturityDate] AS DATEADD(MONTH, [TermMonths], [StartDate]) PERSISTED,

  -- CASE expression in a bare AS
  [SignedAmount] AS CASE WHEN [TermMonths] > 12 THEN 1 ELSE 0 END
);
AS simple: El analizador acepta col AS expression (sin paréntesis que lo rodeen) — incluidas llamadas a funciones como DATEADD(...), referencias calificadas por tabla como c.GrowthDurationDays, y CASE expresiones — terminando en la siguiente coma de columna, PERSISTED, o el final del cuerpo de la tabla.
Salida ERD: Se muestran todas las columnas calculadas. COMPUTED como el tipo y la expresión preservada en los extras de columna / información sobre herramientas.

ALTER TABLE

Estilo de migración común ALTER TABLE sentencias se reproducen después de la creación de la tabla, por lo que el esquema final refleja columnas añadidas, restricciones, cambios de nombre, columnas eliminadas y cambios en el tipo/nulabilidad de columna. Sintaxis de volcado de PostgreSQL usando ALTER TABLE ONLY preserva la identidad de tabla calificada.

Añadir y restringir

ADD COLUMN, ADD PRIMARY KEY, ADD UNIQUE, ADD CHECK y ADD FOREIGN KEY se reflejan en el ERD.

Renombrar y eliminar

Los cambios de nombre de tablas, columnas, restricciones e índices (incluidos MySQL RENAME TABLE, PostgreSQL ALTER INDEX y SQL Server sp_rename) permanecen vinculados a la encarnación correcta del objeto antes de las operaciones DROP posteriores.

Cambios de columna

Se reproducen ALTER COLUMN TYPE/SET DATA TYPE/SET o DROP DEFAULT/nulabilidad de PostgreSQL, ALTER COLUMN de MSSQL y MODIFY/CHANGE COLUMN de MySQL.

Seguridad de relación

Las claves foráneas se validan con respecto al estado final de la tabla después de la reproducción de la migración, incluidos los cambios de PK/UQ/índices y los recuentos exactos de columnas de origen/destino.

3.1. Añadir clave foránea

SQL / Ejemplo
ALTER TABLE table_name
  ADD [CONSTRAINT name] FOREIGN KEY (cols...)
    REFERENCES ref_table[(ref_cols...)]
    [ON DELETE action] [ON UPDATE action]
    [DEFERRABLE|NOT DEFERRABLE] [INITIALLY DEFERRED|IMMEDIATE];

Ejemplo:

SQL / Ejemplo
ALTER TABLE orders
  ADD CONSTRAINT fk_orders_customer
  FOREIGN KEY (customer_id)
  REFERENCES customers(id)
  ON DELETE CASCADE;

3.2. Añadir clave primaria

SQL / Ejemplo
ALTER TABLE table_name
  ADD [CONSTRAINT name] PRIMARY KEY (cols...);

Ejemplo:

SQL / Ejemplo
ALTER TABLE products
  ADD CONSTRAINT pk_products
  PRIMARY KEY (product_id);

3.3. Añadir restricción única

SQL / Ejemplo
ALTER TABLE table_name
  ADD [CONSTRAINT name] UNIQUE (cols...);

Ejemplo:

SQL / Ejemplo
ALTER TABLE users
  ADD CONSTRAINT uq_users_email
  UNIQUE (email);

3.4. Añadir restricción CHECK

SQL / Ejemplo
ALTER TABLE table_name
  ADD [CONSTRAINT name] CHECK (expression);

Ejemplo:

SQL / Ejemplo
ALTER TABLE employees
  ADD CONSTRAINT chk_salary
  CHECK (salary >= 0);

3.5. Ejemplo de reproducción de migración

SQL / Ejemplo
CREATE TYPE app.ticket_status AS ENUM ('new', 'open', 'closed');

CREATE TABLE app.accounts (
  tenant_id  INT NOT NULL,
  account_no TEXT NOT NULL,
  status     app.ticket_status NOT NULL DEFAULT 'new',
  PRIMARY KEY (tenant_id, account_no)
);

CREATE TABLE app.contacts (
  tenant_id   INT NOT NULL,
  account_no  TEXT NOT NULL,
  owner_email TEXT,
  CONSTRAINT fk_contacts_account
    FOREIGN KEY (tenant_id, account_no)
    REFERENCES app.accounts
    ON DELETE CASCADE
    DEFERRABLE INITIALLY DEFERRED
);

ALTER TABLE app.contacts ADD COLUMN audit_state TEXT;
ALTER TABLE app.contacts ALTER COLUMN owner_email TYPE VARCHAR(320);
ALTER TABLE app.contacts ALTER COLUMN owner_email SET NOT NULL;
ALTER TABLE app.contacts RENAME COLUMN owner_email TO contact_email;
ALTER TABLE app.contacts DROP COLUMN audit_state;

CREATE UNIQUE INDEX ux_contacts_email
  ON app.contacts (contact_email);
Lo que hace el ERD: La FK de contacto se resuelve en la clave primaria compuesta en app.accounts, owner_email se convierte en contact_email, audit_state se elimina, y el índice único le da contact_email a UQ insignia.

3.6. MySQL CHANGE / MODIFY COLUMN

SQL / Ejemplo
CREATE TABLE `customers` (
  `id` BIGINT AUTO_INCREMENT PRIMARY KEY,
  `email` VARCHAR(320) NOT NULL,
  UNIQUE INDEX `ux_customers_email` (`email`)
) ENGINE=InnoDB;

CREATE TABLE `orders` (
  `id` BIGINT AUTO_INCREMENT PRIMARY KEY,
  `customer_email` VARCHAR(320),
  `status` ENUM('new','paid') NOT NULL DEFAULT 'new',
  `old_note` VARCHAR(50),
  CONSTRAINT `fk_orders_customer`
    FOREIGN KEY (`customer_email`)
    REFERENCES `customers`(`email`)
    ON DELETE SET NULL
) ENGINE=InnoDB;

ALTER TABLE `orders`
  CHANGE COLUMN `old_note` `note` VARCHAR(255) NOT NULL;
ALTER TABLE `orders`
  MODIFY COLUMN `status` ENUM('new','paid') NOT NULL DEFAULT 'paid';

3.7. MSSQL / SQL Server ALTER COLUMN

SQL / Ejemplo
CREATE TABLE [dbo].[Customers] (
  [CustomerID] INT IDENTITY(1,1) NOT NULL,
  [Email] NVARCHAR(320) NOT NULL,
  CONSTRAINT [PK_Customers] PRIMARY KEY CLUSTERED ([CustomerID]),
  CONSTRAINT [UQ_Customers_Email] UNIQUE NONCLUSTERED ([Email])
);

CREATE TABLE [dbo].[Orders] (
  [OrderID] INT IDENTITY(1,1) NOT NULL,
  [CustomerEmail] NVARCHAR(320),
  [LegacyNote] NVARCHAR(50),
  CONSTRAINT [PK_Orders] PRIMARY KEY NONCLUSTERED ([OrderID]),
  CONSTRAINT [FK_Orders_Customers]
    FOREIGN KEY ([CustomerEmail])
    REFERENCES [dbo].[Customers]([Email])
    ON DELETE SET NULL
);

ALTER TABLE [dbo].[Orders]
  ALTER COLUMN [LegacyNote] NVARCHAR(255) NOT NULL;
ALTER TABLE [dbo].[Orders]
  ADD [CreatedAt] DATETIME2 NOT NULL DEFAULT '2026-01-01';
Límite de sintaxis: La reproducción de la migración de SQL a ERD es intencionalmente más rica que la ejecución de la Vista de Datos. El análisis del diagrama final sigue siendo solo para el navegador y no requiere una conexión a la base de datos; las sentencias de solo ejecución no compatibles no debilitan el modelo de ciclo de vida del ERD.

CREATE INDEX

El DDL de índice se analiza en los cuatro dialectos. Las claves de columna simples se muestran como pequeñas insignias de ERD: IDX para aceleraciones no únicas, UQ para índices únicos globales, y PUQ para índices únicos filtrados / parciales. Las entradas de expresión se conservan en la salida del analizador y se informan cuando no pueden asignarse honestamente a una insignia de columna.

Insignia IDX

Índice no único. Píldora sólida en la columna. Los índices compuestos atenúan la píldora (gris) en cada columna clave para que la diferencia entre una sola columna y múltiples columnas sea evidente de un vistazo.

Insignia UQ

De un CREATE UNIQUE INDEX global. Se comporta como una restricción UNIQUE para la validación de FK y la identificación de columnas.

Insignia PUQ

De CREATE UNIQUE INDEX ... WHERE. Muestra el predicado de unicidad parcial pero no valida los destinos de FK como globalmente únicos.

Regla de supresión

Las restricciones más fuertes ganan: PK ⟶ UQ ⟶ PUQ ⟶ IDX. Una clave más fuerte nunca es degradada por un índice posterior.

Multidialecto

CONCURRENTLY / USING / INCLUDE / WHERE de PostgreSQL, FULLTEXT/SPATIAL y KEY/INDEX en línea de MySQL, CLUSTERED/NONCLUSTERED con INCLUDE de MSSQL e índices estándar de SQLite.

4.1. Sintaxis

SQL / Ejemplo
CREATE [UNIQUE] INDEX [IF NOT EXISTS] [name]
  ON [schema.]table (col1 [ASC|DESC] [NULLS FIRST|LAST], col2, ...)
  [INCLUDE (cols)]      -- PG / MSSQL: covering columns (no badge added)
  [WHERE predicate]     -- PG / MSSQL: partial / filtered index
  [USING method]        -- PG: btree, hash, gin, gist, brin
  [WITH (options)];     -- storage parameters

4.2. Ejemplos

Acelera una búsqueda frecuente de FK (IDX de una sola columna):

SQL / Ejemplo
CREATE INDEX idx_orders_customer ON orders (customer_id);

Índice compuesto (etiqueta IDX tenue en cada columna de clave):

SQL / Ejemplo
CREATE INDEX idx_orders_customer_status
  ON orders (customer_id, status);

Promover una columna a UNIQUE sin alterar su definición:

SQL / Ejemplo
CREATE UNIQUE INDEX uq_shipments_tracking
  ON shipments (tracking_number);

Índice único parcial / filtrado (PUQ, no un objetivo global de FK):

SQL / Ejemplo
CREATE UNIQUE INDEX ux_users_active_email
  ON users (email)
  WHERE deleted_at IS NULL;

Índice en línea de MySQL dentro de CREATE TABLE:

SQL / Ejemplo
CREATE TABLE posts (
  id INT PRIMARY KEY,
  slug VARCHAR(160) NOT NULL,
  body TEXT,
  UNIQUE INDEX ux_posts_slug (slug),
  KEY idx_posts_body (body),
  FULLTEXT KEY ft_body (body)
);

Índice filtrado + INCLUDE en MSSQL / SQL Server:

SQL / Ejemplo
CREATE NONCLUSTERED INDEX idx_active_orders
  ON orders (customer_id)
  INCLUDE (total)
  WHERE status = 'active';

4.3. Comportamiento y semántica

  • Índices funcionales / de expresión (p. ej. CREATE INDEX … ON t (lower(email))) se conservan y generan una advertencia explícita, pero sin insignia — no se asignan limpiamente a una sola columna.
  • Columnas INCLUDE (las columnas de cobertura) se analizan pero nunca reciben insignia — solo las columnas clave obtienen la píldora.
  • Columnas PK / UQ son garantías más fuertes que IDX, por lo que cualquier posterior CREATE INDEX en ellos se omite silenciosamente; no verás píldoras redundantes.
  • Índices únicos parciales / filtrados renderizar como PUQ con el WHERE predicado en los detalles de la columna. No se aceptan como objetivos globalmente únicos para la validación de claves foráneas.
  • Las insignias finales son invariantes al orden: una garantía global única suprime una redundante IDX indica si el índice único o no único aparece primero. Los metadatos del índice compuesto se conservan de igual manera independientemente del orden de declaración.
  • Índices en tablas / columnas desconocidas se descartan silenciosamente, lo cual es útil al portar esquemas parciales sin romper el diagrama.
  • Ciclo de vida del índice incluye de nivel superior CREATE/DROP INDEX, PostgreSQL DROP INDEX CONCURRENTLY, MySQL ALTER TABLE … ADD/DROP/RENAME INDEX, PostgreSQL ALTER INDEX … RENAME, y renombres de índices de SQL Server a través de sp_rename. Los metadatos nombrados UQ/PUQ/IDX siguen el nombre final superviviente.
Consejo: Las etiquetas IDX compuestas se representan en un gris tenue para reflejar el lenguaje visual existente de PK compuesta / UQ compuesta. Una etiqueta IDX sólida siempre significa "índice de una sola columna", lo que facilita el escaneo en diagramas densos.

Soporte multidialecto

El analizador del lado del navegador maneja las diferencias de sintaxis entre SQLite, PostgreSQL, MySQL y MSSQL sin una conexión a la base de datos. La detección automática utiliza señales de sintaxis estructural y permanece neutral para entradas de dialectos genuinamente mixtos; los llamadores también pueden proporcionar un dialecto explícito. Los ejemplos a continuación siguen el mismo orden estándar: SQLite primero, luego PostgreSQL, MySQL y MSSQL.

4.1. Características de SQLite

SQL / Ejemplo
-- SQLite uses type affinities: INTEGER, TEXT, REAL, NUMERIC, BLOB
CREATE TABLE users (
  id       INTEGER PRIMARY KEY,         -- implicit rowid alias
  email    TEXT UNIQUE NOT NULL,
  name     TEXT NOT NULL,
  balance  REAL DEFAULT 0.0,
  metadata BLOB,
  created  TEXT DEFAULT (datetime('now'))
);

-- AUTOINCREMENT prevents rowid reuse after DELETE
CREATE TABLE events (
  id   INTEGER PRIMARY KEY AUTOINCREMENT,
  name TEXT NOT NULL,
  ts   TEXT DEFAULT CURRENT_TIMESTAMP
);

-- WITHOUT ROWID — clustered on the declared PRIMARY KEY
CREATE TABLE kv_store (
  key   TEXT PRIMARY KEY,
  value TEXT
) WITHOUT ROWID;

-- STRICT mode — enforces declared column types
CREATE TABLE audit_log (
  id      INTEGER PRIMARY KEY,
  action  TEXT NOT NULL,
  payload TEXT
) STRICT;

-- STRICT + WITHOUT ROWID combined
CREATE TABLE config (
  key   TEXT PRIMARY KEY,
  value TEXT NOT NULL
) STRICT, WITHOUT ROWID;

-- Foreign keys with ON DELETE / ON UPDATE actions
CREATE TABLE orders (
  id          INTEGER PRIMARY KEY,
  customer_id INTEGER NOT NULL
    REFERENCES users(id) ON DELETE CASCADE ON UPDATE SET NULL,
  total       REAL DEFAULT 0 CHECK (total >= 0)
);

-- IF NOT EXISTS works as expected
CREATE TABLE IF NOT EXISTS sessions (
  token   TEXT PRIMARY KEY,
  user_id INTEGER REFERENCES users(id),
  expires TEXT
);
Específico de SQLite: INTEGER PRIMARY KEY (alias de rowid), AUTOINCREMENT, WITHOUT ROWID, STRICT tablas, columnas sin tipo que no son STRICT, afinidades de tipo (INTEGER, TEXT, REAL, NUMERIC, BLOB), datetime('now') / CURRENT_TIMESTAMP valores predeterminados y estándar REFERENCES con ON DELETE / ON UPDATE acciones.
Corrección de tipo: Las tablas SQLite ordinarias aceptan nombres de tipo declarados arbitrarios (como VARCHAR(255), BOOLEAN, o TIMESTAMP) y puede omitir un tipo. Las tablas STRICT siguen el conjunto exacto permitido por SQLite: INT, INTEGER, REAL, TEXT, BLOB, o ANY; cada columna STRICT debe declarar uno.

Ejemplo de reproducción de migración de SQLite:

SQL / Ejemplo
CREATE TABLE authors (
  id    INTEGER PRIMARY KEY,
  email TEXT NOT NULL UNIQUE
) STRICT;

CREATE TABLE posts (
  author_id INTEGER NOT NULL
    REFERENCES authors(id) ON DELETE CASCADE ON UPDATE RESTRICT,
  post_id   TEXT NOT NULL,
  body      TEXT,
  PRIMARY KEY (author_id, post_id)
) STRICT, WITHOUT ROWID;

ALTER TABLE posts ADD COLUMN summary TEXT;
ALTER TABLE posts RENAME COLUMN summary TO excerpt;
ALTER TABLE authors RENAME TO writers;

4.2. Características de PostgreSQL

SQL / Ejemplo
-- Composite type + ENUM + array column types
CREATE TYPE address AS (street TEXT, city VARCHAR(100), zip VARCHAR(20));
CREATE TYPE org_plan AS ENUM ('free','starter','pro','enterprise');

CREATE TABLE organizations (
  id            BIGSERIAL PRIMARY KEY,
  -- Or: id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
  name          VARCHAR(255) NOT NULL,
  plan          org_plan NOT NULL DEFAULT 'free',

  -- PostgreSQL-specific types
  billing_addr  address,                          -- composite type
  data          JSONB DEFAULT '{}',               -- JSON binary
  tags          TEXT[],                           -- 1-D array
  matrix        INT[5],                           -- sized array
  uuid          UUID DEFAULT gen_random_uuid(),
  ip            INET,
  ts            TIMESTAMPTZ DEFAULT NOW(),

  -- Dollar-quoted defaults
  description   TEXT DEFAULT $$Hello World$$,

  -- Type casting in defaults
  seq_id        INTEGER DEFAULT nextval('org_seq'::regclass)
);

-- Schema-qualified table & type references both work
CREATE TABLE public.users (
  id INTEGER PRIMARY KEY,
  status public.org_plan          -- schema-qualified user-defined type
);

-- Empty body INHERITS (PG-only)
CREATE TABLE child () INHERITS (parent);
PostgreSQL: Admite tipos SERIAL, columnas de identidad, JSONB, BYTEA, INET, variantes de marca de tiempo, matrices, tipos compuestos y ENUM, UNIQUE NULLS NOT DISTINCT, preservación de índices de expresión e identidad exacta de PostgreSQL sensible a mayúsculas y minúsculas para nombres entre comillas.

4.3. Características de MySQL

SQL / Ejemplo
-- Backtick-quoted identifiers + ENGINE / CHARSET / COLLATE
CREATE TABLE `users` (
  `id` BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
  `name` VARCHAR(100) NOT NULL,

  -- Inline ENUM and SET (auto-registered as named types)
  `status` ENUM('active', 'inactive', 'suspended') NOT NULL DEFAULT 'active',
  `flags`  SET('verified','staff','beta','muted'),

  -- UNSIGNED / SIGNED modifiers + TINYINT(1)
  `age`     TINYINT UNSIGNED,
  `is_pro`  TINYINT(1) UNSIGNED DEFAULT 0,

  -- COMMENT on columns
  `email` VARCHAR(255) COMMENT 'User email address',

  -- Timestamps with ON UPDATE CURRENT_TIMESTAMP
  `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  `updated_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,

  -- MySQL-specific types
  `bio`         MEDIUMTEXT,
  `avatar`      LONGBLOB,
  `birth_year` YEAR(4),
  `location`    POINT,

  -- Inline indexes become ERD badges when they map to columns
  INDEX idx_name (`name`),
  FULLTEXT KEY ft_bio (`bio`),
  UNIQUE INDEX ux_name (`name`),
  UNIQUE KEY uk_email (`email`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
Específico de MySQL: AUTO_INCREMENT, COMMENT, modificadores con signo, variantes de entero/texto/blob/espacial, en línea ENUM y SET, índices en línea, CHANGE COLUMN, MODIFY COLUMN, FIRST/AFTER ubicación física, ON UPDATE CURRENT_TIMESTAMP, y opciones de tabla comunes.

4.4. Características de MSSQL / SQL Server

SQL / Ejemplo
-- Bracket-quoted identifiers + IDENTITY + computed columns
CREATE TABLE [dbo].[Users] (
  [UserID]      BIGINT IDENTITY(1,1) NOT NULL CONSTRAINT pk_users PRIMARY KEY CLUSTERED,
  [FirstName]   NVARCHAR(50) NOT NULL,
  [LastName]    NVARCHAR(50) NOT NULL,

  -- Computed column (parenthesized form)
  [FullName]    AS ([FirstName] + ' ' + [LastName]) PERSISTED,

  -- Computed column (bare AS form — also supported)
  [Initials]    AS LEFT([FirstName],1) + LEFT([LastName],1),

  -- MSSQL-specific types
  [IsActive]    BIT DEFAULT 1,
  [CreatedAt]   DATETIME2 DEFAULT GETDATE(),
  [UniqueToken] UNIQUEIDENTIFIER DEFAULT NEWID(),
  [SeqToken]    UNIQUEIDENTIFIER DEFAULT NEWSEQUENTIALID() ROWGUIDCOL,
  [Photo]       VARBINARY(MAX),
  [Notes]       NVARCHAR(MAX),
  [Config]      XML,
  [Location]    GEOGRAPHY,
  [TreePath]    HIERARCHYID
) ON [PRIMARY];
GO

-- ALTER TABLE with WITH CHECK and CONSTRAINT WITH (...)
ALTER TABLE [Users] WITH CHECK
  ADD CONSTRAINT [chk_active] CHECK ([IsActive] IN (0,1));
GO

-- Multi-statement batches separated by GO are honored
CREATE TABLE [dbo].[Orders] (
  [OrderID] INT IDENTITY NOT NULL PRIMARY KEY  -- bare IDENTITY → (1,1)
);
GO
Específico de MSSQL: IDENTITY(seed, increment), NVARCHAR(MAX), fecha/hora, binario, XML, tipos de identificador y espaciales, ROWGUIDCOL, índices agrupados, GO lotes, ALTER COLUMN, columnas calculadas, con nombre DEFAULT ... FOR column restricciones, columnas temporales generadas, y PERIOD FOR SYSTEM_TIME.
Columnas calculadas con AS simple: col AS expression PERSISTED (sin paréntesis que lo rodeen) es totalmente compatible, incluidas las llamadas a funciones (DATEADD, LEFT, …), referencias de columna calificadas por tabla (c.col), y CASE expresiones.

4.5. Estilos de comillas para identificadores

Se admiten las tres convenciones principales de entrecomillado:

SQL / Ejemplo
-- PostgreSQL / Standard SQL: double quotes
CREATE TABLE "My Table" (
  "Column Name" INTEGER
);

-- MySQL: backtick quotes
CREATE TABLE `my_table` (
  `column_name` INT
);

-- MSSQL / SQL Server: square brackets
CREATE TABLE [my_table] (
  [column_name] INT
);

Notas y consejos

Detalles importantes del soporte de sintaxis: qué contribuye a la estructura del esquema, qué DDL/DML se puede reproducir con filas de muestra, qué consultas SELECT pueden leer y dónde están los límites.

✓ Soporte de sintaxis de esquema / ERD

  • Multidialecto: La sintaxis de SQLite, PostgreSQL, MySQL y MSSQL puede compartir un script; la detección automática se mantiene neutral cuando las señales fuertes están genuinamente mezcladas
  • Palabras clave que no distinguen entre mayúsculas y minúsculas: CREATE, TABLE, ALTER, etc. se pueden escribir en cualquier combinación de mayúsculas y minúsculas
  • Identificadores entre comillas: Comillas dobles ("name"), comillas invertidas (`name`), y corchetes ([name])
  • Nombres de columnas con palabras reservadas: Simple key, index, value, name, order, etc. se aceptan cuando van seguidos de un tipo de datos
  • Nombres cualificados por esquema: schema.table y schema.type (p. ej., public.users, dbo.Orders, app.status_enum) — los prefijos de esquema en tipos definidos por el usuario se conservan para búsqueda estricta y se simplifican para mostrar solo cuando no sean ambiguos
  • Comentarios: Una sola línea (-- comment) y comentarios de bloque (/* comment */) se omiten automáticamente
  • BOM y CRLF: La marca de orden de bytes UTF-8 y los finales de línea de Windows se manejan de forma transparente
  • Tipos personalizados: CREATE TYPE … AS ENUM y CREATE TYPE … AS (composite), incluyendo nombres calificados por esquema
  • ENUM y SET en línea (MySQL): ENUM('a','b') y SET('a','b','c') dentro de tipos de columna — registrados automáticamente como tipos nombrados y con espacios de nombres por tabla/columna cuando nombres de columna duplicados usan diferentes dominios
  • Restricciones: A nivel de columna y a nivel de tabla PRIMARY KEY, FOREIGN KEY, UNIQUE, CHECK (incluidas variantes compuestas de varias columnas). Los destinos de FK se validan con respecto a claves primarias, restricciones únicas o índices únicos globales
  • Identidad / autoincremento: SERIAL/BIGSERIAL (PG), GENERATED ALWAYS/BY DEFAULT AS IDENTITY (PG), AUTO_INCREMENT (MySQL), IDENTITY(1,1) y simple IDENTITY (MSSQL) — todos se unifican en el diagrama
  • Columnas calculadas: GENERATED ALWAYS AS (expr) STORED/VIRTUAL (PG/MySQL) y MSSQL col AS (expr) [PERSISTED] + simple col AS expr [PERSISTED]
  • Arrays de PostgreSQL: type[], con tamaño type[5], anidado type[][][], y arreglos de tipos definidos por el usuario (p. ej., webhook_event[])
  • Valores por defecto: Literales, cadenas entre comillas de dólar, llamadas a funciones (now(), CURRENT_TIMESTAMP, GETDATE(), NEWID(), NEWSEQUENTIALID(), gen_random_uuid(), nextval()), y ON UPDATE CURRENT_TIMESTAMP (MySQL)
  • Acciones de FK: ON DELETE / ON UPDATE con CASCADE, RESTRICT, SET NULL, SET DEFAULT, NO ACTION, más MATCH, DEFERRABLE, y INITIALLY metadatos. Las acciones se conservan como metadatos de relación.
  • Reproducción de migración: ALTER TABLE ADD COLUMN, agregar/eliminar/renombrar claves y restricciones, renombres de tabla/columna/índice, DROP COLUMN, ALTER COLUMN TYPE/SET DATA TYPE, SET/DROP DEFAULT, SET/DROP NOT NULL, MSSQL sp_rename, y MySQL MODIFY/CHANGE COLUMN
  • Índices: Nivel superior CREATE/DROP INDEX, PostgreSQL ALTER INDEX … RENAME, MySQL add/drop/rename e inline KEY/INDEX/UNIQUE INDEX/FULLTEXT/SPATIAL definiciones. Los índices respaldados por columnas se renderizan como IDX, UQ, o PUQ insignias
  • IF NOT EXISTS, IF EXISTS: manejado correctamente en ambos CREATE y DROP
  • Envoltorios de transacción solo para esquemas: BEGIN, COMMIT, SET search_path, USE [db] (MSSQL), y SET FOREIGN_KEY_CHECKS (MySQL) se omiten con elegancia
  • Omitido correctamente: CREATE VIEW, CREATE MATERIALIZED VIEW, CREATE FUNCTION/TRIGGER/SCHEMA/SEQUENCE, procedimental EXEC sentencias distintas a sp_rename, DECLARE, PRINT, PARTITION BY, INHERITS (incluido el cuerpo vacío), WITH OIDS, STORAGE PLAIN, EXCLUDE USING gist, y cuerpos de sentencias que no afectan la estructura del ERD

✓ Sintaxis de vista previa de DDL/DML

  • Ejecución de arriba a abajo: El script se reproduce en el orden de las sentencias, por lo que los datos de muestra deben ir después del esquema al que hacen referencia
  • Sentencias admitidas: CREATE TYPE, CREATE TABLE, CREATE VIEW, CREATE INDEX, ALTER TABLE cambios de columna/restricción, DROP INDEX, TRUNCATE TABLE, INSERT, UPDATE, DELETE, DROP TABLE, DROP VIEW, y DROP TYPE
  • Filtros WHERE: =, !=, <>, >, <, >=, <=, LIKE, IN, NOT IN, NOT LIKE, BETWEEN, NOT BETWEEN, IS NULL, y IS NOT NULL
  • Materialización de filas: Las tablas exponen recuentos de filas, metadatos de estructura y datos de fila actuales después de que se ejecutan las sentencias DML
  • Tipos con nombre: Tipos ENUM y compuestos creados con CREATE TYPE se muestran por separado de las tablas
  • Registro de ejecución: Los estados de éxito, advertencia y error se capturan para columnas desconocidas, tablas faltantes, claves duplicadas, violaciones de NULL y actualizaciones/eliminaciones generales; los enlaces de mutación no válidos fallan antes de que las filas cambien
  • Evaluación por defecto: Valores predeterminados literales más funciones como now(), CURRENT_TIMESTAMP, CURRENT_DATE, GETDATE(), y NEWID()

✓ Sintaxis de consulta SELECT

  • SELECT de solo lectura: SELECT sentencias pueden leer las tablas en memoria producidas a partir del archivo SQL principal
  • Metadatos del resultado: Las columnas, el recuento de filas, el tiempo transcurrido, el formato de NULL/booleano/número y los errores de consulta se conservan con el resultado de SELECT
  • Consultas relacionales: Joins, filtros WHERE, GROUP BY, HAVING, ORDER BY, LIMIT/OFFSET, TOP, FETCH FIRST, CTE, tablas derivadas, subconsultas y operadores de conjunto
  • Ayudantes analíticos: Agregados, funciones escalares comunes, ayudantes de JSON, funciones de fecha/cadena y funciones de ventana como ROW_NUMBER, RANK, NTILE, FIRST_VALUE, LAST_VALUE, LAG, y LEAD; los marcos predeterminados ordenados incluyen el grupo de pares actual

✗ Aún no compatible / Omitido

  • ALTER TYPE: No se pueden modificar los tipos ENUM o compuestos existentes
  • Cláusula LIKE: CREATE TABLE foo (LIKE bar INCLUDING …) se omite elegantemente: las columnas copiadas no se materializan
  • Herencia de columnas INHERITS: El INHERITS (parent) la cláusula en sí se analiza sin errores, pero las columnas heredadas no se incluyen en la tabla hija para fines de ERD
  • Ejecución de índice: El DDL de índice puede crear insignias de esquema, pero la ejecución de vista previa no modela motores de almacenamiento, planificadores de consultas ni rendimiento de índices
  • Límites de SELECT: La sintaxis de consulta de solo lectura no admite CTE recursivos, ejecución de bases de datos externas, procedimientos almacenados o sentencias de mutación
  • Otros objetos: Triggers, procedimientos almacenados, funciones y secuencias
  • Ejecución externa: La vista previa de DDL/DML no se conecta a una base de datos real ni persiste filas fuera del archivo SQL actual
Comportamiento de la sintaxis: El DML no contribuye a la generación del diagrama de esquema. Las sentencias de ciclo de vida de tablas, tipos e índices con nombre se reproducen en el orden de origen, incluyendo el cambio de nombre, la eliminación y la recreación posterior sin filtrar metadatos entre las encarnaciones de los objetos. Las sentencias DDL/DML compatibles se ejecutan en memoria de arriba a abajo, y las consultas SELECT de solo lectura leen de ese resultado en memoria sin modificarlo.
Mejores prácticas:
  • Finalice cada sentencia con un punto y coma (;)
  • Definir CREATE TYPE antes de las tablas que los referencian
  • Definir CREATE TABLE antes de los relacionados INSERT, UPDATE, o DELETE sentencias
  • Usar ALTER TABLE para claves foráneas cuando las tablas se referencian entre sí (dependencias circulares)
  • Utilice DDL para la estructura primero, luego DML para validar filas de muestra y el comportamiento de las restricciones.
  • Mantenga los datos de demostración en el propio archivo SQL porque las filas de vista previa se derivan del script
Recuperación de errores: Las declaraciones no admitidas se omiten y las advertencias/errores de sintaxis se muestran con suficiente contexto para seguir refinando el mismo archivo en lugar de empezar desde cero.

Al seguir estos patrones de sintaxis, Erd Go puede generar su esquema ERD, previsualizar Datos en memoria y ejecutar consultas de solo lectura desde el mismo archivo SQL.

ErdGo.com - Transforme SQL en diagramas y previsualice Datos más rápido