DO ESQUEMA PARA O DIAGRAMA
SQL para ERD: guia
Transforme seu esquema de banco de dados em um diagrama. Conheça o SQL compatível, visualize dados e consulte seu modelo.
Contrato de Sintaxe SQL Pronto para IA
Utilize esta página como um contrato compacto ao pedir a uma IA para escrever ou editar SQL para o Erd Go. Prefira os padrões de sintaxe abaixo, mantenha as instruções completas e terminadas em ponto e vírgula, e evite objetos de base de dados não suportados, a menos que apenas precise de SQL bruto fora do Erd Go. As sintaxes SQLite, PostgreSQL, MySQL e MSSQL são suportadas no conjunto partilhado abaixo. A conversão de SQL para ERD executa-se inteiramente no navegador, e os seus motores de análise sintática e pré-visualização estão garantidos por milhares de testes unitários e de integração que cobrem esquemas de produção do mundo real (SaaS, banca, redes sociais, analítica, EHR).
SQLite
Regras rowid de INTEGER PRIMARY KEY, colunas sem tipo, AUTOINCREMENT, WITHOUT ROWID, tabelas STRICT validadas, ações FK e reprodução de migração
PostgreSQL
Tipos ENUM e compostos, arrays, JSONB, SERIAL, colunas de identidade, NULLS NOT DISTINCT, índices de expressão, identidade de esquema e sensibilidade a maiúsculas/minúsculas em nomes entre aspas
MySQL
AUTO_INCREMENT, ENUM e SET inline, backticks, COMMENT, UNSIGNED/SIGNED, índices inline, CHANGE/MODIFY COLUMN e posicionamento FIRST/AFTER
MSSQL
IDENTITY, NVARCHAR(MAX), nomes entre parênteses retos, índices agrupados, lotes GO, ALTER COLUMN, colunas calculadas, predefinições nomeadas e períodos temporais
DDL
Instruções CREATE TYPE, CREATE TABLE, reprodução de migração ALTER TABLE, CREATE INDEX e DROP seguras para a forma do esquema
DML / SELECT
INSERT, UPDATE, DELETE para pré-visualização de dados, além de sintaxe SELECT apenas de leitura para junções, CTEs, agregados, janelas e relatórios
Início Rápido
Utilize isto como uma resposta modelo ao pedir a uma IA SQL compatível com o Erd Go: tipos personalizados primeiro, tabelas a seguir, restrições de relacionamento após as tabelas quando útil, e depois DML de exemplo. Mantenha as consultas SELECT de leitura 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 ou ALTER TABLE ADD FOREIGN KEY. Ambas as formas contribuem com os mesmos metadados de relacionamento.INSERT, UPDATE, e DELETE após o DDL do esquema. O script é avaliado de cima para baixo, pelo que as linhas de exemplo devem referenciar tabelas e tipos já existentes.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;Separadores SQL e importação de ficheiros
Inicie um novo ficheiro SQL com uma amostra, um separador de Esquema em branco ou Importar Ficheiros SQL. A amostra separa o esquema e os dados em separadores. O separador Adicionar SQL cria outro separador de editor; clique duas vezes no seu título para o renomear.
Os separadores ativos são compilados em conjunto na sua ordem visível para o ERD, Vista de Dados, Vista de Consulta e pedidos de IA. Um separador inativo permanece como um rascunho salvo e é excluído desses fluxos de trabalho. Coloque tipos e tabelas antes das instruções que dependem deles.
Importar ficheiros SQL aceita múltiplos ficheiros SQL de texto e analisa problemas de processamento em conjunto antes da importação. Isto ajuda a resolver referências entre ficheiros. Utilize a ordem dos separadores para manter as dependências e os passos de migração intencionais.
Utilize as teclas de seta e Home/End na faixa de separadores para alternar entre separadores, Alt+Esquerda/Direita para os reordenar e Shift+Alt+F para formatar SQL no editor.
Abra o Explorador SQL ao lado dos separadores para uma árvore de pastas redimensionável. Crie pastas aninhadas e ficheiros SQL, selecione um ficheiro para o abrir e organize com arrastar/largar. O pop-up de ação da linha suporta Renomear e Eliminar ficheiro; clique fora para o fechar. Eliminar o último ficheiro mantém um ficheiro SQL em branco aberto. As pastas não alteram a ordem de execução. Remover uma pasta mantém os seus ficheiros e pastas filhas na pasta pai. Salvar retém a árvore de pastas e a preferência do painel.
Editar e revisar o diagrama
O SQL é a fonte do significado do esquema. Utilize Adicionar Tabela para construir uma tabela, ou selecione ações de tabela e coluna na área de trabalho para editar colunas e ligações. As edições do esquema na área de trabalho atualizam os separadores SQL correspondentes, bem como o diagrama.
A remoção de uma coluna pré-visualiza as ligações, chaves, índices e SQL dependente afetados. Reveja a remoção ou cascata antes de confirmar. Migrações complexas ou instruções dependentes não suportadas podem exigir a edição direta de SQL.
Utilize a pontuação de integridade do ERD para inspecionar descobertas estruturais e sugestões de relacionamento opcionais. As relações sugeridas precisam de revisão; não substituem as chaves estrangeiras declaradas nem estabelecem regras de negócio automaticamente.
Organize tabelas com o Modo de Layout, zoom ou Ajustar ao Ecrã, encontre tabelas com o Navegador de Tabelas e use Cores de Tabela ou o minimapa para navegar num diagrama grande. Passe o rato ou foque um controlo da barra de ferramentas para ver o seu texto de ajuda.
Selecione uma tabela e abra o Color Picker para predefinições sólidas ou de gradiente. Introduza um valor hexadecimal ou escolha Custom ao lado para usar o seletor de cores nativo. Ambos os controlos permanecem sincronizados; Salvar mantém a cor da tabela.
Quando as ferramentas de tabela estão definidas para apenas passar o rato, Adicionar coluna aparece quando passa o rato sobre a última linha visível ou foca o botão através do teclado. As ferramentas sempre visíveis mantêm-no mostrado.
Escolha Grupos de tabelas na barra de ferramentas da tela SQL e, em seguida, Novo grupo. Dê um nome e uma cor ao grupo, selecione as suas tabelas e escolha Criar grupo. Uma tabela selecionada começa marcada. Uma tabela pertence a um grupo; o formulário mostra quando a sua seleção moverá uma tabela para fora de outro grupo. São suportados até 50 grupos, com nomes de até 160 carateres.
Clique no cabeçalho de um grupo para editar o seu nome, cor ou membros. Arraste o cabeçalho para mover as suas tabelas em conjunto; solte para aplicar o movimento. Escape, cancelamento do ponteiro ou perda de foco da janela cancela a pré-visualização. Desagrupar tabelas remove a moldura mantendo as tabelas, as suas posições, SQL e relações.
As molduras de grupo seguem os cartões de tabela em tempo real e aparecem em Ajustar ao Ecrã, no minimapa e nas exportações de imagem da vista atual ou de todo o diagrama. Os grupos são estados visuais opcionais guardados com o documento SQL. Os ficheiros mais antigos mantêm o seu esquema existente e os nomes de tabelas temporariamente em falta permanecem no seu grupo até regressarem ao SQL analisado. Os grupos de tabelas pertencem ao SQL para ERD; os pacotes de Diagrama de classes utilizam um modelo separado.
Revisão de IA dentro do editor SQL
- Introduza uma alteração específica no Ask AI para editar SQL e escolha um modelo disponível. A opção 'Set Gemini API key' está disponível quando pretender utilizar a sua própria chave Gemini.
- Reveja as alterações propostas e a pré-visualização temporária do diagrama. O pedido utiliza a captura instantânea do separador ativo obtida quando foi enviado; uma resposta não é salva automaticamente.
- Aceite ou rejeite alterações individuais, ou utilize as ações para as alterações restantes. Navegue pelas alterações de código com F7 e Shift+F7. Os separadores inativos protegidos permanecem como rascunhos.
- Inspecione o SQL aceite e, em seguida, salvar o documento. Copiar Prompt de IA neste guia também permite que use a documentação com um assistente fora da aplicação.
Dados, consultas, exportações e ficheiros salvos
Utilize os botões ERD, Dados e Consulta para alternar entre ambientes de trabalho. A Vista de Dados materializa DDL e DML suportados no navegador e expõe tabelas, linhas, tipos e um registo de execução. Redimensione as colunas da grelha arrastando as suas extremidades ou dê um duplo clique para ajustar. Dê um duplo clique numa célula de Dados ou prima Enter para editar; os campos Boolean e enum oferecem valores válidos. A adição de linhas segue as predefinições do seu esquema. Importe CSV, TSV, TXT ou XLSX com uma pré-visualização do mapeamento de colunas. NULL e texto vazio permanecem distintos. As edições validadas convertem-se em SQL num separador de edições de Dados e podem ser anuladas. Transfira as linhas das tabelas ou os resultados das Consultas como CSV.
Salvar recorda a bancada de trabalho ERD, Dados ou Consulta selecionada; reabrir restaura-a, incluindo Dados/Consulta em telemóveis. Ficheiros mais antigos começam em ERD. Editores nativos de data/hora preservam valores suportados, enquanto carimbos de data/hora com frações ou desvios de fuso horário permanecem editáveis como texto. Identidades geradas pela base de dados permanecem apenas de leitura.
A Vista de Consulta executa consultas SELECT apenas de leitura contra as tabelas em memória atuais. Suporta a sintaxe documentada abaixo; não se liga a uma base de dados externa. O texto da consulta é salvo com o contexto do documento SQL.
Salvar também recorda a tabela de Dados selecionada. Reabrir restaura-a, com a primeira tabela como alternativa se estiver indisponível. Os campos do esquema alinham nomes, tipos e regras; passe o rato sobre um emblema de regra para a sua explicação. Ir para SQL ao lado do cabeçalho da tabela abre o seu separador SQL de definição e revela a instrução CREATE TABLE, reabrindo o painel SQL quando oculto, mantendo a seleção de Dados e rascunhos. Os resultados da Consulta combinam contagens, tempo, Ajustar, Copiar e CSV num único cabeçalho.
Arraste a divisória fina entre o editor de Consulta e os resultados, ou entre o esquema de Dados e as linhas, para redimensionar os painéis. As teclas de setas redimensionam uma divisória focada, Escape cancela o arrastamento e o clique duplo repõe-na. Estes tamanhos de painel permanecem como preferências temporárias da área de trabalho.
Gerar dados de amostra utiliza os seus tipos de coluna, nomes, relações e restrições. O idioma da amostra controla nomes e frases naturais de produto/descrição em 17 idiomas. Reveja os geradores e intervalos sugeridos, pré-visualize o resultado e, em seguida, insira explicitamente um separador de Dados de Amostra separado. Os booleanos são apresentados como true/false; os IDs permanecem numéricos. A geração nunca substitui linhas existentes.
Escolha Exportar ERD para selecionar PNG, SVG baseado em imagem ou PDF com tamanhos HD, 2K ou 4K. As imagens exportadas não substituem um documento salvo editável.
Inicie sessão e utilize Salvar SQL e ERD para salvar o SQL e o contexto do diagrama, incluindo separadores, edições de grelha aplicadas, texto da consulta e layout. O Salvar verifica primeiro uma célula ativa ou um rascunho de nova linha; dados inválidos permanecem visíveis para correção. As pré-visualizações de importação necessitam da sua ação explícita de Importar. Abra ficheiros salvos a partir da lista de ficheiros e utilize Partilhar num documento salvo próprio para configurar o acesso público e distribuir a sua ligação de apenas leitura.
Os documentos SQL, Prisma e Builder abrem nas suas próprias ferramentas. O Prisma e o Builder têm listas de ficheiros separadas e salvamento apenas na nuvem. Os avisos de alterações não salvas protegem os documentos editados ao sair de um espaço de trabalho; salve as suas alterações antes de partilhar ou mudar de página.
Resolver problemas no espaço de trabalho de SQL
| Sintoma | O que verificar |
|---|---|
| Falta uma tabela | Verifique os diagnósticos de análise, os separadores ativos e a ordem das instruções. Um DROP ou renomeação posterior pode alterar o diagrama final. |
| Falta uma relação | Verifique se as tabelas e as colunas existem, se a contagem de colunas de chave estrangeira corresponde e se a chave referenciada é globalmente única. Qualifique nomes ambíguos com o esquema. |
| A Visualização de Dados não mostra linhas | Coloque o INSERT após o seu CREATE TABLE num separador ativo. Inspecione o log de execução para linhas rejeitadas ou um rollback de transação. |
| Os resultados da consulta já não correspondem ao SQL | Execute a Consulta novamente após alterar o esquema ou os Dados; utilize as tabelas em memória atuais. |
| Adicionar Tabela sugere um dialeto diferente | A sintaxe detetada do espaço de trabalho ativo tem prioridade sobre a alternativa selecionada manualmente. Reveja o indicador de linguagem SQL e as predefinições específicas da tabela. |
| Um ficheiro salvar não pode ser editado | Verifique o início de sessão e a propriedade. Uma ligação pública concede acesso apenas de leitura; utilize Tentar novamente ou Abrir ficheiros para erros de carregamento recuperáveis. |
Fluxo de Trabalho de Sintaxe de IA
Ao utilizar um assistente de IA, peça-lhe para produzir SQL nesta ordem. Isto mantém o resultado fácil de analisar, fácil de diagramar e fácil de pré-visualizar com linhas de exemplo ou consultas de apenas leitura.
1. Defina os domínios primeiro
Coloque as definições CREATE TYPE enum/composite antes das tabelas que as referenciam. Prefira nomes explícitos em vez de tipos inline ad hoc quando um domínio é partilhado.
2. Criar tabelas base
Utilize CREATE TABLE para colunas, chaves primárias, unicidade, valores por omissão, verificações, colunas geradas e chaves estrangeiras em linha.
3. Repetir migrações
Utilize ALTER TABLE para restrições adicionadas, renomeações, colunas eliminadas, alterações de tipo/anulação de colunas e chaves estrangeiras circulares.
4. Adicionar dados e consultas em último lugar
Coloque INSERT/UPDATE/DELETE após todo o DDL. Mantenha as consultas SELECT separadas da mutação do esquema quando desejar conjuntos de resultados.
ALTER TYPE. Os índices de expressão são preservados com um aviso; solicite chaves de coluna simples quando precisar de emblemas de índice ERD.Sintaxe DDL & DML
Estas formas de instrução são seguras para scripts de esquema gerados por IA e dados de exemplo. A mesma sintaxe impulsiona a estrutura do ERD e as linhas de pré-visualização em memória, por isso mantenha o DDL antes do DML e evite efeitos secundários externos específicos da base de dados.
Instruções suportadas
-- 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, mais AND / OR combinações. As comparações NULL seguem a lógica UNKNOWN do padrão SQL — col = NULL nunca corresponde; use col IS NULL em vez disso. Alvos de atribuição desconhecidos, referências de coluna no lado direito e colunas de filtro rejeitam a mutação completa antes de quaisquer alterações nas linhas.Pré-visualizar semântica para DML gerado por IA
As linhas são reproduzidas do zero
As instruções DDL e DML são aplicadas em conjunto na ordem de origem; cada instrução de dados utiliza o esquema ativo nesse ponto.
Os tipos permanecem inspecionáveis
Enums nomeados e tipos compostos criados com CREATE TYPE permanecem parte do esquema analisado.
As restrições são aplicadas
PK, FK, NOT NULL, UNIQUE, DEFAULT, CHECK, colunas geradas e domínios enum afetam as linhas de pré-visualização.
Os erros devem ser corrigíveis
Prefira listas de colunas explícitas e cláusulas WHERE concretas para que os diagnósticos possam apontar para a tabela ou coluna exata.
SELECT conjuntos de resultados no script principal de esquema/DML, corpos procedimentais não suportados ou chamadas de base de dados externas. CREATE VIEW, CREATE OR REPLACE VIEW, e MSSQL CREATE OR ALTER VIEW são materializadas a partir das suas SELECT resultado para pré-visualização; mantenha as consultas ad hoc de leitura separadas.Transações em Vista de Dados
A Visualização de Dados suporta BEGIN, COMMIT, ROLLBACK, SAVEPOINT, ROLLBACK TO e RELEASE na pré-visualização em memória. Estas instruções afetam as linhas de pré-visualização; nunca efetuam commit numa base de dados externa.
SQLite, PostgreSQL e SQL Server mantêm DDL transacional na pré-visualização. O DDL do MySQL confirma a transação ativa. SQLite PRAGMA foreign_keys e MySQL SET FOREIGN_KEY_CHECKS afetam a validação DML subsequente.
O renderizador de ERD ignora invólucros de transação e representa as instruções do esquema na ordem de origem. Um rollback de transação na Vista de Dados pode, portanto, produzir um conjunto de tabelas diferente do diagrama. Verifique cada bancada de trabalho para o comportamento que está a testar.
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;Sintaxe de Consulta SELECT
Peça à IA para manter as consultas de relatório apenas de leitura como SELECT instruções. Estas podem referenciar as tabelas e linhas produzidas pelo script de esquema/DML e são úteis para junções, filtros, totais e conjuntos de resultados em forma de relatório sem necessitar de uma base de dados ativa.
Forma de consulta suportada
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;Apenas SELECT
O editor de consultas aceita instruções SELECT, incluindo SELECT sem FROM e WITH CTEs que resolvem para SELECT.
Junções e filtros
Junções INNER, LEFT, RIGHT, FULL e CROSS, condições WHERE, EXISTS, subconsultas IN, BETWEEN, LIKE, ILIKE e verificações NULL.
Agregados
Variantes de GROUP BY, HAVING, COUNT, SUM, AVG, MIN, MAX, ARRAY_AGG, GROUP_CONCAT, STRING_AGG e DISTINCT.
Ordenação e paginação
ORDER BY nomes ou ordinais, ASC/DESC, NULLS FIRST/LAST, LIMIT/OFFSET, TOP, e FETCH FIRST.
Suporte SELECT Avançado
CTEs e tabelas derivadas
Cláusulas WITH, SELECTs aninhados no FROM, subconsultas escalares, EXISTS, NOT EXISTS, IN e NOT IN são suportados.
Operadores de conjunto
UNION, UNION ALL, INTERSECT e EXCEPT podem combinar conjuntos de resultados compatíveis.
Funções de janela
ROW_NUMBER, RANK, DENSE_RANK, NTILE, LAG, LEAD, FIRST_VALUE e LAST_VALUE com OVER e PARTITION BY. As janelas ordenadas utilizam a moldura predefinida de SQL sensível a pares, e o NTILE atribui primeiro os baldes maiores.
Auxiliares de dialeto
Funções comuns de SQLite, PostgreSQL, MySQL e MSSQL são normalizadas para pré-visualização, incluindo auxiliares de JSON e data/string.
INSERT, UPDATE, DELETE, CREATE, ALTER, e DROP instruções no script de esquema/DML. A sintaxe da consulta deve manter-se SELECT-apenas.Diagnósticos e Erros
Os diagnósticos de sintaxe revelam problemas de análise de esquema, execução de DDL/DML e SELECT de leitura apenas com mensagens claras. Os erros de análise incluem posições de linha/coluna quando possível, e as mensagens de execução apontam de volta para a tabela, coluna ou forma de instrução que necessita de correção.
Erros de análise de esquema
O analisador de esquema (SQLite, PostgreSQL, MySQL e MSSQL) reporta problemas com dois níveis de gravidade: erro impede que uma única instrução contribua para o esquema; aviso mantém a sintaxe válida, mas assinala algo sobre o qual o utilizador deve 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
}Erros do analisador
Listas de colunas PRIMARY KEY / UNIQUE / FOREIGN KEY vazias, tipos de dados obrigatórios em falta (incluindo colunas SQLite STRICT), parênteses não correspondentes, vírgulas inesperadas e restrições malformadas.
Avisos do tokenizador
Strings não fechadas, comentários de bloco não fechados, parênteses incompatíveis e expressões CHECK de várias linhas suspeitas.
Avisos de chave estrangeira
As FKs que apontam para uma tabela desconhecida, coluna desconhecida, folha de esquema ambígua, ou alvo não-PK/não-UNIQUE são removidas do diagrama com um aviso descritivo.
Diagnósticos agrupados
Os avisos são agrupados por causa, incluindo Relação eliminada, Tabela desconhecida, Coluna desconhecida, Alvo de FK não único, Avisos e Erros de análise.
SQL vazio
A entrada vazia é válida e produz um esquema vazio. Apenas entradas não-string inválidas lançam erros.
Log de Execução DDL/DML
Cada instrução DDL ou DML executada anexa uma entrada estruturada ao log de execução em memória. O fluxo de mensagens preserva a ordem cronológica e classifica cada instrução como erro, aviso, ou sucesso.
// 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 Comuns
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 dados personalizados para reutilização em todo o seu esquema de base de dados. Tipos enum e compostos nomeados devem aparecer antes das tabelas que os referenciam, incluindo referências qualificadas pelo esquema.
1.1. Tipo Composto
Defina tipos compostos personalizados com vários campos de diversos tipos de dados.
CREATE TYPE type_name AS (
field1 data_type1,
field2 data_type2,
...
);Exemplo:
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
Crie tipos enumerados com valores predefinidos para uma melhor integridade de dados e legibilidade.
CREATE TYPE enum_name AS ENUM (
'value1',
'value2',
...
);Exemplo:
CREATE TYPE status_enum AS ENUM (
'pending',
'active',
'completed',
'cancelled'
);
CREATE TYPE priority_level AS ENUM (
'low', 'medium', 'high', 'critical'
);1.3. Tipos Qualificados por Esquema
Os tipos definidos pelo utilizador são resolvidos com o mesmo conhecimento de esquema que as tabelas. Se dois esquemas definirem o mesmo nome folha, o ERD mantém-nos distintos; se um tipo for único, o nome de exibição permanece simples.
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 resolve para s2.status apenas porque ambos partilham o nome da folha status. Os nomes de tipos qualificados são estritos, enquanto os nomes não qualificados resolvem-se apenas quando não são ambíguos.CREATE TABLE
Defina tabelas de base de dados com colunas, tipos de dados e restrições.
2.1. Estrutura Básica da Tabela
A sintaxe geral para criar uma tabela:
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"), crases (\`name\`), ou parênteses retos ([name]) para escapar caracteres especiais ou palavras-chave reservadas.2.2. Definições ao Nível da Coluna
Cada coluna pode incluir várias restrições e propriedades:
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 cada linha de forma única
UNIQUE
Garante que os valores das colunas são distintos
NOT NULL
Previne valores nulos
DEFAULT
Define valores predefinidos (literais ou funções)
CHECK
Valida dados com expressões booleanas
REFERENCES
Cria relações de chave estrangeira
- Literais: números (
123), strings ('text') - Funções de PostgreSQL:
now(),CURRENT_TIMESTAMP,CURRENT_DATE,nextval('seq'::regclass) - Funções MSSQL:
GETDATE(),NEWID()
REFERENCES table(column), qualificado pelo esquema REFERENCES schema.table(column), colunas de destino omitidas tais como REFERENCES departments, e ações de FK tais como ON DELETE CASCADE, ON UPDATE SET NULL, MATCH FULL, e DEFERRABLE INITIALLY DEFERRED.2.3. Colunas Geradas / Computadas
Referência rápida. Veja o dedicado Colunas Computadas secção abaixo para o detalhe completo por dialeto, incluindo a forma simples de AS do 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 Inline
Pode declarar um ENUM diretamente numa definição de coluna (estilo MySQL). O analisador irá registá-lo como um enum com nome e substituir o tipo de coluna automaticamente.
CREATE TABLE tasks (
id INTEGER PRIMARY KEY,
status ENUM('todo', 'doing', 'done'),
priority ENUM('low', 'medium', 'high')
);column_enum (por exemplo, status_enum); tabelas posteriores com uma definição diferente para o mesmo nome de coluna recebem um nome qualificado pela tabela, como tasks_status_enum para que os domínios nunca colapsem acidentalmente.CREATE TYPE ... AS ENUM em vez disso.2.5. Restrições ao Nível da Tabela
Defina restrições no final do corpo da tabela. Útil para chaves compostas e restrições de várias colunas:
-- 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)Exemplo:
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) é opcional.REFERENCES ref_table omite a lista de colunas de destino, o Erd Go resolve-a para a chave primária da tabela referenciada, incluindo chaves primárias compostas. Se especificar as colunas de destino explicitamente, estas devem ser suportadas por uma PRIMARY KEY, restrição UNIQUE ou global CREATE UNIQUE INDEX; índices únicos filtrados / parciais não contam como alvos de FK. As relações inválidas são descartadas com um aviso.2.6. Nomes de Colunas com Palavras Reservadas
Palavras como key, index, value, e name são reservadas em alguns dialetos, mas comumente usadas como nomes de coluna noutros. O analisador desambigua automaticamente quando o token seguinte é um tipo de dados conhecido, pelo que o uso simples sem aspas 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 por uma palavra-chave de tipo de dados (VARCHAR, INT, …) é um coluna. Seguido de um identificador e de uma lista de colunas entre parênteses, é um índice. Para segurança absoluta, coloque a coluna entre aspas com "key", `key`, ou [key].Colunas de identidade / incremento automático
Utilize a sintaxe de identidade nativa para o dialeto selecionado. Todas as formas suportadas produzem uma coluna de chave primária com o AUTO_INCREMENT marcador, mas o SQLite tem uma regra estrita: AUTOINCREMENT requer um único INTEGER PRIMARY KEY coluna.
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. Não utilize BIGINT, INT, ou uma chave primária composta com 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 é um identidade coluna (auto-incremento), distinta de GENERATED ALWAYS AS (expression) que é um calculada coluna. O analisador mantém-nas separadas automaticamente.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 tag — para que possa misturar dialetos num único esquema sem perder a indicação de incremento automático.Colunas Computadas (por dialeto)
Uma coluna calculada deriva o seu valor de uma expressão sobre outras colunas na mesma linha. Suportado nos quatro dialetos com as suas respetivas sintaxes.
PostgreSQL & 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 armazena o valor calculado e VIRTUAL calcula-o na leitura. O Erd Go mantém valores de pré-visualização na memória; o ERD preserva cada modo como metadados de coluna.MSSQL / SQL Server — coluna AS expressão [PERSISTED]
O MSSQL tem a sua própria sintaxe: column_name AS expression, opcionalmente seguido por PERSISTED (e opcionalmente NOT NULL). Ambos entre parênteses e simples formas de expressão são suportadas.
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 (sem parênteses envolventes) — incluindo chamadas de função como DATEADD(...), referências qualificadas pela tabela como c.GrowthDurationDays, e CASE expressões — terminando na próxima vírgula de coluna, PERSISTED, ou fim do corpo da tabela.COMPUTED como o tipo e a expressão preservada nos extras / tooltip da coluna.ALTER TABLE
Estilo de migração comum ALTER TABLE instruções são reexecutadas após a criação das tabelas, pelo que o esquema final reflete colunas adicionadas, restrições, renomeações, colunas eliminadas e alterações do tipo de coluna/anulabilidade. Sintaxe de dump do PostgreSQL usando ALTER TABLE ONLY preserva a identidade da tabela qualificada.
Adicionar e restringir
ADD COLUMN, ADD PRIMARY KEY, ADD UNIQUE, ADD CHECK e ADD FOREIGN KEY são refletidos no ERD.
Renomear e eliminar
Renomeações de tabelas, colunas, restrições e índices — incluindo MySQL RENAME TABLE, PostgreSQL ALTER INDEX e SQL Server sp_rename — permanecem vinculadas à encarnação correta do objeto antes de operações DROP posteriores.
Alterações de coluna
PostgreSQL ALTER COLUMN TYPE/SET DATA TYPE/SET ou DROP DEFAULT/nullability, MSSQL ALTER COLUMN e MySQL MODIFY/CHANGE COLUMN são reproduzidos.
Segurança de relacionamento
As chaves estrangeiras são validadas em relação ao estado final da tabela após a repetição da migração, incluindo alterações de PK/UQ/index e contagens exatas de colunas de origem/destino.
3.1. Adicionar Chave Estrangeira
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];Exemplo:
ALTER TABLE orders
ADD CONSTRAINT fk_orders_customer
FOREIGN KEY (customer_id)
REFERENCES customers(id)
ON DELETE CASCADE;3.2. Adicionar Chave Primária
ALTER TABLE table_name
ADD [CONSTRAINT name] PRIMARY KEY (cols...);Exemplo:
ALTER TABLE products
ADD CONSTRAINT pk_products
PRIMARY KEY (product_id);3.3. Adicionar Restrição de Unicidade
ALTER TABLE table_name
ADD [CONSTRAINT name] UNIQUE (cols...);Exemplo:
ALTER TABLE users
ADD CONSTRAINT uq_users_email
UNIQUE (email);3.4. Adicionar Restrição de Verificação
ALTER TABLE table_name
ADD [CONSTRAINT name] CHECK (expression);Exemplo:
ALTER TABLE employees
ADD CONSTRAINT chk_salary
CHECK (salary >= 0);3.5. Exemplo de Replay de Migração
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 torna-se contact_email, audit_state é removido, e o índice único dá contact_email um UQ emblema.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
O DDL de índice é analisado nos quatro dialetos. As chaves de coluna simples são apresentadas como pequenos emblemas de ERD: IDX para acelerações não únicas, UQ para índices únicos globais, e PUQ para índices únicos filtrados / parciais. As entradas de expressão são preservadas na saída do analisador e reportadas quando não podem ser mapeadas honestamente para um emblema de coluna.
Crachá IDX
Índice não único. Indicador sólido na coluna. Índices compostos atenuam o indicador (cinzento) em cada coluna de chave para que a diferença entre coluna única vs multi-coluna seja óbvia à primeira vista.
Badge UQ
De um CREATE UNIQUE INDEX global. Comporta-se como uma restrição UNIQUE para validação de FK e identificação de colunas.
Crachá PUQ
De CREATE UNIQUE INDEX ... WHERE. Mostra o predicado de unicidade parcial, mas não valida os alvos de FK como globalmente únicos.
Regra de supressão
As restrições mais fortes prevalecem: PK ⟶ UQ ⟶ PUQ ⟶ IDX. Uma chave mais forte nunca é despromovida por um índice posterior.
Multi-dialeto
PostgreSQL CONCURRENTLY / USING / INCLUDE / WHERE, MySQL FULLTEXT/SPATIAL & KEY/INDEX inline, MSSQL CLUSTERED/NONCLUSTERED com INCLUDE, índices padrão SQLite.
4.1. Sintaxe
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. Exemplos
Acelere uma procura de FK frequente (IDX de coluna única):
CREATE INDEX idx_orders_customer ON orders (customer_id);Índice composto (pílula IDX suave em cada coluna de chave):
CREATE INDEX idx_orders_customer_status
ON orders (customer_id, status);Promover uma coluna a UNIQUE sem alterar a sua definição:
CREATE UNIQUE INDEX uq_shipments_tracking
ON shipments (tracking_number);Índice único parcial / filtrado (PUQ, não é um alvo de FK global):
CREATE UNIQUE INDEX ux_users_active_email
ON users (email)
WHERE deleted_at IS NULL;Índice inline do 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)
);MSSQL / SQL Server filtrado + índice INCLUDE:
CREATE NONCLUSTERED INDEX idx_active_orders
ON orders (customer_id)
INCLUDE (total)
WHERE status = 'active';4.3. Comportamento e Semântica
- Índices funcionais / de expressão (p. ex.
CREATE INDEX … ON t (lower(email))) são preservados e produzem um aviso explícito, mas sem badge — não mapeiam de forma limpa para uma única coluna. - Colunas INCLUDE (colunas de cobertura) são analisadas mas nunca recebem o distintivo — apenas as colunas de chave ganham o selo.
- Colunas PK / UQ são garantias mais fortes do que IDX, pelo que qualquer
CREATE INDEXneles é ignorado silenciosamente — não verá pílulas redundantes. - Índices únicos parciais / filtrados renderizar como
PUQcom oWHEREpredicado nos detalhes da coluna. Não são aceites como destinos globalmente únicos para validação de chave estrangeira. - Os emblemas finais são invariantes à ordem: uma garantia de unicidade global suprime um
IDXemblema se o índice único ou não único aparece primeiro. Os metadados do índice composto são igualmente retidos, independentemente da ordem de declaração. - Índices em tabelas / colunas desconhecidas são omitidos silenciosamente — útil ao portar esquemas parciais sem quebrar o diagrama.
- Ciclo de vida do índice inclui de nível superior
CREATE/DROP INDEX, PostgreSQLDROP INDEX CONCURRENTLY, MySQLALTER TABLE … ADD/DROP/RENAME INDEX, PostgreSQLALTER INDEX … RENAME, e renomeações de índices SQL Server através desp_rename. Os metadados UQ/PUQ/IDX nomeados seguem o nome final sobrevivente.
Suporte Multi-Dialeto
O analisador no navegador lida com diferenças de sintaxe no SQLite, PostgreSQL, MySQL e MSSQL sem uma ligação à base de dados. A deteção automática utiliza sinais estruturais de sintaxe e permanece neutra para entradas de dialetos verdadeiramente mistos; os chamadores também podem fornecer um dialeto explícito. Os exemplos abaixo seguem a mesma ordem padrão: primeiro o SQLite, seguido do PostgreSQL, MySQL e MSSQL.
4.1. Funcionalidades do 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 tabelas, colunas sem tipo non-STRICT, afinidades de tipo (INTEGER, TEXT, REAL, NUMERIC, BLOB), datetime('now') / CURRENT_TIMESTAMP predefinições e padrão REFERENCES com ON DELETE / ON UPDATE ações.VARCHAR(255), BOOLEAN, ou TIMESTAMP) e podem omitir um tipo. As tabelas STRICT seguem o conjunto exato permitido pelo SQLite: INT, INTEGER, REAL, TEXT, BLOB, ou ANY; cada coluna STRICT deve declarar uma.Exemplo de reprodução de migração 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. Funcionalidades do 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, preservação de índices de expressão e a identidade exata sensível a maiúsculas e minúsculas do PostgreSQL para nomes entre aspas.4.3. Funcionalidades do 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 com sinal, variantes de inteiro/texto/blob/espacial, inline ENUM e SET, índices em linha, CHANGE COLUMN, MODIFY COLUMN, FIRST/AFTER colocação física, ON UPDATE CURRENT_TIMESTAMP, e opções de tabela comuns.4.4. Funcionalidades do 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), data/hora, binário, XML, tipos de identificador e espaciais, ROWGUIDCOL, índices agrupados, GO lotes, ALTER COLUMN, colunas calculadas, nomeadas DEFAULT ... FOR column restrições, colunas temporais geradas, e PERIOD FOR SYSTEM_TIME.col AS expression PERSISTED (sem parênteses envolventes) é totalmente suportado, incluindo chamadas de função (DATEADD, LEFT, …), referências de colunas qualificadas pela tabela (c.col), e CASE expressões.4.5. Estilos de Aspas para Identificadores
As três principais convenções de aspas são suportadas:
-- 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 e Dicas
Detalhes importantes do suporte de sintaxe: o que contribui para a estrutura do esquema, que DDL/DML pode ser reproduzido com linhas de amostra, o que as consultas SELECT podem ler e onde estão os limites.
✓ Suporte de sintaxe de esquema / ERD
- Multi-dialeto: As sintaxes SQLite, PostgreSQL, MySQL e MSSQL podem partilhar um script; a deteção automática permanece neutra quando sinais fortes estão genuinamente misturados
- Palavras-chave insensíveis a maiúsculas e minúsculas: CREATE, TABLE, ALTER, etc. podem ser escritos em qualquer capitalização
- Identificadores entre aspas: Aspas duplas (
"name"), crases (`name`), e parênteses retos ([name]) - Nomes de colunas com palavras reservadas: Simples
key,index,value,name,order, etc. são aceites quando seguidos por um tipo de dados - Nomes qualificados pelo esquema:
schema.tableeschema.type(p. ex.,public.users,dbo.Orders,app.status_enum) — os prefixos de esquema em tipos definidos pelo utilizador são preservados para pesquisa estrita e simplificados para exibição apenas quando inequívocos - Comentários: Linha única (
-- comment) e comentários de bloco (/* comment */) são ignorados automaticamente - BOM & CRLF: O byte-order-mark UTF-8 e as quebras de linha do Windows são processados de forma transparente
- Tipos personalizados:
CREATE TYPE … AS ENUMeCREATE TYPE … AS (composite), incluindo nomes qualificados pelo esquema - ENUM e SET em linha (MySQL):
ENUM('a','b')eSET('a','b','c')dentro dos tipos de coluna — registados automaticamente como tipos nomeados e com espaço de nomes por tabela/coluna quando nomes de coluna duplicados usam domínios diferentes - Restrições: Ao nível da coluna e ao nível da tabela
PRIMARY KEY,FOREIGN KEY,UNIQUE,CHECK(incluindo variantes compostas de várias colunas). Os alvos de FK são validados contra chaves primárias, restrições de unicidade ou índices únicos globais - Identidade / incremento automático:
SERIAL/BIGSERIAL(PG),GENERATED ALWAYS/BY DEFAULT AS IDENTITY(PG),AUTO_INCREMENT(MySQL),IDENTITY(1,1)e simplesIDENTITY(MSSQL) — todos se unificam no diagrama - Colunas computadas:
GENERATED ALWAYS AS (expr) STORED/VIRTUAL(PG/MySQL) e MSSQLcol AS (expr) [PERSISTED]+ simplescol AS expr [PERSISTED] - Arrays de PostgreSQL:
type[], com tamanhotype[5], aninhadotype[][][], e arrays de tipos definidos pelo utilizador (ex.,webhook_event[]) - Valores predefinidos: Literais, strings entre cifrões, chamadas de função (
now(),CURRENT_TIMESTAMP,GETDATE(),NEWID(),NEWSEQUENTIALID(),gen_random_uuid(),nextval()), eON UPDATE CURRENT_TIMESTAMP(MySQL) - Ações FK:
ON DELETE/ON UPDATEcomCASCADE,RESTRICT,SET NULL,SET DEFAULT,NO ACTION, maisMATCH,DEFERRABLE, eINITIALLYmetadados. As ações são preservadas como metadados da relação. - Repetição de migração:
ALTER TABLE ADD COLUMN, adicionar/remover/renomear chaves e restrições, renomeações de tabelas/colunas/índices,DROP COLUMN,ALTER COLUMN TYPE/SET DATA TYPE,SET/DROP DEFAULT,SET/DROP NOT NULL, MSSQLsp_rename, e MySQLMODIFY/CHANGE COLUMN - Índices: Nível superior
CREATE/DROP INDEX, PostgreSQLALTER INDEX … RENAME, MySQL add/drop/rename e inlineKEY/INDEX/UNIQUE INDEX/FULLTEXT/SPATIALdefinições. Índices baseados em colunas são renderizados comoIDX,UQ, ouPUQemblemas - IF NOT EXISTS, IF EXISTS: tratado de forma elegante em ambos
CREATEeDROP - Wrappers de transação apenas de esquema:
BEGIN,COMMIT,SET search_path,USE [db](MSSQL), eSET FOREIGN_KEY_CHECKS(MySQL) são ignorados graciosamente - Ignorado graciosamente:
CREATE VIEW,CREATE MATERIALIZED VIEW,CREATE FUNCTION/TRIGGER/SCHEMA/SEQUENCE, procedimentalEXECinstruções além desp_rename,DECLARE,PRINT,PARTITION BY,INHERITS(incluindo corpo vazio),WITH OIDS,STORAGE PLAIN,EXCLUDE USING gist, e corpos de instruções que não afetam a estrutura do ERD
✓ Sintaxe de pré-visualização DDL/DML
- Execução de cima para baixo: O script é reproduzido pela ordem das instruções, pelo que os dados de exemplo devem vir após o esquema a que fazem referência
- Instruções suportadas:
CREATE TYPE,CREATE TABLE,CREATE VIEW,CREATE INDEX,ALTER TABLEalterações de coluna/restrição,DROP INDEX,TRUNCATE TABLE,INSERT,UPDATE,DELETE,DROP TABLE,DROP VIEW, eDROP TYPE - Filtros WHERE:
=,!=,<>,>,<,>=,<=,LIKE,IN,NOT IN,NOT LIKE,BETWEEN,NOT BETWEEN,IS NULL, eIS NOT NULL - Materialização de linhas: As tabelas expõem contagens de linhas, metadados de estrutura e dados de linhas atuais após a execução de instruções DML
- Tipos nomeados: Tipos ENUM e compostos criados com
CREATE TYPEsão apresentadas separadamente das tabelas - Registo de execução: Os estados de sucesso, aviso e erro são capturados para colunas desconhecidas, tabelas em falta, chaves duplicadas, violações de NULL e atualizações/eliminações abrangentes; as vinculações de mutação inválidas falham antes de as linhas serem alteradas
- Avaliação predefinida: Padrões literais e funções como
now(),CURRENT_TIMESTAMP,CURRENT_DATE,GETDATE(), eNEWID()
✓ Sintaxe de consulta SELECT
- SELECT de apenas leitura:
SELECTinstruções podem ler as tabelas em memória produzidas a partir do ficheiro SQL principal - Metadados do resultado: Colunas, contagens de linhas, tempo decorrido, formatação de NULL/booleano/número e erros de consulta são preservados com o resultado SELECT.
- Consultas relacionais: Junções, filtros WHERE, GROUP BY, HAVING, ORDER BY, LIMIT/OFFSET, TOP, FETCH FIRST, CTEs, tabelas derivadas, subconsultas e operadores de conjunto
- Auxiliares analíticos: Agregados, funções escalares comuns, auxiliares JSON, funções de data/string e funções de janela como
ROW_NUMBER,RANK,NTILE,FIRST_VALUE,LAST_VALUE,LAG, eLEAD; os frames predefinidos ordenados incluem o grupo de pares atual
✗ Ainda não suportado / Ignorado
- ALTER TYPE: Não é possível modificar tipos ENUM ou compostos existentes
- Cláusula LIKE:
CREATE TABLE foo (LIKE bar INCLUDING …)é ignorado graciosamente — as colunas copiadas não são materializadas - Herança de colunas INHERITS: O
INHERITS (parent)a própria cláusula é analisada sem erros, mas as colunas herdadas não são puxadas para a tabela filha para fins de ERD - Execução de índice: O DDL de índice pode criar emblemas de esquema, mas a execução da pré-visualização não modela motores de armazenamento, planeadores de consulta ou o desempenho do índice
- Limites de SELECT: A sintaxe de consulta de apenas leitura não suporta CTEs recursivos, execução de base de dados externa, procedimentos armazenados ou instruções de mutação
- Outros objetos: Triggers, procedimentos armazenados, funções e sequências
- Execução externa: A pré-visualização DDL/DML não se liga a uma base de dados real nem persiste linhas fora do ficheiro SQL atual
- Termine cada instrução com um ponto e vírgula (
;) - Definir
CREATE TYPEantes das tabelas que as referenciam - Definir
CREATE TABLEantes de relacionadosINSERT,UPDATE, ouDELETEinstruções - Utilizar
ALTER TABLEpara chaves estrangeiras quando as tabelas se referenciam mutuamente (dependências circulares) - Utilize DDL primeiro para a estrutura e, depois, DML para validar linhas de exemplo e o comportamento das restrições.
- Mantenha os dados de demonstração no próprio ficheiro SQL porque as linhas de pré-visualização são derivadas do script