כלים

השרת מציע 77 כלים: חמישה כלי סשן, ארבעה כלי קריאה, 67 כלי עריכה, אחד לכל פעולת עריכה, ו-erd_batch, שמריץ כמה כלי עריכה כעריכה אחת.

כל כלי מלבד erd_list_documents מקבל את ה-path של המסמך כארגומנט הראשון שלו, והטבלאות שלהלן משמיטות אותו. ארגומנט שמסומן ב-? הוא אופציונלי.

כלי סשן

כלי	ארגומנטים	מה הוא עושה
erd_list_documents		מציג רשימה של מסמכי ERD עם path, open, active, dirty ו-readonly: את המסמכים של העורך שמשרת את תיקיית העבודה, וב-IDE של JetBrains מכל הפרויקטים הפתוחים, ואחרת את קובצי ה-ERD שתחת תיקיית העבודה.
erd_open_document	create?	פותח מסמך לעריכה, ב-ERD Editor של העורך שמשרת אותו, אם יש כזה. עם create הוא יוצר תחילה את הקובץ אם הוא חסר, ושם ללא סיומת מקבל .erd.json.
erd_save		שומר מסמך שעורך מחזיק. VS Code משאיר את העריכות של הסוכן לא שמורות עד שקוראים לכלי הזה; Obsidian ו-IDE של JetBrains שומרים אותן כפי שהם שומרים את העריכות של המשתמש, והכלי הזה כותב אותן מיד. במצב ללא ממשק, כל עריכה כבר נכתבה, כפי שמציין ה-saved: true שבתוצאה שלה, והכלי הזה אינו עושה דבר.
erd_undo		מבטל את העריכה האחרונה שהסוכן הזה ביצע, ולעולם לא את העריכות של המשתמש. הוא מדלג על קריאות שלא יצרו צעד ביטול ומציין אותן בשמן.
erd_redo		מחיל שוב את העריכה ש-erd_undo ביטל לאחרונה.

לגבי מה שהשמירה וביטול הפעולה עושים בכל מצב, ראו מצב חי ומצב ללא ממשק.

קריאת מסמך

כלי	ארגומנטים	מה הוא עושה
erd_list	query?, offset?, limit?, namesOnly?	ההגדרות והספירות, ואחריהן דף של טבלאות עם האינדקסים והקשרים שלהן, כל טבלה עם המזהה שלה, המיקום והגודל שלה בבד הציור, מספר העמודות שלה, השם הלוגי שלה, אם יש לה כזה, וקבוצת הטבלאות שלה, אם היא שייכת לאחת. אלא אם מתבצע חיפוש, אחרי הטבלאות באות קבוצות הטבלאות, הפתקים, ואחריהם התחומים, המונחים והמילים.
erd_get	tableIds?, tableNames?, relationshipIds?, indexIds?, memoIds?, tableGroupIds?, wordIds?, termIds?, domainIds?	הישויות שצוינו, במלואן: טבלאות עם העמודות שלהן וקבוצת הטבלאות שלהן, קשרים עם העמודות שלהם וה-onDelete וה-onUpdate שלהם, אינדקסים עם העמודות שלהם, פתקים עם הטקסט שלהם, קבוצות טבלאות עם הטבלאות שלהן, ומילים, מונחים ותחומים עם כל השדות שלהם.
erd_read	format, vendor?, statements?, header?, logicalNameAsComment?, tableIds?, tableNames?, groupNames?	המסמך כולו בבת אחת באחד מארבעה פורמטים, או ה-DDL של טבלאות או קבוצות טבלאות מסוימות בלבד.
erd_list_checks	level?, tableIds?, tableNames?, offset?, limit?	מה שמילוני המילים, המונחים והתחומים מוצאים כשגוי, כפי שהגיליון Checks של כרטיסיית מילון בעורך מציג זאת, דף אחר דף. הוא אינו משנה דבר – ראו בדיקות המילון.

סוכן מוצא מזהים באמצעות erd_list, קורא עמודות, שורות מילון ופרטים אחרים באמצעות erd_get, ומעביר את המזהים האלה לכלי העריכה. הגודל של טבלה ב-erd_list הוא המלבן שהיא תופסת בבד הציור: הגובה מדויק, והרוחב משוער. קבוצת טבלאות מופיעה ברשימה לפי המלבן שהיא שומרת, עם השם שלה, הצבע שלה ומספר הטבלאות שהיא מכילה. כל קשר מופיע ברשימה פעם אחת, עם אחת משתי הטבלאות שלו. שורת מילון מופיעה ברשימה לפי המזהה שלה, ה-name שלה ומה שהיא נותנת לשם פיזי או לעמודה: ה-dataType של תחום, ה-physicalName וה-domainId של מונח, וה-abbreviation של מילה. כל מילון מציג את השורות שלו בסדר שבו הגיליון שלו מציג אותן. ההגדרות ש-erd_list ו-erd_read מדווחים עליהן הן אלה שהקובץ שומר – ראו הגדרות.

ב-erd_get ובפורמט snapshot של erd_read, כל טבלה ועמודה נושאת את ה-logicalName שלה, מחרוזת ריקה כשאין כזה, ואת nameDerived, שהוא true כל עוד השם ניתן על ידי המילונים, כך ששם לוגי חדש גוזר אותו מחדש – ראו מילונים. כל עמודה נושאת את ה-domainId שלה, וכך גם כל מונח: מחרוזת ריקה כשאין כזה, או כשמדובר בתחום שהמסמך כבר אינו מציג.

erd_read מקבל אחד מארבעה פורמטים:

format	מה הוא מחזיר
snapshot	JSON תמציתי עם כל ישות והמזהה שלה, כולל קבוצות הטבלאות ושורות המילים, המונחים והתחומים, ועם ההגדרות יחד עם הסקריפטים של סכמת SQL. הוא משמיט את מה שמשתנה מצופה אחד לאחר: הרוחבים שנמדדו, סדר השכבות, התצוגה, הכרטיסייה ותצוגת השמות. בסכמה גדולה הוא גדול.
sql	DDL לאחד משמונה מסדי הנתונים, Databricks, MariaDB, MSSQL, MySQL, Oracle, PostgreSQL, Snowflake או SQLite. ברירת המחדל של vendor היא מסד הנתונים שהמסמך מוגדר אליו. ה-DDL של המסמך כולו כולל את הסקריפטים שלו שלפני הטבלאות ואחריהן. עם tableIds, tableNames או groupNames, רק הטבלאות האלה, עם המפתחות הזרים שהן מכילות, וללא סקריפטים. המפתחות הזרים כוללים את פעולות ה-ON DELETE וה-ON UPDATE שלהם, מלבד אלה שמסד נתוני היעד משמיט – ראו ON DELETE ו-ON UPDATE.
json	המסמך כולו בדיוק כפי ששמירה כותבת את הקובץ, כולל עריכות שהעורך עדיין לא שמר – ראו צורת האחסון.
scripts	רק הסקריפטים של המסמך שלפני הטבלאות ואחריהן, בצורה {"before":"…","after":"…"}, כל אחד מהם ריק כשאינו מוגדר, ללא תלות בגודל הסכמה.

רק הפורמט sql מקבל את vendor, statements, header, logicalNameAsComment, tableIds, tableNames ו-groupNames, ופורמט אחר דוחה אותם.

• statements: create, ברירת המחדל; ifNotExists, שכותב CREATE TABLE IF NOT EXISTS ב-MySQL, MariaDB, PostgreSQL, SQLite ו-Databricks ו-CREATE TABLE רגיל בשאר מסדי הנתונים; או recreate, שמוחק את הטבלאות לפני שהוא יוצר אותן, ובמקום זאת Snowflake כותב CREATE OR REPLACE TABLE.
• header: none, ברירת המחדל; use, שבוחר את מסד הנתונים או את הסכמה ששם מסד הנתונים של המסמך מציין; או createAndUse, שיוצר אותו תחילה. ב-Oracle יש רק use, ולכן שם createAndUse כותב use, וב-PostgreSQL יש רק createAndUse, ולכן שם use אינו כותב כותרת. SQLite אינו כותב כותרת, ואף מסד נתונים אינו כותב כותרת כל עוד שם מסד הנתונים ריק או אינו מזהה פשוט.
• logicalNameAsComment: true כותב את השם הלוגי של טבלה או של עמודה כהערה שלה כל עוד ההערה ריקה או מכילה תווי רווח בלבד, במקום ובצורה שבהם כל מסד נתונים כותב הערה, ושומר כל הערה שיש בה טקסט; false, ברירת המחדל, אינו כותב שם לוגי – ראו שמות לוגיים כהערות.
• groupNames: הטבלאות של קבוצות הטבלאות שצוינו, לפי השם, ללא תלות ברישיות, יחד עם הטבלאות של tableIds ו-tableNames. שם שאינו תואם אף קבוצה נדחה עם notFound. קבוצה שאינה מכילה טבלה אינה מוסיפה אף טבלה, וקריאה שלא נותרה בה אף טבלה, כמו כשכל הקבוצות שצוינו ריקות ולא צוינה אף טבלה, נדחית עם invalidArgs.

statements, header ו-logicalNameAsComment חלים גם על ה-DDL של טבלאות מסוימות. הם פועלים כמו האפשרויות Statements ו-Header והמתג Write logical names into empty comments בכרטיסיית סכמת SQL של העורך, אף שהכרטיסייה מתחילה ב-If not exists וב-CREATE + USE. המתג מתחיל כשהוא כבוי, כמו logicalNameAsComment. השמות נתחמים בסוג המירכאות שהקובץ שומר, כלומר בסוג הנעול כל עוד Bracket Type נעול – ראו נעילה.

סכמות גדולות

גם סכמות של מאות או אלפי טבלאות עובדות. קריאה מחזירה לכל היותר 40,000 תווים, מתחת לסף שבו Claude Code מעביר תוצאת כלי לקובץ נפרד.

• erd_list מחזיר כברירת מחדל דף של 100, תחילה הטבלאות, אחריהן קבוצות הטבלאות, הפתקים, התחומים, המונחים והמילים, כשהיסט אחד עובר על כולם, ומציין היכן מתחיל הדף הבא באמצעות nextOffset ו-note. יש להעביר את ה-nextOffset הזה כ-offset, עם אותו query.
• query מוצא טבלאות לפי מילים בשם, בשם הלוגי או בהערה של טבלה או של עמודה, ללא תלות ברישיות. טבלאות ששמותיהן או שמותיהן הלוגיים מכילים יותר מהמילים מופיעות ראשונות. חיפוש אינו מציג קבוצות טבלאות, פתקים או שורות מילון.
• namesOnly מציג רק את שמות הטבלאות, כ-2,000 שמות קצרים בתשובה אחת.
• erd_get ו-erd_read מקבלים את tableNames בנוסף למזהים, ו-erd_read מקבל את groupNames, כך שסוכן שמבקשים ממנו שאילתת SQL על סכמה גדולה קורא רק את ה-DDL של הטבלאות שהוא צריך.
• גם המילונים מגיעים בחלקים: erd_list עובר דף אחר דף על השורות שלהם אחרי הטבלאות, ו-erd_get מחזיר שורות במלואן לפי domainIds, termIds ו-wordIds.
• erd_get מציג תחת missing מזהים ושמות שאינם מציינים דבר, ותחת notReturned את המזהים שלא היה להם מקום בתשובה אחת, כדי לבקש אותם שוב.
• erd_list_checks מחזיר דף אחר דף באותו אופן – ראו בדיקות המילון.
• קריאה גדולה מדי לתשובה אחת נדחית עם tooLarge, ועם הסבר כיצד לצמצם אותה.

בדיקות המילון

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

• level: error או warning לרמה הזאת בלבד; כברירת מחדל, שתיהן.
• tableIds ו-tableNames: רק הבדיקות של הטבלאות האלה ושל העמודות שלהן, שמות ללא תלות ברישיות, מה שמשמיט את השורות של המילונים עצמם. מזהה או שם שאינם מציינים אף טבלה נדחים עם notFound.
• offset ו-limit: כברירת מחדל דף של 100 בדיקות, שנעצר גם במקום שבו תשובה אחת מתמלאת. כל עוד יש בדיקות נוספות, nextOffset ו-note מציינים היכן מתחיל הדף הבא; יש להעביר אותו כ-offset עם אותם מסננים. אחרי תיקון של כמה בדיקות, יש להציג את הרשימה שוב מההיסט 0: בדיקה שתוקנה יוצאת מהרשימה, ולכן היסט מאוחר יותר ידלג על בדיקות שעדיין לא תוקנו.

התשובה מכילה את total, מספר הבדיקות שהמסננים משאירים; את counts, כמה מהן יש לכל קוד, בלי קוד שאין לו אף בדיקה; ואת הדף כ-checks. כל בדיקה מציינת את ה-level שלה, את ה-code שלה, ואת ה-kind וה-id של היעד שלה: table, column, word, term או domain. בדיקה של עמודה מוסיפה את ה-tableId שלה ואת שם הטבלה שלה כ-table. name הוא שם היעד, השם הפיזי של טבלה או של עמודה, עם ה-logicalName שלו כשיש לו כזה. field הוא מה שהבדיקה קוראת: name, logicalName או domainId. text הוא מה שהיא מצאה שם, ו-suggestions, כשהמילונים מציעים משהו, הוא מה שיש להשתמש בו במקום זאת. כך סוכן יכול לתקן בדיקה בלי erd_get:

{"level":"warning","code":"physicalNameMismatch","kind":"column","id":"8e1z0q4xk2m7cwd5tfb9h3ynp","tableId":"03h17be2plxpj5n59tqag7ogj","table":"users","name":"id","logicalName":"Member Number","field":"name","text":"id","suggestions":["MBR_NO"]}

code	level	Type בגיליון	מה נמצא
duplicateName	error	Duplicate name	שם ששתי שורות של מילון אחד חולקות. כל אחת מהשורות מופיעה ברשימה.
unknownDomain	error	Unknown domain	עמודה או מונח שמקושרים לתחום שהמסמך כבר אינו מציג. text הוא שם התחום הזה, או המזהה שלו כששם אינו ידוע.
forbiddenWord	error	Forbidden word	מילה שמילה כלשהי מציינת כאסורה, בשם הלוגי של טבלה או של עמודה או בשם של מונח. suggestions הן המילים התקניות.
unregisteredWord	warning	Unregistered word	טקסט שאף מילה אינה מציינת, באותם מקומות.
synonymWord	warning	Synonym	מילה נרדפת שמשמשת במקום מילה תקנית, באותם מקומות. suggestions הן המילים התקניות.
physicalNameMismatch	warning	Physical name mismatch	שם פיזי של טבלה או של עמודה שאינו השם שהמונח של השם הלוגי שלה נותן. ההצעה היא השם הפיזי של המונח, או השם שהמילים שלו מרכיבות כשהמונח אינו מכיל שם פיזי.
domainTypeMismatch	warning	Domain type mismatch	עמודה שסוג הנתונים שלה אינו זה של התחום שהיא מקושרת אליו. text הוא הסוג של העמודה, וההצעה היא הסוג של התחום.

האופן שבו כל בדיקה קוראת שם מתואר במה כל בדיקה מוצאת.

כלי עריכה

המזהים מגיעים מ-erd_list ומ-erd_get, או מה-createdIds של הקריאה שיצרה את הישות. מזהה חדש מורכב מ-25 אותיות קטנות וספרות, כגון 03h17be2plxpj5n59tqag7ogj, ואילו מזהה שכבר קיים במסמך שומר על צורתו, ולכן אין להסיק דבר מצורתו של מזהה. x ו-y הם הקצה השמאלי והקצה העליון בבד הציור, בפיקסלים, וצבע הוא צבע CSS הקסדצימלי כגון #3b82f6, או מחרוזת ריקה, שמסירה את הצבע.

טבלאות

כלי	ארגומנטים	מה הוא עושה
erd_add_table		מוסיף טבלה ריקה במקום פנוי ומחזיר את המזהה שלה ב-createdIds.
erd_remove_table	tableId	מסיר טבלה יחד עם העמודות שלה, האינדקסים שלה וכל קשר שנוגע בה.
erd_change_table_name	tableId, value	משנה את שמה של טבלה. השם נחשב אז לשם שנכתב ידנית, ולכן שם לוגי שנקבע מאוחר יותר משאיר אותו כפי שהוא כל עוד הוא אינו ריק – ראו מילונים.
erd_change_table_comment	tableId, value	קובע את ההערה של טבלה. מחרוזת ריקה מנקה אותה.
erd_set_table_logical_name	tableId, value	קובע את השם הלוגי של טבלה. מחרוזת ריקה מנקה אותו ומשאירה את השם. כל עוד השם של הטבלה ריק או נגזר, המילונים גוזרים אותו מהשם הלוגי – ראו מילונים. מונח אינו נותן לטבלה תחום.
erd_change_table_color	tableId, color	קובע את הצבע של טבלה.
erd_move_table	tableId, x, y	מזיז טבלה למיקום בבד הציור.
erd_move_tables	positions	מזיז כמה טבלאות בעריכה אחת, שקריאה אחת ל-erd_undo מבטלת. positions מכיל { tableId, x, y } לכל טבלה, כל טבלה פעם אחת לכל היותר.
erd_sort_tables		ממקם את כל הטבלאות בשורות לרוחב בד הציור, בסדר עולה של מספר העמודות, כפי ש-erd_import_sql, erd_import_graphql, erd_import_dbml ו-erd_import_aml ממקמים אותן. הטבלאות של קבוצת טבלאות נשארות יחד, והמלבן של כל קבוצה מותאם סביבן.

עמודות

כלי	ארגומנטים	מה הוא עושה
erd_add_column	tableId	מוסיף עמודה ריקה לטבלה ומחזיר את המזהה שלה ב-createdIds.
erd_remove_columns	tableId, columnIds	מסיר עמודות מטבלה אחת, יחד עם הקשרים והרשומות באינדקסים שמשתמשים בהן.
erd_change_column_name	tableId, columnId, value	משנה את שמה של עמודה. השם נחשב אז לשם שנכתב ידנית, כמו השם של טבלה.
erd_change_column_data_type	tableId, columnId, value	קובע את סוג הנתונים, כגון INT או VARCHAR(255). כל עוד סנכרון סוג הנתונים בקשרים מופעל, השינוי עובר לאורך הקשרים בשני הכיוונים, כפי שקורה בעורך: סוג serial מגיע למפתחות הזרים כסוג המספר השלם שהוא מאחסן, כפי ש-erd_add_relationship מעתיק אותו, ומפתח serial שומר על הסוג שלו כשאחד מהמפתחות הזרים שלו משתנה, מה שעוצר שם את השינוי. הפעלת הסנכרון וכיבויו שמורים למשתמש, ו-erd_list מדווח עליו כ-relationshipDataTypeSync. הקישור של עמודה שמקושרת לתחום מבוטל כשהיא מקבלת סוג שונה מזה של התחום, וכך גם הקישור של כל עמודה שהסנכרון מגיע אליה ושהסוג החדש שלה שונה מזה של התחום שלה – ראו ביטול הקישור.
erd_change_column_default	tableId, columnId, value	קובע את ערך ברירת המחדל, כטקסט SQL. מחרוזת ריקה מנקה אותו.
erd_change_column_comment	tableId, columnId, value	קובע את ההערה. מחרוזת ריקה מנקה אותה.
erd_set_column_logical_name	tableId, columnId, value	קובע את השם הלוגי של עמודה. מחרוזת ריקה מנקה אותו ומשאירה את השם. כל עוד השם של העמודה ריק או נגזר, המילונים גוזרים אותו, והתחום של מונח מקושר לעמודה ונותן לה את סוג הנתונים של התחום – ראו מילונים.
erd_set_column_domain	tableId, columnId, domainId?, domainName?	מקשר עמודה לתחום, שמצוין לפי מזהה או לפי שם, אחד מהשניים. העמודה מקבלת את סוג הנתונים של התחום, שעובר לאורך הקשרים כל עוד סנכרון סוג הנתונים בקשרים מופעל, עם אותו ביטול קישור כמו ב-erd_change_column_data_type. domainId שהוא null או מחרוזת ריקה, או domainName ריק, מבטלים את הקישור של העמודה ושומרים על הסוג שלה.
erd_set_column_primary_key	tableId, columnId, value	true הופך את העמודה לחלק מהמפתח הראשי, ו-false מוציא אותה ממנו.
erd_set_column_unique	tableId, columnId, value	קובע אם העמודה ייחודית.
erd_set_column_not_null	tableId, columnId, value	קובע אם העמודה היא NOT NULL.
erd_set_column_auto_increment	tableId, columnId, value	קובע אם לעמודה יש מספור אוטומטי.
erd_move_column	tableId, columnId, targetColumnId	מזיז עמודה בתוך הטבלה שלה למיקום של עמודה אחרת.

קשרים

relationshipType הוא הקרדינליות בקצה של טבלת הבן: ZeroOne, ZeroN, OneOnly או OneN. טבלת ההתחלה היא טבלת האב, הצד שאליו מפנים ושמחזיק את המפתח הראשי, וטבלת הסיום היא טבלת הבן. onDelete ו-onUpdate הם פעולות ה-ON DELETE וה-ON UPDATE של המפתח הזר: none, noAction, cascade, setNull, setDefault או restrict. none אינו כותב פסוקית, ולכן חלה ברירת המחדל של מסד הנתונים – ראו ON DELETE ו-ON UPDATE. פעולה שהושמטה ב-erd_add_relationship או ב-erd_link_columns היא none.

כלי	ארגומנטים	מה הוא עושה
erd_add_relationship	startTableId, endTableId, relationshipType, onDelete?, onUpdate?	יוצר קשר בין שתי טבלאות. הוא מעתיק את המפתח הראשי של טבלת האב לטבלת הבן כעמודות מפתח זר, ויוצר תחילה עמודת מפתח ראשי אם אין לטבלת האב כזו. כל עמודת מפתח זר מקבלת את השם ששרטוט קשר בעורך נותן לה: המפתח id של users נותן users_id, ומפתח כגון member_id שומר על שמו – ראו שמות עמודות של מפתחות זרים. כל אחת מעתיקה את סוג הנתונים של המפתח שלה, אלא שמפתח serial נותן את סוג המספר השלם שהוא מאחסן, כגון integer עבור serial4, ו-serial לבדו נשאר serial מחוץ ל-PostgreSQL, MySQL ו-MariaDB – ראו קשרים מזהים. כל אחת גם מקבלת את השם הלוגי של המפתח שלה, ומקושרת לתחום שהמפתח שלה מקושר אליו, אלא אם מפתח serial נותן לה סוג אחר. createdIds מכיל את עמודת המפתח החדשה הזו אם נוצרה, את עמודות המפתח הזר, ובסוף את המזהה של הקשר.
erd_link_columns	startTableId, startColumnIds, endTableId, endColumnIds, relationshipType, onDelete?, onUpdate?	משרטט קשר בין עמודות שכבר קיימות, ומצמיד עמודות התחלה לעמודות סיום לפי המיקום. הוא אינו משנה שם של אף עמודה, אינו משנה אף סוג נתונים ואינו מעתיק שם לוגי או תחום.
erd_remove_relationship	relationshipId	מסיר קו קשר. עמודות המפתח הזר שלו נשארות בטבלה.
erd_change_relationship_type	relationshipId, relationshipType	משנה את הקרדינליות של קשר.
erd_change_relationship_on_delete	relationshipId, onDelete	קובע את פעולת ה-ON DELETE של קשר: מה מחיקת שורת אב עושה לשורות הבן שלה.
erd_change_relationship_on_update	relationshipId, onUpdate	קובע את פעולת ה-ON UPDATE של קשר: מה שינוי מפתח אב עושה לשורות הבן שלו.

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

אף כלי אינו משנה את העמודות של קשר קיים כפי שעושה מיפוי עמודות בעורך. כדי למפות קשר לעמודות אחרות, יש להריץ את erd_remove_relationship, שמשאיר את עמודות המפתח הזר שלו בטבלה, ואת erd_link_columns עם העמודות הרצויות, ב-erd_batch אחד, שקריאה אחת ל-erd_undo מבטלת.

אינדקסים

מזהה של עמודת אינדקס הוא רשומה ברשימת העמודות של האינדקס ש-erd_get מחזיר, ולא המזהה של עמודת הטבלה.

כלי	ארגומנטים	מה הוא עושה
erd_add_index	tableId	מוסיף אינדקס ריק לטבלה ומחזיר את המזהה שלו ב-createdIds.
erd_remove_index	indexId	מסיר אינדקס.
erd_change_index_name	indexId, value	משנה את שמו של אינדקס.
erd_set_index_unique	indexId, value	קובע אם האינדקס ייחודי.
erd_add_index_column	indexId, columnId	מוסיף עמודה של הטבלה של האינדקס ומחזיר את המזהה של עמודת האינדקס החדשה. עמודה שכבר נמצאת באינדקס נשארת ללא שינוי.
erd_remove_index_column	indexId, indexColumnId	מסיר עמודה אחת מאינדקס.
erd_move_index_column	indexId, indexColumnId, targetIndexColumnId	מזיז עמודה בתוך אינדקס למיקום של עמודה אחרת שלו.
erd_set_index_column_order	indexId, indexColumnId, orderType	קובע את סדר המיון של עמודה אחת באינדקס, ASC או DESC.

פתקים

כלי	ארגומנטים	מה הוא עושה
erd_add_memo		מוסיף פתק ריק במקום פנוי ומחזיר את המזהה שלו ב-createdIds.
erd_remove_memo	memoId	מסיר פתק.
erd_change_memo_value	memoId, value	מחליף את הטקסט של פתק.
erd_change_memo_color	memoId, color	קובע את הצבע של פתק.
erd_move_memo	memoId, x, y	מזיז פתק למיקום בבד הציור.
erd_resize_memo	memoId, width, height	משנה את הגודל של פתק. הרוחב חייב להיות לפחות כ-116 פיקסלים, והגובה לפחות 100. הוא אינו יוצר צעד ביטול, כי העורך רושם שינוי גודל של פתק רק מגרירה.

כל עוד הפתקים מוסתרים באמצעות View Option ← Memos, erd_add_memo עדיין מוסיף פתק, והוא נשאר מוסתר עד שהפתקים מוצגים שוב. erd_list ו-erd_get מציגים גם פתקים מוסתרים.

קבוצות טבלאות

קבוצת טבלאות היא מלבן בעל שם שמוצג מאחורי הטבלאות שלה, והצבע שלה מופיע על המלבן ולרוחב הכותרות של הטבלאות שלה – ראו קבוצות טבלאות. טבלה שייכת לקבוצה אחת לכל היותר. erd_move_table, erd_move_tables ו-erd_move_table_group לעולם אינם משנים אילו טבלאות קבוצה מכילה, בכל מקום שבו הם ממקמים טבלה, ואילו בעורך טבלה מצטרפת לקבוצה או עוזבת אותה לפי המקום שבו משחררים אותה – ראו הוספה והסרה של טבלאות. erd_add_table_group ו-erd_set_table_group מכניסים טבלאות לקבוצה, ו-erd_remove_table_group משאיר את הטבלאות שלה ללא קבוצה. קבוצה שומרת מלבן, ברוחב 160 פיקסלים לפחות ובגובה 100 לפחות, כולל שורת הכותרת, והעורך מציג את המלבן מוגדל כך שיכיל כל אחת מהטבלאות שלה.

כלי	ארגומנטים	מה הוא עושה
erd_add_table_group	name, color?, x?, y?, width?, height?, tableIds?	מוסיף קבוצה ומחזיר את המזהה שלה ב-createdIds. יש להעביר את tableIds או מלבן, כלומר את x, y, width ו-height יחד. עם tableIds, כל טבלה עוזבת כל קבוצה שהייתה בה, והמלבן מותאם סביבן כפי שקיבוץ הטבלאות שנבחרו מתאים אותו. מלבן קולט כל טבלה שאינה בקבוצה ושמרכזה נמצא בתוכו, כפי ששרטוט קבוצה עושה. name ריק משאיר את הקבוצה ללא שם. קריאה אחת ל-erd_undo מסירה את הקבוצה ומחזירה כל טבלה לקבוצה שהייתה בה.
erd_remove_table_group	groupId	מסיר קבוצה. הטבלאות שלה נשארות במקומן, ללא קבוצה.
erd_change_table_group_name	groupId, value	משנה את שמה של קבוצה. מחרוזת ריקה משאירה אותה ללא שם.
erd_change_table_group_color	groupId, color	קובע את הצבע של קבוצה.
erd_move_table_group	groupId, x, y	מזיז קבוצה כך שהמלבן שלה מתחיל בנקודה הזו, ואת הטבלאות שלה באותו מרחק, כפי שעושה גרירה של שורת הכותרת שלה. הזזה של פחות מ-20 פיקסלים, בסכום התזוזה האופקית והאנכית, אינה יוצרת צעד ביטול. החל מגרסה 1.2.0 של השרת, ההזזה מגיעה לעורך כנקודות שבהן הקבוצה והטבלאות שלה מסתיימות, ולכן עם הרחבת VS Code בגרסה 4.3.0 ומעלה או עם התוסף ל-Obsidian או ל-JetBrains בגרסה 1.3.0 ומעלה, הזזה של הקבוצה או של אחת מהטבלאות שלה שנעשתה שם באותו רגע מסתיימת באחד משני המיקומים, ולעולם לא בסכומם – ראו עריכות שנעשות באותו רגע.
erd_resize_table_group	groupId, x?, y?, width, height	קובע את המלבן של קבוצה, והטבלאות שלה נשארות במקומן. השמטה של x ו-y משאירה את הפינה של המלבן במקומה. מלבן שלא יכיל את הטבלאות של הקבוצה עם הריווח שלהן נדחה, עם הודעה שמציינת את המלבן שהוא חייב להכיל.
erd_set_table_group	tableIds, groupId	מכניס טבלאות לקבוצה, וכל אחת מהן עוזבת כל קבוצה שהייתה בה. הערך null או מחרוזת ריקה ב-groupId מוציאים אותן מכל קבוצה.

כל עוד הקבוצות מוסתרות באמצעות View Option ← Table Groups, הכלים האלה עדיין מוסיפים ומשנים קבוצות, שנשארות מוסתרות עד שהקבוצות מוצגות – ראו הסתרת קבוצות. erd_sort_tables שומר את הטבלאות של כל קבוצה יחד, erd_import_dbml ו-erd_import_json מביאים קבוצות – ראו ייבוא – ו-erd_read כותב את ה-DDL של קבוצות נבחרות באמצעות groupNames. גרסה של ERD Editor שקודמת לקבוצות הטבלאות משמיטה את הקבוצות של קובץ כשהיא שומרת אותו, כפי שעושים הרחבת VS Code בגרסה שקודמת ל-4.0.0 והתוספים ל-Obsidian ול-JetBrains בגרסה שקודמת ל-1.0.0 – ראו עדכון.

מילונים

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

• מילה היא מילה תקנית ששמות לוגיים מורכבים ממנה, עם הקיצור שהיא כותבת בשם פיזי, כגון Member ו-MBR.
• מונח הוא שם לוגי שלם עם השם הפיזי שהוא נותן, ועבור עמודה, התחום שהוא מקשר, כגון Member Number עם MBR_NO ו-Identifier.
• תחום הוא סוג נתונים בעל שם שעמודות מקושרות אליו, כגון Identifier עבור INT.

כלי	ארגומנטים	מה הוא עושה
erd_add_word	name, abbreviation, englishName?, description?, synonyms?, forbiddenWords?	מוסיף מילה בסוף מילון המילים ומחזיר את המזהה שלה ב-createdIds. synonyms ו-forbiddenWords מופרדים בפסיקים: איותים אחרים של המילה, ומילים שאסור להשתמש בהן במקומה.
erd_update_word	wordId, name?, abbreviation?, englishName?, description?, synonyms?, forbiddenWords?	משנה את השדות שהועברו ומשאיר את השאר.
erd_remove_word	wordId	מסיר מילה.
erd_add_term	name, physicalName?, domainId?, domainName?, description?, synonyms?	מוסיף מונח בסוף מילון המונחים ומחזיר את המזהה שלו ב-createdIds. ללא physicalName, המילים מרכיבות שם פיזי אם הן יכולות, כגון MBR_NO עבור Member Number.
erd_update_term	termId, name?, physicalName?, domainId?, domainName?, description?, synonyms?	משנה את השדות שהועברו ומשאיר את השאר. name שמועבר כשהמונח אינו מכיל שם פיזי, או עם physicalName ריק, כותב גם את השם הפיזי שהמילים שלו מרכיבות, אם הן מרכיבות כזה.
erd_remove_term	termId	מסיר מונח.
erd_add_domain	name, category?, dataType, description?	מוסיף תחום בסוף מילון התחומים ומחזיר את המזהה שלו ב-createdIds. category מקבץ תחומים, כגון Number או Text.
erd_update_domain	domainId, name?, category?, dataType?, description?	משנה את השדות שהועברו ומשאיר את השאר. dataType חדש מגיע לכל עמודה שמקושרת לתחום, ועובר לאורך הקשרים כל עוד סנכרון סוג הנתונים בקשרים מופעל, עם אותו ביטול קישור כמו ב-erd_change_column_data_type.
erd_remove_domain	domainId	מסיר תחום. העמודות שמקושרות אליו שומרות על סוג הנתונים שלהן, והן והמונחים שמקושרים אליו אינם מציגים תחום: ה-domainId שלהם נקרא כמחרוזת ריקה. erd_undo מחזיר את הקישורים, ושמירה משמיטה אותם מהקובץ.
erd_derive_physical_names	scope, tableId?, columnId?	גוזר מחדש שמות פיזיים מהשמות הלוגיים, כפי שגזירה מחדש של השמות הפיזיים בעורך עושה, לעמודה אחת, לטבלה אחת או למסמך כולו.

• מילון מכיל כל שם פעם אחת, ולכן שם ששורה אחרת באותו מילון כבר מכילה נדחה עם invalidArgs. השמות מושווים לאחר הסרת הרווחים שבקצוות, ובהתחשב ברישיות, כך ש-Member ו-member הם שני שמות.
• עדכון מציין את השורה לפי המזהה שלה ומעביר לפחות שדה אחד. ערכים שהשורה כבר מכילה אינם משנים דבר ואינם יוצרים צעד ביטול; הוספה או הסרה תמיד יוצרות צעד ביטול.
• התחום של מונח ניתן באמצעות domainId, עם null או מחרוזת ריקה כשאין תחום, או באמצעות domainName, עם מחרוזת ריקה כשאין תחום. domainName לוקח את התחום הראשון בשם הזה לפי סדר המילון, בהשוואה כמו של שמות. העברה של שניהם, או של domainName שאף תחום אינו נושא, נדחית. erd_set_column_domain מקבל תחום באותו אופן.
• שינוי או הסרה של מילה או של מונח אינם משנים אף שם ואינם מבטלים אף קישור: השמות והתחומים שהם נתנו נשארים כפי שהם. erd_derive_physical_names גוזר מחדש את השמות ומקשר את התחום שמונח נותן כעת, אבל עמודה שאף מונח אינו תואם לה כעת, או שהמונח שלה אינו נותן תחום, שומרת על התחום שהיא מקושרת אליו. erd_set_column_domain עם domainId ריק מבטל את הקישור שלה.
• אף כלי אינו מייבא או מייצא מילון כ-CSV, ממיין מילון או מוסיף שורות במיקום מסוים, כפי שכרטיסיית מילון עושה.

erd_list מציג את השורות, erd_get מחזיר כל שדה, הפורמט snapshot של erd_read מכיל את כולן, ו-erd_list_checks מציג את מה שהמילונים מוצאים כשגוי – ראו קריאת מסמך.

erd_set_table_logical_name ו-erd_set_column_logical_name גוזרים שם פיזי כפי שהעורך עושה כשנכתב שם לוגי – ראו גזירת שמות פיזיים:

• שם נגזר רק כל עוד הוא ריק או שהוא עצמו נגזר, מה שהקריאות מציגות כ-nameDerived: true. שם שאינו ריק ונכתב ידנית נשאר, ורק השם הלוגי נכתב. erd_change_table_name, erd_change_column_name, ייבוא של SQL, GraphQL, DBML ו-AML, ועמודות המפתח הזר ש-erd_add_relationship נותן להן שמות, כולם כותבים שמות ידנית. שם ששונה למחרוזת ריקה נגזר מחדש על ידי השם הלוגי הבא.
• המונח שהשם שלו הוא השם הלוגי קודם לכול, בהשוואה כמו של שמות במילון. הוא נותן את השם הפיזי שלו, או את השם שהמילים שלו מרכיבות כשאין לו שם פיזי. עבור עמודה, הוא גם מקשר אליה את התחום של המונח, גם כשלא נגזר אף שם, והעמודה מקבלת את סוג הנתונים של התחום, שעובר לאורך הקשרים כל עוד סנכרון סוג הנתונים בקשרים מופעל.
• כשאין מונח כזה, המילים מרכיבות את השם, והקיצורים שלהן מחוברים בקווים תחתונים: Member Number נותן MBR_NO. זה הכול או כלום: מילה נרדפת, מילה אסורה, טקסט שאף מילה אינה מציינת, או מילה ללא קיצור אינם מרכיבים דבר, והשם נשאר כפי שהיה. המילים אינן מקשרות תחום, וגם לא מונח שאין לו תחום, ולכן עמודה שומרת על התחום שהיא מקושרת אליו.
• עמודה שהשם הנגזר שלה כבר שייך לעמודה אחרת בטבלה שלה, ללא תלות ברישיות, שומרת על השם שלה, על ה-nameDerived שלה ועל התחום שלה.
• ניקוי של שם לוגי משאיר את השם הפיזי כפי שהוא. קריאה שהשם הלוגי שלה, ומה שהוא גוזר, כבר קיימים אינה משנה דבר ואינה יוצרת צעד ביטול.

erd_derive_physical_names מקבל scope: column, עם tableId ו-columnId, לעמודה הזאת; table, עם tableId, לשם של הטבלה ולכל העמודות שלה; או document, ללא מזהה, לכל טבלה ולעמודות שלה. scope שחסר לו מזהה שהוא צריך, או שקיבל מזהה שהוא אינו מקבל, נדחה. כל שם שהקריאה חלה עליו ושיש לו שם לוגי חוזר לניהול המילונים, כולל שם שנכתב ידנית, ומקבל את מה שהם נותנים כעת: השם הפיזי של מונח, ועבור עמודה גם את התחום ואת הסוג שלו, או אחרת את מה שהמילים מרכיבות, מה שמשאיר את התחום של העמודה כפי שהוא. שם לוגי שאינו גוזר דבר משאיר את השם כפי שהוא, כש-nameDerived הוא כעת true. שם ללא שם לוגי נשאר כפי שהוא, וכך גם עמודה שהשם החדש שלה שייך לעמודה אחרת בטבלה שלה, כגון מפתח זר שני לאותה טבלה, שגם שומרת על ה-nameDerived שלה. קריאה אחת ל-erd_undo מבטלת את הקריאה כולה. השמות של סכמה מיובאת נחשבים לשמות שנכתבו ידנית, ולכן כדי לתת לה שמות מהמילונים יש לקבוע את השמות הלוגיים ואחר כך לקרוא ל-erd_derive_physical_names. הקריאה הזאת נותנת את השם הפיזי של המונח עצמו, ששינוי במילים של המונח אינו מרכיב מחדש. לכן, אחרי שינוי המילים של מונח, יש לעדכן תחילה את המונח: להעביר את ה-name שלו עם physicalName ריק כדי שהמילים ירכיבו אותו מחדש, או להעביר את ה-physicalName החדש.

גרסה של ERD Editor שקודמת לכרטיסיית מילון משמיטה את השמות הלוגיים, את הקישורים לתחומים ואת שורות המילון של קובץ כשהיא שומרת אותו, כפי שעושים הרחבת VS Code בגרסה שקודמת ל-4.2.0 והתוספים ל-Obsidian ול-JetBrains בגרסה שקודמת ל-1.2.0. מביניהן, ההרחבה בגרסה 4.0.0 או 4.1.0 והתוספים בגרסה 1.0.0 או 1.1.0 עדיין עורכים בזמן אמת עם השרת, אך אינם מציגים ואינם שומרים את השמות הלוגיים, את הקישורים לתחומים ואת שורות המילון שסוכן כותב – ראו עדכון.

הגדרות

סוכן קובע את ההגדרות של הסכמה עצמה: מסד הנתונים, השם שלו והסקריפטים של סכמת SQL. כל הגדרה אחרת שהמסמך שומר נקבעת בידי המשתמש בעורך: תצוגת השמות, המתגים של אפשרויות התצוגה, האפשרויות של כרטיסיית הגדרות, שפת הקוד וסגנונות השמות של מחולל הקוד, סוג המירכאות והנעילות. אף כלי אינו משנה אותן, מלבד כלי הייבוא במצב replace: erd_import_json מביא את ההגדרות והנעילות של המסמך שהוא טוען, וארבעת האחרים מחזירים את התצוגה לתחילת בד הציור – ראו ייבוא. השרת בגרסה 1.0.0 הסיר את הכלים שקבעו אותן: erd_set_language, erd_set_table_name_case, erd_set_column_name_case, erd_set_bracket_type, erd_set_relationship_data_type_sync, erd_set_relationship_optimization, erd_set_column_order, erd_set_max_width_comment, erd_set_ignore_save_settings ו-erd_set_show.

erd_list והפורמט snapshot של erd_read מדווחים על ההגדרות כפי שהקובץ שומר אותן, כש-lockSettings מכיל דגל אחד לכל נעילה: viewport, canvasType, language, tableNameCase, columnNameCase, bracketType ו-unlockNameViewMode. האחרון מתפרש הפוך: הוא false כל עוד הנעילה Name View מופעלת, כפי שהיא במסמך חדש ובקובץ שנשמר לפני שהנעילה הזאת הייתה קיימת, ו-true לאחר שהמשתמש מכבה את הנעילה. שפת קוד, סגנון שמות או סוג מירכאות נעולים מדווחים בערך הנעול שלהם, זה שהקובץ שומר ושכל עורך נפתח בו, בלי קשר למה שמוצג במסך של עורך. התצוגה, הכרטיסייה ותצוגת השמות אינן מדווחות. סוכן קורא וכותב שמות לוגיים בלי קשר למה שתצוגת השמות מציגה.

erd_set_ddl_script יוצר צעד ביטול. erd_set_database ו-erd_set_database_name אינם יוצרים צעד כזה, ולכן erd_undo אינו יכול לבטל אותם.

כלי	ארגומנטים	מה הוא עושה
erd_set_database	value	קובע את מסד הנתונים: MariaDB, MSSQL, MySQL, Oracle, PostgreSQL, SQLite, Databricks או Snowflake. הוא בוחר את סוגי הנתונים של מסד הנתונים, ואת ה-DDL ש-erd_read כותב כשלא ניתן vendor.
erd_set_database_name	value	קובע את שם מסד הנתונים, שהכותרות use ו-createAndUse של erd_read מציינות.
erd_set_ddl_script	position, sql	קובע אחד משני הסקריפטים שנכתבים סביב הטבלאות – ראו סקריפטים לפני הטבלאות ואחריהן. position הוא before, שנכתב לפני הטבלאות, כגון CREATE EXTENSION או CREATE SCHEMA, או after, שנכתב אחריהן, כגון GRANT או CREATE VIEW. sql מחליף את הסקריפט כולו, עד 10,000 תווים, ומחרוזת ריקה מסירה אותו. יש לקרוא תחילה את הסקריפט הנוכחי באמצעות הפורמט scripts של erd_read.

סקריפט נכנס כמות שהוא ל-DDL של כל מסד נתונים, ולכן יש לכתוב אותו עבור מסד הנתונים של המסמך. ב-MSSQL, שורת GO מתווספת אחרי סקריפט שהשורה האחרונה שלו אינה GO. גרסה של ERD Editor שקודמת לסקריפטים האלה משמיטה את הסקריפטים של קובץ כשהיא שומרת אותו, כפי שעושים הרחבת VS Code בגרסה שקודמת ל-4.0.0 והתוספים ל-Obsidian ול-JetBrains בגרסה שקודמת ל-1.0.0 – ראו עדכון.

ייבוא

הכלים האלה קוראים סכמה כפי שעושה תפריט הייבוא של העורך – ראו ייבוא וייצוא של קבצים. כל אחד מהם מקבל את הטקסט כ-value, ואת mode: replace, ברירת המחדל, או append.

כלי	ארגומנטים	מה הוא עושה
erd_import_sql	value, mode?	טוען DDL של SQL, משפטי CREATE TABLE וכדומה.
erd_import_graphql	value, mode?	טוען SDL של GraphQL.
erd_import_dbml	value, mode?	טוען DBML. כל TableGroup הופך לקבוצת טבלאות של הטבלאות שהוא מציין – ראו DBML.
erd_import_aml	value, mode?	טוען AML.
erd_import_json	value, mode?	טוען מסמך JSON של erd-editor, כגון קובץ .erd.json אחר.

replace מחליף את המסמך, ו-erd_undo משחזר את המסמך הקודם:

• erd_import_sql, erd_import_graphql, erd_import_dbml ו-erd_import_aml מחליפים כל טבלה, קשר, אינדקס, פתק וקבוצת טבלאות. הם שומרים על ההגדרות של המסמך, כולל הנעילות שלו, מלבד התצוגה, שחוזרת לתחילת בד הציור ב-100%, והם שומרים על מילוני המילים, המונחים והתחומים שלו. לטבלאות שהם מביאים אין שמות לוגיים, ואף אחת מהן אינה מקושרת לתחום.
• erd_import_json מחליף את המסמך כולו, כולל ההגדרות והמילונים שלו: ההגדרות, הנעילות, המילים, המונחים והתחומים של ה-JSON באים במקום אלה של המסמך הזה, ו-JSON שאינו מתעד נעילות מפעיל את כל הנעילות ומציב את התצוגה בתחילת בד הציור. כל צופה שומר על תצוגת השמות שלו, אלא אם הנעילה Name View כבויה ב-JSON, ואז הוא מביא את תצוגת השמות שלו. כדי לשמור על ההגדרות של המסמך הזה, יש להתחיל מהטקסט שהפורמט json של erd_read מחזיר. טקסט ריק נותן מסמך חדש, כמו זה ש-erd_open_document יוצר עם create.

בעורך עם הרחבת VS Code בגרסה 4.3.0 ומעלה או עם התוסף ל-Obsidian או ל-JetBrains בגרסה 1.3.0 ומעלה, replace ו-erd_undo או erd_redo שלו מסיימים גם ציור קשר שהמשתמש מבצע – ראו מצב חי.

append מוסיף את הייבוא למסמך, כפי שעושה ייבוא והוספה בעורך, וקריאה אחת ל-erd_undo מסירה את כל התוספת:

• מה שהטקסט מכיל נכנס כישויות חדשות עם מזהים חדשים, בבלוק שמתחת לכל מה שהמסמך מכיל, כולל פתקים וקבוצות טבלאות מוסתרים, ומיושר לקצה השמאלי של התוכן הקיים. כל טבלה והגדרה שכבר קיימות נשארות, כולל טבלה בעלת אותו שם: שום דבר אינו מתמזג לפי שם.
• קשרים ואינדקסים נוצרים רק בין הטבלאות שהייבוא מביא, ולכן מפתח זר לטבלה שהטקסט אינו מצהיר עליה מושמט.
• erd_import_sql, erd_import_graphql ו-erd_import_aml מוסיפים טבלאות עם הקשרים והאינדקסים שלהן, ו-erd_import_dbml גם את קבוצות הטבלאות שלו. erd_import_json מוסיף טבלאות, קשרים, אינדקסים, פתקים וקבוצות טבלאות, לעולם לא את ההגדרות שלו, ודוחה טקסט ריק. הטבלאות והעמודות שלו מביאות את השמות הלוגיים שלהן, אבל אף עמודה אינה מקושרת לתחום, ואף אחת מהמילים, מהמונחים או מהתחומים של ה-JSON אינה נכנסת.

מסמך JSON שומר על הסידור שלו, כולל קבוצות הטבלאות שלו: עם replace במקום שבו הוא ממקם את הטבלאות שלו, ועם append בתוך הבלוק שנוסף. הטבלאות של SQL, GraphQL, DBML ו-AML נפרסות בשורות, בסדר עולה של מספר העמודות ועם הטבלאות של כל קבוצה יחד, כפי ש-erd_sort_tables ממקם אותן, ולעולם לא בפריסת Flow, שבה הייבוא של העורך עצמו פורס אותן כשהדבר אפשרי. ארבעת הכלים האלה דוחים טקסט ריק בשני המצבים.

erd_batch

erd_batch מריץ כמה כלי עריכה לפי הסדר כעריכה אחת, הכול או כלום.

• operations מכיל עד 100 רשומות, כל אחת { tool, as?, args? }, כש-tool הוא כלי עריכה ו-args הם הארגומנטים של הכלי ללא path. כלי קריאה, כגון erd_list_checks, נדחה.
• הפעולות מנוסות תחילה על עותק של המסמך. פעולה שנדחית מצוינת בשמה, כגון operations[1] erd_remove_table: …, ושום דבר אינו מוחל.
• קריאה אחת ל-erd_undo מבטלת את כל האצווה, מלבד הפעולות שאין באפשרותה לבטל, שה-undoNote של התוצאה מציין: פעולות של כלי שאינו יוצר צעד ביטול, כגון erd_set_database, ופעולות ששינו את המסמך בלי ליצור צעד כזה, כגון erd_move_table_group קצר. erd_undo מדלג על אצווה שלא יצרה אף צעד ביטול. historyEntries בתוצאה סופר את הרשומות בהיסטוריית העורך שבתוך האצווה, ולא קריאות ל-erd_undo.
• בסשן במצב חי, העורך מקבל את האצווה כולה או אף לא חלק ממנה.

סוכן אינו יכול לדעת את המזהים שאצווה יוצרת לפני הקריאה, ולכן פעולה שקיבלה שם באמצעות as מאפשרת לפעולה מאוחרת יותר להפנות אליהם: $name או $name.0 למזהה הראשון שהיא יצרה, $name.1 לשני, ו-$name.last לאחרון. שם מכיל אותיות ASCII, ספרות וקווים תחתונים, אינו מתחיל בספרה, ומציין פעולה אחת בלבד. הפניה נפתרת רק במקום שבו ארגומנט מקבל מזהה של ישות, כולל wordId, termId ו-domainId, ולכן שם או הערה שכתוב בהם $x נשארים טקסט. גם domainName הוא טקסט, אבל הוא נקרא כשהפעולה שלו רצה, ולכן הוא יכול לציין תחום שפעולה מוקדמת יותר באצווה הוסיפה.

טבלה עם העמודות שלה וקשר, בקריאה אחת:

{
  "path": "shop.erd.json",
  "operations": [
    { "tool": "erd_add_table", "as": "users" },
    { "tool": "erd_change_table_name", "args": { "tableId": "$users", "value": "users" } },
    { "tool": "erd_add_column", "as": "uid", "args": { "tableId": "$users" } },
    { "tool": "erd_change_column_name", "args": { "tableId": "$users", "columnId": "$uid", "value": "id" } },
    { "tool": "erd_change_column_data_type", "args": { "tableId": "$users", "columnId": "$uid", "value": "BIGINT" } },
    { "tool": "erd_set_column_primary_key", "args": { "tableId": "$users", "columnId": "$uid", "value": true } },
    { "tool": "erd_add_table", "as": "orders" },
    { "tool": "erd_change_table_name", "args": { "tableId": "$orders", "value": "orders" } },
    { "tool": "erd_add_relationship", "args": { "startTableId": "$users", "endTableId": "$orders", "relationshipType": "ZeroN", "onDelete": "cascade" } }
  ]
}

הטבלה users והמפתח שלה id מקבלים שם לפני הקשר, ולכן עמודת המפתח הזר שהקשר מוסיף ל-orders היא users_id.

מילים, תחום ומונח, ואחריהם טבלה שמקבלת מהם שמות לפי השמות הלוגיים שלה:

{
  "path": "shop.erd.json",
  "operations": [
    { "tool": "erd_add_word", "args": { "name": "Member", "abbreviation": "MBR" } },
    { "tool": "erd_add_word", "args": { "name": "Number", "abbreviation": "NO" } },
    { "tool": "erd_add_word", "args": { "name": "Name", "abbreviation": "NM" } },
    { "tool": "erd_add_domain", "as": "identifier", "args": { "name": "Identifier", "dataType": "INT" } },
    { "tool": "erd_add_term", "args": { "name": "Member Number", "domainId": "$identifier" } },
    { "tool": "erd_add_table", "as": "members" },
    { "tool": "erd_set_table_logical_name", "args": { "tableId": "$members", "value": "Member" } },
    { "tool": "erd_add_column", "as": "no", "args": { "tableId": "$members" } },
    { "tool": "erd_set_column_logical_name", "args": { "tableId": "$members", "columnId": "$no", "value": "Member Number" } },
    { "tool": "erd_add_column", "as": "nm", "args": { "tableId": "$members" } },
    { "tool": "erd_set_column_logical_name", "args": { "tableId": "$members", "columnId": "$nm", "value": "Member Name" } }
  ]
}

המונח מרכיב את MBR_NO מהמילים שלו, והטבלה מקבלת את השם MBR. העמודה Member Number מקבלת את ה-MBR_NO של המונח ואת התחום שלו, ולכן היא מקושרת ל-Identifier ומקבלת את הסוג INT, ו-Member Name, שאף מונח אינו מכיל, מורכב כ-MBR_NM.

תוצאות

עריכה מחזירה שורה אחת של JSON:

{"tool":"erd_add_table","mode":"live","createdIds":["03h17be2plxpj5n59tqag7ogj"],"batches":1,"historyEntries":1}

שדה	משמעות
mode	live או headless – ראו מצב חי ומצב ללא ממשק.
saved	true בתוצאה של כל עריכה במצב ללא ממשק, של erd_batch, של erd_undo ושל erd_redo: הקובץ מכיל את השינוי עד שהקריאה עונה, כך שלא נשאר דבר לשמור. בתוצאה במצב חי אין saved, מכיוון שהעורך מחזיק את השינוי – ראו שמירה.
createdIds	המזהים של מה שהקריאה יצרה, לפי הסדר.
batches, historyEntries	כמה אצוות שינויים הקריאה שלחה, וכמה רשומות בהיסטוריית העורך היא יצרה.
undoable, undoNote	undoable הוא false כש-erd_undo ידלג על הקריאה, ו-undoNote מסביר מדוע: הכלי אינו יוצר צעד ביטול, הקריאה שינתה את המסמך בלי ליצור צעד כזה, כפי שעושה erd_move_table_group של פחות מ-20 פיקסלים, או שהערך כבר היה במסמך. תוצאה של erd_batch כוללת תמיד undoNote. כשהאצווה יצרה צעד ביטול, ההערה מציינת שקריאה אחת ל-erd_undo מבטלת את האצווה, ומציינת כל פעולה שהביטול משאיר בתוקף; כשלא יצרה, התוצאה כוללת undoable: false, וההערה מציינת ש-erd_undo מדלג עליה.
mismatch	קיים כשהקריאה יצרה מספר אצוות או רשומות בהיסטוריה שונה ממה שהכלי מצהיר.
notes	קיים כשמשהו בסשן השתנה, כגון עורך שנסגר או הפסיק לשרת את המסמך, או קובץ שהשתנה בדיסק.

סירוב הוא תוצאת שגיאה שכוללת קוד והודעה שמסבירה מה לעשות:

{"error":{"code":"notFound","message":"tableId nope names no live table; read the document for current ids"}}

code	סיבה
notFound	מזהה אינו מציין שום דבר שקיים כעת, או שהקובץ אינו קיים.
invalidArgs	ארגומנט חסר או שיש לו ערך שגוי.
invalidPath	הנתיב אינו מסמך ERD. ב-Windows, גם נתיב עם שם ש-Windows אינו שומר כפי שנכתב, או נתיב שמגיע למסמך שעורך מחזיק תחת נתיב אחר, שההודעה מציינת.
invalidDocument	הקובץ אינו מסמך שהעורך יכול לקרוא.
tooLarge	קריאה אינה נכנסת בתשובה אחת.
blocked	עורך שה-hub שלו כבוי מחזיק את המסמך. ההודעה מסבירה כיצד להפעיל אותו: ב-VS Code, לתת אמון בסביבת העבודה ולהפעיל את dineug.erd-editor.agentHub.enabled, או לטעון מחדש את החלון; ב-Obsidian, להפעיל את Coding agents, או לטעון מחדש את Obsidian; ב-IDE של JetBrains, להפעיל את Coding agents, או להפעיל מחדש את ה-IDE אם ההגדרה מופעלת.
hubDisabled	IDE של JetBrains מחזיק את המסמך רק בפרויקט שהוא אינו נותן בו אמון. קריאות עדיין עובדות; כדי לאפשר לסוכן לערוך, יש לתת אמון בפרויקט.
conflict	הקובץ השתנה בדיסק במהלך הקריאה. שום דבר לא נכתב.
hubAppeared, hubGone	עורך התחיל לשרת מסמך שהסוכן ערך בדיסק, או שהעורך ששירת אותו עדיין פועל, אבל קובץ הנעילה והחיבור שלו נעלמו. שום דבר לא נכתב.
notSaved	erd_save לא הצליח לשמור את המסמך של העורך.
readonly	העורך מחזיק את המסמך לקריאה בלבד, כגון קובץ שהוא אינו יכול לכתוב אליו או אינו יכול לקרוא כתרשים. כשאין עורך, הקובץ עצמו לקריאה בלבד, כגון קובץ Perforce או TFVC שלא בוצע עליו check out. שום דבר לא נכתב.
protocolMismatch	ההרחבה או התוסף של ERD Editor בעורך והשרת מדברים בגרסאות פרוטוקול שונות, כגון השרת בגרסה 1.0.0 ומעלה עם הרחבת VS Code בגרסה 3.x. גם קריאות נדחות, וההודעה מציינת את הצד שיש לעדכן – ראו עדכון.
hubUnreachable, timeout, disconnected	ה-hub של עורך לא קיבל את החיבור, לא ענה בתוך 30 שניות, או ניתק במהלך הקריאה. ב-Windows, hubUnreachable פירושו גם ש-Windows מנע מהסוכן גישה ל-hub: העורך פועל עם יותר הרשאות מהסוכן, כמו כשהוא הופעל כמנהל מערכת והסוכן לא, או שהסוכן פועל בארגז חול.

קודים אחרים נדירים יותר, וכל סירוב כולל הודעה שמסבירה מה קרה.

כלי העריכה, erd_batch וארבעת כלי הקריאה דוחים ארגומנט שהם אינם מצהירים עליו, או ארגומנט מסוג שגוי, בשגיאת invalid params של JSON-RPC (-32602) לפני שהם נוגעים במסמך, כך שארגומנט עם שגיאת כתיב לעולם אינו מושמט בשקט. חמשת כלי הסשן מתעלמים מארגומנטים שהם אינם מכירים.