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.
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.
-- 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;REFERENCES o ALTER TABLE ADD FOREIGN KEY. Ambas formas aportan los mismos metadatos de relación.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.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
- 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.
- 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.
- 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.
- 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
| Síntoma | Qué verificar |
|---|---|
| Falta una tabla | Compruebe 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ón | Compruebe 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 filas | Ponga 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 SQL | Ejecute 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 diferente | La 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 editar | Compruebe 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.
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
-- 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;=, !=, <>, >, <, >=, <=, 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
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.
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.
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;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
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.
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.
// 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.
// Each log entry is:
{
type: "success" | "warning" | "error",
message: "Inserted 3 row(s) into \"users\"",
timestamp: 1734567890123 // ms since epoch, monotonic
}-- 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 existDiagnósticos comunes
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.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.
CREATE TYPE type_name AS (
field1 data_type1,
field2 data_type2,
...
);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)
);1.2. Tipo Enum
Cree tipos enumerados con valores predefinidos para una mejor integridad de Datos y legibilidad.
CREATE TYPE enum_name AS ENUM (
'value1',
'value2',
...
);Ejemplo:
CREATE TYPE status_enum AS ENUM (
'pending',
'active',
'completed',
'cancelled'
);
CREATE TYPE priority_level AS ENUM (
'low', 'medium', 'high', 'critical'
);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.
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
);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:
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 ( ... );"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:
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
- Literales: números (
123), cadenas ('text') - Funciones de PostgreSQL:
now(),CURRENT_TIMESTAMP,CURRENT_DATE,nextval('seq'::regclass) - Funciones de MSSQL:
GETDATE(),NEWID()
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.
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.
CREATE TABLE tasks (
id INTEGER PRIMARY KEY,
status ENUM('todo', 'doing', 'done'),
priority ENUM('low', 'medium', 'high')
);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.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:
-- 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:
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)
);CONSTRAINT name) es opcional.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:
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
);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
-- 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 keyINTEGER PRIMARY KEY AUTOINCREMENT. No use BIGINT, INT, o una clave primaria compuesta con AUTOINCREMENT.PostgreSQL
-- 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
);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
CREATE TABLE users (
id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
email VARCHAR(255) NOT NULL UNIQUE
) ENGINE=InnoDB;MSSQL / SQL Server
-- 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
);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
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
);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.
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
);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.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
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:
ALTER TABLE orders
ADD CONSTRAINT fk_orders_customer
FOREIGN KEY (customer_id)
REFERENCES customers(id)
ON DELETE CASCADE;3.2. Añadir clave primaria
ALTER TABLE table_name
ADD [CONSTRAINT name] PRIMARY KEY (cols...);Ejemplo:
ALTER TABLE products
ADD CONSTRAINT pk_products
PRIMARY KEY (product_id);3.3. Añadir restricción única
ALTER TABLE table_name
ADD [CONSTRAINT name] UNIQUE (cols...);Ejemplo:
ALTER TABLE users
ADD CONSTRAINT uq_users_email
UNIQUE (email);3.4. Añadir restricción CHECK
ALTER TABLE table_name
ADD [CONSTRAINT name] CHECK (expression);Ejemplo:
ALTER TABLE employees
ADD CONSTRAINT chk_salary
CHECK (salary >= 0);3.5. Ejemplo de reproducción de migración
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);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
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
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';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
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 parameters4.2. Ejemplos
Acelera una búsqueda frecuente de FK (IDX de una sola columna):
CREATE INDEX idx_orders_customer ON orders (customer_id);Índice compuesto (etiqueta IDX tenue en cada columna de clave):
CREATE INDEX idx_orders_customer_status
ON orders (customer_id, status);Promover una columna a UNIQUE sin alterar su definición:
CREATE UNIQUE INDEX uq_shipments_tracking
ON shipments (tracking_number);Índice único parcial / filtrado (PUQ, no un objetivo global de FK):
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:
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:
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 INDEXen ellos se omite silenciosamente; no verás píldoras redundantes. - Índices únicos parciales / filtrados renderizar como
PUQcon elWHEREpredicado 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
IDXindica 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, PostgreSQLDROP INDEX CONCURRENTLY, MySQLALTER TABLE … ADD/DROP/RENAME INDEX, PostgreSQLALTER INDEX … RENAME, y renombres de índices de SQL Server a través desp_rename. Los metadatos nombrados UQ/PUQ/IDX siguen el nombre final superviviente.
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
-- 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
);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.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:
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
-- 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);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
-- 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;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
-- 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)
);
GOIDENTITY(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.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:
-- 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.tableyschema.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 ENUMyCREATE TYPE … AS (composite), incluyendo nombres calificados por esquema - ENUM y SET en línea (MySQL):
ENUM('a','b')ySET('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 simpleIDENTITY(MSSQL) — todos se unifican en el diagrama - Columnas calculadas:
GENERATED ALWAYS AS (expr) STORED/VIRTUAL(PG/MySQL) y MSSQLcol AS (expr) [PERSISTED]+ simplecol AS expr [PERSISTED] - Arrays de PostgreSQL:
type[], con tamañotype[5], anidadotype[][][], 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()), yON UPDATE CURRENT_TIMESTAMP(MySQL) - Acciones de FK:
ON DELETE/ON UPDATEconCASCADE,RESTRICT,SET NULL,SET DEFAULT,NO ACTION, másMATCH,DEFERRABLE, yINITIALLYmetadatos. 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, MSSQLsp_rename, y MySQLMODIFY/CHANGE COLUMN - Índices: Nivel superior
CREATE/DROP INDEX, PostgreSQLALTER INDEX … RENAME, MySQL add/drop/rename e inlineKEY/INDEX/UNIQUE INDEX/FULLTEXT/SPATIALdefiniciones. Los índices respaldados por columnas se renderizan comoIDX,UQ, oPUQinsignias - IF NOT EXISTS, IF EXISTS: manejado correctamente en ambos
CREATEyDROP - Envoltorios de transacción solo para esquemas:
BEGIN,COMMIT,SET search_path,USE [db](MSSQL), ySET FOREIGN_KEY_CHECKS(MySQL) se omiten con elegancia - Omitido correctamente:
CREATE VIEW,CREATE MATERIALIZED VIEW,CREATE FUNCTION/TRIGGER/SCHEMA/SEQUENCE, procedimentalEXECsentencias distintas asp_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 TABLEcambios de columna/restricción,DROP INDEX,TRUNCATE TABLE,INSERT,UPDATE,DELETE,DROP TABLE,DROP VIEW, yDROP TYPE - Filtros WHERE:
=,!=,<>,>,<,>=,<=,LIKE,IN,NOT IN,NOT LIKE,BETWEEN,NOT BETWEEN,IS NULL, yIS 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 TYPEse 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(), yNEWID()
✓ Sintaxis de consulta SELECT
- SELECT de solo lectura:
SELECTsentencias 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, yLEAD; 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
- Finalice cada sentencia con un punto y coma (
;) - Definir
CREATE TYPEantes de las tablas que los referencian - Definir
CREATE TABLEantes de los relacionadosINSERT,UPDATE, oDELETEsentencias - Usar
ALTER TABLEpara 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