Przejdź do dokumentacji

OD SCHEMATU DO DIAGRAMU

SQL do ERD — poradnik

Przekształć schemat bazy danych w diagram. Poznaj obsługiwany SQL, wyświetl dane i odpytuj model.

SQL DDL → Diagram EROtwórz SQL do ERD
PIERWSZE KROKI

Kontrakt składni SQL gotowy na AI

Użyj tej strony jako zwięzłego kontraktu podczas proszenia AI o napisanie lub edycję SQL dla Erd Go. Preferuj poniższe wzorce składni, zachowaj kompletność instrukcji zakończonych średnikami i unikaj nieobsługiwanych obiektów bazy danych, chyba że potrzebujesz tylko surowego SQL poza Erd Go. Składnia SQLite, PostgreSQL, MySQL i MSSQL jest obsługiwana w ramach wspólnego podzbioru poniżej. Konwersja SQL do ERD odbywa się całkowicie w przeglądarce, a jej silniki parsera i podglądu są zabezpieczone tysiącami testów jednostkowych i integracyjnych obejmujących rzeczywiste schematy produkcyjne (SaaS, bankowość, media społecznościowe, analityka, EHR).

SQLite

Reguły rowid dla INTEGER PRIMARY KEY, kolumny beztypowe, AUTOINCREMENT, WITHOUT ROWID, walidowane tabele STRICT, akcje FK i powtarzanie migracji

PostgreSQL

Typy ENUM i złożone, tablice, JSONB, SERIAL, kolumny tożsamości, NULLS NOT DISTINCT, indeksy wyrażeń, tożsamość schematu oraz wrażliwość na wielkość liter w nazwach w cudzysłowie

MySQL

AUTO_INCREMENT, wbudowane ENUM i SET, backticki, COMMENT, UNSIGNED/SIGNED, wbudowane indeksy, CHANGE/MODIFY COLUMN oraz pozycjonowanie FIRST/AFTER

MSSQL

IDENTITY, NVARCHAR(MAX), nazwy w nawiasach, indeksy klastrowane, partie GO, ALTER COLUMN, kolumny obliczeniowe, nazwane wartości domyślne i okresy czasowe

DDL

Instrukcje CREATE TYPE, CREATE TABLE, powtórzenie migracji ALTER TABLE, CREATE INDEX oraz bezpieczne instrukcje DROP dla kształtu schematu

DML / SELECT

INSERT, UPDATE, DELETE dla podglądu danych, plus składnia SELECT tylko do odczytu dla złączeń, CTE, agregatów, okien i raportów

Szybki start

Użyj tego jako wzorcowej odpowiedzi podczas proszenia AI o SQL zgodny z Erd Go: najpierw typy niestandardowe, potem tabele, następnie więzy relacji po tabelach, gdy są przydatne, a na końcu przykładowy DML. Oddziel zapytania SELECT tylko do odczytu.

PostgreSQL / Szybki start z 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;
Składnia schematu: Relacje mogą być deklarowane albo wewnątrz wiersza REFERENCES lub ALTER TABLE ADD FOREIGN KEY. Obie formy wnoszą te same metadane relacji.
Składnia DML: Umieść INSERT, UPDATE, oraz DELETE po DDL schematu. Skrypt jest oceniany od góry do dołu, więc przykładowe wiersze powinny odnosić się do tabel i typów, które już istnieją.
Składnia SELECT: Przechowuj Zapytania raportowe tylko do odczytu oddzielnie od skryptów mutacji. Powinny one odwoływać się wyłącznie do tabel i wierszy utworzonych przez skrypt schematu/DML.
SQL / Przykład
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;

Karty SQL i import plików

Rozpocznij nowy plik SQL od przykładu, pustej karty Schemat lub Importuj pliki SQL. Przykład rozdziela schemat i dane na karty. Karta Dodaj SQL tworzy kolejną kartę edytora; kliknij dwukrotnie jej tytuł, aby zmienić jej nazwę.

Aktywne karty są kompilowane razem w widocznej kolejności dla ERD, Widoku Danych, Widoku Zapytania i żądań AI. Nieaktywna karta pozostaje zapisaną wersją roboczą i jest wykluczona z tych procesów. Umieść typy i tabele przed instrukcjami, które od nich zależą.

Import plików SQL akceptuje wiele tekstowych plików SQL i wspólnie przegląda problemy z parsowaniem przed importem. Pomaga to rozwiązać odniesienia między plikami. Użyj kolejności kart, aby zachować celowość zależności i kroków migracji.

Użyj klawiszy strzałek oraz Home/End na pasku kart, aby przełączać karty, Alt+Lewo/Prawo, aby zmienić ich kolejność, oraz Shift+Alt+F, aby sformatować SQL w edytorze.

Otwórz Eksplorator SQL obok kart, aby uzyskać drzewo folderów o zmiennym rozmiarze. Twórz zagnieżdżone foldery i pliki SQL, wybierz plik, aby go otworzyć, i organizuj za pomocą przeciągnij i upuść. Menu podręczne akcji wiersza obsługuje Zmień nazwę i Usuń plik; kliknij poza nim, aby je zamknąć. Usunięcie ostatniego pliku pozostawia otwarty pusty plik SQL. Foldery nie zmieniają kolejności wykonywania. Usunięcie folderu zachowuje jego pliki i foldery podrzędne w folderze nadrzędnym. Zapisz zachowuje drzewo folderów i preferencje panelu.

Edytuj i sprawdź diagram

SQL jest źródłem znaczenia schematu. Użyj Dodaj tabelę, aby skonstruować tabelę, lub wybierz akcje tabeli i kolumny na kanwie, aby edytować kolumny i połączenia. Edycje schematu na kanwie aktualizują powiązane karty SQL, jak również diagram.

Usunięcie kolumny powoduje wyświetlenie podglądu powiązanych połączeń, kluczy, indeksów i zależnego SQL. Przejrzyj usunięcie lub kaskadę przed potwierdzeniem. Złożone migracje lub nieobsługiwane instrukcje zależne mogą wymagać bezpośredniej edycji SQL.

Używaj wskaźnika kondycji ERD, aby sprawdzać ustalenia strukturalne i korzystać z sugestii relacji. Sugerowane relacje wymagają przeglądu; nie zastępują one zadeklarowanych kluczy obcych ani nie ustanawiają automatycznie reguł biznesowych.

Rozmieść tabele za pomocą trybu układu, powiększenia lub dopasowania do ekranu, znajdź tabele za pomocą nawigatora tabel i użyj kolorów tabel lub minimapy, aby poruszać się po dużym diagramie. Najedź kursorem lub ustaw fokus na kontrolce paska narzędzi, aby zobaczyć jej tekst pomocy.

Wybierz tabelę i otwórz Paletę kolorów dla gotowych ustawień jednolitych lub gradientowych. Wprowadź wartość hex lub wybierz Niestandardowy obok, aby użyć natywnego wyboru koloru. Obie kontrolki pozostają zsynchronizowane; Zapisz zachowuje kolor tabeli.

Gdy narzędzia tabel są ustawione na „tylko po najechaniu”, przycisk Dodaj kolumnę pojawia się po najechaniu kursorem na ostatni widoczny wiersz lub ustawieniu fokusu na przycisku za pomocą klawiatury. Narzędzia zawsze widoczne utrzymują go wyświetlonym.

Wybierz Grupy tabel na pasku narzędzi obszaru roboczego SQL, a następnie Nowa grupa. Nadaj grupie nazwę i kolor, wybierz jej tabele i wybierz Utwórz grupę. Wybrana tabela jest początkowo zaznaczona. Tabela należy do jednej grupy; formularz pokazuje, kiedy Twój wybór przeniesie tabelę z innej grupy. Obsługiwanych jest do 50 grup, o nazwach do 160 znaków.

Kliknij nagłówek grupy, aby edytować jej nazwę, kolor lub członków. Przeciągnij nagłówek, aby przenieść jej tabele razem; puść, aby zastosować przesunięcie. Klawisz Escape, anulowanie wskaźnika lub utrata fokusu okna anuluje podgląd. Rozgrupowanie tabel usuwa ramkę, zachowując tabele, ich pozycje, SQL i relacje.

Ramki grup podążają za aktywnymi kartami tabel i pojawiają się w Dopasuj do ekranu, minimapie oraz eksportach obrazów bieżącego widoku lub całego diagramu. Grupy są opcjonalnym stanem wizualnym zapisywanym wraz z dokumentem SQL. Starsze pliki zachowują swój istniejący układ, a tymczasowo brakujące nazwy tabel pozostają w swojej grupie, dopóki nie powrócą do przetworzonego SQL. Grupy tabel należą do SQL do ERD; pakiety Diagram klas używają oddzielnego modelu.

Przegląd AI wewnątrz edytora SQL

  1. Wprowadź konkretną zmianę w Ask AI, aby edytować SQL i wybierz dostępny model. Opcja Set Gemini API key jest dostępna, gdy chcesz użyć własnego klucza Gemini.
  2. Przejrzyj proponowane zmiany i tymczasowy podgląd diagramu. Żądanie używa migawki aktywnej karty przechwyconej w momencie wysłania; odpowiedź nie jest zapisywana automatycznie.
  3. Zaakceptuj lub odrzuć poszczególne zmiany lub użyj akcji dla pozostałych zmian. Nawiguj po zmianach kodu za pomocą F7 i Shift+F7. Chronione nieaktywne karty pozostają wersjami roboczymi.
  4. Sprawdź zaakceptowany SQL, a następnie Zapisz dokument. Kopiowanie Promptu AI w tym przewodniku pozwala również na korzystanie z dokumentacji z asystentem poza aplikacją.

Dane, zapytania, eksporty i zapisane pliki

Używaj przycisków ERD, Dane i Zapytanie, aby przełączać obszary robocze. Widok danych materializuje obsługiwane DDL i DML w przeglądarce oraz udostępnia tabele, wiersze, typy i dziennik wykonywania. Zmieniaj rozmiar kolumn siatki, przeciągając ich krawędzie lub klikając dwukrotnie, aby dopasować. Kliknij dwukrotnie komórkę Dane lub naciśnij Enter, aby edytować; pola logiczne i wyliczeniowe oferują prawidłowe wartości. Dodawanie wiersza odbywa się zgodnie z domyślnymi ustawieniami schematu. Importuj pliki CSV, TSV, TXT lub XLSX z podglądem mapowania kolumn. NULL i pusty tekst pozostają rozróżnialne. Zatwierdzone edycje stają się kodem SQL w zakładce edycji danych i można je cofnąć. Pobieraj wiersze tabeli lub wyniki Zapytania jako CSV.

Zapisz zapamiętuje wybrany obszar roboczy ERD, Dane lub Zapytanie; ponowne otwarcie przywraca go, w tym Dane/Zapytanie na telefonach. Starsze pliki uruchamiają się w ERD. Natywne edytory daty/czasu zachowują obsługiwane wartości, podczas gdy znaczniki czasu z ułamkami lub przesunięciami strefy czasowej pozostają edytowalne jako tekst. Tożsamości generowane przez bazę danych pozostają tylko do odczytu.

Widok Zapytanie uruchamia zapytania SELECT tylko do odczytu na bieżących tabelach w pamięci. Obsługuje składnię udokumentowaną poniżej; nie łączy się z zewnętrzną bazą danych. Tekst zapytania jest zapisywany wraz z kontekstem dokumentu SQL.

Zapisz zapamiętuje również wybraną tabelę Dane. Ponowne otwarcie przywraca ją, z pierwszą tabelą jako rezerwową, jeśli jest niedostępna. Pola schematu dopasowują nazwy, typy i reguły; najedź na plakietkę reguły, aby zobaczyć jej wyjaśnienie. Przejdź do SQL obok nagłówka tabeli otwiera jej definiującą kartę SQL i pokazuje instrukcję CREATE TABLE, otwierając ponownie panel SQL, gdy jest ukryty, zachowując wybór Dane i wersje robocze. Wyniki Zapytanie łączą licznik, czas, Dopasuj, Kopiuj i CSV w jednym nagłówku.

Przeciągnij wąski separator między edytorem zapytań a wynikami lub między schematem danych a wierszami, aby zmienić rozmiar paneli. Klawisze strzałek zmieniają rozmiar aktywnego separatora, Escape anuluje przeciąganie, a dwukrotne kliknięcie go resetuje. Te rozmiary paneli pozostają tymczasowymi preferencjami obszaru roboczego.

Generowanie przykładowych danych wykorzystuje typy kolumn, nazwy, relacje i ograniczenia. Język próbek kontroluje nazwy oraz naturalne frazy produktów/opisów w 17 językach. Przejrzyj sugerowane generatory i zakresy, podejrzyj wynik, a następnie jawnie wstaw oddzielną kartę Dane przykładowe. Wartości logiczne są wyświetlane jako true/false; identyfikatory pozostają numeryczne. Generowanie nigdy nie zastępuje istniejących wierszy.

Wybierz Eksportuj ERD, aby wybrać PNG, SVG oparte na obrazie lub PDF w rozmiarach HD, 2K lub 4K. Wyeksportowane obrazy nie zastępują edytowalnego zapisanego dokumentu.

Zaloguj się i użyj Zapisz SQL i ERD, aby zapisać SQL i kontekst diagramu, w tym karty, zastosowane edycje siatki, tekst zapytania i układ. Zapisz najpierw sprawdza aktywną komórkę lub szkic nowego wiersza; nieprawidłowe dane pozostają widoczne do poprawy. Podglądy importu wymagają jawnej akcji Importuj. Otwieraj zapisane pliki z listy plików i używaj Udostępnij na własnym zapisanym dokumencie, aby skonfigurować dostęp publiczny i rozpowszechnić link tylko do odczytu.

Dokumenty SQL, Prisma i Builder otwierają się we własnych narzędziach. Prisma i Builder mają oddzielne listy plików i zapisywanie wyłącznie w chmurze. Monity o niezapisanych zmianach chronią edytowane dokumenty podczas opuszczania obszaru roboczego; zapisz zmiany przed udostępnieniem lub przełączeniem się.

Rozwiązywanie problemów z obszarem roboczym SQL

Rozwiązywanie problemów z obszarem roboczym SQL
SymptomCo sprawdzić
Brakuje tabeliSprawdź diagnostykę parsowania, aktywne karty i kolejność instrukcji. Późniejsze DROP lub zmiana nazwy może zmienić ostateczny diagram.
Brakuje relacjiSprawdź, czy istnieją zarówno tabele, jak i kolumny, czy liczba kolumn klucza obcego się zgadza oraz czy przywoływany klucz jest unikalny w skali globalnej. Użyj kwalifikacji schematu dla niejednoznacznych nazw.
Widok danych nie pokazuje żadnych wierszyUmieść INSERT po odpowiadającym mu CREATE TABLE w aktywnej karcie. Sprawdź dziennik wykonywania pod kątem odrzuconych wierszy lub wycofania transakcji.
Wyniki zapytania nie pasują już do SQLUruchom zapytanie ponownie po zmianie schematu lub danych; użyj bieżących tabel w pamięci.
Dodaj tabelę sugeruje inny dialektWykryta składnia aktywnego obszaru roboczego ma priorytet nad ręcznie wybraną opcją rezerwową. Przejrzyj wskaźnik języka SQL i domyślne ustawienia specyficzne dla tabeli.
Zapisany plik nie może być edytowanySprawdź logowanie i własność. Publiczny link przyznaje dostęp tylko do odczytu; użyj opcji Ponów próbę lub Otwórz pliki w przypadku naprawialnych błędów ładowania.

Przepływ pracy składni AI

Korzystając z asystenta AI, poproś go o wygenerowanie SQL w tej kolejności. Dzięki temu wynik jest łatwy do przeanalizowania, łatwy do narysowania na diagramie i łatwy do podglądu za pomocą przykładowych wierszy lub zapytań tylko do odczytu.

1. Najpierw zdefiniuj domeny

Umieść definicje CREATE TYPE enum/composite przed tabelami, które się do nich odwołują. Preferuj jawne nazwy nad doraźnymi typami wbudowanymi (inline), gdy domena jest współdzielona.

2. Utwórz tabele bazowe

Użyj CREATE TABLE dla kolumn, kluczy głównych, unikalności, wartości domyślnych, kontroli (checks), kolumn generowanych i wbudowanych kluczy obcych.

3. Ponowne uruchomienie migracji

Użyj ALTER TABLE dla dodanych ograniczeń, zmian nazw, usuniętych kolumn, zmian typu/nullability kolumn oraz cyklicznych kluczy obcych.

4. Dodaj dane i zapytania na końcu

Umieść INSERT/UPDATE/DELETE po wszystkich instrukcjach DDL. Oddziel zapytania SELECT od mutacji schematu, gdy chcesz uzyskać zestawy wyników.

Wskazówka dotycząca promptu AI: Poproś o jeden kompletny skrypt SQL zakończony średnikami. Powiedz AI, aby unikało nieobsługiwanych obiektów, takich jak procedury składowane, wyzwalacze, rekurencyjne CTE w zapytaniach SELECT tylko do odczytu oraz ALTER TYPE. Indeksy wyrażeń są zachowywane z ostrzeżeniem; żądaj prostych kluczy kolumn, gdy potrzebujesz plakietek indeksów ERD.

Składnia DDL i DML

Te formy instrukcji są bezpieczne dla skryptów schematów i przykładowych Danych generowanych przez AI. Ta sama składnia napędza strukturę ERD i wiersze podglądu w pamięci, dlatego należy umieszczać DDL przed DML i unikać zewnętrznych efektów ubocznych specyficznych dla bazy danych.

Obsługiwane instrukcje

SQL / Przykład
-- 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;
Obsługa WHERE: =, !=, <>, >, <, >=, <=, LIKE, NOT LIKE, IN, NOT IN, BETWEEN, NOT BETWEEN, IS NULL, IS NOT NULL, plus AND / OR kombinacje. Porównania NULL są zgodne ze standardową logiką SQL UNKNOWN — col = NULL nigdy nie pasuje; użyj col IS NULL zamiast tego. Nieznane cele przypisania, odwołania do kolumn po prawej stronie i kolumny filtrów odrzucają kompletną mutację przed jakimikolwiek zmianami wierszy.

Podgląd semantyki dla DML wygenerowanego przez AI

Generuj przykładowe dane lokalnie: W widoku Dane wybierz Generuj dane przykładowe, wybierz automatyczne wykrywanie lub dialekt SQL, słownik nazw z 26 krajów lub ogólny angielski, opcjonalny procent wartości nullable oraz liczbę wierszy tabeli, a następnie rozwiń tabelę, aby dostosować jej generatory, zakresy lub dozwolone wartości. Najpierw podejrzyj, a następnie skopiuj/pobierz SQL lub wstaw nowy Przykładowe Dane karta. Klucz AI ani żądanie danych zewnętrznych nie są potrzebne. Jeśli zastąpiłeś wbudowany schemat, najpierw ustaw jego starą kartę Dane przykładowe handlu jako nieaktywną. Generowanie zachowuje istniejące wiersze, kopiuje kompletne krotki kluczy obcych ze zrównoważonym pokryciem nadrzędnym i waliduje obsługiwane ograniczenia oraz typy skalarne. Ograniczenia CHECK składające się wyłącznie z IS NULL / IS NOT NULL, AND, OR oraz nawiasów mają priorytet nad opcjonalnym procentem NULL, w tym wyłącznymi odniesieniami do postów/filmów. Katalog zawiera ponad 4200 wbudowanych wpisów, w tym ponad 2600 nazwisk z rodzimą pisownią i identyfikatorami e-mail ASCII, a także firmy, produkty, zawody, ulice, opisy w języku naturalnym i przykłady lokalizacji w ponad 40 krajach, wraz z walutami, adresami IP, jednostkami SKU, statusami, kolorami, datami i JSON. Partie obsługują do 5000 wierszy na tabelę, łącznie 10 000 wierszy i 150 000 komórek oraz 5 MB SQL. Wymagane puste cykle relacji, wyczerpane unikalne domeny, kolidujące nazwy tabel w schematach i nieobsługiwane wymagane typy złożone wymagają dostosowania przed zakończeniem generowania. Złożone wartości dopuszczające wartość null i odniesienia przerywające cykle mogą stać się NULL z notatką w podglądzie. Ziarna powtarzają wygenerowane wartości słownikowe; domyślne ustawienia bazy danych nadal zachowują się normalnie. Najpierw zakończ przegląd AI i otwórz ponownie generator, jeśli obszar roboczy SQL ulegnie zmianie.

Wiersze są odtwarzane od zera

Instrukcje DDL i DML są stosowane razem w kolejności źródłowej; każda instrukcja danych używa schematu aktualnego w danym punkcie.

Typy pozostają możliwe do sprawdzenia

Nazwane typy wyliczeniowe i typy złożone utworzone za pomocą CREATE TYPE pozostają częścią sparsowanego schematu.

Ograniczenia są wymuszane

PK, FK, NOT NULL, UNIQUE, DEFAULT, CHECK, kolumny generowane i domeny enum wpływają na wiersze podglądu.

Błędy powinny być możliwe do naprawienia

Preferuj jawne listy kolumn i konkretne klauzule WHERE, aby diagnostyka mogła wskazać dokładną tabelę lub kolumnę.

Nie proś AI o poleganie na: samodzielny SELECT zestawy wyników w głównym schemacie/skrypcie DML, nieobsługiwane ciała proceduralne lub wywołania zewnętrznych baz danych. CREATE VIEW, CREATE OR REPLACE VIEW, oraz MSSQL CREATE OR ALTER VIEW są materializowane z ich SELECT wyniku do podglądu; oddziel doraźne zapytania tylko do odczytu.

Transakcje w widoku Dane

Widok danych obsługuje BEGIN, COMMIT, ROLLBACK, SAVEPOINT, ROLLBACK TO oraz RELEASE w podglądzie w pamięci. Instrukcje te wpływają na wiersze podglądu; nigdy nie zatwierdzają zmian w zewnętrznej bazie danych.

SQLite, PostgreSQL i SQL Server zachowują transakcyjne DDL w podglądzie. MySQL DDL zatwierdza aktywną transakcję. SQLite PRAGMA foreign_keys i MySQL SET FOREIGN_KEY_CHECKS wpływają na późniejszą walidację DML.

Renderer ERD ignoruje opakowania transakcji i reprezentuje instrukcje schematu w kolejności źródłowej. Wycofanie transakcji w widoku Dane może zatem wygenerować inny zestaw tabel niż na diagramie. Sprawdź każdy warsztat pod kątem zachowania, które testujesz.

SQL / Podgląd transakcji
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;
W tym przykładzie Widok Danych zachowuje elementy 1 i 2. Element 3 zostaje usunięty przez ROLLBACK TO przed COMMIT. Widok Zapytania odczytuje te końcowe wiersze podglądu.

Składnia zapytania SELECT

Poproś AI o zachowanie raportowych zapytań tylko do odczytu jako SELECT instrukcje. Mogą one odwoływać się do tabel i wierszy utworzonych przez skrypt schematu/DML i są przydatne do złączeń, filtrów, sum oraz zestawów wyników w formie raportów bez konieczności posiadania aktywnej bazy danych.

Obsługiwany kształt zapytania

SQL / Przykład
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;

Tylko SELECT

Edytor zapytań akceptuje instrukcje SELECT, w tym SELECT bez FROM oraz WITH CTE, które rozwiązują się do SELECT.

Złączenia i filtry

Złączenia INNER, LEFT, RIGHT, FULL i CROSS, warunki WHERE, EXISTS, podzapytania IN, BETWEEN, LIKE, ILIKE oraz sprawdzenia NULL.

Agregaty

Warianty GROUP BY, HAVING, COUNT, SUM, AVG, MIN, MAX, ARRAY_AGG, GROUP_CONCAT, STRING_AGG oraz DISTINCT.

Sortowanie i stronicowanie

ORDER BY nazwy lub pozycje, ASC/DESC, NULLS FIRST/LAST, LIMIT/OFFSET, TOP i FETCH FIRST.

Zaawansowana obsługa SELECT

CTE i tabele pochodne

Klauzule WITH, zagnieżdżone SELECT w FROM, podzapytania skalarne, EXISTS, NOT EXISTS, IN oraz NOT IN są obsługiwane.

Operatory zbiorów

UNION, UNION ALL, INTERSECT i EXCEPT mogą łączyć kompatybilne zestawy wyników.

Funkcje okna

ROW_NUMBER, RANK, DENSE_RANK, NTILE, LAG, LEAD, FIRST_VALUE oraz LAST_VALUE z OVER i PARTITION BY. Uporządkowane okna używają domyślnej ramki SQL uwzględniającej elementy równorzędne (peer-aware), a NTILE najpierw przypisuje większe koszyki.

Pomocnicy dialektu

Typowe funkcje SQLite, PostgreSQL, MySQL i MSSQL są normalizowane na potrzeby podglądu, w tym pomocnicy JSON oraz daty/ciągów znaków.

Tylko do odczytu z założenia: Zachowaj INSERT, UPDATE, DELETE, CREATE, ALTER, oraz DROP instrukcje w skrypcie schematu/DML. Składnia Zapytanie powinna pozostać SELECT-tylko.

Diagnostyka i błędy

Diagnostyka składni ujawnia problemy z analizą schematu, wykonywaniem DDL/DML oraz zapytaniami SELECT tylko do odczytu za pomocą jasnych komunikatów. Błędy analizy zawierają pozycje linii/kolumny, gdy jest to możliwe, a komunikaty o wykonaniu wskazują z powrotem na tabelę, kolumnę lub kształt instrukcji wymagający poprawy.

Błędy parsowania schematu

Parser schematów (SQLite, PostgreSQL, MySQL i MSSQL) zgłasza problemy o dwóch poziomach dotkliwości: błąd powoduje, że pojedyncza instrukcja nie wpływa na schemat; ostrzeżenie zachowuje poprawną składnię, ale sygnalizuje coś, o czym użytkownik powinien wiedzieć.

SQL / Przykład
// 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
}

Błędy parsera

Puste listy kolumn PRIMARY KEY / UNIQUE / FOREIGN KEY, brakujące wymagane typy danych (w tym kolumny SQLite STRICT), niedopasowane nawiasy, nieoczekiwane przecinki i błędnie sformułowane ograniczenia.

Ostrzeżenia tokenizera

Niedomknięte ciągi znaków, niedomknięte komentarze blokowe, niedopasowane nawiasy i podejrzane wieloliniowe wyrażenia CHECK.

Ostrzeżenia dotyczące kluczy obcych

Klucze obce (FK), które wskazują na nieznaną tabelę, nieznaną kolumnę, niejednoznaczny liść schematu lub cel niebędący PK/UNIQUE, są usuwane z diagramu wraz z opisowym ostrzeżeniem.

Pogrupowana diagnostyka

Ostrzeżenia są pogrupowane według przyczyny, w tym: Porzucona relacja, Nieznana tabela, Nieznana kolumna, Nieunikalny cel FK, Ostrzeżenia i błędy parsowania.

Pusty SQL

Puste wejście jest prawidłowe i generuje pusty schemat. Tylko nieprawidłowe dane wejściowe niebędące ciągami znaków zgłaszają błąd.

Dziennik wykonywania DDL/DML

Każda wykonana instrukcja DDL lub DML dodaje jeden ustrukturyzowany wpis do dziennika wykonywania w pamięci. Strumień komunikatów zachowuje porządek chronologiczny i klasyfikuje każdą instrukcję jako błąd, ostrzeżenie, lub sukces.

SQL / Przykład
// Each log entry is:
{
  type:      "success" | "warning" | "error",
  message:   "Inserted 3 row(s) into \"users\"",
  timestamp: 1734567890123  // ms since epoch, monotonic
}
SQL / Przykład
-- 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
Zawsze możliwe do wykonania. Każdy błąd i ostrzeżenie cytuje nazwę tabeli/kolumny, której dotyczy, dzięki czemu można precyzyjnie wskazać problem bez ponownego czytania skryptu.

Typowa diagnostyka

SQL / Przykład
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.
Odporny na awarie. Analiza składniowa schematu, wykonywanie DDL/DML i wykonywanie SELECT przekształcają niepoprawnie sformatowany SQL w widoczne błędy, dzięki czemu możesz nadal udoskonalać ten sam skrypt.

CREATE TYPE

Zdefiniuj niestandardowe typy danych do ponownego użycia w schemacie bazy danych. Nazwane typy wyliczeniowe (enum) i złożone powinny pojawić się przed tabelami, które się do nich odwołują, w tym odwołaniami kwalifikowanymi schematem.

1.1. Typ złożony

Zdefiniuj niestandardowe typy złożone z wieloma polami o różnych typach danych.

SQL / Przykład
CREATE TYPE type_name AS (
  field1 data_type1,
  field2 data_type2,
  ...
);

Przykład:

SQL / Przykład
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)
);
Obsługiwane typy danych: 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 i więcej.

1.2. Typ Enum

Twórz typy wyliczeniowe z predefiniowanymi wartościami dla lepszej integralności danych i czytelności.

SQL / Przykład
CREATE TYPE enum_name AS ENUM (
  'value1',
  'value2',
  ...
);

Przykład:

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

CREATE TYPE priority_level AS ENUM (
  'low', 'medium', 'high', 'critical'
);
Ważne: Wartości Enum muszą być ujęte w pojedyncze cudzysłowy ('wartość'), a nie podwójne.

1.3. Typy kwalifikowane schematem

Typy zdefiniowane przez użytkownika są rozpoznawane z taką samą świadomością schematu jak tabele. Jeśli dwa schematy definiują tę samą nazwę liścia, ERD zachowuje ich odrębność; jeśli typ jest unikalny, nazwa wyświetlana pozostaje prosta.

SQL / Przykład
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
);
Reguła rozstrzygania: s1.status nigdy nie rozwiązuje się do s2.status tylko dlatego, że oba współdzielą nazwę liścia status. Kwalifikowane nazwy typów są ścisłe, podczas gdy nazwy niekwalifikowane są rozstrzygane tylko wtedy, gdy są jednoznaczne.

CREATE TABLE

Zdefiniuj tabele bazy danych z kolumnami, typami danych i ograniczeniami.

2.1. Podstawowa struktura tabeli

Ogólna składnia tworzenia tabeli:

SQL / Przykład
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 ( ... );
Uwaga: Nazwy tabel i kolumn mogą używać podwójnych cudzysłowów (""name"), grawisy (\`name\`), lub nawiasy kwadratowe ([name]) do ucieczki znaków specjalnych lub zastrzeżonych słów kluczowych.

2.2. Definicje na poziomie kolumny

Każda kolumna może zawierać różne ograniczenia i właściwości:

SQL / Przykład
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

Unikalnie identyfikuje każdy wiersz

UNIQUE

Zapewnia, że wartości w kolumnie są unikalne

NOT NULL

Zapobiega wartościom null

DEFAULT

Ustawia wartości domyślne (literały lub funkcje)

CHECK

Waliduje dane za pomocą wyrażeń logicznych

REFERENCES

Tworzy relacje kluczy obcych

Obsługa wartości DEFAULT:
  • Literały: liczby (123), ciągi znaków ('text')
  • Funkcje PostgreSQL: now(), CURRENT_TIMESTAMP, CURRENT_DATE, nextval('seq'::regclass)
  • Funkcje MSSQL: GETDATE(), NEWID()
REFERENCES (w linii): Rozpoznaje REFERENCES table(column), kwalifikowane schematem REFERENCES schema.table(column), pominięte kolumny docelowe, takie jak REFERENCES departments, oraz akcje FK takie jak ON DELETE CASCADE, ON UPDATE SET NULL, MATCH FULL, oraz DEFERRABLE INITIALLY DEFERRED.

2.3. Kolumny generowane / obliczane

Szybkie odniesienie. Zobacz dedykowany Kolumny obliczane sekcja poniżej zawierająca pełny podział według dialektów, w tym formę bare-AS dla MSSQL.

SQL / Przykład
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. Wbudowane typy ENUM

Możesz zadeklarować ENUM bezpośrednio w definicji kolumny (styl MySQL). Parser zarejestruje go jako nazwany enum i automatycznie zastąpi typ kolumny.

SQL / Przykład
CREATE TABLE tasks (
  id INTEGER PRIMARY KEY,
  status ENUM('todo', 'doing', 'done'),
  priority ENUM('low', 'medium', 'high')
);
Jak to działa: Wstawione ENUM są automatycznie rejestrowane jako typy nazwane. Pierwsza prosta nazwa używa column_enum (na przykład, status_enum); późniejsze tabele z inną definicją dla tej samej nazwy kolumny otrzymują nazwę kwalifikowaną tabelą, taką jak tasks_status_enum aby domeny nigdy nie zwinęły się przypadkowo.
Wskazówka: Jeśli potrzebujesz współdzielonych typów wyliczeniowych (enums) lub niestandardowych nazw, zdefiniuj je jawnie za pomocą CREATE TYPE ... AS ENUM zamiast tego.

2.5. Ograniczenia na poziomie tabeli

Zdefiniuj ograniczenia na końcu treści tabeli. Przydatne dla kluczy złożonych i ograniczeń wielokolumnowych:

SQL / Przykład
-- 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)

Przykład:

SQL / Przykład
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)
);
Obsługiwane ograniczenia: PRIMARY KEY, FOREIGN KEY, UNIQUE oraz CHECK są obsługiwane na poziomie tabeli. Nazwa ograniczenia (CONSTRAINT name) jest opcjonalne.
Poprawność klucza obcego: Jeśli REFERENCES ref_table pomija listę kolumn docelowych, Erd Go rozwiązuje ją do klucza głównego tabeli referencyjnej, w tym złożonych kluczy głównych. Jeśli określisz kolumny docelowe jawnie, muszą one być wspierane przez PRIMARY KEY, ograniczenie UNIQUE lub globalne CREATE UNIQUE INDEX; filtrowane / częściowe indeksy unikalne nie liczą się jako cele FK. Nieprawidłowe relacje są usuwane z ostrzeżeniem.

2.6. Nazwy kolumn będące słowami zastrzeżonymi

Słowa takie jak key, index, value, oraz name są zarezerwowane w niektórych dialektach, ale powszechnie używane jako nazwy kolumn w innych. Parser automatycznie rozstrzyga niejednoznaczności, gdy następny token jest znanym typem danych, więc proste użycie bez cudzysłowów działa:

SQL / Przykład
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
);
Reguła ujednoznacznienia: KEY / INDEX / FULLTEXT / SPATIAL po którym następuje słowo kluczowe typu danych (VARCHAR, INT, …) jest kolumna. Po którym następuje identyfikator i ujęta w nawiasy lista kolumn, jest to indeks. Dla absolutnego bezpieczeństwa ujmij kolumnę w cudzysłów za pomocą "key", `key`, lub [key].

Kolumny Identity / Auto-Increment

Używaj natywnej składni tożsamości dla wybranego dialektu. Wszystkie obsługiwane formy tworzą kolumnę klucza głównego z AUTO_INCREMENT znacznik, ale SQLite ma jedną ścisłą zasadę: AUTOINCREMENT wymaga pojedynczego INTEGER PRIMARY KEY kolumna.

SQLite

SQL / Przykład
-- 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
Reguła SQLite: użyj dokładnie INTEGER PRIMARY KEY AUTOINCREMENT. Nie używaj BIGINT, INT, lub złożony klucz główny z AUTOINCREMENT.

PostgreSQL

SQL / Przykład
-- 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
);
Ważne: GENERATED ALWAYS AS IDENTITY to tożsamość kolumna (auto-inkrementacja), różna od GENERATED ALWAYS AS (expression) który jest obliczany kolumna. Parser automatycznie utrzymuje je oddzielnie.

MySQL

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

MSSQL / SQL Server

SQL / Przykład
-- 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
);
Wynik ERD: Każda powyższa forma pojawia się identycznie na diagramie — ikona klucza PK plus AUTO_INCREMENT tag — dzięki czemu możesz mieszać dialekty w jednym schemacie bez utraty wskazówki dotyczącej automatycznego zwiększania (auto-increment).

Kolumny obliczane (zależne od dialektu)

Kolumna obliczeniowa wywodzi swoją wartość z wyrażenia opartego na innych kolumnach w tym samym wierszu. Obsługiwane we wszystkich czterech dialektach z ich odpowiednimi składniami.

PostgreSQL & MySQL — GENERATED ALWAYS AS

SQL / Przykład
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
);
Tryby bazy danych: W natywnej bazie danych, STORED przechowuje obliczoną wartość i VIRTUAL oblicza go przy odczycie. Erd Go przechowuje wartości podglądu w pamięci; ERD zachowuje każdy tryb jako metadane kolumny.

MSSQL / SQL Server — kolumna AS wyrażenie [PERSISTED]

MSSQL posiada własną składnię: column_name AS expression, opcjonalnie z następującym po nim PERSISTED (i opcjonalnie NOT NULL). Oba ujęty w nawiasy i surowy formy wyrażeń są obsługiwane.

SQL / Przykład
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
);
Czyste AS: Parser akceptuje col AS expression (brak nawiasów otaczających) — w tym wywołania funkcji takie jak DATEADD(...), odwołania kwalifikowane tabelą, takie jak c.GrowthDurationDays, oraz CASE wyrażenia — kończące się na następnym przecinku kolumny, PERSISTED, lub koniec treści tabeli.
Wynik ERD: Wszystkie kolumny obliczeniowe są widoczne COMPUTED jako typ i wyrażenie zachowane w dodatkach kolumny / podpowiedzi.

ALTER TABLE

Typowy styl migracji ALTER TABLE instrukcje są odtwarzane po utworzeniu tabeli, więc ostateczny schemat odzwierciedla dodane kolumny, ograniczenia, zmiany nazw, usunięte kolumny oraz zmiany typu/możliwości przypisania wartości null w kolumnach. Składnia zrzutu PostgreSQL wykorzystująca ALTER TABLE ONLY zachowuje kwalifikowaną tożsamość tabeli.

Dodaj i ogranicz

ADD COLUMN, ADD PRIMARY KEY, ADD UNIQUE, ADD CHECK oraz ADD FOREIGN KEY są odzwierciedlone w ERD.

Zmień nazwę i usuń

Zmiany nazw tabel, kolumn, ograniczeń i indeksów — w tym MySQL RENAME TABLE, PostgreSQL ALTER INDEX i SQL Server sp_rename — pozostają powiązane z poprawnym wcieleniem obiektu przed późniejszymi operacjami DROP.

Zmiany kolumn

PostgreSQL ALTER COLUMN TYPE/SET DATA TYPE/SET lub DROP DEFAULT/nullability, MSSQL ALTER COLUMN oraz MySQL MODIFY/CHANGE COLUMN są odtwarzane.

Bezpieczeństwo relacji

Klucze obce są walidowane względem końcowego stanu tabeli po odtworzeniu migracji, w tym zmian PK/UQ/indeksów oraz dokładnej liczby kolumn źródłowych/docelowych.

3.1. Dodaj klucz obcy

SQL / Przykład
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];

Przykład:

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

3.2. Dodaj klucz podstawowy

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

Przykład:

SQL / Przykład
ALTER TABLE products
  ADD CONSTRAINT pk_products
  PRIMARY KEY (product_id);

3.3. Dodaj ograniczenie unikalności

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

Przykład:

SQL / Przykład
ALTER TABLE users
  ADD CONSTRAINT uq_users_email
  UNIQUE (email);

3.4. Dodaj ograniczenie CHECK

SQL / Przykład
ALTER TABLE table_name
  ADD [CONSTRAINT name] CHECK (expression);

Przykład:

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

3.5. Przykład powtórzenia migracji

SQL / Przykład
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);
Co robi ERD: Klucz obcy kontaktu odwołuje się do złożonego klucza podstawowego w app.accounts, owner_email staje się contact_email, audit_state zostaje usunięte, a unikalny indeks daje contact_email a UQ etykieta.

3.6. MySQL CHANGE / MODIFY COLUMN

SQL / Przykład
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 / Przykład
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';
Granica składni: Powtórzenie migracji SQL do ERD jest celowo bogatsze niż wykonanie w Widoku Danych. Parsowanie końcowego diagramu pozostaje ograniczone do przeglądarki i nie wymaga połączenia z bazą danych; nieobsługiwane instrukcje służące wyłącznie do wykonania nie osłabiają modelu cyklu życia ERD.

CREATE INDEX

DDL indeksu jest analizowany we wszystkich czterech dialektach. Proste klucze kolumn są prezentowane jako małe plakietki ERD: IDX dla nieunikalnych przyspieszeń, UQ dla globalnych unikalnych indeksów oraz PUQ dla filtrowanych / częściowych unikalnych indeksów. Wpisy wyrażeń są zachowywane w danych wyjściowych parsera i zgłaszane, gdy nie można ich rzetelnie odwzorować na plakietkę kolumny.

Odznaka IDX

Indeks nieunikalny. Pełna pigułka przy kolumnie. Indeksy złożone wyciszają pigułkę (na szaro) dla każdej kolumny klucza, więc różnica między pojedynczą kolumną a wieloma kolumnami jest widoczna na pierwszy rzut oka.

Odznaka UQ

Z globalnego CREATE UNIQUE INDEX. Zachowuje się jak ograniczenie UNIQUE dla walidacji FK i oznaczania kolumn.

Odznaka PUQ

Z CREATE UNIQUE INDEX ... WHERE. Pokazuje predykat częściowej unikalności, ale nie waliduje celów FK jako globalnie unikalnych.

Reguła tłumienia

Silniejsze ograniczenia wygrywają: PK ⟶ UQ ⟶ PUQ ⟶ IDX. Silniejszy klucz nigdy nie jest degradowany przez późniejszy indeks.

Wielodialektowy

PostgreSQL CONCURRENTLY / USING / INCLUDE / WHERE, MySQL FULLTEXT/SPATIAL & inline KEY/INDEX, MSSQL CLUSTERED/NONCLUSTERED z INCLUDE, standardowe indeksy SQLite.

4.1. Składnia

SQL / Przykład
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. Przykłady

Przyspiesz częste wyszukiwanie klucza obcego (jednokolumnowy IDX):

SQL / Przykład
CREATE INDEX idx_orders_customer ON orders (customer_id);

Indeks złożony (stonowana pigułka IDX na każdej kolumnie klucza):

SQL / Przykład
CREATE INDEX idx_orders_customer_status
  ON orders (customer_id, status);

Podnieś kolumnę do UNIQUE bez zmiany jej definicji:

SQL / Przykład
CREATE UNIQUE INDEX uq_shipments_tracking
  ON shipments (tracking_number);

Częściowy / filtrowany indeks unikalny (PUQ, niebędący globalnym celem FK):

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

Indeks wierszowy MySQL wewnątrz CREATE TABLE:

SQL / Przykład
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 filtrowany + indeks INCLUDE:

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

4.3. Zachowanie i semantyka

  • Indeksy funkcyjne / wyrażeń (np. CREATE INDEX … ON t (lower(email))) są zachowywane i generują wyraźne ostrzeżenie, ale brak odznaki — nie mapują się one czysto na pojedynczą kolumnę.
  • Kolumny INCLUDE (kolumny pokrywające) są analizowane, ale nigdy nie otrzymują oznaczenia — tylko kolumny kluczowe otrzymują plakietkę.
  • Kolumny PK / UQ są silniejszymi gwarancjami niż IDX, więc każde późniejsze CREATE INDEX na nich jest po cichu pomijane — nie zobaczysz nadmiarowych pigułek.
  • Częściowe / filtrowane indeksy unikalne renderuj jako PUQ z WHERE predykat w szczegółach kolumny. Nie są one akceptowane jako globalnie unikalne cele dla walidacji klucza obcego.
  • Końcowe odznaki są niezależne od kolejności: globalna gwarancja unikalności tłumi nadmiarowy IDX etykieta informująca, czy indeks unikalny czy nieunikalny pojawia się jako pierwszy. Metadane indeksu złożonego są podobnie zachowywane niezależnie od kolejności deklaracji.
  • Indeksy na nieznanych tabelach / kolumnach są po cichu odrzucane — przydatne przy przenoszeniu częściowych schematów bez niszczenia diagramu.
  • Cykl życia indeksu zawiera najwyższy poziom CREATE/DROP INDEX, PostgreSQL DROP INDEX CONCURRENTLY, MySQL ALTER TABLE … ADD/DROP/RENAME INDEX, PostgreSQL ALTER INDEX … RENAME, oraz zmiany nazw indeksów SQL Server poprzez sp_rename. Nazwane metadane UQ/PUQ/IDX podążają za ostateczną zachowaną nazwą.
Wskazówka: Pigułki złożonego IDX są renderowane w stonowanej szarości, aby odzwierciedlić istniejący język wizualny złożonego PK / złożonego UQ. Pełna pigułka IDX zawsze oznacza „indeks jednokolumnowy” — łatwy do odczytania w gęstych diagramach.

Obsługa wielu dialektów

Parser po stronie przeglądarki obsługuje różnice w składni między SQLite, PostgreSQL, MySQL i MSSQL bez połączenia z bazą danych. Automatyczne wykrywanie wykorzystuje sygnały składni strukturalnej i pozostaje neutralne dla danych wejściowych o prawdziwie mieszanych dialektach; wywołujący mogą również podać jawny dialekt. Poniższe przykłady zachowują tę samą standardową kolejność: najpierw SQLite, potem PostgreSQL, MySQL i MSSQL.

4.1. Funkcje SQLite

SQL / Przykład
-- 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
);
Specyficzne dla SQLite: INTEGER PRIMARY KEY (alias rowid), AUTOINCREMENT, WITHOUT ROWID, STRICT tabele, beztypowe kolumny inne niż STRICT, powinowactwa typów (INTEGER, TEXT, REAL, NUMERIC, BLOB), datetime('now') / CURRENT_TIMESTAMP wartości domyślne i standardowe REFERENCES z ON DELETE / ON UPDATE akcje.
Poprawność typów: Zwykłe tabele SQLite akceptują dowolne zadeklarowane nazwy typów (takie jak VARCHAR(255), BOOLEAN, lub TIMESTAMP) i mogą pomijać typ. Tabele STRICT przestrzegają dokładnego dozwolonego zestawu SQLite: INT, INTEGER, REAL, TEXT, BLOB, lub ANY; każda kolumna STRICT musi ją zadeklarować.

Przykład powtórzenia migracji SQLite:

SQL / Przykład
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. Funkcje PostgreSQL

SQL / Przykład
-- 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: Obsługuje typy SERIAL, kolumny tożsamości, JSONB, BYTEA, INET, warianty znaczników czasu, tablice, typy złożone i ENUM, UNIQUE NULLS NOT DISTINCT, zachowanie indeksów wyrażeń oraz dokładna tożsamość PostgreSQL uwzględniająca wielkość liter dla nazw w cudzysłowie.

4.3. Funkcje MySQL

SQL / Przykład
-- 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;
Specyficzne dla MySQL: AUTO_INCREMENT, COMMENT, modyfikatory ze znakiem, warianty integer/text/blob/spatial, w linii ENUM i SET, indeksy wbudowane (inline), CHANGE COLUMN, MODIFY COLUMN, FIRST/AFTER rozmieszczenie fizyczne, ON UPDATE CURRENT_TIMESTAMP, oraz typowe opcje tabeli.

4.4. Funkcje MSSQL / SQL Server

SQL / Przykład
-- 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
Specyficzne dla MSSQL: IDENTITY(seed, increment), NVARCHAR(MAX), typy data/godzina, binarne, XML, identyfikatory i przestrzenne, ROWGUIDCOL, indeksy klastrowane, GO partie, ALTER COLUMN, kolumny obliczane, nazwane DEFAULT ... FOR column ograniczenia, generowane kolumny czasowe oraz PERIOD FOR SYSTEM_TIME.
Kolumny obliczane typu Bare-AS: col AS expression PERSISTED (brak nawiasów otaczających) jest w pełni obsługiwany, w tym wywołania funkcji (DATEADD, LEFT, …), odwołania do kolumn kwalifikowane tabelą (c.col), oraz CASE wyrażenia.

4.5. Style cytowania identyfikatorów

Obsługiwane są wszystkie trzy główne konwencje cytowania:

SQL / Przykład
-- 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
);

Notatki i wskazówki

Ważne szczegóły dotyczące obsługi składni: co wpływa na strukturę schematu, jakie DDL/DML można odtworzyć z przykładowymi wierszami, co mogą odczytać Zapytania SELECT i gdzie leżą ograniczenia.

✓ Obsługa składni schematu / ERD

  • Wielodialektowy: Składnia SQLite, PostgreSQL, MySQL i MSSQL może współdzielić skrypt; automatyczne wykrywanie pozostaje neutralne, gdy silne sygnały są rzeczywiście wymieszane
  • Słowa kluczowe niezależne od wielkości liter: CREATE, TABLE, ALTER itp. mogą być pisane dowolną wielkością liter
  • Identyfikatory w cudzysłowie: Cudzysłowy ("name"), grawisy (`name`), oraz nawiasy ([name])
  • Nazwy kolumn będące słowami zastrzeżonymi: Czysty key, index, value, name, order, itp. są akceptowane, gdy następuje po nich typ danych
  • Nazwy kwalifikowane schematem: schema.table i schema.type (np., public.users, dbo.Orders, app.status_enum) — prefiksy schematów w typach zdefiniowanych przez użytkownika są zachowywane w celu ścisłego wyszukiwania i upraszczane do wyświetlania tylko wtedy, gdy są jednoznaczne
  • Komentarze: Jednowierszowy (-- comment) i komentarze blokowe (/* comment */) są automatycznie pomijane
  • BOM i CRLF: Znacznik kolejności bajtów UTF-8 i zakończenia linii Windows są obsługiwane w sposób przejrzysty
  • Niestandardowe typy: CREATE TYPE … AS ENUM i CREATE TYPE … AS (composite), w tym nazwy kwalifikowane schematem
  • Wstawione ENUM i SET (MySQL): ENUM('a','b') i SET('a','b','c') wewnątrz typów kolumn — automatycznie rejestrowane jako typy nazwane i umieszczane w przestrzeni nazw według tabeli/kolumny, gdy duplikaty nazw kolumn używają różnych domen
  • Ograniczenia: Na poziomie kolumny i na poziomie tabeli PRIMARY KEY, FOREIGN KEY, UNIQUE, CHECK (w tym złożone warianty wielokolumnowe). Cele FK są walidowane względem kluczy podstawowych, ograniczeń unikalności lub globalnych indeksów unikalnych
  • Identity / auto-increment: SERIAL/BIGSERIAL (PG), GENERATED ALWAYS/BY DEFAULT AS IDENTITY (PG), AUTO_INCREMENT (MySQL), IDENTITY(1,1) i proste IDENTITY (MSSQL) — wszystkie jednoczą się na diagramie
  • Kolumny obliczane: GENERATED ALWAYS AS (expr) STORED/VIRTUAL (PG/MySQL) i MSSQL col AS (expr) [PERSISTED] + proste col AS expr [PERSISTED]
  • Tablice PostgreSQL: type[], o określonym rozmiarze type[5], zagnieżdżone type[][][], oraz tablice typów zdefiniowanych przez użytkownika (np. webhook_event[])
  • Wartości domyślne: Literały, ciągi znaków w cudzysłowie dolarowym, wywołania funkcji (now(), CURRENT_TIMESTAMP, GETDATE(), NEWID(), NEWSEQUENTIALID(), gen_random_uuid(), nextval()), oraz ON UPDATE CURRENT_TIMESTAMP (MySQL)
  • Akcje FK: ON DELETE / ON UPDATE z CASCADE, RESTRICT, SET NULL, SET DEFAULT, NO ACTION, plus MATCH, DEFERRABLE, oraz INITIALLY metadane. Akcje są zachowywane jako metadane relacji.
  • Powtórzenie migracji: ALTER TABLE ADD COLUMN, dodawanie/usuwanie/zmiana nazw kluczy i ograniczeń, zmiany nazw tabel/kolumn/indeksów, DROP COLUMN, ALTER COLUMN TYPE/SET DATA TYPE, SET/DROP DEFAULT, SET/DROP NOT NULL, MSSQL sp_rename, oraz MySQL MODIFY/CHANGE COLUMN
  • Indeksy: Poziom najwyższy CREATE/DROP INDEX, PostgreSQL ALTER INDEX … RENAME, MySQL dodawanie/usuwanie/zmiana nazwy i inline KEY/INDEX/UNIQUE INDEX/FULLTEXT/SPATIAL definicje. Indeksy oparte na kolumnach są renderowane jako IDX, UQ, lub PUQ etykiety
  • IF NOT EXISTS, IF EXISTS: obsługiwane płynnie na obu CREATE i DROP
  • Opakowania transakcji dotyczące tylko schematu: BEGIN, COMMIT, SET search_path, USE [db] (MSSQL) oraz SET FOREIGN_KEY_CHECKS (MySQL) są bezpiecznie pomijane
  • Pomyślnie pominięto: CREATE VIEW, CREATE MATERIALIZED VIEW, CREATE FUNCTION/TRIGGER/SCHEMA/SEQUENCE, proceduralne EXEC instrukcje inne niż sp_rename, DECLARE, PRINT, PARTITION BY, INHERITS (w tym pusty korpus), WITH OIDS, STORAGE PLAIN, EXCLUDE USING gist, oraz treści instrukcji, które nie wpływają na strukturę ERD

✓ Składnia podglądu DDL/DML

  • Wykonywanie od góry do dołu: Skrypt jest odtwarzany w kolejności instrukcji, więc przykładowe Dane powinny znajdować się po schemacie, do którego się odwołują
  • Obsługiwane instrukcje: CREATE TYPE, CREATE TABLE, CREATE VIEW, CREATE INDEX, ALTER TABLE zmiany kolumny/ograniczenia, DROP INDEX, TRUNCATE TABLE, INSERT, UPDATE, DELETE, DROP TABLE, DROP VIEW, oraz DROP TYPE
  • Filtry WHERE: =, !=, <>, >, <, >=, <=, LIKE, IN, NOT IN, NOT LIKE, BETWEEN, NOT BETWEEN, IS NULL, oraz IS NOT NULL
  • Materializacja wierszy: Tabele udostępniają liczbę wierszy, metadane struktury oraz aktualne dane wierszy po wykonaniu instrukcji DML
  • Nazwane typy: Typy ENUM i złożone utworzone za pomocą CREATE TYPE są wyświetlane oddzielnie od tabel
  • Dziennik wykonania: Stany sukcesu, ostrzeżenia i błędu są rejestrowane dla nieznanych kolumn, brakujących tabel, duplikatów kluczy, naruszeń NULL oraz szerokich aktualizacji/usuwania; nieprawidłowe powiązania mutacji kończą się niepowodzeniem przed zmianą wierszy
  • Domyślna ewaluacja: Dosłowne wartości domyślne oraz funkcje takie jak now(), CURRENT_TIMESTAMP, CURRENT_DATE, GETDATE(), oraz NEWID()

✓ Składnia zapytania SELECT

  • SELECT tylko do odczytu: SELECT instrukcje mogą odczytywać tabele w pamięci wygenerowane z głównego pliku SQL
  • Metadane wyniku: Kolumny, liczba wierszy, czas trwania, formatowanie NULL/boolean/liczba oraz błędy zapytania są zachowywane wraz z wynikiem SELECT
  • Zapytania relacyjne: Złączenia, filtry WHERE, GROUP BY, HAVING, ORDER BY, LIMIT/OFFSET, TOP, FETCH FIRST, CTE, tabele pochodne, podzapytania i operatory zbiorów
  • Pomocniki analityczne: Agregaty, typowe funkcje skalarne, pomocniki JSON, funkcje daty/ciągów znaków oraz funkcje okna, takie jak ROW_NUMBER, RANK, NTILE, FIRST_VALUE, LAST_VALUE, LAG, oraz LEAD; uporządkowane ramki domyślne obejmują bieżącą grupę rówieśniczą

✗ Wciąż nieobsługiwane / Pominięte

  • ALTER TYPE: Nie można modyfikować istniejących typów ENUM lub typów złożonych
  • Klauzula LIKE: CREATE TABLE foo (LIKE bar INCLUDING …) jest bezpiecznie pomijane — skopiowane kolumny nie są materializowane
  • Dziedziczenie kolumn INHERITS: Ten INHERITS (parent) sama klauzula jest analizowana bez błędów, ale kolumny dziedziczone nie są pobierane do tabeli podrzędnej na potrzeby ERD
  • Wykonanie indeksu: DDL indeksu może tworzyć plakietki schematu, ale wykonanie podglądu nie modeluje silników pamięci masowej, planistów zapytań ani wydajności indeksów
  • Limity SELECT: Składnia zapytania tylko do odczytu nie obsługuje rekurencyjnych CTE, wykonywania w zewnętrznych bazach danych, procedur składowanych ani instrukcji modyfikujących
  • Inne obiekty: Wyzwalacze, procedury składowane, funkcje i sekwencje
  • Zewnętrzne wykonanie: Podgląd DDL/DML nie łączy się z rzeczywistą bazą danych ani nie utrwala wierszy poza bieżącym plikiem SQL
Zachowanie składni: DML nie wpływa na generowanie diagramu schematu. Instrukcje cyklu życia tabel, typów i nazwanych indeksów są odtwarzane w kolejności źródłowej, w tym zmiana nazwy, usunięcie i późniejsze ponowne utworzenie bez wycieku metadanych między inkarnacjami obiektów. Obsługiwane instrukcje DDL/DML są wykonywane w pamięci od góry do dołu, a zapytania SELECT tylko do odczytu czytają z tego wyniku w pamięci bez jego modyfikowania.
Najlepsze praktyki:
  • Zakończ każdą instrukcję średnikiem (;)
  • Zdefiniuj CREATE TYPE przed tabelami, które się do nich odwołują
  • Zdefiniuj CREATE TABLE przed powiązanymi INSERT, UPDATE, lub DELETE instrukcje
  • Użyj ALTER TABLE dla kluczy obcych, gdy tabele odwołują się do siebie nawzajem (zależności cykliczne)
  • Użyj najpierw DDL dla struktury, a następnie DML, aby zweryfikować przykładowe wiersze i zachowanie ograniczeń.
  • Przechowuj Dane demonstracyjne w samym pliku SQL, ponieważ wiersze podglądu są pochodnymi skryptu
Odzyskiwanie po błędach: Nieobsługiwane instrukcje są pomijane, a ostrzeżenia/błędy składniowe są wyświetlane z wystarczającym kontekstem, aby kontynuować dopracowywanie tego samego pliku zamiast zaczynać od zera.

Postępując zgodnie z tymi wzorcami składni, Erd Go może wygenerować schemat ERD, wyświetlić podgląd danych w pamięci i uruchamiać zapytania tylko do odczytu z tego samego pliku SQL.

ErdGo.com - Przekształcaj SQL w diagramy i szybciej przeglądaj Dane