Ir para a documentação

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.

SQL DDL → Diagrama ERAbrir SQL para ERD
INTRODUÇÃO

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.

PostgreSQL / Início rápido de PostgreSQL
-- Define custom types
CREATE TYPE status_enum AS ENUM (
  'active', 'inactive', 'suspended'
);

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

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

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

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

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

UPDATE employees
  SET status = 'active'
  WHERE id = 2;
Sintaxe do esquema: Os relacionamentos podem ser declarados em linha REFERENCES ou ALTER TABLE ADD FOREIGN KEY. Ambas as formas contribuem com os mesmos metadados de relacionamento.
Sintaxe DML: Colocar 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.
Sintaxe SELECT: Mantenha as consultas de relatório apenas de leitura separadas dos scripts de mutação. Elas devem apenas referenciar tabelas e linhas produzidas pelo script de esquema/DML.
SQL / Exemplo
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

  1. 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.
  2. 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.
  3. 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.
  4. 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

Resolver problemas no espaço de trabalho de SQL
SintomaO que verificar
Falta uma tabelaVerifique 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çãoVerifique 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 linhasColoque 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 SQLExecute a Consulta novamente após alterar o esquema ou os Dados; utilize as tabelas em memória atuais.
Adicionar Tabela sugere um dialeto diferenteA 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 editadoVerifique 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.

Dica de prompt de IA: Peça um script SQL completo, terminado em ponto e vírgula. Diga à IA para evitar objetos não suportados, tais como procedimentos armazenados, triggers, CTEs recursivos em consultas SELECT apenas de leitura e 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

SQL / Exemplo
-- 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;
Suporte para WHERE: =, !=, <>, >, <, >=, <=, 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

Gerar Dados de amostra localmente: Na Vista de Dados, escolha Gerar dados de exemplo, escolha a deteção automática ou um dialeto SQL, um dicionário de nomes de 26 países ou inglês geral, uma percentagem opcional de valores nulos e contagens de linhas de tabela, e expanda uma tabela para personalizar os seus geradores, intervalos ou valores permitidos. Pré-visualize primeiro, depois copie/descarregue o SQL ou insira um novo Dados de exemplo separador. Não é necessária nenhuma chave de IA nem pedido de dados externos. Se substituiu o esquema integrado, desative primeiro o antigo separador de Dados de amostra do comércio. A geração preserva as linhas existentes, copia tuplos de chave estrangeira completos com cobertura de pais equilibrada e valida as restrições e tipos escalares suportados. As restrições CHECK compostas inteiramente por IS NULL / IS NOT NULL, AND, OR e parênteses têm prioridade sobre a percentagem opcional de NULL, incluindo referências exclusivas de publicação/vídeo. O catálogo conta com mais de 4.200 entradas integradas, incluindo mais de 2.600 nomes com grafia nativa e identificadores de e-mail ASCII, além de empresas, produtos, cargos, ruas, descrições em linguagem natural e exemplos de localizações em mais de 40 países, a par de moedas, endereços IP, SKUs, estados, cores, datas e JSON. Os lotes suportam até 5.000 linhas por tabela, 10.000 linhas e 150.000 células no total, e 5 MB de SQL. Ciclos de relação vazios obrigatórios, domínios únicos esgotados, colisão de nomes de tabelas entre esquemas e tipos complexos obrigatórios não suportados necessitam de ajustes antes que a geração possa terminar. Valores complexos anuláveis e referências de quebra de ciclo podem tornar-se NULL com uma nota de pré-visualização. Os seeds repetem valores de dicionário gerados; os valores predefinidos da base de dados continuam a seguir o seu comportamento normal. Conclua primeiro a revisão da IA e volte a abrir o gerador se o espaço de trabalho SQL se alterar.

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.

Não peça à IA para confiar em: independente 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.

SQL / Pré-visualizar transação
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;
Neste exemplo, a Visualização de Dados retém os itens 1 e 2. O item 3 é removido por ROLLBACK TO antes do COMMIT. A Visualização de Consulta lê essas linhas de pré-visualização finais.

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

SQL / Exemplo
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.

Apenas leitura por design: Manter 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.

SQL / Exemplo
// 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.

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

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

-- error (unknown table)
INSERT INTO ghost VALUES (1);
-- → error: INSERT INTO "ghost": table does not exist
Sempre acionável. Cada erro e aviso cita o nome da tabela/coluna em causa, para que possa identificar o problema sem reler o script.

Diagnósticos Comuns

SQL / Exemplo
error    : INSERT INTO "x": unknown column(s): foo
warning  : INSERT INTO "x" row 3: expected 4 values but got 3
warning  : UPDATE "x": setting NOT NULL column "name" to NULL
warning  : DELETE FROM "x": no WHERE clause — all 1200 row(s) will be removed
error    : DROP: table "ghost" does not exist
warning  : ALTER "x": column "old_col" does not exist
warning  : Relation dropped: foreign key 'posts.user_id' references column
           'users.no_such' which does not exist on table 'users'.
warning  : Relation dropped: foreign key 'events.email' references 'users.email',
           but the target is only partial-unique, not globally unique.
Resistente a falhas. A análise de esquema, a execução de DDL/DML e a execução de SELECT recuperam SQL malformado em erros visíveis para que possa continuar a refinar o mesmo script.

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.

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

Exemplo:

SQL / 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)
);
Tipos de dados suportados: INTEGER, BIGINT, SMALLINT, TEXT, VARCHAR(n), CHAR(n), DECIMAL(p,s), NUMERIC, BOOLEAN, DATE, TIME, TIMESTAMP, FLOAT, REAL, DOUBLE PRECISION, UUID, JSON, JSONB, BYTEA, MONEY e mais.

1.2. Tipo Enum

Crie tipos enumerados com valores predefinidos para uma melhor integridade de dados e legibilidade.

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

Exemplo:

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

CREATE TYPE priority_level AS ENUM (
  'low', 'medium', 'high', 'critical'
);
Importante: Os valores de Enum devem estar entre aspas simples ('valor'), não aspas duplas.

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.

SQL / Exemplo
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
);
Regra de resolução: 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:

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

-- Also supports:
CREATE TABLE IF NOT EXISTS table_name ( ... );
CREATE TABLE schema_name.table_name ( ... );
Nota: Os nomes de tabelas e colunas podem usar aspas duplas (""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:

SQL / Exemplo
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

Suporte a valores DEFAULT:
  • Literais: números (123), strings ('text')
  • Funções de PostgreSQL: now(), CURRENT_TIMESTAMP, CURRENT_DATE, nextval('seq'::regclass)
  • Funções MSSQL: GETDATE(), NEWID()
REFERENCES (inline): Reconhece 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.

SQL / Exemplo
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.

SQL / Exemplo
CREATE TABLE tasks (
  id INTEGER PRIMARY KEY,
  status ENUM('todo', 'doing', 'done'),
  priority ENUM('low', 'medium', 'high')
);
Como funciona: Os ENUMs em linha são registados automaticamente como tipos nomeados. O primeiro nome simples utiliza 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.
Dica: Se precisar de enums partilhados ou nomes personalizados, defina-os explicitamente com 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:

SQL / Exemplo
-- 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:

SQL / 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)
);
Restrições suportadas: PRIMARY KEY, FOREIGN KEY, UNIQUE e CHECK são todos suportados ao nível da tabela. O nome da restrição (CONSTRAINT name) é opcional.
Correção de chave estrangeira: Se 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:

SQL / Exemplo
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
);
Regra de desambiguação: 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

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

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

-- Invalid for SQLite AUTOINCREMENT:
-- 1. BIGINT PRIMARY KEY AUTOINCREMENT
-- 2. INT PRIMARY KEY AUTOINCREMENT
-- 3. AUTOINCREMENT on a composite primary key
Regra SQLite: utilizar exatamente INTEGER PRIMARY KEY AUTOINCREMENT. Não utilize BIGINT, INT, ou uma chave primária composta com AUTOINCREMENT.

PostgreSQL

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

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

CREATE TABLE invoices (
  id BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY
);
Importante: GENERATED ALWAYS AS IDENTITY é um identidade coluna (auto-incremento), distinta de GENERATED ALWAYS AS (expression) que é um calculada coluna. O analisador mantém-nas separadas automaticamente.

MySQL

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

MSSQL / SQL Server

SQL / Exemplo
-- 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
);
Saída ERD: Cada forma acima aparece de forma idêntica no diagrama — ícone de chave PK mais 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

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

-- Complex expressions, including CASE
CREATE TABLE orders (
  id BIGSERIAL PRIMARY KEY,
  qty INT,
  flag INT GENERATED ALWAYS AS (CASE WHEN qty > 100 THEN 1 ELSE 0 END) STORED
);
Modos de base de dados: Numa base de dados nativa, 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.

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

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

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

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

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

  -- CASE expression in a bare AS
  [SignedAmount] AS CASE WHEN [TermMonths] > 12 THEN 1 ELSE 0 END
);
AS simples: O analisador aceita 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.
Saída ERD: Todas as colunas calculadas são apresentadas 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

SQL / Exemplo
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:

SQL / 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

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

Exemplo:

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

3.3. Adicionar Restrição de Unicidade

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

Exemplo:

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

3.4. Adicionar Restrição de Verificação

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

Exemplo:

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

3.5. Exemplo de Replay de Migração

SQL / Exemplo
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);
O que o ERD faz: A FK de contacto resolve para a chave primária composta em 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

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

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

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

3.7. MSSQL / SQL Server ALTER COLUMN

SQL / Exemplo
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';
Limite da sintaxe: A reprodução da migração SQL para ERD é intencionalmente mais rica do que a execução da Visualização de Dados. A análise do diagrama final permanece apenas no navegador e não requer uma ligação à base de dados; instruções apenas de execução não suportadas não enfraquecem o modelo de ciclo de vida do ERD.

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

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

4.2. Exemplos

Acelere uma procura de FK frequente (IDX de coluna única):

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

Índice composto (pílula IDX suave em cada coluna de chave):

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

Promover uma coluna a UNIQUE sem alterar a sua definição:

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

Índice único parcial / filtrado (PUQ, não é um alvo de FK global):

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

Índice inline do MySQL dentro de CREATE TABLE:

SQL / Exemplo
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:

SQL / Exemplo
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 INDEX neles é ignorado silenciosamente — não verá pílulas redundantes.
  • Índices únicos parciais / filtrados renderizar como PUQ com o WHERE predicado 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 IDX emblema 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, PostgreSQL DROP INDEX CONCURRENTLY, MySQL ALTER TABLE … ADD/DROP/RENAME INDEX, PostgreSQL ALTER INDEX … RENAME, e renomeações de índices SQL Server através de sp_rename. Os metadados UQ/PUQ/IDX nomeados seguem o nome final sobrevivente.
Dica: As pílulas IDX compostas são renderizadas num cinzento suave para espelhar a linguagem visual existente de PK composta / UQ composta. Uma pílula IDX sólida significa sempre "índice de coluna única" — fácil de analisar em diagramas densos.

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

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

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

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

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

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

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

-- IF NOT EXISTS works as expected
CREATE TABLE IF NOT EXISTS sessions (
  token   TEXT PRIMARY KEY,
  user_id INTEGER REFERENCES users(id),
  expires TEXT
);
Específico do SQLite: 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.
Correção de tipo: As tabelas SQLite ordinárias aceitam nomes de tipos declarados arbitrários (tais como 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:

SQL / Exemplo
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

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

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

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

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

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

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

-- Empty body INHERITS (PG-only)
CREATE TABLE child () INHERITS (parent);
PostgreSQL: Suporta tipos SERIAL, colunas de identidade, JSONB, BYTEA, INET, variantes de timestamp, arrays, tipos compostos e ENUM, 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

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

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

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

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

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

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

  -- Inline indexes become ERD badges when they map to columns
  INDEX idx_name (`name`),
  FULLTEXT KEY ft_bio (`bio`),
  UNIQUE INDEX ux_name (`name`),
  UNIQUE KEY uk_email (`email`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
Específico do MySQL: 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

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

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

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

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

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

-- Multi-statement batches separated by GO are honored
CREATE TABLE [dbo].[Orders] (
  [OrderID] INT IDENTITY NOT NULL PRIMARY KEY  -- bare IDENTITY → (1,1)
);
GO
Específico do MSSQL: IDENTITY(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.
Colunas calculadas com AS simples: 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:

SQL / Exemplo
-- 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.table e schema.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 ENUM e CREATE TYPE … AS (composite), incluindo nomes qualificados pelo esquema
  • ENUM e SET em linha (MySQL): ENUM('a','b') e SET('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 simples IDENTITY (MSSQL) — todos se unificam no diagrama
  • Colunas computadas: GENERATED ALWAYS AS (expr) STORED/VIRTUAL (PG/MySQL) e MSSQL col AS (expr) [PERSISTED] + simples col AS expr [PERSISTED]
  • Arrays de PostgreSQL: type[], com tamanho type[5], aninhado type[][][], 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()), e ON UPDATE CURRENT_TIMESTAMP (MySQL)
  • Ações FK: ON DELETE / ON UPDATE com CASCADE, RESTRICT, SET NULL, SET DEFAULT, NO ACTION, mais MATCH, DEFERRABLE, e INITIALLY metadados. 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, MSSQL sp_rename, e MySQL MODIFY/CHANGE COLUMN
  • Índices: Nível superior CREATE/DROP INDEX, PostgreSQL ALTER INDEX … RENAME, MySQL add/drop/rename e inline KEY/INDEX/UNIQUE INDEX/FULLTEXT/SPATIAL definições. Índices baseados em colunas são renderizados como IDX, UQ, ou PUQ emblemas
  • IF NOT EXISTS, IF EXISTS: tratado de forma elegante em ambos CREATE e DROP
  • Wrappers de transação apenas de esquema: BEGIN, COMMIT, SET search_path, USE [db] (MSSQL), e SET FOREIGN_KEY_CHECKS (MySQL) são ignorados graciosamente
  • Ignorado graciosamente: CREATE VIEW, CREATE MATERIALIZED VIEW, CREATE FUNCTION/TRIGGER/SCHEMA/SEQUENCE, procedimental EXEC instruções além de sp_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 TABLE alterações de coluna/restrição, DROP INDEX, TRUNCATE TABLE, INSERT, UPDATE, DELETE, DROP TABLE, DROP VIEW, e DROP TYPE
  • Filtros WHERE: =, !=, <>, >, <, >=, <=, LIKE, IN, NOT IN, NOT LIKE, BETWEEN, NOT BETWEEN, IS NULL, e IS 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 TYPE sã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(), e NEWID()

✓ Sintaxe de consulta SELECT

  • SELECT de apenas leitura: SELECT instruçõ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, e LEAD; 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
Comportamento da sintaxe: O DML não contribui para a geração do diagrama de esquema. As instruções de ciclo de vida de tabela, tipo e índice nomeado são reproduzidas na ordem de origem, incluindo renomeação, eliminação e recriação posterior sem fuga de metadados entre encarnações de objetos. As instruções DDL/DML suportadas são executadas em memória de cima para baixo, e as consultas SELECT de apenas leitura leem desse resultado em memória sem o alterar.
Boas Práticas:
  • Termine cada instrução com um ponto e vírgula (;)
  • Definir CREATE TYPE antes das tabelas que as referenciam
  • Definir CREATE TABLE antes de relacionados INSERT, UPDATE, ou DELETE instruções
  • Utilizar ALTER TABLE para 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
Recuperação de Erros: As instruções não suportadas são ignoradas e os avisos/erros de sintaxe são apresentados com contexto suficiente para continuar a refinar o mesmo ficheiro em vez de recomeçar do zero.

Ao seguir estes padrões de sintaxe, o Erd Go pode gerar o seu esquema ERD, pré-visualizar dados em memória e executar consultas de leitura a partir do mesmo ficheiro SQL.

ErdGo.com - Transforme SQL em diagramas e pré-visualize Dados mais rapidamente