ข้ามไปยังเอกสาร

จากสคีมาสู่แผนภาพ

คู่มือ SQL เป็น ERD

เปลี่ยนสคีมาฐานข้อมูลของคุณเป็นแผนภาพ เรียนรู้ SQL ที่รองรับ ดูตัวอย่างข้อมูล และใช้คิวรีกับแบบจำลองของคุณ

SQL DDL → แผนภาพ ERเปิด SQL เป็น ERD
การเริ่มต้นใช้งาน

สัญญาไวยากรณ์ SQL ที่พร้อมสำหรับ AI

ใช้หน้านี้เป็นสัญญาขนาดกะทัดรัดเมื่อขอให้ AI เขียนหรือแก้ไข SQL สำหรับ Erd Go แนะนำให้ใช้รูปแบบไวยากรณ์ด้านล่าง รักษาคำสั่งให้สมบูรณ์และลงท้ายด้วยอัฒภาค และหลีกเลี่ยงออบเจกต์ฐานข้อมูลที่ไม่รองรับ เว้นแต่คุณจะต้องการเพียง SQL ดิบภายนอก Erd Go ไวยากรณ์ SQLite, PostgreSQL, MySQL และ MSSQL ได้รับการรองรับในส่วนย่อยที่แชร์ด้านล่าง การแปลง SQL เป็น ERD ทำงานทั้งหมดในเบราว์เซอร์ และเอ็นจิ้นตัวแยกวิเคราะห์และแสดงตัวอย่างถูกล็อกไว้ด้วยการทดสอบหน่วยและการทดสอบรวมหลายพันรายการที่ครอบคลุมสคีมาการผลิตจริง (SaaS, การธนาคาร, โซเชียล, การวิเคราะห์, EHR)

SQLite

กฎ rowid ของ INTEGER PRIMARY KEY, คอลัมน์ที่ไม่มีประเภท, AUTOINCREMENT, WITHOUT ROWID, ตาราง STRICT ที่ผ่านการตรวจสอบ, การดำเนินการ FK และการเล่นซ้ำการย้ายข้อมูล

PostgreSQL

ENUM และประเภทข้อมูลคอมโพสิต, อาร์เรย์, JSONB, SERIAL, คอลัมน์ identity, NULLS NOT DISTINCT, ดัชนี expression, identity ของสคีมา และความไวต่อตัวพิมพ์ใหญ่-เล็กของชื่อที่อยู่ในเครื่องหมายคำพูด

MySQL

AUTO_INCREMENT, ENUM & SET แบบอินไลน์, backticks, COMMENT, UNSIGNED/SIGNED, ดัชนีแบบอินไลน์, CHANGE/MODIFY COLUMN และการวางตำแหน่ง FIRST/AFTER

MSSQL

IDENTITY, NVARCHAR(MAX), ชื่อในวงเล็บ, ดัชนีแบบคลัสเตอร์, ชุดคำสั่ง GO, ALTER COLUMN, คอลัมน์ที่คำนวณได้, ค่าเริ่มต้นที่มีชื่อ และช่วงเวลาชั่วคราว

DDL

CREATE TYPE, CREATE TABLE, การเล่นซ้ำการย้ายข้อมูล ALTER TABLE, CREATE INDEX และคำสั่ง DROP ที่ปลอดภัยสำหรับรูปร่างสคีมา

DML / SELECT

INSERT, UPDATE, DELETE สำหรับข้อมูลตัวอย่าง รวมถึงไวยากรณ์ SELECT แบบอ่านอย่างเดียวสำหรับ joins, CTEs, aggregates, windows และรายงาน

เริ่มต้นใช้งานอย่างรวดเร็ว

ใช้สิ่งนี้เป็นคำตอบต้นแบบเมื่อขอ SQL ที่เข้ากันได้กับ Erd Go จาก AI: ประเภทข้อมูลแบบกำหนดเองก่อน ตามด้วยตาราง ข้อจำกัดความสัมพันธ์หลังจากตารางเมื่อมีประโยชน์ แล้วตามด้วย DML ตัวอย่าง แยกคิวรี SELECT แบบอ่านอย่างเดียวไว้ต่างหาก

PostgreSQL / เริ่มต้นใช้งาน 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;
ไวยากรณ์สคีมา: ความสัมพันธ์สามารถประกาศได้ด้วยแบบอินไลน์ REFERENCES หรือ ALTER TABLE ADD FOREIGN KEY. ทั้งสองรูปแบบให้ข้อมูลเมตาความสัมพันธ์เดียวกัน
ไวยากรณ์ DML: วาง INSERT, UPDATE, และ DELETE หลังจาก DDL ของสคีมา สคริปต์จะถูกประเมินจากบนลงล่าง ดังนั้นแถวตัวอย่างควรอ้างอิงถึงตารางและประเภทที่มีอยู่แล้ว
ไวยากรณ์ SELECT: แยกคิวรีรายงานแบบอ่านอย่างเดียวออกจากสคริปต์การแก้ไขข้อมูล โดยคิวรีเหล่านั้นควรอ้างอิงเฉพาะตารางและแถวที่สร้างขึ้นโดยสคริปต์ Schema/DML เท่านั้น
SQL / ตัวอย่าง
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;

แท็บ SQL และการนำเข้าไฟล์

เริ่มไฟล์ SQL ใหม่ด้วยตัวอย่าง, แท็บสคีมาว่างเปล่า หรือนำเข้าไฟล์ SQL ตัวอย่างจะแยกสคีมาและข้อมูลไว้ในแท็บต่างๆ การเพิ่มแท็บ SQL จะสร้างแท็บตัวแก้ไขอีกแท็บหนึ่ง; ดับเบิลคลิกที่ชื่อเพื่อเปลี่ยนชื่อ

แท็บที่ใช้งานอยู่จะถูกคอมไพล์ร่วมกันตามลำดับที่มองเห็นสำหรับ ERD, มุมมองข้อมูล, มุมมองคิวรี และคำขอ AI แท็บที่ไม่ได้ใช้งานจะยังคงเป็นฉบับร่างที่บันทึกไว้และถูกแยกออกจากเวิร์กโฟลว์เหล่านั้น ให้วางประเภทและตารางไว้ก่อนคำสั่งที่ขึ้นต่อกัน

การนำเข้าไฟล์ SQL รองรับไฟล์ SQL แบบข้อความหลายไฟล์และตรวจสอบปัญหาการแยกวิเคราะห์ (parsing) ร่วมกันก่อนนำเข้า ซึ่งจะช่วยแก้ไขการอ้างอิงระหว่างไฟล์ต่างๆ ให้ใช้ลำดับแท็บเพื่อให้การจัดการการขึ้นต่อกันและขั้นตอนการย้ายข้อมูลเป็นไปตามเจตนา

ใช้ปุ่มลูกศรและ Home/End ในแถบแท็บเพื่อสลับแท็บ, Alt+Left/Right เพื่อจัดลำดับใหม่ และ Shift+Alt+F เพื่อจัดรูปแบบ SQL ในตัวแก้ไข

เปิด SQL Explorer ข้างแท็บสำหรับโครงสร้างโฟลเดอร์ที่ปรับขนาดได้ สร้างโฟลเดอร์ซ้อนและไฟล์ SQL เลือกไฟล์เพื่อเปิด และจัดระเบียบด้วยการลาก/วาง ป๊อปอัปการดำเนินการแถวรองรับการ เปลี่ยนชื่อ และ ลบ ไฟล์; คลิกภายนอกเพื่อปิดป๊อปอัป การลบไฟล์สุดท้ายจะทำให้ไฟล์ SQL เปล่าเปิดอยู่ โฟลเดอร์ไม่เปลี่ยนลำดับการดำเนินการ การลบโฟลเดอร์จะเก็บไฟล์และโฟลเดอร์ย่อยไว้ในโฟลเดอร์หลัก การ บันทึก จะคงโครงสร้างโฟลเดอร์และการตั้งค่าพาเนลไว้

แก้ไขและตรวจสอบแผนภาพ

SQL คือแหล่งที่มาของความหมายของสคีมา ใช้ "เพิ่มตาราง" เพื่อสร้างตาราง หรือเลือกการดำเนินการของตารางและคอลัมน์บนผืนผ้าใบเพื่อแก้ไขคอลัมน์และการเชื่อมต่อ การแก้ไขสคีมาบนผืนผ้าใบจะอัปเดตแท็บ SQL ที่เป็นเจ้าของรวมถึงแผนภาพด้วย

การลบคอลัมน์จะแสดงตัวอย่างการเชื่อมต่อ คีย์ ดัชนี และ SQL ที่เกี่ยวข้องที่ได้รับผลกระทบ ตรวจสอบการลบหรือการลบแบบต่อเนื่อง (cascade) ก่อนยืนยัน การย้ายข้อมูลที่ซับซ้อนหรือคำสั่งที่ขึ้นต่อกันที่ไม่รองรับอาจต้องมีการแก้ไข SQL โดยตรง

ใช้คะแนนสุขภาพ ERD เพื่อตรวจสอบผลลัพธ์เชิงโครงสร้างและเลือกรับคำแนะนำความสัมพันธ์ ความสัมพันธ์ที่แนะนำจำเป็นต้องได้รับการตรวจสอบ ไม่สามารถแทนที่คีย์นอกที่ประกาศไว้หรือสร้างกฎทางธุรกิจโดยอัตโนมัติ

จัดเรียงตารางด้วยโหมดเค้าโครง, ซูมหรือพอดีกับหน้าจอ, ค้นหาตารางด้วยตัวนำทางตาราง และใช้สีตารางหรือแผนที่ย่อเพื่อนำทางแผนภาพขนาดใหญ่ วางเมาส์เหนือหรือโฟกัสที่ตัวควบคุมแถบเครื่องมือเพื่อดูข้อความช่วยเหลือ

เลือกตารางและเปิด Color Picker สำหรับค่าที่ตั้งไว้ล่วงหน้าแบบสีทึบหรือไล่ระดับสี ป้อนค่าเลขฐานสิบหกหรือเลือก Custom ข้างๆ เพื่อใช้ตัวเลือกสีแบบเนทีฟ การควบคุมทั้งสองจะซิงโครไนซ์กัน บันทึกจะเก็บสีของตารางไว้

เมื่อเครื่องมือตารางถูกตั้งค่าให้แสดงเฉพาะเมื่อวางเมาส์ (hover-only) ปุ่มเพิ่มคอลัมน์จะปรากฏขึ้นเมื่อคุณวางเมาส์เหนือแถวสุดท้ายที่มองเห็นได้หรือโฟกัสที่ปุ่มด้วยแป้นพิมพ์ เครื่องมือที่แสดงตลอดเวลาจะทำให้ปุ่มนั้นแสดงอยู่เสมอ

เลือก Table groups บนแถบเครื่องมือพื้นที่ทำงาน SQL จากนั้นเลือก New group ตั้งชื่อและสีให้กับกลุ่ม เลือกตารางของกลุ่ม และเลือก Create group ตารางที่เลือกจะเริ่มต้นด้วยการทำเครื่องหมาย ตารางหนึ่งตารางเป็นของกลุ่มเดียว แบบฟอร์มจะแสดงเมื่อการเลือกของคุณจะย้ายตารางออกจากกลุ่มอื่น รองรับสูงสุด 50 กลุ่ม โดยมีชื่อยาวสูงสุด 160 ตัวอักษร

คลิกที่ส่วนหัวของกลุ่มเพื่อแก้ไขชื่อ สี หรือสมาชิก ลากส่วนหัวเพื่อย้ายตารางไปพร้อมกัน ปล่อยเพื่อใช้การย้าย การกด Escape การยกเลิกตัวชี้ หรือการสูญเสียโฟกัสของหน้าต่างจะเป็นการยกเลิกการแสดงตัวอย่าง การยกเลิกการจัดกลุ่มตารางจะเป็นการลบกรอบออกโดยที่ยังคงตาราง ตำแหน่ง SQL และความสัมพันธ์ไว้

กรอบกลุ่มจะตามหลังการ์ดตารางแบบสดและปรากฏใน Fit to Screen, มินิแมพ และการส่งออกรูปภาพในมุมมองปัจจุบันหรือทั้งแผนภาพ กลุ่มเป็นสถานะทางภาพทางเลือกที่บันทึกไว้พร้อมกับเอกสาร SQL ไฟล์เก่าจะคงเค้าโครงเดิมไว้ และชื่อตารางที่หายไปชั่วคราวจะยังคงอยู่ในกลุ่มจนกว่าจะกลับไปยัง SQL ที่ถูกแยกวิเคราะห์ กลุ่มตารางเป็นส่วนหนึ่งของ SQL เป็น ERD; แพ็กเกจแผนภาพคลาสจะใช้แบบจำลองแยกต่างหาก

การตรวจสอบโดย AI ภายในตัวแก้ไข SQL

  1. ป้อนการเปลี่ยนแปลงเฉพาะใน Ask AI เพื่อแก้ไข SQL และเลือกโมเดลที่มีอยู่ การตั้งค่าคีย์ Gemini API จะพร้อมใช้งานเมื่อคุณต้องการใช้คีย์ Gemini ของคุณเอง
  2. ตรวจสอบการเปลี่ยนแปลงที่เสนอและตัวอย่างแผนภาพชั่วคราว คำขอใช้สแนปชอตของแท็บที่ใช้งานอยู่ที่บันทึกไว้เมื่อส่ง; การตอบกลับจะไม่ถูกบันทึกโดยอัตโนมัติ
  3. ยอมรับหรือปฏิเสธการเปลี่ยนแปลงแต่ละรายการ หรือใช้การดำเนินการสำหรับการเปลี่ยนแปลงที่เหลือ นำทางผ่านการเปลี่ยนแปลงโค้ดด้วย F7 และ Shift+F7 แท็บที่ไม่ได้ใช้งานที่ได้รับการป้องกันจะยังคงเป็นฉบับร่าง
  4. ตรวจสอบ SQL ที่ยอมรับ จากนั้นบันทึกเอกสาร คัดลอก AI Prompt ในคู่มือนี้ยังช่วยให้คุณใช้เอกสารประกอบกับผู้ช่วยภายนอกแอปได้อีกด้วย

ข้อมูล, คิวรี, การส่งออก และไฟล์ที่บันทึกไว้

ใช้ปุ่ม ERD, Data และ Query เพื่อสลับพื้นที่ทำงาน มุมมองข้อมูล (Data View) จะแสดง DDL และ DML ที่รองรับในเบราว์เซอร์และเปิดเผยตาราง แถว ประเภท และบันทึกการดำเนินการ ปรับขนาดคอลัมน์ตารางโดยการลากขอบหรือดับเบิลคลิกเพื่อปรับให้พอดี ดับเบิลคลิกที่เซลล์ข้อมูลหรือกด Enter เพื่อแก้ไข ฟิลด์บูลีนและ enum จะเสนอค่าที่ถูกต้อง การเพิ่มแถวจะเป็นไปตามค่าเริ่มต้นของสคีมาของคุณ นำเข้า CSV, TSV, TXT หรือ XLSX พร้อมตัวอย่างการแมปคอลัมน์ NULL และข้อความว่างจะยังคงแยกจากกัน การแก้ไขที่ผ่านการตรวจสอบจะกลายเป็น SQL ในแท็บการแก้ไขข้อมูลและสามารถยกเลิกได้ ดาวน์โหลดแถวตารางหรือผลลัพธ์คิวรีเป็น CSV

การบันทึกจะจดจำ ERD, ข้อมูล หรือเวิร์กเบนช์คิวรีที่เลือกไว้ การเปิดใหม่จะกู้คืนค่าเหล่านั้น รวมถึงข้อมูล/คิวรีบนโทรศัพท์ ไฟล์เก่าจะเริ่มต้นใน ERD ตัวแก้ไขวันที่/เวลาแบบเนทีฟจะคงค่าที่รองรับไว้ ในขณะที่การประทับเวลาที่มีเศษส่วนหรือออฟเซ็ตเขตเวลาจะยังคงแก้ไขได้ในรูปแบบข้อความ ข้อมูลระบุตัวตนที่สร้างโดยฐานข้อมูลจะยังคงเป็นแบบอ่านอย่างเดียว

มุมมองคิวรี (Query View) จะรันคิวรี SELECT แบบอ่านอย่างเดียวกับตารางในหน่วยความจำปัจจุบัน รองรับไวยากรณ์ที่ระบุไว้ด้านล่าง ไม่มีการเชื่อมต่อกับฐานข้อมูลภายนอก ข้อความคิวรีจะถูกบันทึกไปพร้อมกับบริบทของเอกสาร SQL

การบันทึกจะจดจำตารางข้อมูลที่เลือกไว้ด้วย การเปิดใหม่จะกู้คืนตารางนั้น โดยมีตารางแรกเป็นค่าสำรองหากตารางนั้นไม่พร้อมใช้งาน ฟิลด์สคีมาจะจัดแนวชื่อ ประเภท และกฎให้ตรงกัน ให้วางเมาส์เหนือป้ายกำกับกฎเพื่อดูคำอธิบาย การไปที่ SQL ข้างหัวข้อตารางจะเป็นการเปิดแท็บ SQL ที่กำหนดและแสดงคำสั่ง CREATE TABLE โดยจะเปิดแผง SQL อีกครั้งเมื่อถูกซ่อนไว้ในขณะที่ยังคงการเลือกข้อมูลและฉบับร่างไว้ ผลลัพธ์ของคิวรีจะรวมจำนวน, เวลา, Fit, คัดลอก และ CSV ไว้ในส่วนหัวเดียว

ลากตัวแบ่งแบบบางระหว่างตัวแก้ไข Query และผลลัพธ์ หรือระหว่าง Data schema และแถว เพื่อปรับขนาดบานหน้าต่าง ปุ่มลูกศรจะปรับขนาดตัวแบ่งที่โฟกัสอยู่ Escape จะยกเลิกการลาก และดับเบิลคลิกจะเป็นการรีเซ็ต ขนาดบานหน้าต่างเหล่านี้จะเป็นการตั้งค่าพื้นที่ทำงานชั่วคราว

สร้างข้อมูลตัวอย่างโดยใช้ประเภทคอลัมน์ ชื่อ ความสัมพันธ์ และข้อจำกัดของคุณ ภาษาตัวอย่างจะควบคุมชื่อรวมถึงวลีผลิตภัณฑ์/คำอธิบายที่เป็นธรรมชาติใน 17 ภาษา ตรวจสอบตัวสร้างและช่วงที่แนะนำ ดูตัวอย่างผลลัพธ์ จากนั้นแทรกแท็บข้อมูลตัวอย่างแยกต่างหากอย่างชัดเจน ค่าบูลีนจะแสดงเป็น true/false; ID จะยังคงเป็นตัวเลข การสร้างข้อมูลจะไม่แทนที่แถวที่มีอยู่เดิม

เลือก Export ERD เพื่อเลือก PNG, SVG ที่มีรูปภาพประกอบ หรือ PDF ที่มีขนาด HD, 2K หรือ 4K รูปภาพที่ส่งออกจะไม่แทนที่เอกสารที่บันทึกไว้ซึ่งแก้ไขได้

ลงชื่อเข้าใช้และใช้ Save SQL และ ERD เพื่อบันทึกบริบทของ SQL และแผนภาพ รวมถึงแท็บ การแก้ไขตารางที่ใช้ ข้อความคิวรี และเค้าโครง การบันทึกจะตรวจสอบเซลล์ที่ใช้งานอยู่หรือร่างแถวใหม่ก่อน ข้อมูลที่ไม่ถูกต้องจะยังคงแสดงอยู่เพื่อให้แก้ไข การแสดงตัวอย่างการนำเข้าต้องมีการดำเนินการนำเข้าที่ชัดเจน เปิดไฟล์ที่บันทึกไว้จากรายการไฟล์ และใช้แชร์บนเอกสารที่บันทึกไว้ที่เป็นเจ้าของเพื่อกำหนดค่าการเข้าถึงสาธารณะและแจกจ่ายลิงก์แบบอ่านอย่างเดียว

เอกสาร SQL, Prisma และ Builder จะเปิดในเครื่องมือของตนเอง Prisma และ Builder มีรายการไฟล์แยกต่างหากและการบันทึกบนคลาวด์เท่านั้น ข้อความแจ้งเตือนการเปลี่ยนแปลงที่ยังไม่ได้บันทึกจะช่วยปกป้องเอกสารที่แก้ไขเมื่อออกจากพื้นที่ทำงาน โปรดบันทึกการเปลี่ยนแปลงของคุณก่อนแชร์หรือสลับออก

แก้ไขปัญหาพื้นที่ทำงาน SQL

แก้ไขปัญหาพื้นที่ทำงาน SQL
อาการสิ่งที่ควรตรวจสอบ
ตารางหายไปตรวจสอบการวินิจฉัยการแยกวิเคราะห์ (parsing diagnostics), แท็บที่ใช้งานอยู่ และลำดับคำสั่ง การใช้ DROP หรือการเปลี่ยนชื่อในภายหลังอาจเปลี่ยนแผนภาพสุดท้ายได้
ความสัมพันธ์หายไปตรวจสอบว่าทั้งตารางและคอลัมน์มีอยู่จริง จำนวนคอลัมน์ของคีย์นอกตรงกัน และคีย์ที่อ้างอิงมีความเป็นเอกลักษณ์ทั่วทั้งระบบ ให้ระบุ Schema สำหรับชื่อที่กำกวม
มุมมองข้อมูลไม่แสดงแถวข้อมูลวาง INSERT ไว้หลัง CREATE TABLE ในแท็บที่ใช้งานอยู่ ตรวจสอบบันทึกการทำงานเพื่อดูแถวที่ถูกปฏิเสธหรือการย้อนกลับของธุรกรรม
ผลลัพธ์ของคิวรีไม่ตรงกับ SQL อีกต่อไปเรียกใช้ คิวรี อีกครั้งหลังจากเปลี่ยนสคีมาหรือ ข้อมูล; ใช้ตารางในหน่วยความจำปัจจุบัน
Add Table แนะนำภาษาถิ่นที่แตกต่างกันไวยากรณ์ของพื้นที่ทำงานที่ใช้งานอยู่จะมีความสำคัญเหนือกว่าค่าสำรองที่เลือกด้วยตนเอง ตรวจสอบตัวบ่งชี้ภาษา SQL และค่าเริ่มต้นเฉพาะตาราง
ไม่สามารถแก้ไขไฟล์ที่บันทึกไว้ได้ตรวจสอบการลงชื่อเข้าใช้และความเป็นเจ้าของ ลิงก์สาธารณะให้สิทธิ์การเข้าถึงแบบอ่านอย่างเดียวเท่านั้น ให้ใช้ ลองใหม่ หรือ เปิดไฟล์ สำหรับข้อผิดพลาดในการโหลดที่กู้คืนได้

เวิร์กโฟลว์ไวยากรณ์ AI

เมื่อใช้ผู้ช่วย AI ให้ขอให้สร้าง SQL ตามลำดับนี้ สิ่งนี้จะช่วยให้ผลลัพธ์แยกวิเคราะห์ได้ง่าย นำไปทำแผนภาพได้ง่าย และดูตัวอย่างด้วยแถวข้อมูลตัวอย่างหรือคิวรีแบบอ่านอย่างเดียวได้ง่าย

1. กำหนดโดเมนก่อน

วางคำนิยาม enum/composite ของ CREATE TYPE ไว้ก่อนตารางที่อ้างอิงถึงสิ่งเหล่านั้น ควรใช้ชื่อที่ชัดเจนแทนการใช้ประเภทข้อมูลแบบอินไลน์เฉพาะกิจเมื่อมีการใช้โดเมนร่วมกัน

2. สร้างตารางพื้นฐาน

ใช้ CREATE TABLE สำหรับคอลัมน์, Primary Keys, ความไม่ซ้ำกัน, ค่าเริ่มต้น, การตรวจสอบ, คอลัมน์ที่สร้างขึ้น และ Foreign Keys แบบอินไลน์

3. เล่นซ้ำการย้ายข้อมูล (migrations)

ใช้ ALTER TABLE สำหรับข้อจำกัดที่เพิ่มเข้ามา, การเปลี่ยนชื่อ, คอลัมน์ที่ถูกลบ, การเปลี่ยนแปลงประเภทคอลัมน์/ความสามารถในการเป็นค่าว่าง และ Foreign Keys แบบวงกลม

4. เพิ่มข้อมูลและคิวรีเป็นลำดับสุดท้าย

วาง INSERT/UPDATE/DELETE ไว้หลัง DDL ทั้งหมด แยกคิวรี SELECT ออกจากการเปลี่ยนแปลงสคีมาเมื่อคุณต้องการชุดผลลัพธ์

เคล็ดลับการแจ้งเตือน AI: ขอสคริปต์ SQL ที่สมบูรณ์หนึ่งชุดที่ลงท้ายด้วยเซมิโคลอน บอกให้ AI หลีกเลี่ยงวัตถุที่ไม่รองรับ เช่น สตอร์โปรซีเดอร์, ทริกเกอร์, CTE แบบเรียกซ้ำในคิวรี SELECT แบบอ่านอย่างเดียว และ ALTER TYPE. ดัชนีแบบนิพจน์จะถูกเก็บไว้พร้อมคำเตือน; ขอคีย์คอลัมน์แบบง่ายเมื่อคุณต้องการป้ายดัชนี ERD

ไวยากรณ์ DDL และ DML

รูปแบบคำสั่งเหล่านี้ปลอดภัยสำหรับสคริปต์สคีมาและข้อมูลตัวอย่างที่สร้างโดย AI ไวยากรณ์เดียวกันนี้ขับเคลื่อนโครงสร้าง ERD และแถวตัวอย่างในหน่วยความจำ ดังนั้นควรเก็บ DDL ไว้ก่อน DML และหลีกเลี่ยงผลข้างเคียงเฉพาะของฐานข้อมูลภายนอก

คำสั่งที่รองรับ

SQL / ตัวอย่าง
-- 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;
การรองรับ WHERE: =, !=, <>, >, <, >=, <=, LIKE, NOT LIKE, IN, NOT IN, BETWEEN, NOT BETWEEN, IS NULL, IS NOT NULL, บวกกับ AND / OR การรวมกัน การเปรียบเทียบค่า NULL เป็นไปตามตรรกะ UNKNOWN ตามมาตรฐาน SQL — col = NULL ไม่ตรงกันเลย; ใช้ col IS NULL แทน เป้าหมายการกำหนดที่ไม่รู้จัก การอ้างอิงคอลัมน์ทางขวา และคอลัมน์ตัวกรองจะปฏิเสธการเปลี่ยนแปลงที่สมบูรณ์ก่อนที่จะมีการเปลี่ยนแปลงแถวใดๆ

ดูตัวอย่างความหมายสำหรับ DML ที่สร้างโดย AI

สร้างข้อมูลตัวอย่างในเครื่อง: ในมุมมองข้อมูล (Data View) ให้เลือก สร้างข้อมูลตัวอย่าง, เลือกการตรวจจับอัตโนมัติหรือภาษา SQL, พจนานุกรมชื่อจาก 26 ประเทศหรือภาษาอังกฤษทั่วไป, เปอร์เซ็นต์ของค่าว่างที่เลือกได้, และจำนวนแถวของตาราง และขยายตารางเพื่อปรับแต่งตัวสร้าง, ช่วง, หรือค่าที่อนุญาต ดูตัวอย่างก่อน จากนั้นคัดลอก/ดาวน์โหลด SQL หรือแทรกใหม่ ข้อมูลตัวอย่าง แท็บ ไม่จำเป็นต้องใช้คีย์ AI หรือการร้องขอข้อมูลภายนอก หากคุณแทนที่สคีมาในตัว ให้ปิดใช้งานแท็บ ข้อมูลตัวอย่าง (Sample Data) การพาณิชย์แบบเก่าก่อน การสร้างข้อมูลจะรักษาแถวที่มีอยู่ คัดลอกทูเพิลคีย์นอกที่สมบูรณ์พร้อมความครอบคลุมของพาเรนต์ที่สมดุล และตรวจสอบข้อจำกัดและประเภทสเกลาร์ที่รองรับ ข้อจำกัด CHECK ที่สร้างขึ้นจาก IS NULL / IS NOT NULL, AND, OR และวงเล็บทั้งหมดจะมีลำดับความสำคัญเหนือกว่าเปอร์เซ็นต์ NULL ที่เป็นทางเลือก รวมถึงการอ้างอิงโพสต์/วิดีโอแบบพิเศษ แคตตาล็อกมีรายการในตัวมากกว่า 4,200 รายการ รวมถึงชื่อมากกว่า 2,600 ชื่อที่มีการสะกดแบบดั้งเดิมและแฮนเดิลอีเมลแบบ ASCII บวกกับบริษัท ผลิตภัณฑ์ งาน ถนน คำอธิบายภาษาธรรมชาติ และตัวอย่างสถานที่ในกว่า 40 ประเทศ พร้อมด้วยสกุลเงิน ที่อยู่ IP, SKU, สถานะ, สี, วันที่ และ JSON การประมวลผลแบบกลุ่มรองรับสูงสุด 5,000 แถวต่อตาราง, 10,000 แถวและ 150,000 เซลล์โดยรวม และ SQL ขนาด 5 MB รอบความสัมพันธ์ที่ว่างเปล่าที่จำเป็น, โดเมนที่ไม่ซ้ำกันที่หมดลง, ชื่อตารางที่ซ้ำกันข้ามสคีมา และประเภทที่ซับซ้อนที่จำเป็นซึ่งไม่รองรับ จำเป็นต้องมีการปรับเปลี่ยนก่อนที่การสร้างจะเสร็จสิ้น ค่าที่ซับซ้อนที่สามารถเป็น NULL ได้และการอ้างอิงที่ทำลายรอบสามารถกลายเป็น NULL พร้อมบันทึกตัวอย่างได้ Seeds จะทำซ้ำค่าพจนานุกรมที่สร้างขึ้น; ค่าเริ่มต้นของฐานข้อมูลยังคงเป็นไปตามพฤติกรรมปกติของมัน ให้ตรวจสอบ AI ให้เสร็จสิ้นก่อน และเปิดตัวสร้างอีกครั้งหากพื้นที่ทำงาน SQL เปลี่ยนแปลง

แถวถูกเล่นซ้ำตั้งแต่ต้น

คำสั่ง DDL และ DML จะถูกนำไปใช้พร้อมกันตามลำดับในซอร์สโค้ด คำสั่งข้อมูลแต่ละรายการจะใช้สคีมาที่ใช้งานจริง ณ จุดนั้น

ประเภทข้อมูลยังคงสามารถตรวจสอบได้

Enum และประเภทข้อมูลคอมโพสิตที่มีชื่อซึ่งสร้างด้วย CREATE TYPE จะยังคงเป็นส่วนหนึ่งของสคีมาที่ถูกแยกวิเคราะห์

ข้อจำกัดถูกบังคับใช้

PK, FK, NOT NULL, UNIQUE, DEFAULT, CHECK, คอลัมน์ที่สร้างขึ้น และโดเมน enum ส่งผลต่อแถวตัวอย่าง

ข้อผิดพลาดควรจะสามารถแก้ไขได้

เลือกใช้รายการคอลัมน์ที่ชัดเจนและประโยค WHERE ที่เป็นรูปธรรม เพื่อให้การวินิจฉัยสามารถชี้ไปยังตารางหรือคอลัมน์ที่ถูกต้องได้

อย่าขอให้ AI พึ่งพา: แบบสแตนด์อโลน SELECT ชุดผลลัพธ์ในสคีมาหลัก/สคริปต์ DML, ส่วนของกระบวนการที่ไม่รองรับ หรือการเรียกฐานข้อมูลภายนอก CREATE VIEW, CREATE OR REPLACE VIEW, และ MSSQL CREATE OR ALTER VIEW ถูกสร้างขึ้นจาก SELECT ผลลัพธ์สำหรับการแสดงตัวอย่าง; แยกคิวรีแบบเฉพาะกิจที่อ่านได้อย่างเดียวไว้ต่างหาก

ธุรกรรมในมุมมองข้อมูล

มุมมองข้อมูลรองรับ BEGIN, COMMIT, ROLLBACK, SAVEPOINT, ROLLBACK TO และ RELEASE ในการแสดงตัวอย่างในหน่วยความจำ คำสั่งเหล่านี้ส่งผลต่อแถวข้อมูลในการแสดงตัวอย่าง แต่จะไม่บันทึกลงในฐานข้อมูลภายนอก

SQLite, PostgreSQL และ SQL Server จะคง DDL แบบทรานแซกชันไว้ในการแสดงตัวอย่าง DDL ของ MySQL จะคอมมิตทรานแซกชันที่ใช้งานอยู่ PRAGMA foreign_keys ของ SQLite และ SET FOREIGN_KEY_CHECKS ของ MySQL จะส่งผลต่อการตรวจสอบความถูกต้องของ DML ในภายหลัง

ตัวแสดงผล ERD จะเพิกเฉยต่อตัวห่อหุ้มธุรกรรมและแสดงคำสั่งสคีมาตามลำดับแหล่งที่มา ดังนั้นการย้อนกลับธุรกรรมในมุมมองข้อมูลอาจสร้างชุดตารางที่แตกต่างจากแผนภาพ ตรวจสอบแต่ละเวิร์กเบนช์สำหรับพฤติกรรมที่คุณกำลังทดสอบ

SQL / ดูตัวอย่างธุรกรรม
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;
ในตัวอย่างนี้ Data View จะเก็บรายการที่ 1 และ 2 ไว้ รายการที่ 3 จะถูกลบออกโดย ROLLBACK TO ก่อน COMMIT ส่วน Query View จะอ่านแถวตัวอย่างสุดท้ายเหล่านั้น

ไวยากรณ์ คิวรี SELECT

ขอให้ AI เก็บข้อมูลคิวรีรายงานแบบอ่านอย่างเดียวไว้เป็น SELECT คำสั่ง สิ่งเหล่านี้สามารถอ้างอิงตารางและแถวที่สร้างจากสคีมา/สคริปต์ DML และมีประโยชน์สำหรับการรวม (join), ตัวกรอง, ผลรวม และชุดผลลัพธ์ในรูปแบบรายงานโดยไม่ต้องใช้ฐานข้อมูลจริง

รูปแบบคิวรีที่รองรับ

SQL / ตัวอย่าง
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;

SELECT เท่านั้น

ตัวแก้ไขคิวรีจะยอมรับคำสั่ง SELECT รวมถึง SELECT ที่ไม่มี FROM และ WITH CTEs ที่แก้ไขเป็น SELECT

การเชื่อมต่อและตัวกรอง

INNER, LEFT, RIGHT, FULL และ CROSS joins, เงื่อนไข WHERE, EXISTS, IN subqueries, BETWEEN, LIKE, ILIKE และการตรวจสอบ NULL

Aggregates

GROUP BY, HAVING, COUNT, SUM, AVG, MIN, MAX, ARRAY_AGG, GROUP_CONCAT, STRING_AGG และตัวแปร DISTINCT

การจัดลำดับและการแบ่งหน้า

ORDER BY ตามชื่อหรือลำดับ, ASC/DESC, NULLS FIRST/LAST, LIMIT/OFFSET, TOP และ FETCH FIRST

รองรับ SELECT ขั้นสูง

CTEs และตารางที่ได้มาจากคิวรี

รองรับคำสั่ง WITH, SELECT ที่ซ้อนกันใน FROM, สเกลาร์ซับคิวรี, EXISTS, NOT EXISTS, IN และ NOT IN

ตั้งค่าตัวดำเนินการ

UNION, UNION ALL, INTERSECT และ EXCEPT สามารถรวมชุดผลลัพธ์ที่เข้ากันได้

Window functions

ROW_NUMBER, RANK, DENSE_RANK, NTILE, LAG, LEAD, FIRST_VALUE และ LAST_VALUE พร้อมด้วย OVER และ PARTITION BY หน้าต่างที่มีการจัดลำดับจะใช้เฟรมเริ่มต้นของ SQL ที่รับรู้ peer และ NTILE จะกำหนดกลุ่มที่มีขนาดใหญ่กว่าก่อน

ตัวช่วยภาษาถิ่น

ฟังก์ชันทั่วไปของ SQLite, PostgreSQL, MySQL และ MSSQL ได้รับการปรับให้เป็นมาตรฐานสำหรับการแสดงตัวอย่าง รวมถึงตัวช่วย JSON และวันที่/สตริง

ออกแบบมาให้อ่านได้อย่างเดียว: เก็บ INSERT, UPDATE, DELETE, CREATE, ALTER, และ DROP คำสั่งในสคีมา/สคริปต์ DML ไวยากรณ์ของคิวรีควรคงไว้ SELECT-เท่านั้น

การวินิจฉัยและข้อผิดพลาด

การวินิจฉัยไวยากรณ์จะแสดงปัญหาการแยกวิเคราะห์สคีมา การดำเนินการ DDL/DML และปัญหา SELECT แบบอ่านอย่างเดียวพร้อมข้อความที่ชัดเจน ข้อผิดพลาดในการแยกวิเคราะห์จะรวมตำแหน่งบรรทัด/คอลัมน์เมื่อเป็นไปได้ และข้อความการดำเนินการจะชี้กลับไปยังตาราง คอลัมน์ หรือรูปทรงของคำสั่งที่จำเป็นต้องแก้ไข

ข้อผิดพลาดในการแยกวิเคราะห์สคีมา

ตัวแยกวิเคราะห์สคีมา (SQLite, PostgreSQL, MySQL และ MSSQL) จะรายงานปัญหาด้วยระดับความรุนแรงสองระดับ: ข้อผิดพลาด หยุดคำสั่งเดียวจากการมีส่วนร่วมในสคีมา; คำเตือน ยังคงไวยากรณ์ที่ถูกต้องไว้ แต่จะแจ้งเตือนสิ่งที่ผู้ใช้ควรทราบ

SQL / ตัวอย่าง
// 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
}

ข้อผิดพลาดของตัวแยกวิเคราะห์

รายการคอลัมน์ PRIMARY KEY / UNIQUE / FOREIGN KEY ที่ว่างเปล่า, ขาดประเภทข้อมูลที่จำเป็น (รวมถึงคอลัมน์ SQLite STRICT), วงเล็บที่ไม่ตรงกัน, จุลภาคที่ไม่คาดคิด และข้อจำกัดที่ผิดรูปแบบ

คำเตือนของ Tokenizer

สตริงที่ไม่ได้ปิด, บล็อกคอมเมนต์ที่ไม่ได้ปิด, วงเล็บที่ไม่ตรงกัน และนิพจน์ CHECK ข้ามบรรทัดที่น่าสงสัย

คำเตือนเกี่ยวกับ Foreign-key

FK ที่ชี้ไปยังตารางที่ไม่รู้จัก, คอลัมน์ที่ไม่รู้จัก, ลีฟสคีมาที่คลุมเครือ หรือเป้าหมายที่ไม่ใช่ PK/ไม่ใช่ UNIQUE จะถูกลบออกจากแผนภาพพร้อมคำเตือนที่อธิบายรายละเอียด

การวินิจฉัยแบบจัดกลุ่ม

คำเตือนจะถูกจัดกลุ่มตามสาเหตุ รวมถึงความสัมพันธ์ที่ถูกลบ, ตารางที่ไม่รู้จัก, คอลัมน์ที่ไม่รู้จัก, เป้าหมาย FK ที่ไม่ซ้ำกัน, คำเตือน และข้อผิดพลาดในการแยกวิเคราะห์

SQL ว่างเปล่า

อินพุตว่างเปล่าถือว่าถูกต้องและสร้างสคีมาว่างเปล่า เฉพาะอินพุตที่ไม่ใช่สตริงที่ไม่ถูกต้องเท่านั้นที่จะเกิดข้อผิดพลาด

บันทึกการดำเนินการ DDL/DML

คำสั่ง DDL หรือ DML ทุกคำสั่งที่ดำเนินการจะเพิ่มรายการที่มีโครงสร้างหนึ่งรายการลงในบันทึกการดำเนินการในหน่วยความจำ สตรีมข้อความจะรักษาลำดับเหตุการณ์และจัดประเภทแต่ละคำสั่งเป็น ข้อผิดพลาด, คำเตือน, หรือ สำเร็จ.

SQL / ตัวอย่าง
// Each log entry is:
{
  type:      "success" | "warning" | "error",
  message:   "Inserted 3 row(s) into \"users\"",
  timestamp: 1734567890123  // ms since epoch, monotonic
}
SQL / ตัวอย่าง
-- 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
ดำเนินการได้เสมอ ข้อผิดพลาดและคำเตือนทุกรายการจะอ้างอิงชื่อตาราง/คอลัมน์ที่เป็นปัญหา เพื่อให้คุณสามารถระบุปัญหาได้โดยไม่ต้องอ่านสคริปต์ซ้ำ

การวินิจฉัยทั่วไป

SQL / ตัวอย่าง
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.
ทนทานต่อการขัดข้อง การแยกวิเคราะห์สคีมา การดำเนินการ DDL/DML และการดำเนินการ SELECT จะกู้คืน SQL ที่ผิดรูปแบบให้เป็นข้อผิดพลาดที่มองเห็นได้ เพื่อให้คุณสามารถปรับปรุงสคริปต์เดิมต่อไปได้

CREATE TYPE

กำหนดประเภทข้อมูลที่กำหนดเองเพื่อนำกลับมาใช้ใหม่ทั่วทั้งสคีมาฐานข้อมูลของคุณ ประเภท enum และคอมโพสิตที่มีชื่อควรปรากฏก่อนตารางที่อ้างอิงถึงประเภทเหล่านั้น รวมถึงการอ้างอิงที่มีการระบุสคีมา

1.1. ประเภทคอมโพสิต

กำหนดประเภทคอมโพสิตที่กำหนดเองพร้อมฟิลด์หลายฟิลด์ที่มีประเภทข้อมูลหลากหลาย

SQL / ตัวอย่าง
CREATE TYPE type_name AS (
  field1 data_type1,
  field2 data_type2,
  ...
);

ตัวอย่าง:

SQL / ตัวอย่าง
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)
);
ประเภทข้อมูลที่รองรับ: 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 และอื่นๆ

1.2. ประเภท Enum

สร้างประเภทที่แจกแจงได้ (enumerated types) พร้อมค่าที่กำหนดไว้ล่วงหน้าเพื่อความสมบูรณ์ของข้อมูลและความสามารถในการอ่านที่ดีขึ้น

SQL / ตัวอย่าง
CREATE TYPE enum_name AS ENUM (
  'value1',
  'value2',
  ...
);

ตัวอย่าง:

SQL / ตัวอย่าง
CREATE TYPE status_enum AS ENUM (
  'pending',
  'active',
  'completed',
  'cancelled'
);

CREATE TYPE priority_level AS ENUM (
  'low', 'medium', 'high', 'critical'
);
สำคัญ: ค่า Enum ต้องอยู่ในเครื่องหมายคำพูดเดี่ยว ('value') ไม่ใช่เครื่องหมายคำพูดคู่

1.3. ประเภทที่มีคุณสมบัติครบถ้วนตามสคีมา

ประเภทข้อมูลที่ผู้ใช้กำหนดจะถูกแก้ไขด้วยการรับรู้สคีมาเช่นเดียวกับตาราง หากสองสคีมากำหนดชื่อใบเดียวกัน ERD จะแยกความแตกต่างไว้ หากประเภทข้อมูลนั้นไม่ซ้ำกัน ชื่อที่แสดงจะยังคงเรียบง่าย

SQL / ตัวอย่าง
CREATE TYPE s1.status AS ENUM ('draft', 'active');
CREATE TYPE s2.status AS ENUM ('queued', 'done');

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

CREATE TABLE s2.items (
  id    INT PRIMARY KEY,
  state s2.status
);
กฎการแก้ไข: s1.status ไม่เคยแก้ไขไปเป็น s2.status เพียงเพราะทั้งคู่ใช้ชื่อ leaf เหมือนกัน status. ชื่อประเภทที่มีคุณสมบัติครบถ้วน (Qualified type names) จะเข้มงวด ในขณะที่ชื่อที่ไม่มีคุณสมบัติจะแก้ไขได้ก็ต่อเมื่อไม่มีความคลุมเครือเท่านั้น

CREATE TABLE

กำหนดตารางฐานข้อมูลพร้อมคอลัมน์ ประเภทข้อมูล และข้อจำกัด

2.1. โครงสร้างตารางพื้นฐาน

ไวยากรณ์ทั่วไปสำหรับการสร้างตาราง:

SQL / ตัวอย่าง
CREATE TABLE table_name (
  column_name data_type [constraints],
  ...
  -- table-level constraints (optional)
);

-- Also supports:
CREATE TABLE IF NOT EXISTS table_name ( ... );
CREATE TABLE schema_name.table_name ( ... );
หมายเหตุ: ชื่อตารางและคอลัมน์สามารถใช้เครื่องหมายคำพูดคู่ ("name"), เครื่องหมายแบ็กทิก (\`name\`), หรือวงเล็บเหลี่ยม ([name]) สำหรับการหลีกอักขระพิเศษหรือคำสงวน

2.2. คำจำกัดความระดับคอลัมน์

แต่ละคอลัมน์สามารถรวมข้อจำกัดและคุณสมบัติต่างๆ ได้:

SQL / ตัวอย่าง
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

ระบุแต่ละแถวอย่างไม่ซ้ำกัน

UNIQUE

ตรวจสอบให้แน่ใจว่าค่าในคอลัมน์มีความแตกต่างกัน

NOT NULL

ป้องกันค่าว่าง

DEFAULT

ตั้งค่าเริ่มต้น (ค่าคงที่หรือฟังก์ชัน)

CHECK

ตรวจสอบความถูกต้องของข้อมูลด้วยนิพจน์บูลีน

REFERENCES

สร้างความสัมพันธ์คีย์นอก (foreign key)

การรองรับค่า DEFAULT:
  • ค่าตัวอักษร: ตัวเลข (123), สตริง ('text')
  • ฟังก์ชันของ PostgreSQL: now(), CURRENT_TIMESTAMP, CURRENT_DATE, nextval('seq'::regclass)
  • ฟังก์ชันของ MSSQL: GETDATE(), NEWID()
REFERENCES (อินไลน์): รับรู้ REFERENCES table(column), ที่มีสคีมากำกับ REFERENCES schema.table(column), คอลัมน์เป้าหมายที่ละไว้ เช่น REFERENCES departments, และการดำเนินการ FK เช่น ON DELETE CASCADE, ON UPDATE SET NULL, MATCH FULL, และ DEFERRABLE INITIALLY DEFERRED.

2.3. คอลัมน์ที่สร้างขึ้น / คำนวณได้

ข้อมูลอ้างอิงด่วน ดูที่ คอลัมน์ที่คำนวณได้ ส่วนด้านล่างสำหรับการแจกแจงรายละเอียดตามภาษา SQL รวมถึงรูปแบบ MSSQL bare-AS

SQL / ตัวอย่าง
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. ประเภท ENUM แบบอินไลน์

คุณสามารถประกาศ ENUM โดยตรงในคำจำกัดความของคอลัมน์ (สไตล์ MySQL) ตัวแยกวิเคราะห์จะลงทะเบียนเป็น enum ที่มีชื่อและแทนที่ประเภทคอลัมน์โดยอัตโนมัติ

SQL / ตัวอย่าง
CREATE TABLE tasks (
  id INTEGER PRIMARY KEY,
  status ENUM('todo', 'doing', 'done'),
  priority ENUM('low', 'medium', 'high')
);
วิธีการทำงาน: ENUM แบบอินไลน์จะถูกลงทะเบียนโดยอัตโนมัติเป็นประเภทที่มีชื่อ ชื่ออย่างง่ายชื่อแรกจะใช้ column_enum (ตัวอย่างเช่น, status_enum); ตารางในภายหลังที่มีคำจำกัดความต่างกันสำหรับชื่อคอลัมน์เดียวกันจะได้รับชื่อที่ระบุตาราง เช่น tasks_status_enum เพื่อไม่ให้โดเมนยุบรวมกันโดยไม่ได้ตั้งใจ
เคล็ดลับ: หากคุณต้องการ enum ที่ใช้ร่วมกันหรือชื่อที่กำหนดเอง ให้กำหนดไว้อย่างชัดเจนด้วย CREATE TYPE ... AS ENUM แทน

2.5. ข้อจำกัดระดับตาราง

กำหนดข้อจำกัดที่ส่วนท้ายของเนื้อหาตาราง มีประโยชน์สำหรับคีย์ผสมและข้อจำกัดหลายคอลัมน์:

SQL / ตัวอย่าง
-- 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)

ตัวอย่าง:

SQL / ตัวอย่าง
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)
);
ข้อจำกัดที่รองรับ: PRIMARY KEY, FOREIGN KEY, UNIQUE และ CHECK ทั้งหมดได้รับการสนับสนุนที่ระดับตาราง ชื่อข้อจำกัด (CONSTRAINT name) เป็นทางเลือก
ความถูกต้องของ Foreign-key: If REFERENCES ref_table ละรายการคอลัมน์เป้าหมาย Erd Go จะแก้ไขไปที่คีย์หลักของตารางที่อ้างอิง รวมถึงคีย์หลักแบบผสม หากคุณระบุคอลัมน์เป้าหมายอย่างชัดเจน คอลัมน์เหล่านั้นจะต้องได้รับการสนับสนุนโดย PRIMARY KEY, ข้อกำหนด UNIQUE หรือ global CREATE UNIQUE INDEX; ดัชนีเฉพาะแบบกรอง / บางส่วน ไม่นับเป็นเป้าหมาย FK ความสัมพันธ์ที่ไม่ถูกต้องจะถูกลบออกพร้อมคำเตือน

2.6. ชื่อคอลัมน์ที่เป็นคำสงวน

คำต่างๆ เช่น key, index, value, และ name ถูกสงวนไว้ในบางภาษาแต่ใช้เป็นชื่อคอลัมน์ในภาษาอื่น ตัวแยกวิเคราะห์จะแยกความแตกต่างโดยอัตโนมัติเมื่อโทเค็นถัดไปเป็นประเภทข้อมูลที่รู้จัก ดังนั้นการใช้แบบเปล่าโดยไม่ใส่เครื่องหมายคำพูดจึงใช้งานได้:

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

-- The MySQL "KEY ... (cols)" index form is still recognized correctly
CREATE TABLE posts (
  id   INT PRIMARY KEY,
  body TEXT,
  KEY idx_body (body),                 -- treated as index, adds IDX badge
  FULLTEXT KEY ft_body (body)          -- treated as fulltext index badge
);
กฎการขจัดความกำกวม: KEY / INDEX / FULLTEXT / SPATIAL ตามด้วยคำสำคัญของประเภทข้อมูล (VARCHAR, INT, …) คือ คอลัมน์. ตามด้วยตัวระบุและรายการคอลัมน์ในวงเล็บ มันคือ ดัชนี (index). เพื่อความปลอดภัยสูงสุด ให้ใส่เครื่องหมายคำพูดที่คอลัมน์ด้วย "key", `key`, หรือ [key].

คอลัมน์ Identity / Auto-Increment

ใช้ไวยากรณ์ identity แบบเนทีฟสำหรับภาษาที่เลือก รูปแบบที่รองรับทั้งหมดจะสร้างคอลัมน์คีย์หลักพร้อมกับ AUTO_INCREMENT ตัวทำเครื่องหมาย แต่ SQLite มีกฎที่เข้มงวดหนึ่งข้อคือ: AUTOINCREMENT ต้องการเพียงหนึ่งเดียว INTEGER PRIMARY KEY คอลัมน์

SQLite

SQL / ตัวอย่าง
-- 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
กฎของ SQLite: ใช้ INTEGER PRIMARY KEY AUTOINCREMENT. ห้ามใช้ BIGINT, INT, หรือคีย์หลักแบบผสมที่มี AUTOINCREMENT.

PostgreSQL

SQL / ตัวอย่าง
-- Classic SERIAL family
CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  big_id BIGSERIAL,
  small_id SMALLSERIAL
);

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

CREATE TABLE invoices (
  id BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY
);
สำคัญ: GENERATED ALWAYS AS IDENTITY คือ identity คอลัมน์ (เพิ่มค่าอัตโนมัติ) ซึ่งแตกต่างจาก GENERATED ALWAYS AS (expression) ซึ่งเป็น ที่คำนวณได้ คอลัมน์ ตัวแยกวิเคราะห์จะแยกคอลัมน์เหล่านั้นออกจากกันโดยอัตโนมัติ

MySQL

SQL / ตัวอย่าง
CREATE TABLE users (
  id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
  email VARCHAR(255) NOT NULL UNIQUE
) ENGINE=InnoDB;

MSSQL / SQL Server

SQL / ตัวอย่าง
-- 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
);
ผลลัพธ์ ERD: ทุกรูปแบบด้านบนจะแสดงเหมือนกันในแผนภาพ — ไอคอนกุญแจ PK บวกกับ AUTO_INCREMENT แท็ก — เพื่อให้คุณสามารถผสมภาษาต่างๆ ในสคีมาเดียวได้โดยไม่สูญเสียคำแนะนำการเพิ่มค่าอัตโนมัติ

คอลัมน์ที่คำนวณได้ (ตามภาษา SQL)

คอลัมน์ที่คำนวณได้ (Computed column) จะได้รับค่ามาจากนิพจน์ที่คำนวณจากคอลัมน์อื่นในแถวเดียวกัน รองรับในทั้งสี่ภาษา (dialects) ด้วยไวยากรณ์เฉพาะของแต่ละภาษา

PostgreSQL & MySQL — GENERATED ALWAYS AS

SQL / ตัวอย่าง
CREATE TABLE products (
  id SERIAL PRIMARY KEY,
  price NUMERIC(10,2),
  qty INTEGER,
  total NUMERIC GENERATED ALWAYS AS (price * qty) STORED,
  discount NUMERIC GENERATED ALWAYS AS (price * 0.1) VIRTUAL
);

-- Complex expressions, including CASE
CREATE TABLE orders (
  id BIGSERIAL PRIMARY KEY,
  qty INT,
  flag INT GENERATED ALWAYS AS (CASE WHEN qty > 100 THEN 1 ELSE 0 END) STORED
);
โหมดฐานข้อมูล: ในฐานข้อมูลดั้งเดิม, STORED จัดเก็บค่าที่คำนวณได้และ VIRTUAL คำนวณค่าเมื่ออ่าน Erd Go จะเก็บค่าตัวอย่างไว้ในหน่วยความจำ แผนภาพคลาส (ERD) จะรักษาแต่ละโหมดไว้เป็นเมทาดาตาของคอลัมน์

MSSQL / SQL Server — คอลัมน์ในรูปแบบนิพจน์ [PERSISTED]

MSSQL มีไวยากรณ์เฉพาะของตนเอง: column_name AS expression, ตามด้วยตัวเลือก PERSISTED (และทางเลือกคือ NOT NULL). ทั้ง ในวงเล็บ และ เปล่า รองรับรูปแบบนิพจน์

SQL / ตัวอย่าง
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
);
Bare AS: ตัวแยกวิเคราะห์ยอมรับ col AS expression (ไม่มีวงเล็บล้อมรอบ) — รวมถึงการเรียกใช้ฟังก์ชันเช่น DATEADD(...), การอ้างอิงที่มีตารางกำกับ เช่น c.GrowthDurationDays, และ CASE นิพจน์ — สิ้นสุดที่เครื่องหมายจุลภาคของคอลัมน์ถัดไป PERSISTED, หรือจุดสิ้นสุดของเนื้อหาตาราง
ผลลัพธ์ ERD: แสดงคอลัมน์ที่คำนวณได้ทั้งหมด COMPUTED เป็นประเภทและนิพจน์ที่เก็บรักษาไว้ในส่วนเสริมคอลัมน์ / คำแนะนำเครื่องมือ

ALTER TABLE

รูปแบบการย้ายข้อมูลทั่วไป ALTER TABLE คำสั่งจะถูกเล่นซ้ำหลังจากสร้างตาราง ดังนั้นสคีมาสุดท้ายจะสะท้อนถึงคอลัมน์ที่เพิ่มเข้ามา, ข้อจำกัด, การเปลี่ยนชื่อ, คอลัมน์ที่ถูกลบ และการเปลี่ยนแปลงประเภทคอลัมน์/ค่าว่าง ไวยากรณ์การดัมพ์ของ PostgreSQL โดยใช้ ALTER TABLE ONLY รักษาเอกลักษณ์ของตารางที่มีคุณสมบัติครบถ้วนไว้

เพิ่ม & กำหนดเงื่อนไข

ADD COLUMN, ADD PRIMARY KEY, ADD UNIQUE, ADD CHECK และ ADD FOREIGN KEY จะแสดงอยู่ใน ERD

เปลี่ยนชื่อและลบ

การเปลี่ยนชื่อตาราง คอลัมน์ ข้อจำกัด และดัชนี รวมถึง MySQL RENAME TABLE, PostgreSQL ALTER INDEX และ SQL Server sp_rename จะยังคงผูกอยู่กับออบเจกต์ที่ถูกต้องก่อนการดำเนินการ DROP ในภายหลัง

การเปลี่ยนแปลงคอลัมน์

PostgreSQL ALTER COLUMN TYPE/SET DATA TYPE/SET หรือ DROP DEFAULT/nullability, MSSQL ALTER COLUMN และ MySQL MODIFY/CHANGE COLUMN จะถูกเล่นซ้ำ

ความปลอดภัยของความสัมพันธ์

Foreign keys จะถูกตรวจสอบกับสถานะตารางสุดท้ายหลังจากรีเพลย์การย้ายข้อมูล รวมถึงการเปลี่ยนแปลง PK/UQ/index และจำนวนคอลัมน์ต้นทาง/ปลายทางที่แน่นอน

3.1. เพิ่มคีย์นอก

SQL / ตัวอย่าง
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];

ตัวอย่าง:

SQL / ตัวอย่าง
ALTER TABLE orders
  ADD CONSTRAINT fk_orders_customer
  FOREIGN KEY (customer_id)
  REFERENCES customers(id)
  ON DELETE CASCADE;

3.2. เพิ่มคีย์หลัก

SQL / ตัวอย่าง
ALTER TABLE table_name
  ADD [CONSTRAINT name] PRIMARY KEY (cols...);

ตัวอย่าง:

SQL / ตัวอย่าง
ALTER TABLE products
  ADD CONSTRAINT pk_products
  PRIMARY KEY (product_id);

3.3. เพิ่มข้อจำกัดที่ไม่ซ้ำกัน

SQL / ตัวอย่าง
ALTER TABLE table_name
  ADD [CONSTRAINT name] UNIQUE (cols...);

ตัวอย่าง:

SQL / ตัวอย่าง
ALTER TABLE users
  ADD CONSTRAINT uq_users_email
  UNIQUE (email);

3.4. เพิ่มข้อจำกัดการตรวจสอบ

SQL / ตัวอย่าง
ALTER TABLE table_name
  ADD [CONSTRAINT name] CHECK (expression);

ตัวอย่าง:

SQL / ตัวอย่าง
ALTER TABLE employees
  ADD CONSTRAINT chk_salary
  CHECK (salary >= 0);

3.5. ตัวอย่างการเล่นซ้ำการย้ายข้อมูล

SQL / ตัวอย่าง
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);
สิ่งที่ ERD ทำ: คีย์นอกของ contact จะเชื่อมโยงไปยังคีย์หลักแบบผสมบน app.accounts, owner_email กลายเป็น contact_email, audit_state ถูกลบออก และดัชนีเฉพาะให้ contact_email a UQ ป้ายกำกับ

3.6. MySQL CHANGE / MODIFY COLUMN

SQL / ตัวอย่าง
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 / ตัวอย่าง
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';
ขอบเขตของไวยากรณ์: การเล่นซ้ำการย้ายข้อมูล SQL เป็น ERD นั้นมีความสมบูรณ์มากกว่าการดำเนินการ Data View โดยเจตนา การแยกวิเคราะห์แผนภาพสุดท้ายยังคงทำได้ในเบราว์เซอร์เท่านั้นและไม่จำเป็นต้องมีการเชื่อมต่อฐานข้อมูล คำสั่งที่รองรับเฉพาะการดำเนินการจะไม่ทำให้โมเดลวงจรชีวิต ERD อ่อนแอลง

CREATE INDEX

Index DDL ถูกแยกวิเคราะห์ในทั้งสี่ภาษา คีย์คอลัมน์แบบง่ายจะแสดงเป็นป้ายกำกับ ERD ขนาดเล็ก: IDX สำหรับการเพิ่มความเร็วที่ไม่ซ้ำกัน UQ สำหรับดัชนีที่ไม่ซ้ำกันทั่วโลก และ PUQ สำหรับดัชนีที่ไม่ซ้ำกันแบบกรอง / บางส่วน รายการนิพจน์จะถูกเก็บไว้ในผลลัพธ์ของตัวแยกวิเคราะห์และรายงานเมื่อไม่สามารถแมปกับป้ายคอลัมน์ได้อย่างถูกต้อง

ป้าย IDX

ดัชนีที่ไม่ซ้ำกัน (Non-unique index) จะแสดงเป็นเม็ดยาสีทึบบนคอลัมน์ ดัชนีแบบผสมจะทำให้เม็ดยากลายเป็นสีเทาบนคอลัมน์คีย์ทุกคอลัมน์ เพื่อให้เห็นความแตกต่างระหว่างคอลัมน์เดียวกับหลายคอลัมน์ได้อย่างชัดเจนในทันที

ป้ายกำกับ UQ

จาก CREATE UNIQUE INDEX ทั่วโลก ทำงานเหมือนข้อจำกัด UNIQUE สำหรับการตรวจสอบ FK และการติดป้ายคอลัมน์

ป้าย PUQ

จาก CREATE UNIQUE INDEX ... WHERE แสดงเงื่อนไขความเป็นเอกลักษณ์บางส่วน แต่ไม่ได้ตรวจสอบเป้าหมาย FK ว่าเป็นเอกลักษณ์ทั่วโลกหรือไม่

กฎการระงับ

ข้อจำกัดที่แข็งแกร่งกว่าจะเป็นฝ่ายชนะ: PK ⟶ UQ ⟶ PUQ ⟶ IDX คีย์ที่แข็งแกร่งกว่าจะไม่ถูกลดระดับโดยดัชนีที่ตามมา

หลายภาษา SQL

PostgreSQL CONCURRENTLY / USING / INCLUDE / WHERE, MySQL FULLTEXT/SPATIAL & inline KEY/INDEX, MSSQL CLUSTERED/NONCLUSTERED พร้อม INCLUDE, ดัชนีมาตรฐานของ SQLite

4.1. ไวยากรณ์

SQL / ตัวอย่าง
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. ตัวอย่าง

เพิ่มความเร็วในการค้นหา FK ที่พบบ่อย (IDX คอลัมน์เดียว):

SQL / ตัวอย่าง
CREATE INDEX idx_orders_customer ON orders (customer_id);

ดัชนีแบบคอมโพสิต (IDX แบบจางบนทุกคอลัมน์คีย์):

SQL / ตัวอย่าง
CREATE INDEX idx_orders_customer_status
  ON orders (customer_id, status);

เลื่อนระดับคอลัมน์เป็น UNIQUE โดยไม่ต้องเปลี่ยนคำจำกัดความ:

SQL / ตัวอย่าง
CREATE UNIQUE INDEX uq_shipments_tracking
  ON shipments (tracking_number);

ดัชนีเฉพาะบางส่วน / กรองแล้ว (PUQ ไม่ใช่เป้าหมาย FK ทั่วโลก):

SQL / ตัวอย่าง
CREATE UNIQUE INDEX ux_users_active_email
  ON users (email)
  WHERE deleted_at IS NULL;

ดัชนีแบบอินไลน์ของ MySQL ภายใน CREATE TABLE:

SQL / ตัวอย่าง
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 แบบกรองข้อมูล + ดัชนี INCLUDE:

SQL / ตัวอย่าง
CREATE NONCLUSTERED INDEX idx_active_orders
  ON orders (customer_id)
  INCLUDE (total)
  WHERE status = 'active';

4.3. พฤติกรรม & ความหมาย

  • ดัชนีฟังก์ชัน / นิพจน์ (เช่น CREATE INDEX … ON t (lower(email))) จะถูกเก็บไว้และสร้างคำเตือนที่ชัดเจน แต่ ไม่มีป้ายกำกับ — มันไม่สามารถแมปเข้ากับคอลัมน์เดียวได้อย่างชัดเจน
  • คอลัมน์ INCLUDE (คอลัมน์ที่ครอบคลุม) จะถูกแยกวิเคราะห์แต่จะไม่ถูกติดป้าย — มีเพียงคอลัมน์ที่เป็นคีย์เท่านั้นที่จะได้รับป้าย
  • คอลัมน์ PK / UQ เป็นการรับประกันที่แข็งแกร่งกว่า IDX ดังนั้นในภายหลัง CREATE INDEX บนพวกมันจะถูกข้ามไปโดยเงียบๆ — คุณจะไม่เห็นพิลล์ (pills) ที่ซ้ำซ้อน
  • ดัชนีเฉพาะบางส่วน / กรองแล้ว แสดงผลเป็น PUQ ด้วย WHERE เพรดิเคตในรายละเอียดคอลัมน์ สิ่งเหล่านี้ไม่ได้รับการยอมรับว่าเป็นเป้าหมายที่ไม่ซ้ำกันทั่วโลกสำหรับการตรวจสอบคีย์นอก
  • ป้ายกำกับสุดท้ายไม่ขึ้นอยู่กับลำดับ: การรับประกันความเป็นเอกลักษณ์ทั่วโลกจะระงับสิ่งที่ซ้ำซ้อน IDX ป้ายกำกับว่าดัชนีแบบไม่ซ้ำหรือแบบซ้ำปรากฏขึ้นก่อน เมทาดาตาของดัชนีแบบผสมจะถูกเก็บไว้เช่นเดียวกันโดยไม่คำนึงถึงลำดับการประกาศ
  • ดัชนีบนตาราง / คอลัมน์ที่ไม่รู้จัก จะถูกละทิ้งอย่างเงียบๆ — มีประโยชน์เมื่อย้ายสคีมาบางส่วนโดยไม่ทำให้แผนภาพเสียหาย
  • วงจรชีวิตของดัชนี รวมถึงระดับบนสุด CREATE/DROP INDEX, PostgreSQL DROP INDEX CONCURRENTLY, MySQL ALTER TABLE … ADD/DROP/RENAME INDEX, PostgreSQL ALTER INDEX … RENAME, และการเปลี่ยนชื่อดัชนี SQL Server ผ่าน sp_rename. เมทาดาตา UQ/PUQ/IDX ที่ตั้งชื่อไว้จะตามหลังชื่อสุดท้ายที่ยังคงอยู่
เคล็ดลับ: IDX แบบคอมโพสิตจะแสดงเป็นสีเทาจางเพื่อสะท้อนภาษาภาพของ PK แบบคอมโพสิต / UQ แบบคอมโพสิตที่มีอยู่เดิม IDX แบบทึบหมายถึง "ดัชนีคอลัมน์เดียว" เสมอ ซึ่งง่ายต่อการกวาดสายตาดูในแผนภาพที่มีความหนาแน่น

รองรับหลายภาษา SQL (Multi-Dialect Support)

ตัวแยกวิเคราะห์ฝั่งเบราว์เซอร์จะจัดการความแตกต่างของไวยากรณ์ระหว่าง SQLite, PostgreSQL, MySQL และ MSSQL โดยไม่ต้องเชื่อมต่อฐานข้อมูล การตรวจจับอัตโนมัติจะใช้สัญญาณไวยากรณ์เชิงโครงสร้างและยังคงเป็นกลางสำหรับอินพุตที่มีหลายภาษาปนกัน ผู้เรียกยังสามารถระบุภาษาที่ต้องการได้อย่างชัดเจน ตัวอย่างด้านล่างเป็นไปตามลำดับมาตรฐานเดียวกัน: SQLite ก่อน ตามด้วย PostgreSQL, MySQL และ MSSQL

4.1. คุณสมบัติของ SQLite

SQL / ตัวอย่าง
-- 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
);
เฉพาะ SQLite: INTEGER PRIMARY KEY (นามแฝง rowid), AUTOINCREMENT, WITHOUT ROWID, STRICT ตาราง, คอลัมน์ที่ไม่มีประเภทและไม่เป็น STRICT, ความสัมพันธ์ของประเภท (INTEGER, TEXT, REAL, NUMERIC, BLOB), datetime('now') / CURRENT_TIMESTAMP ค่าเริ่มต้น และมาตรฐาน REFERENCES ด้วย ON DELETE / ON UPDATE การกระทำ
ความถูกต้องของประเภท: ตาราง SQLite ปกติยอมรับชื่อประเภทที่ประกาศตามอำเภอใจ (เช่น VARCHAR(255), BOOLEAN, หรือ TIMESTAMP) และอาจละประเภทไว้ได้ ตาราง STRICT จะปฏิบัติตามชุดที่อนุญาตที่แน่นอนของ SQLite: INT, INTEGER, REAL, TEXT, BLOB, หรือ ANY; คอลัมน์ STRICT ทุกคอลัมน์ต้องประกาศหนึ่งรายการ

ตัวอย่างการเล่นซ้ำการย้ายข้อมูล SQLite:

SQL / ตัวอย่าง
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. คุณสมบัติของ PostgreSQL

SQL / ตัวอย่าง
-- 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: รองรับประเภท SERIAL, คอลัมน์ identity, JSONB, BYTEA, INET, รูปแบบ timestamp, อาร์เรย์, ประเภทคอมโพสิต และ ENUM UNIQUE NULLS NOT DISTINCT, การคงไว้ซึ่งดัชนีแบบนิพจน์ และเอกลักษณ์ที่คำนึงถึงตัวพิมพ์เล็ก-ใหญ่ของ PostgreSQL สำหรับชื่อที่อยู่ในเครื่องหมายคำพูด

4.3. คุณสมบัติของ MySQL

SQL / ตัวอย่าง
-- 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;
เฉพาะ MySQL: AUTO_INCREMENT, COMMENT, ตัวปรับแต่งที่มีเครื่องหมาย, รูปแบบจำนวนเต็ม/ข้อความ/บล็อบ/เชิงพื้นที่, อินไลน์ ENUM และ SET, ดัชนีแบบอินไลน์, CHANGE COLUMN, MODIFY COLUMN, FIRST/AFTER การจัดวางทางกายภาพ ON UPDATE CURRENT_TIMESTAMP, และตัวเลือกตารางทั่วไป

4.4. คุณสมบัติของ MSSQL / SQL Server

SQL / ตัวอย่าง
-- 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
เฉพาะของ MSSQL: IDENTITY(seed, increment), NVARCHAR(MAX), วันที่/เวลา, ไบนารี, XML, ประเภทตัวระบุและประเภทเชิงพื้นที่, ROWGUIDCOL, ดัชนีแบบคลัสเตอร์, GO ชุดข้อมูล, ALTER COLUMN, คอลัมน์ที่คำนวณได้, ที่ตั้งชื่อ DEFAULT ... FOR column ข้อจำกัด คอลัมน์เวลาที่สร้างขึ้น และ PERIOD FOR SYSTEM_TIME.
คอลัมน์คำนวณแบบ Bare-AS: col AS expression PERSISTED (ไม่มีวงเล็บล้อมรอบ) ได้รับการสนับสนุนอย่างเต็มที่ รวมถึงการเรียกใช้ฟังก์ชัน (DATEADD, LEFT, …), การอ้างอิงคอลัมน์ที่มีตารางกำกับ (c.col), และ CASE นิพจน์

4.5. รูปแบบการอ้างอิงตัวระบุ

รองรับข้อตกลงการใส่เครื่องหมายคำพูดหลักทั้งสามแบบ:

SQL / ตัวอย่าง
-- 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
);

บันทึกย่อและเคล็ดลับ

รายละเอียดการรองรับไวยากรณ์ที่สำคัญ: สิ่งที่มีผลต่อโครงสร้างสคีมา, DDL/DML ใดที่สามารถเล่นซ้ำได้ด้วยแถวตัวอย่าง, คิวรี SELECT ใดที่สามารถอ่านได้ และขีดจำกัดอยู่ที่ตรงไหน

✓ การรองรับไวยากรณ์ Schema / ERD

  • หลายภาษา SQL: ไวยากรณ์ SQLite, PostgreSQL, MySQL และ MSSQL สามารถใช้สคริปต์ร่วมกันได้ การตรวจจับอัตโนมัติจะยังคงเป็นกลางเมื่อสัญญาณที่ชัดเจนมีความปะปนกันอย่างแท้จริง
  • คำสำคัญที่ไม่คำนึงถึงตัวพิมพ์เล็ก-ใหญ่: CREATE, TABLE, ALTER ฯลฯ สามารถเขียนด้วยตัวพิมพ์ใดก็ได้
  • ตัวระบุที่มีเครื่องหมายคำพูด: เครื่องหมายคำพูดคู่ ("name"), เครื่องหมายแบ็กทิก (`name`), และวงเล็บเหลี่ยม ([name])
  • ชื่อคอลัมน์ที่เป็นคำสงวน: Bare key, index, value, name, order, ฯลฯ จะได้รับการยอมรับเมื่อตามด้วยประเภทข้อมูล
  • ชื่อที่ระบุสคีมา: schema.table และ schema.type (เช่น, public.users, dbo.Orders, app.status_enum) — คำนำหน้าสคีมาบนประเภทที่ผู้ใช้กำหนดจะถูกเก็บไว้สำหรับการค้นหาที่เข้มงวดและทำให้ง่ายขึ้นสำหรับการแสดงผลเมื่อไม่มีความคลุมเครือเท่านั้น
  • ความคิดเห็น: บรรทัดเดียว (-- comment) และความคิดเห็นแบบบล็อก (/* comment */) จะถูกข้ามโดยอัตโนมัติ
  • BOM & CRLF: UTF-8 byte-order-mark และการขึ้นบรรทัดใหม่แบบ Windows จะถูกจัดการอย่างโปร่งใส
  • ประเภทที่กำหนดเอง: CREATE TYPE … AS ENUM และ CREATE TYPE … AS (composite), รวมถึงชื่อที่มีสคีมากำกับ
  • ENUM & SET แบบอินไลน์ (MySQL): ENUM('a','b') และ SET('a','b','c') ภายในประเภทคอลัมน์ — ลงทะเบียนอัตโนมัติเป็นประเภทที่มีชื่อและกำหนดเนมสเปซตามตาราง/คอลัมน์ เมื่อชื่อคอลัมน์ซ้ำกันใช้โดเมนที่แตกต่างกัน
  • ข้อจำกัด: ระดับคอลัมน์และระดับตาราง PRIMARY KEY, FOREIGN KEY, UNIQUE, CHECK (รวมถึงรูปแบบหลายคอลัมน์แบบผสม) เป้าหมายของ FK จะถูกตรวจสอบเทียบกับคีย์หลัก, ข้อจำกัดที่ไม่ซ้ำกัน (unique constraints) หรือดัชนีที่ไม่ซ้ำกันทั่วโลก
  • Identity / auto-increment: SERIAL/BIGSERIAL (PG), GENERATED ALWAYS/BY DEFAULT AS IDENTITY (PG), AUTO_INCREMENT (MySQL), IDENTITY(1,1) และแบบเปล่า IDENTITY (MSSQL) — ทั้งหมดจะถูกรวมเข้าด้วยกันในแผนภาพ
  • คอลัมน์ที่คำนวณได้: GENERATED ALWAYS AS (expr) STORED/VIRTUAL (PG/MySQL) และ MSSQL col AS (expr) [PERSISTED] + เปล่า col AS expr [PERSISTED]
  • อาร์เรย์ของ PostgreSQL: type[], ที่กำหนดขนาด type[5], ที่ซ้อนกัน type[][][], และอาร์เรย์ของประเภทข้อมูลที่ผู้ใช้กำหนด (เช่น webhook_event[])
  • ค่าเริ่มต้น: ค่าตัวอักษร, สตริงที่ครอบด้วยเครื่องหมายดอลลาร์, การเรียกใช้ฟังก์ชัน (now(), CURRENT_TIMESTAMP, GETDATE(), NEWID(), NEWSEQUENTIALID(), gen_random_uuid(), nextval()), และ ON UPDATE CURRENT_TIMESTAMP (MySQL)
  • การดำเนินการ FK: ON DELETE / ON UPDATE ด้วย CASCADE, RESTRICT, SET NULL, SET DEFAULT, NO ACTION, บวกกับ MATCH, DEFERRABLE, และ INITIALLY ข้อมูลเมตา (metadata) การดำเนินการจะถูกเก็บรักษาไว้เป็นข้อมูลเมตาของความสัมพันธ์
  • การเล่นซ้ำการย้ายข้อมูล: ALTER TABLE ADD COLUMN, เพิ่ม/ลบ/เปลี่ยนชื่อคีย์และข้อจำกัด, การเปลี่ยนชื่อตาราง/คอลัมน์/ดัชนี, DROP COLUMN, ALTER COLUMN TYPE/SET DATA TYPE, SET/DROP DEFAULT, SET/DROP NOT NULL, MSSQL sp_rename, และ MySQL MODIFY/CHANGE COLUMN
  • ดัชนี: ระดับบนสุด CREATE/DROP INDEX, PostgreSQL ALTER INDEX … RENAME, MySQL เพิ่ม/ลบ/เปลี่ยนชื่อ และแบบอินไลน์ KEY/INDEX/UNIQUE INDEX/FULLTEXT/SPATIAL คำนิยาม ดัชนีที่อิงตามคอลัมน์จะแสดงผลเป็น IDX, UQ, หรือ PUQ ป้ายกำกับ
  • IF NOT EXISTS, IF EXISTS: จัดการได้อย่างราบรื่นทั้งสอง CREATE และ DROP
  • ตัวห่อหุ้มธุรกรรมเฉพาะสคีมา: BEGIN, COMMIT, SET search_path, USE [db] (MSSQL) และ SET FOREIGN_KEY_CHECKS (MySQL) จะถูกข้ามไปอย่างราบรื่น
  • ข้ามไปอย่างราบรื่น: CREATE VIEW, CREATE MATERIALIZED VIEW, CREATE FUNCTION/TRIGGER/SCHEMA/SEQUENCE, เชิงกระบวนการ EXEC คำสั่งอื่นนอกเหนือจาก sp_rename, DECLARE, PRINT, PARTITION BY, INHERITS (รวมถึงเนื้อหาว่าง), WITH OIDS, STORAGE PLAIN, EXCLUDE USING gist, และเนื้อหาคำสั่งที่ไม่ส่งผลต่อโครงสร้าง ERD

✓ ตัวอย่างไวยากรณ์ DDL/DML

  • การดำเนินการจากบนลงล่าง: สคริปต์จะถูกเล่นซ้ำตามลำดับคำสั่ง ดังนั้นข้อมูลตัวอย่างควรมาหลังจากสคีมาที่อ้างอิง
  • คำสั่งที่รองรับ: CREATE TYPE, CREATE TABLE, CREATE VIEW, CREATE INDEX, ALTER TABLE การเปลี่ยนแปลงคอลัมน์/ข้อจำกัด, DROP INDEX, TRUNCATE TABLE, INSERT, UPDATE, DELETE, DROP TABLE, DROP VIEW, และ DROP TYPE
  • ตัวกรอง WHERE: =, !=, <>, >, <, >=, <=, LIKE, IN, NOT IN, NOT LIKE, BETWEEN, NOT BETWEEN, IS NULL, และ IS NOT NULL
  • การทำให้แถวเป็นรูปธรรม: ตารางจะแสดงจำนวนแถว ข้อมูลเมตาของโครงสร้าง และข้อมูลแถวปัจจุบันหลังจากคำสั่ง DML ทำงาน
  • ประเภทข้อมูลที่มีชื่อ: ENUM และประเภทข้อมูลคอมโพสิตที่สร้างด้วย CREATE TYPE จะถูกแสดงแยกต่างหากจากตาราง
  • บันทึกการดำเนินการ: สถานะความสำเร็จ คำเตือน และข้อผิดพลาดจะถูกบันทึกไว้สำหรับคอลัมน์ที่ไม่รู้จัก, ตารางที่หายไป, คีย์ที่ซ้ำกัน, การละเมิด NULL และการอัปเดต/ลบแบบวงกว้าง; การผูกมัดการเปลี่ยนแปลงที่ไม่ถูกต้องจะล้มเหลวก่อนที่แถวจะเปลี่ยน
  • การประเมินค่าเริ่มต้น: ค่าเริ่มต้นแบบตัวอักษรบวกกับฟังก์ชันต่างๆ เช่น now(), CURRENT_TIMESTAMP, CURRENT_DATE, GETDATE(), และ NEWID()

✓ ไวยากรณ์คิวรี SELECT

  • SELECT แบบอ่านอย่างเดียว: SELECT คำสั่งสามารถอ่านตารางในหน่วยความจำที่สร้างจากไฟล์ SQL หลัก
  • ข้อมูลเมตาของผลลัพธ์: คอลัมน์ จำนวนแถว เวลาที่ใช้ การจัดรูปแบบ NULL/บูลีน/ตัวเลข และข้อผิดพลาดของคิวรีจะถูกเก็บรักษาไว้พร้อมกับผลลัพธ์ของ SELECT
  • คิวรีเชิงสัมพันธ์: Joins, ตัวกรอง WHERE, GROUP BY, HAVING, ORDER BY, LIMIT/OFFSET, TOP, FETCH FIRST, CTEs, ตารางที่ได้รับ (derived tables), คิวรีย่อย และตัวดำเนินการเซต
  • ตัวช่วยวิเคราะห์: Aggregates, ฟังก์ชันสเกลาร์ทั่วไป, ตัวช่วย JSON, ฟังก์ชันวันที่/สตริง และฟังก์ชันหน้าต่าง เช่น ROW_NUMBER, RANK, NTILE, FIRST_VALUE, LAST_VALUE, LAG, และ LEAD; เฟรมเริ่มต้นที่เรียงลำดับรวมถึงกลุ่มเพียร์ปัจจุบัน

✗ ยังไม่รองรับ / ข้ามไป

  • ALTER TYPE: ไม่สามารถแก้ไข ENUM หรือประเภทคอมโพสิตที่มีอยู่ได้
  • คำสั่ง LIKE: CREATE TABLE foo (LIKE bar INCLUDING …) ถูกข้ามไปอย่างราบรื่น — คอลัมน์ที่คัดลอกมาจะไม่ถูกสร้างขึ้นจริง
  • การสืบทอดคอลัมน์ INHERITS: เดอะ INHERITS (parent) ตัวประโยคเองสามารถแยกวิเคราะห์ได้โดยไม่มีข้อผิดพลาด แต่คอลัมน์ที่สืบทอดมาจะไม่ถูกดึงเข้ามาในตารางลูกเพื่อวัตถุประสงค์ของแผนภาพคลาส (ERD)
  • การดำเนินการดัชนี: Index DDL สามารถสร้างป้ายกำกับสคีมาได้ แต่การดำเนินการตัวอย่างไม่ได้จำลองเอนจินการจัดเก็บ ตัววางแผนคิวรี หรือประสิทธิภาพของดัชนี
  • ขีดจำกัดของ SELECT: ไวยากรณ์คิวรีแบบอ่านอย่างเดียวไม่รองรับ recursive CTEs, การรันบนฐานข้อมูลภายนอก, สตอร์โปรซีเจอร์ หรือคำสั่งการเปลี่ยนแปลงข้อมูล
  • วัตถุอื่นๆ: ทริกเกอร์, สตอเรจโพรซีเดอร์, ฟังก์ชัน และลำดับ
  • การดำเนินการภายนอก: การแสดงตัวอย่าง DDL/DML ไม่ได้เชื่อมต่อกับฐานข้อมูลจริงหรือบันทึกแถวข้อมูลไว้นอกไฟล์ SQL ปัจจุบัน
พฤติกรรมของไวยากรณ์: DML ไม่ได้มีส่วนช่วยในการสร้างแผนภาพสคีมา คำสั่งวงจรชีวิตของตาราง ประเภท และดัชนีที่มีชื่อจะถูกเล่นซ้ำตามลำดับในซอร์สโค้ด รวมถึงการเปลี่ยนชื่อ การลบ และการสร้างใหม่ในภายหลังโดยไม่มีข้อมูลเมตารั่วไหลระหว่างออบเจกต์ คำสั่ง DDL/DML ที่รองรับจะทำงานในหน่วยความจำจากบนลงล่าง และคิวรี SELECT แบบอ่านอย่างเดียวจะอ่านจากผลลัพธ์ในหน่วยความจำนั้นโดยไม่มีการเปลี่ยนแปลง
แนวปฏิบัติที่ดีที่สุด:
  • จบแต่ละคำสั่งด้วยเครื่องหมายอัฒภาค (;);)
  • กำหนด CREATE TYPE ก่อนตารางที่อ้างอิงถึงตารางเหล่านั้น
  • กำหนด CREATE TABLE ก่อนที่เกี่ยวข้อง INSERT, UPDATE, หรือ DELETE คำสั่ง
  • ใช้ ALTER TABLE สำหรับคีย์นอกเมื่อตารางอ้างอิงซึ่งกันและกัน (การพึ่งพาแบบวงกลม)
  • ใช้ DDL สำหรับโครงสร้างก่อน จากนั้นใช้ DML เพื่อตรวจสอบแถวตัวอย่างและพฤติกรรมของข้อจำกัด (constraint)
  • เก็บข้อมูลตัวอย่างไว้ในไฟล์ SQL เอง เพราะแถวตัวอย่างจะถูกดึงมาจากสคริปต์
การกู้คืนข้อผิดพลาด: คำสั่งที่ไม่รองรับจะถูกข้ามไป และคำเตือน/ข้อผิดพลาดของไวยากรณ์จะแสดงขึ้นพร้อมบริบทที่เพียงพอเพื่อให้ปรับปรุงไฟล์เดิมต่อไปได้แทนที่จะต้องเริ่มใหม่ตั้งแต่ต้น

การปฏิบัติตามรูปแบบไวยากรณ์เหล่านี้ช่วยให้ Erd Go สามารถสร้างสคีมา ERD ของคุณ ดูตัวอย่างข้อมูลในหน่วยความจำ และเรียกใช้คิวรีแบบอ่านอย่างเดียวจากไฟล์ SQL เดียวกันได้

ErdGo.com - แปลง SQL เป็นแผนภาพและดูตัวอย่างข้อมูลได้เร็วขึ้น