סכמת SQL

הכרטיסייה Schema SQL מציגה את ה-DDL של התרשים עבור מסד הנתונים שנבחר: ה-SQL שיוצר את הטבלאות שלו עם המפתחות, האינדקסים והמפתחות הזרים שלהן.
יש לעבור לכרטיסייה Schema SQL בסרגל הכלים, או לבחור ב-Schema SQL תחת Tab בחיפוש המהיר. בחירה ב-Schema SQL בתפריט המשנה Export פותחת אותה גם כן, מוכנה לשמירה – ראו שמירה או העתקה של ה-SQL.

ה-SQL נמצא משמאל, ומימינו חלונית אפשרויות שכותרתה Schema SQL מכילה את הבחירות שקובעות את צורתו – ראו חלונית אפשרויות. גם בשפת תצוגה מימין לשמאל, ה-SQL נשאר משמאל ונקרא משמאל לימין.
החלונית נפתחת מעצמה, אלא אם העורך צר מ-640 px כשהכרטיסייה נפתחת לראשונה. הלחצן Hide options בראש החלונית מכווץ אותה, והלחצן Show options בפינה הימנית העליונה של הקוד מחזיר אותה. לאחר מכן היא נשארת פתוחה או מכווצת כפי שהושארה, גם במעבר בין כרטיסיות, כל עוד העורך פתוח. היא מתכווצת ונפתחת בנפרד מהחלונית של כרטיסיית מחולל קוד, ולעולם אינה נשמרת בקובץ.

לחיצה ימנית על ה-SQL פותחת את תפריט ההקשר שלו:

• Database ו-Bracket, כל אחד מהם תפריט משנה שמסמן את הערך הנוכחי.
• Statements ו-Header, כל אחד מהם תפריט משנה שמסמן את האפשרות שבתוקף. אפשרות שאין במסד הנתונים נושאת הערה עמומה, כגון not in Oracle, ואינה עושה דבר.
• Options panel, שמסומן כל עוד החלונית מוצגת, ושמכווץ או פותח אותה.
• Save file

כל עוד הכרטיסייה הזו פתוחה, החיפוש המהיר מציע את Database ואת Bracket; את Schema SQL: Statements ואת Schema SQL: Header, שמציגים רק את האפשרויות שיש במסד הנתונים; ואת Schema SQL: Options panel, שמכווץ או פותח את החלונית.
תפריט ההקשר והחיפוש המהיר אינם מציעים את Write logical names into empty comments, שנמצא בחלונית האפשרויות בלבד – ראו שמות לוגיים כהערות.

ה-SQL נכתב כשהכרטיסייה נפתחת, ושוב בכל פעם שאחת מהבחירות בחלונית, שם מסד הנתונים או סקריפט משתנה. עריכה שנעשית בטבלאות בזמן שהכרטיסייה פתוחה, כגון עריכה של שותף לעריכה או של סוכן קוד, מוצגת לאחר שיוצאים מהכרטיסייה וחוזרים אליה, או לאחר שאחד מאלה משתנה.

לחלון מאפייני הטבלה יש כרטיסיית Schema SQL משלו, שמציגה את ה-DDL של טבלה אחת. היא תמיד כותבת משפטי CREATE פשוטים, ללא כותרת או סקריפטים, לעולם אינה כותבת שם לוגי בהערה ריקה, אין בה חלונית אפשרויות, ותפריט ההקשר שלה מציע רק את Database ואת Bracket.

חלונית אפשרויות

החלונית מכילה שלוש קבוצות, כל אחת תחת כיתוב:

1. Saved in the document: Database ו-Bracket – ראו מסד נתונים ומירכאות. עורך לקריאה בלבד נותן להם את הכותרת This window only – ראו עורכים לקריאה בלבד.
2. This window only: Statements, Header, Write logical names into empty comments, וכל עוד יש בתרשים קבוצת טבלאות, גם Tables – ראו משפטים, כותרת, שמות לוגיים כהערות וטבלאות.
3. Saved in the document · written as is for every database: הסקריפטים Before tables ו-After tables – ראו סקריפטים לפני הטבלאות ואחריהן.

הלחצנים Save file ו-Copy נמצאים בתחתית החלונית – ראו שמירה או העתקה של ה-SQL.

הבחירות תחת This window only שייכות לחלון העורך שבו הן נעשו. הן אינן נשמרות במסמך, אינן משותפות עם שותפים לעריכה ואינן נרשמות לביטול פעולה, והן מתאפסות כשהעורך נסגר או נטען מחדש; מעבר בין כרטיסיות שומר עליהן.
הערך ההתחלתי של Statements הוא If not exists, של Header הוא CREATE + USE, ו-Write logical names into empty comments כבוי בהתחלה. ה-SQL שדף שמטמיע את העורך קורא באמצעות getSchemaSQL(), וה-SQL שסוכן קוד קורא, מתחילים במקום זאת ב-Create, ללא כותרת, ואינם כותבים שמות לוגיים אלא אם התבקשו לכך.

אפשרות שאין במסד הנתונים שנבחר נשארת בחלונית, מעומעמת, עם תיאור הכלי Not in <database>, כגון Not in Oracle, ולחיצה עליה אינה עושה דבר.
ה-SQL משתמש אז בצורה הקרובה ביותר שיש במסד הנתונים, והלחצן של אותה צורה נראה לחוץ: If not exists מוחלף ב-Create, CREATE + USE ב-USE, או ב-None כשאין במסד הנתונים גם USE, ו-USE ב-None. הבחירה עצמה נשמרת, כך שמעבר למסד נתונים שיש בו אפשרות זו מחזיר אותה.

מסד נתונים ומירכאות

Database הוא מסד הנתונים של התרשים, אותה הגדרה כמו Database בתפריט ההקשר של בד הציור וכמו ההגדרה של מחולל הקוד – ראו מסדי נתונים. הוא כולל את Databricks, MSSQL, MariaDB, MySQL, Oracle, PostgreSQL, Snowflake ו-SQLite, הערך ההתחלתי שלו הוא MySQL, והוא נשמר בקובץ כמו כל עריכה.

Bracket קובע את המירכאות שתוחמות שמות של טבלאות, עמודות, אילוצים ואינדקסים: SingleQuote, DoubleQuote, Backtick, או None ללא תיחום כלל, שהוא ברירת המחדל. זו אותה הגדרה כמו ההגדרה של מחולל הקוד – ראו מירכאות.
Snowflake, שתוחם שמות רק במירכאות כפולות, משתמש בהן בכל בחירה מלבד None, ו-Databricks תמיד תוחם שמות בגרשים הפוכים.
Bracket נשמר בקובץ רק כל עוד הנעילה Bracket Type בכרטיסיית הגדרות כבויה, ובתרשים חדש כל הנעילות מופעלות. כל עוד הנעילה מופעלת, שינוי כותב מחדש את ה-SQL בעורך הזה בלבד: העורכים האחרים הפתוחים על התרשים שומרים על המירכאות שלהם, והקובץ שומר את הערך הנעול, ולכן התרשים נפתח מחדש איתו – ראו נעילה.

כל עוד מסד הנתונים הוא Oracle וה-SQL מכיל שם ארוך מ-30 בתים, ש-Oracle 12.1 ומטה דוחה, הערה מתחת לשתי הרשימות מפרטת כל אחד מהשמות האלה: Oracle 12.2+ for names over 30 bytes: <names>. היא בודקת שמות של טבלאות, עמודות, סכמות, מפתחות, אינדקסים, רצפים וטריגרים. ה-SQL עצמו אינו משתנה.

משפטים

Statements קובע כיצד הטבלאות נוצרות:

• Create כותב משפטי CREATE פשוטים.
• If not exists מדלג על הטבלאות והאינדקסים שכבר קיימים. האפשרות קיימת ב-MySQL, MariaDB, PostgreSQL, SQLite ו-Databricks; MSSQL, Oracle ו-Snowflake כותבים במקומה Create.
  • MySQL כותב כל טבלה כ-CREATE TABLE IF NOT EXISTS שאילוצי הייחודיות, האינדקסים והמפתחות הזרים שלה נמצאים בתוכו, ומציב את כל האצווה בין SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0; לבין SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;.
  • MariaDB מוסיף IF NOT EXISTS לכל משפט: ל-CREATE TABLE, לכל אילוץ UNIQUE ו-FOREIGN KEY, ולכל CREATE INDEX.
  • PostgreSQL כותב CREATE TABLE IF NOT EXISTS ו-CREATE INDEX IF NOT EXISTS, ומוחק כל מפתח זר באמצעות DROP CONSTRAINT IF EXISTS לפני שהוא מוסיף אותו שוב.
  • SQLite כותב CREATE TABLE IF NOT EXISTS ו-CREATE INDEX IF NOT EXISTS.
  • Databricks כותב CREATE TABLE IF NOT EXISTS, ומוחק כל מפתח זר באמצעות DROP CONSTRAINT IF EXISTS לפני שהוא מוסיף אותו שוב.
• Drop & re-create מוחק את כל הטבלאות שהוא כותב לפני שהוא יוצר אותן מחדש, מלבד ב-Snowflake. האפשרות קיימת בכל מסדי הנתונים:
  • MySQL ו-MariaDB כותבים DROP TABLE IF EXISTS לכל טבלה, בין אותן שתי שורות שמכבות את בדיקות המפתחות הזרים ומפעילות אותן מחדש.
  • PostgreSQL כותב DROP TABLE IF EXISTS אחד שמונה את כל הטבלאות, והוא נכשל אם טבלה שמחוץ לרשימה מפנה לאחת מהן. תחת כותרת CREATE + USE, טבלה שבשמה לא מצוינת סכמה נמחקת מאותה סכמה, כגון shop.member.
  • MSSQL כותב טרנזקציה אחת, שדורשת SQL Server 2016 ומעלה, כפי שמציין תיאור הכלי SQL Server 2016+ של הלחצן. היא מוחקת את המפתחות הזרים שבטבלאות הנכתבות, ואחר כך את הטבלאות באמצעות DROP TABLE IF EXISTS אחד, ומבצעת חזרה לאחור במקרה של שגיאה. מפתח זר שנמצא בטבלה שמחוץ לרשימה עדיין חוסם את המחיקה.
  • SQLite כותב PRAGMA foreign_keys=OFF;, שנשאר בתוקף עבור אותו חיבור, ואחר כך DROP TABLE IF EXISTS לכל טבלה.
  • Oracle כותב DROP TABLE … CASCADE CONSTRAINTS לכל טבלה ו-DROP SEQUENCE לכל רצף של מספור אוטומטי, כל אחד בבלוק PL/SQL שמסתיים בשורת / ומתעלם מהשגיאה שמתקבלת כשטבלה או רצף אינם קיימים.
  • Databricks כותב DROP TABLE IF EXISTS לכל טבלה.
  • Snowflake אינו מוחק דבר, וכותב במקום זאת CREATE OR REPLACE TABLE.

כל עוד Drop & re-create בתוקף, אזהרה בחלונית מציינת את הטבלאות שהוא מוחק: Drops <tables> before creating them. Their rows are lost., או ב-Snowflake Replaces <tables>. Their rows are lost.
כשיש עד חמש טבלאות, כולן מצוינות בשמן. מעבר לחמש, האזהרה מציינת את ארבע הראשונות וסופרת את השאר, כגון a, b, c, d, and 3 more tables.

כותרת

Header פותח את ה-SQL במשפטים שיוצרים או בוחרים את מסד הנתונים, או את הסכמה, שבהם הוא רץ. השם הוא שם מסד הנתונים של התרשים, שמוקלד בשדה database name בסרגל הכלים, והוא נתחם בתו שנקבע ב-Bracket.

• MySQL ו-MariaDB: USE כותב USE shop;, ו-CREATE + USE כותב לפניו CREATE DATABASE IF NOT EXISTS shop;.
• MSSQL: USE כותב USE shop ו-GO, ו-CREATE + USE כותב לפניהם IF DB_ID(N'shop') IS NULL CREATE DATABASE shop ו-GO.
• ב-PostgreSQL יש רק CREATE + USE, שכותב CREATE SCHEMA IF NOT EXISTS shop; ו-SET search_path TO shop, public;.
• ב-Oracle יש רק USE, שכותב ALTER SESSION SET CURRENT_SCHEMA = shop;. CREATE + USE מוחלף בו, ולכן זו השורה ש-Oracle כותב תחת כותרת ברירת המחדל של הכרטיסייה.
• Snowflake ו-Databricks: USE כותב USE SCHEMA shop;, ו-CREATE + USE כותב לפניו CREATE SCHEMA IF NOT EXISTS shop;.
• ב-SQLite אין אף אחת מהן, והוא אינו כותב כותרת.

כשיש במסד הנתונים USE או CREATE + USE, תיאור הכלי של הלחצן מציין מה הוא כותב בו, כגון CREATE SCHEMA + SET search_path ב-PostgreSQL.

כותרת נכתבת רק כל עוד שם מסד הנתונים הוא מזהה פשוט: אות ASCII (A עד Z, a עד z) או _, ואחריה אותיות ASCII, ספרות או _.
עם כל שם אחר, כולל שם ריק, לא נכתבת כותרת, ואז ה-DROP TABLE של PostgreSQL אינו מציין סכמה. כל עוד בתוקף כותרת שאינה None, הערה מתחת ל-Header מציינת זאת: Database name "<name>" is not a valid identifier.
שם מסד הנתונים של תרשים חדש ריק, ולכן עד שנותנים לו שם, החלונית מציגה Database name "" is not a valid identifier.

שמות לוגיים כהערות

Write logical names into empty comments, מתג תחת This window only, כותב ב-DDL את השם הלוגי של טבלה או של עמודה במקום שבו ההערה שלה ריקה, בכל מסד נתונים.

• הערה שיש בה טקסט גוברת תמיד: השם הלוגי לעולם אינו מחליף אותה ולעולם אינו מתווסף אליה.
• הערה שמכילה רווחים לבנים בלבד נחשבת לריקה, ולכן השם הלוגי נכתב במקומה. שם לוגי ריק או כזה שמכיל רווחים לבנים בלבד אינו כותב דבר, והטבלה או העמודה עדיין אינן מקבלות הערה.
• השם הלוגי נכתב במקום ובצורה שבהם מסד הנתונים כותב הערה, והמירכאות שבו מוברחות באותו אופן – ראו הערות.

ב-MySQL, לדוגמה, עמודה id עם השם הלוגי Member ID וללא הערה נכתבת עם COMMENT 'Member ID', ואילו עמודה email עם השם הלוגי Email וההערה Sign-in address שומרת על COMMENT 'Sign-in address'.

כמו Statements ו-Header, המתג שייך לחלון ומתחיל כבוי – ראו חלונית אפשרויות.
ייבוא לעולם אינו קורא הערה כזו בחזרה כשם לוגי – ראו הערות.

טבלאות

כל עוד יש בתרשים לפחות קבוצת טבלאות אחת, מוצגת או מוסתרת, Tables מופיע תחת This window only עם תיבת סימון לכל אפשרות:

• All, שמסמן את כל התיבות או מבטל את הסימון שלהן. הוא מציג מצב מעורב כל עוד רק חלק מהן מסומנות.
• תיבה אחת לכל קבוצת טבלאות, לפי סדר הקבוצות בתרשים, שהתווית שלה היא שם הקבוצה, או unnamed לקבוצה ללא שם, אחרי נקודה בצבע הקבוצה כשיש לה צבע.
• No group, עבור הטבלאות שאינן שייכות לאף קבוצה.

כשכל התיבות מסומנות, הכרטיסייה כותבת את התרשים כולו.
כשרק חלק מהן מסומנות, היא כותבת את הטבלאות של התיבות המסומנות עם האינדקסים שלהן והמפתחות הזרים שבהן, כולל מפתח זר שמפנה לטבלה שלא נכללה. הסקריפטים שלפני הטבלאות ואחריהן עדיין נכתבים, ו-Drop & re-create, האזהרה שלו וההערה של Oracle על שמות ארוכים חלים רק על הטבלאות האלה.
כשאף תיבה אינה מסומנת, הכרטיסייה אינה כותבת דבר, ומעל הקוד מופיעה ההודעה No tables chosen. Check some under Tables. במצב זה Save file שומר קובץ ריק, ו-Copy מעתיק טקסט ריק.

כמו Statements ו-Header, הבחירה שייכת לחלון – ראו חלונית אפשרויות.
קבוצה שנוספת מאוחר יותר מתחילה כמסומנת רק אם כל התיבות היו מסומנות באותו רגע. הסרת קבוצה מסירה את התיבה שלה, והסרת הקבוצה האחרונה מסמנת שוב את הכול.
הבחירה חלה על הכרטיסייה הזו בלבד. הכרטיסייה Schema SQL של חלון מאפייני הטבלה ו-getSchemaSQL() אינם מושפעים ממנה.

סקריפטים לפני הטבלאות ואחריהן

Before tables ו-After tables מכילים SQL שהמשתמש כותב בעצמו, כגון משפטי CREATE EXTENSION או SET לפני הטבלאות, או הרשאות, תצוגות ונתוני התחלה אחריהן.
הם נשמרים במסמך, זוג אחד לכל התרשים, בלי קשר למסד הנתונים. כל אחד מהם נכתב לתוך ה-SQL כפי שהוקלד, ללא כל בדיקה: הסקריפט שלפני הטבלאות בא אחרי הכותרת ולפני משפטי ה-DROP והטבלאות, והסקריפט שאחרי הטבלאות בא ממש בסוף.

מעברי שורה נכתבים כ-LF, והשורות הריקות שלפני סקריפט והרווחים הלבנים שאחריו מושמטים.
ב-MSSQL, שורת GO מתווספת אחרי סקריפט ששורתו האחרונה אינה GO (או GO עם מספר), כפי שמציינת השורה שמתחת לשני השדות. ב-Oracle, יש לסיים בלוק PL/SQL בשורת ה-/ שלו באופן ידני.

השדות מדגישים את תחביר ה-SQL וגדלים לפי הטקסט שבהם.
עריכה מוחלת כשיוצאים מהשדה, בלחיצה במקום אחר או במעבר בין כרטיסיות, ורק אז משתנים ה-SQL שלידו והמסמך. שדה שנכנסים אליו בלחיצה בלבד אינו משנה דבר.
עריכת סקריפט משנה את התרשים כמו כל עריכה אחרת: היא נשמרת בקובץ, השותפים לעריכה רואים אותה, וכל עריכה שמוחלת היא צעד אחד בהיסטוריית הפעולות, וביטולו נעשה מכרטיסיית ERD.
בזמן ההקלדה בשדה, קיצורי המקשים של העורך עצמו מפנים את מקומם לשדה, כך ש-Ctrl + Z (Windows/Linux) או ⌘ + Z (Mac) מבטל את ההקלדה בו, והעתקה, גזירה והדבקה פועלות על הטקסט ולא על התרשים.
החיפוש המהיר והחיפוש של הסייר עדיין נפתחים מקיצורי המקשים שלהם, Ctrl + K ו-Ctrl + F (Windows/Linux) או ⌘ + K ו-⌘ + F (Mac). מכיוון ש-Ctrl + F או ⌘ + F עובר לכרטיסיית ERD, הוא מחיל את העריכה, כמו כל מעבר בין כרטיסיות.
שדה שאין בו פוקוס עוקב אחר שינוי ששותף לעריכה או סוכן קוד מבצע בסקריפט שלו. שדה שהמשתמש נמצא בו מציג את השינוי הזה כשהמשתמש יוצא ממנו בלי שהקליד דבר. אם המשתמש הקליד, הטקסט שלו מוחל ביציאה ומחליף את הטקסט שלהם.

שמירה או העתקה של ה-SQL

Save file, בתחתית החלונית או בתפריט ההקשר, שומר בדיוק את ה-SQL שהכרטיסייה מציגה, עם מסד הנתונים, המירכאות, המשפטים, הכותרת, ההערות של השמות הלוגיים, הטבלאות והסקריפטים הנוכחיים שלה, כ-<database name>-<timestamp>.sql. הקובץ מקבל שם ונשמר כמו כל ייצוא אחר – ראו ייצוא.

Export ◂ Schema SQL, בתפריט ההקשר של בד הציור או בחיפוש המהיר, אינו שומר דבר בעצמו.
הוא עובר לכרטיסייה הזו, פותח את חלונית האפשרויות גם אם הייתה מכווצת, ומעביר את הפוקוס ללחצן Save file, כך שהקשה על Enter שומרת את הקובץ.

הלחצן Copy בתחתית החלונית, או לחצן ההעתקה שמופיע בפינה הימנית העליונה של הקוד כשסמן העכבר נמצא מעל הקוד, מעתיק את ה-SQL.
הודעה קופצת Copied! עם סימן וי מאשרת זאת למשך שתי שניות. אם הדפדפן או הסביבה המארחת חוסמים את הגישה ללוח, הודעה קופצת Couldn't copy to the clipboard עם סימן אזהרה מציינת זאת במקומה, למשך חמש שניות. העתקה נוספת מחליפה את ההודעה הקופצת במקום להוסיף עוד אחת.
ניתן גם לבחור את ה-SQL, וכך לקחת רק חלק ממנו.

מה ה-DDL כותב

הכללים האלה חלים בכל מקום שבו העורך כותב סכמת SQL: בכרטיסייה הזו ובקובץ שלה, וב-SQL שדף שמטמיע את העורך או סוכן קוד קוראים.
הכרטיסייה Schema SQL של חלון מאפייני הטבלה פועלת לפיהם עבור הטבלה היחידה שהיא מציגה. היא אינה כותבת רצף או טריגר של Oracle, וגם לא מפתחות זרים, מלבד אלה של SQLite, שנמצאים בתוך ה-CREATE TABLE של הטבלה. היא גם אינה כותבת את משפטי ההערות ש-PostgreSQL, Oracle ו-MSSQL מציבים אחרי טבלה, ולכן בשלושת אלה היא אינה מציגה הערות.

החלקים מופיעים בסדר הזה, עם שורה ריקה ביניהם: הכותרת, הסקריפט שלפני הטבלאות, משפטי ה-DROP, הטבלאות והסקריפט שאחרי הטבלאות. הטבלאות נכתבות לפי סדר שמותיהן.
תרשים ללא טבלאות וללא סקריפטים אינו כותב דבר, גם כשנבחרה כותרת.

טבלאות ועמודות נכתבות לפי השמות הפיזיים שלהן, בלי קשר למה שתצוגת השמות מציגה. עמודה שמקושרת לתחום נכתבת עם סוג הנתונים שלה עצמה, שהתחום קובע – ראו תחומים וסוגי נתונים.

מספור אוטומטי

עמודה שמסומנת ב-Auto Increment נכתבת כפי שכל מסד נתונים כותב אותה: AUTO_INCREMENT ב-MySQL וב-MariaDB, IDENTITY(1,1) ב-MSSQL, AUTOINCREMENT ב-Snowflake, ו-GENERATED ALWAYS AS IDENTITY ב-PostgreSQL וב-Databricks.
ב-Oracle נוצרים רצף SEQ_<table> וטריגר SEQ_TRG_<table> שממלא את העמודה ממנו. הטריגר מסתיים בשורת /, כך ש-SQL*Plus ו-SQLcl מריצים אותו.

כשמסד נתונים אינו מקבל מספור אוטומטי בסוג הנתונים של העמודה, הפסוקית מושמטת, ושורת הערה אחרי הטבלה מציינת את העמודה:

• PostgreSQL מקבל אותו רק ב-smallint, integer או bigint, תחת כל אחד מהשמות שלהם: INT, INTEGER, BIGINT, SMALLINT, INT2, INT4 או INT8. עמודה מסוג אחר אינה מקבלת לא את הפסוקית ולא ערך ברירת מחדל, וההערה היא, לדוגמה, -- PostgreSQL takes IDENTITY only on smallint, integer or bigint, so member.id is written without it.
• Databricks מקבל אותו רק ב-BIGINT או ב-LONG.
• SQLite מקבל AUTOINCREMENT רק בעמודת המפתח הראשי היחידה של טבלה, כשהיא מסוג מספר שלם, כגון INT, BIGINT או INT8, עם רוחב או בלעדיו. עמודה זו נכתבת כ-INTEGER, והמפתח כ-PRIMARY KEY (id AUTOINCREMENT). מפתח יחיד מכל סוג אחר נכתב בלעדיו.

פעולות הפניה

הפעולות של ON DELETE ו-ON UPDATE שכל מסד נתונים כותב מפורטות ב-ON DELETE ו-ON UPDATE.
כש-Snowflake משמיט פעולה, הערה מעל ה-ALTER TABLE של אותו מפתח זר מציינת אותה, כגון -- Snowflake creates no foreign key with a referential action other than NO ACTION, so ON DELETE CASCADE is left out.

שמות טבלאות עם שם סכמה

כש-Bracket מוגדר ל-None, שם טבלה עם נקודה, כגון sales.users, נקרא כסכמה וטבלה, ומפוצל בנקודה האחרונה שלו שמחוץ לסוגריים מרובעים או למירכאות כפולות.

• MySQL, MariaDB, MSSQL, Oracle ו-PostgreSQL בונים את השמות האוטומטיים שהם כותבים מחלק הטבלה בלבד: FK_users_TO_orders ו-IDX_users בכל החמישה, UQ_users_email בכולם מלבד PostgreSQL, ו-PK_users ב-MSSQL וב-Oracle, השניים מביניהם שנותנים שם למפתח הראשי. בשניים האלה, גם [sales].[users] ו-"sales"."users" מניבים PK_users, ו-[Order] מניב PK_Order.
• SQLite אינו נותן שמות לאילוצים, ולכן השם האוטומטי היחיד שהוא בונה הוא שם האינדקס: CREATE INDEX sales.IDX_users ON users.
• Oracle יוצר את האינדקסים של הטבלה, ואת הרצף והטריגר של עמודת מספור אוטומטי, בסכמה של הטבלה: sales.IDX_users, sales.SEQ_users ו-sales.SEQ_TRG_users.
• ב-Oracle וב-SQLite, שם אינדקס שצוינה בו סכמה באופן ידני שומר עליה.
• שם אוטומטי של מפתח זר או של אינדקס שחוזר על שם קודם, ללא הבחנה ברישיות, מקבל מספר. כש-orders מפנה גם ל-sales.users וגם ל-hr.Users, המפתח השני הוא FK_Users_TO_orders1.

תחת כל ערך אחר של Bracket, שם הטבלה כולו הוא מזהה אחד, כגון "PK_sales.users". Snowflake ו-Databricks תמיד שומרים על השם כולו.
השורות Keys בכרטיסייה אינדקסים מציגות את אותם שמות.

ערכי ברירת מחדל

ערך ברירת המחדל של עמודה נכתב כפי שהוקלד, אבל בתוך סוגריים כשמסד הנתונים קורא את הביטוי הזה רק בתוכם. ערך ברירת מחדל שכבר נמצא בסוגריים נשאר כמות שהוא.

• MySQL עוטף כל דבר מלבד ליטרל או הזמן הנוכחי, כגון (uuid()). הוא גם עוטף כל ערך ברירת מחדל מלבד NULL בעמודה מסוג BLOB, TEXT, JSON, מרחבי או LONG…, ואת הזמן הנוכחי בכל עמודה שאינה TIMESTAMP או DATETIME.
• MariaDB עוטף כל דבר מלבד ליטרל, הזמן הנוכחי, קריאה לפונקציה או שם.
• SQLite עוטף כל דבר מלבד ליטרל או שם, כגון (datetime('now')).
• PostgreSQL עוטף רק ביטוי שיש בו, מחוץ לסוגריים, מילה כגון AT TIME ZONE, AND, OR, IS, IN, LIKE, COLLATE או = ANY, כגון (now() AT TIME ZONE 'utc').
• MSSQL, Oracle, Snowflake ו-Databricks כותבים כל ערך ברירת מחדל כפי שהוקלד.

הערות

ההערה של טבלה או של עמודה שאינה ריקה, או השם הלוגי ש-Write logical names into empty comments כותב במקומה, נכתבים כפי שכל מסד נתונים כותב הערות:

• MySQL ו-MariaDB כותבים אותה בתוך השורה: עמודה מסתיימת ב-COMMENT 'Member ID', והטבלה נסגרת ב-) COMMENT 'Members';, גם באצווה If not exists של MySQL.
• Snowflake כותב את ההערה של עמודה בתוך השורה, COMMENT 'Member ID', ואת ההערה של הטבלה בשורה משלה אחרי סוגר הסגירה, COMMENT = 'Members';.
• Databricks כותב את ההערה של עמודה בתוך השורה, ואת ההערה של הטבלה כ-COMMENT 'Members'; אחרי USING DELTA.
• PostgreSQL כותב COMMENT ON TABLE member IS 'Members'; ו-COMMENT ON COLUMN member.id IS 'Member ID'; מיד אחרי ה-CREATE TABLE של הטבלה. Oracle כותב את אותם משפטים אחרי הטבלה, אחרי אילוצי הייחודיות שלה ואחרי הרצף והטריגר של המספור האוטומטי שלה.
• MSSQL כותב קריאה אחת לכל טבלה ולכל עמודה, אחרי הטבלה ואילוצי הייחודיות שלה, וכל אחת מהן מלווה ב-GO: EXECUTE sys.sp_addextendedproperty 'MS_Description', N'Members', 'schema', 'dbo', 'table', 'member', ועבור עמודה מתווסף 'column', 'id'.
  הטקסט הוא ליטרל לאומי, N'…', כך ש-SQL Server שומר טקסט שמחוץ לדף הקוד של מסד הנתונים, כגון קוריאנית, במקום לאחסן סימני שאלה.
  כש-Bracket מוגדר ל-None, טבלה בשם sales.users מניבה את הסכמה sales ואת הטבלה users, וכך גם [sales].[users] ו-"sales"."users", שהסוגריים המרובעים והמירכאות הכפולות שלהם מושמטים. שם ללא סכמה נמצא ב-dbo. חלק שלפני הסכמה, כמו ב-shop.sales.users, מריץ את הפרוצדורה של אותו מסד נתונים, shop.sys.sp_addextendedproperty. תחת כל ערך אחר של Bracket, השם כולו הוא הטבלה, ב-dbo.
• SQLite אינו שומר הערות, ולכן הוא כותב כל אחת מהן כשורת -- מעל מה שהיא מתארת: -- Members מעל CREATE TABLE member, ו--- Member ID מעל העמודה.

מירכה בתוך הערה שתחומה במירכאות מוכפלת, כמו ב-'it''s' וב-N'it''s', וכך גם מירכה בשמות שהקריאות של MSSQL מעבירות. Databricks מבריח במקום זאת מירכה ולוכסן הפוך באמצעות לוכסן הפוך, כמו ב-'it\'s', הצורה שכל גרסה של Spark קוראת. שורות ה--- של SQLite אינן תחומות במירכאות, ולכן הן שומרות על מירכה כפי שהוקלדה: -- it's.
מלבד זאת, הטקסט נכתב כפי שהוקלד, כולל מעברי שורה, חוץ משני מסדי נתונים:

• Oracle משמיט שורות ריקות, כששורה שמכילה רק רווחים או טאבים נחשבת לריקה, מכיוון ש-SQL*Plus מסיים משפט בשורה ריקה ומדלג על שאר המשפט. הערת טבלה של Members, שורה ריקה ו-Active only נכתבת כ-COMMENT ON TABLE member IS 'Members עם Active only'; בשורה הבאה.
• SQLite כותב כל רצף של מעברי שורה כרווח אחד, מכיוון שמעבר שורה היה מסיים את שורת ה--- ומריץ את השאר כ-SQL. אותה הערה נכתבת כ--- Members Active only.

האופן שבו ההערות האלה נקראות בחזרה בייבוא מתואר בסעיף הערות.

עורכים לקריאה בלבד

בעורך readonly הכרטיסייה פועלת עבור הקורא, ודבר שנעשה בה אינו מגיע אל המסמך:

• Database ו-Bracket עדיין כותבים מחדש את ה-SQL, אבל רק באותו חלון, ולכן החלונית נותנת גם להם את הכותרת This window only. בחירה אינה נשמרת בקובץ, אינה משותפת עם שותפים לעריכה ואינה נרשמת לביטול, יהיו הנעילות אשר יהיו, ושינוי של שותף בהגדרה שנבחרה משאיר את הבחירה על המסך. כרטיסיית מחולל הקוד מציגה את אותה בחירה, ו-getSchemaSQL() הנקראת בלי מסד נתונים כותבת אותה גם כן. ברגע שהעורך חוזר להיות ניתן לכתיבה, מסד הנתונים והמירכאות שנבחרו חוזרים למה שהעורך הציג קודם, עם כל שינוי ששותף לעריכה ביצע מאז – ראו עורכים לקריאה בלבד בדף הגדרות.
• Statements, Header, Write logical names into empty comments ו-Tables פועלים כמו בכל מקום, כי הם שייכים לחלון כבר.
• שני שדות הסקריפטים הם לקריאה בלבד: הם מציגים את הסקריפטים של המסמך, שה-SQL עדיין כותב, ואינם מקבלים הקלדה.
• Save file ו-Copy שומרים ומעתיקים את ה-SQL שהכרטיסייה מציגה.