מודל אנמי (Anemic Domain Model) - דפוס עיצוב שלילי

מודל אנמי (Anemic Domain Model, או בקיצור ADM) הוא תיאור שמתייחס למודל "מוחלש" בצורה שאתאר מיד.

הצורה הנפוצה והפשוטה של מודל אנמי היא מצב בו קיים פער או מרחק בין ה state - הנשמר במחלקה אחת, לפעולות - הנשמרות במחלקה אחרת.

• במבט ראשון המחלקות נראות הגיוניות: יש להן גודל הגיוני, תחום התעסקות הגיוני, מתודות הגיוניות וכו'.
• במבט שני אנו שמים לב שבעצם רוב הפעולות של ה state מתבצעות במקום "מרוחק" - כל פעילות על Order מתבצעת ב OrderManager.

באופן טיפוסי המחלקה בעלת המתודות תיקרא בשמות כגון xxxManager, xxxService, xxxHandler או xxxUtils - שמות המעידים על קשר ברור, אך אחריות כללית שקשה להגדירה.

כאשר אנחנו מזהים מודל אנמי, הדבר הראשון שמציק לנו הוא ש "זוהי איננה גישת Object Oriented: הרי מחלקות צריכות להכיל גם את ה state וגם את הפעולות על ה state - באותו המקום".

בצורה יותר פורמאלית ניתן לומר שיש לנו שתי מחלקות בעלות high cohesion (קרבה רעיונית גדולה) אבל גם high coupling (תלות חזקה). מדוע אם כן אלו שתי מחלקות, ולא מחלקה אחת?!

מה הבעיה לחבר ביניהן?

ובכן - לכו ובדקו.


בד"כ זה לא עניין של קובץ גדול מדי (כמה גדול יכול להיות ה state?!). סיכויים טובים שתגלו ש:

• אובייקט ה Order הוא Data Access Object (מכיל ידע על שמירה לבסיס הנתונים) או Data Transfer Object (מכיר ידע על serialization בכדי לעבור על גבי הרשת) - קוד שמרגיש לא נכון לערבב אותו עם "Business Logic", או
• יש יותר ממחלקה אחת המבצעת פעולות על Order. למשל:

דפוס שכדאי לשים לב אליו הוא מתודות ב Service/Manager/Handler המקבלות את האובייקט כולו לצורך פעולות של שינוי state. משהו בנוסח:

updateItemPrices(Order o) // updates the order with up-to-date item prices

מתודה כאלו נקראות external methods.

מקור

"אחי, מה כואב לך?"

מה אכפת לנו, בעצם?

הקוד עובד? - עובד.
הכנסנו שינויים לקוד, והמערכת לא "התפוצצה"? - גם נכון, היא לא "התפוצצה".

אז מה זה משנה שיש לנו Anemic Domain Model (בקיצור: ADM)?


נתחיל בדוגמה ממקום קצת אחר.

מכירים את המצב בו יש לנו מערכת חיצונית בה משתמשות מספר מחלקות במערכת, מערכת לשליחת מיילים - למשל?

האם נרשה לכל מחלקה במערכת לגשת אליה ישירות?

מה פתאום!!!

בסיטואציה כזו, הקונצנזוס הוא גורף ומיידי!

• "ומה אם נרצה להחליף את מערכת צד השלישי לספק אחר?"
• "ומה אם נרצה להוסיף פונקציונליות (למשל throttling או logging) גורפת לכל העולות מול אותו ספק?"

ברור שנרצה מחלקה אחת (להלן דפוס של Gateway) שדרכה תתבצע כל אינטראקציה עם השירות החיצוני.


מדוע אם כן אנו שלווים, כאשר יש מספר מחלקות הניגשות ל state במערכת, שלא ע"י נקודת גישה אחת?

• מה יקרה אם נרצה לשנות את הייצוג של ה state של Order / לבצע refactoring?
• מה יקרה אם נרצה להוסיף פונקציונליות (אימות נתונים, או Logging) גורפת על ה state הזה?

הסיטואציות הן שקולות. 

יתרה מכך: שינוי state באובייקט ליבה של הדומיין הוא נפוץ יותר מהחלפה של ספק חיצוני.

אני מניח שהסיבה שאיננו מוכנים לקבל את הסיטואציה בתצורה אחת, בעוד אנחנו מוכנים לקבל את אותה הסיטואציה (וחמורה יותר) בתוצרה שונה - היא פשוט עוד הטיה אנושית, לא רציונלית.

בטבע פותרים אנמיה בעזרת תזונה טובה יותר.
בתוכנה פותרים אנמיה בעזרת הכמסה ו/או Rich Domain Model.

מה הבעיה עם ADM? - ניתוח פורמאלי

הבעיה העיקרית של ADM היא המחסור בהכמסה (Encapsulation).

האובייקט Order לא יכול "לשלוט" במה שקורה ל properties שלו - כי "כל העולם נוגע ב properties בלי לשאול אותו". כלומר: אין מתודות שליטה בגישה ל properties - בהן אפשר לבצע validations או לקבוע התנהגויות.

כתוצאה מכך:

• יווצר קוד כפול שבודק את תקינות ה properties של Order - באופן אקראי במחלקות A, B, C.
• קוד הבדיקה, ותפעול (שינוי הערכים) של Order properties, במחלקות A, B, C - לא יהיה עקבי, וייתכן שיכיל חוסר-התאמות ואף סתירות.
• מכאן יווצרו באגים, שיאטו את הפיתוח בשני אופנים:
• הצורך לתקן את הבאגים - שקשה למנוע את היווצרותם.
• הפחד מלבצע שינויים במערכת (המחשבה ש״שינוי״ יגרום ל״באג״) -> הקוד פחות מתחדש, פחות מתעדכן לצרכים העדכניים מהמערכת -> יותר עבודה להכניס שינויים.
• הבעיה תלך ותחמיר ככל שהמערכת תגדל: יותר קוד (A עד F שעובדים עם Order, במקום A עד C), ויותר מפתחים שעובדים על ה codebase. 
• הבאגים שיווצרו יהיו גם הם - קשים יותר לאיתור.
• עם הזמן הערכת הזמנים לשינויים בקוד הופכת להיות פחות אמינה: שיניתי ב A את הדברים, אבל רק לקראת סיום גיליתי שב C יש מנגנון שלם מסביב ל state שנגעתי בו - וצריך להמשיך בפיתוח בלתי-מתוכנן.
• זו לא בעיה מסוג הבעיות ש״מתפוצצות״, אלא מסוג הבעיות שהן רגרגסיות הדרגתיות שלא מבחינים בהן בזמן שהן מתרחשות.

אני לא יודע כיצד להדגיש מספיק עד כמה הבעיה הזו הרסנית למערכת, במיוחד אם מדובר בקוד בליבת המערכת (core domain model), ובמיוחד כאשר מדובר במערכת בעלת חוקים עסקיים מורכבים.

מצב לא תקין שחלחל. גורם לקושי לאתר את מקור התקלה - ולצורך בתיקונים מורכבים יותר. הסתכלו על ה flow הבא:

כאשר אנחנו "מגלים" שיש לנו מצב לא תקין בשלב 4 - נעשו כבר נזקים, ויותר קשה לנו לאתר את שלב 1 - בו באמת קרתה התקלה.

הנטיה הטבעית, קצרת הטווח, היא להוסיף הגנות נוספות ב Class W, ולאחר שגילינו שדברים הסתבכו - עוד בדיקות ב Class Y. התוצאה: כפילות קוד, חוסר קונסיסטניות, ואי פתרון שורשי של הבעיה!

תופעת לוואי נוספות הן בדיקות פחות יעילות: מכיוון שקוד אימות ה state נמצא ״עמוק״ ב branching של הקוד - סביר יותר שהבדיקות יריצו תסריטים בעייתים מבלי שהמצב יתגלה:

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

הפתרון הוא כמובן פשוט מאוד - Fail Fast!
ואת זה משיגים בעזרת בדיקות תקינות ה state - ברגע שהוכנס ערך, ולא שורה מאוחר יותר.

מנקודות מבט מסוימות "failing fast" עשויה להראות כמו גישה המעודדת כפילות קוד - אך בפועל זו גישה המפשטת משמעותית את ה maintenance.
חוצמזה, אין סיבה לבדוק פעמיים. אם אתם סומכים על הבדיקות של Order - מחלקות אחרות יכולות לוותר על הבדיקה הכפולה.



אני רוצה לחדד פעם נוספת את הבעיה שביכולת לבצע שינויים ב state ממקומות שונים, ומדוע בעיות של data integrity  (להלן ״שלמות נתונים״) גורמות להאצה וסיבוך של באגים בקוד.

ניקח כדוגמה את המחלקה Triangle - משולש. לא מחלקה פשוטה מדי (אחרת ייתכן ואין בעיה), אבל מספיק פשוטה בכדי להשתמש בה בפוסט.

הנה דוגמה:

יש המון וריאציות של משולשים תקינים, אך לא כולם כאלו.

אם לדוגמה נשנה את ערכי אחת הזוויות כך שסך הזוויות יהיה 190 מעלות - חישוב השטח שלנו לא יהיה נכון.

האם יעוף exception באותו הרגע? לא.

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

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

זו לא דוגמה ליעילות תפעולית.
זו גם דוגמה לבעיה שאפשר להניף בה הרבה אצבעות מאשימות, ולפספס בכלל שמדובר בבעיה ארכיטקטונית (הרי מישהו כתב קוד במחלקה C. למה הוא לא בדק מה מתרחש במחלקה B?!).

אפשר לטעון (בכמה מישורים) שהקוד שהצגתי הוא לא אופטימלי - כי הוא מאפשר ל state להיכנס למצב בלתי-תקין בקלות. למשל: אין בעיה להוסיף זווית רביעית למשולש.

הנה שיפור, עם יותר constraints, ויותר ערכים מחושבים (derived values):

כאן כבר לא נוכל לקבוע משלוש עם סך זוויות פנימיות של 190 מעלות, או ארבע זוויות פנימיות. זהו שיפור.

אבל עדיין נוכל לקבוע:

• זווית של 0 מעלות
• זווית של 200 מעלות, ולגרור מכך זוויות עם ערכים שליליים של זוויות
• 3 זוויות שמסתכמות ל 180 מעלות, ושלוש צלעות סבירות לכאורה - שהן עדיין לא משולש הגיוני.

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

המגבלה שאיני יכול לקבוע את הזווית השלישית בצורה ישירה - יכולה בקלות לסרבל את הקוד שמתשמש ב Triangle.

המשולש הוא מטאפורה, לאובייקט עסקי מורכב.

ואובייקט עסקי מורכב הוא כזה שקל לייצר ב state שלו מצבים בלתי-נכונים.

מכיוון שאין כוונת זדון, לא סביר באמת שמישהו יקבע זווית פנימית של 3600000-.

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

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

הקוד לא נבדק. זהו pseudo code שנכתב בזריזות
עדכון: תודה לעידו שהעיר שהקוד הזה לא ישים. יש לאפשר מתודה set המקבלת את שלושת הזווית / צלעות - כי כמעט כל שינוי במשולש כך שיישר תקין מצריך לפחות זוג של שינויים. אני מניח שעדיין אפשר להבין את העיקרון.
הערה נוספת: שווה להוסיף בדיקה ל value גדול מ 0. 

אימות הנתונים הקפדני שווה רק כל עוד יש הכמסה על ה state.
אם מסירים את ה private מהשדות הפנימיים - כל האימות הופך לפרוץ עד חסר-משמעות.

מודל אנמי - שלב 2

עוד בעיה שמתרחשת עם מודל אנמי היא טרנזיטיביות של התלויות.

נניח שיש לנו מודל מורכב יותר (composite) של הזמנה - ופריט בהזמנה (להלן LineItem). למשל: ההזמנה היא הזמנה מהסופר, וה LineItems הם קורנפלקס, חמאת בוטנים, ולחם אחיד.

האם נכון שה Service Classes (או אובייקטים אחרים) המכירים את Order, יכירו גם את LineItem ואם כן - באיזו מידה?

הערה חשובה: מדובר על מצב בו בין Order ו LineItem יש קשר של composition (ב UML: מעוין שחור / "כתף מלאה"), כלומר: לאובייקט LineItem אין קיום או משמעות ללא אובייקט Order.

אם מחלקת שירות יכולה לשנות ערכים מ LineItem מבלי שה Order יידע או יוכל להגיב - מדובר בהפרת ההכמסה.
אם, גרוע יותר, מחלקת שירות יכולה לכתוב ולקרוא LineItem ישירות מה DB מבלי שה Order יהיה מעורב - מדובר בהפרת הכמסה.

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

הסכנה אם כן היא שמחלקת שירות תבצע שינויים על LineItem כלשהו, ותיצור:

• סתירה / חוסר-התאמה עם תכונה של אובייקט ה Order. 
• למשל אובייקט ה Order צריך לדעת אם צריך משלוח עם קירור, אבל הוספה של קוטג' למשלוח תשנה את המצב מבלי שהוא יהיה מודע לו.
• סתירה / חוסר-התאמה עם ה state של LineItem אחר.
• למשל: יש כלל שאסור להכניס לאותה הזמנה בשר וחלב. אם יש פריטים מסוג "חלבי" אין לאפשר הוספהש של פריטים מסוג "בשרי" להזמנה (ולהיפך).

הערה: אם אף אחד מהתנאים הללו לא מתרחש, ולא הגיוני שיתרחש עם התפתחות המערכת - אז כנראה שאין בעיה לאפשר למחלקות אחרות גישה לאובייקט הכפוף (LineItem) ללא מתן שליטה לאובייקט המרכז (Order).

אם כן אפשרנו גישה ללא-הכמסה, התוצאות הן שוב:

• שכפול לוגיקת אימות-נתונים בין הצרכנים של Order.
• ריבוי תלויות במערכת, הגברת ה fragility (הסבירות ליצירת באגים תוך כדי שינויי קוד - עולה) ול rigidity (שינוי אחד במערכת, מאלץ אותנו לשינויים לא-צפויים בחלקים אחרים של המערכת).
• באגים קשים לאיתור, ובדיקות פחות יעילות.

שום "פיצוץ" - רק דעיכה מתמשכת.

אני מזכיר את זה בשל קיומם של מנהלים שרגישים לשבירות ("באג בפרודקשיין! חמור מאוד!"), אבל אטומים בפני הסדקים שגורמים לשבירות הללו ("קוד לא יפה? קוד שלכם, באחריותכם. לא מעניין אותי.").

מה עושים?
בד"כ בעזרת עבודה עם Rich Domain Model (להן RDM).
אובייקט שהוא Composite (נקרא גם Aggregate) הוא בעל האחריות לגישה לאובייקטים הכפופים שלו.

פתרון מקובל הוא לחשוף interface המכיל גישה read-only (ומגובלת מעבר לכך ע"פ הצורך) לאובייקט הבן.
אובייקט ה Order יחזיר LineItemInfo ע"פ הצורך במתודות שלו.
בכדי לבצע שינוי ב LineItem, יש לקרוא ל Order, עם אובייקט ה LineItemInfo כפרמטר: "זה? תן לו 2 בכמות", או לסירוגין "כל האובייקטים שנוצרו אתמול - בטל אותם".

אופי האינטרקציה הזה מאפשר ל Order לוודא ש "2 בכמות" הוא מצב תקין, שלא מפר אף כלל עסקי.

כלל אצבע שימושי הוא שאסור לאפשר למחלקת השירות - לגשת ל id (מזהה ייחודי) של אובייקט ה LineItem.

ברגע שיש אחיזה ב id - מתחילה ההידרדרות הפוטנציאלית לכיוון שבירת ההכמסה: בהתחלה שמירת ids אצל מחלקת השירות, שעכשיו מסוגלת לזהות את המופעים השונים. בהמשך, אח"כ אולי גישה אליהם דרך flow אחר, או (חס וחלילה) ישירות ב DB.

אם מחלקת השירות לא יכולה להגיע ל Id - אז היא לא יכולה להתדרדר לעוולות הללו.

הבחנה: הכמסה לפעמים נראית כאילו יש "אויב" שיש להתגונן מפניו.
זה נכון.

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

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

קונטרה

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


Rich Domain Model הוא Overhead מיותר. כתיבה של קוד מיותר.

זה נכון: Anemic Model היא גישה חסכונית יותר בכתיבת קוד. אפשר לפתח איתה מהר יותר - עד גודל מסוים של קוד. גישה זו נקראת גם transaction script.

אני לא טוען RDM הוא עדיף תמיד.
הוא עדיף במערכות מורכבות (הרבה תנאי If ולולאות בקוד), בעלות מורכבות משמעותית מעבר ל CRUD.
הוא עדיף כאשר יש תנאים או חוקים עסקיים רבים שצריך להשביע.
הוא הופך לעדיף ככל שהמערכת גדלה ומפתחת.

גם ניהול ה state במשתנים גלובאליים יקצר את זמני הפיתוח.
לחלוקת המשתנים ל scopes, יש תקורה - אך גם תועלת.

אם הקדמתם סטארט-אפ, ולאחר שנה אתם מסתכלים על הקוד והוא נראה טוב - כנראה שעשיתם over-engineering.
בכל זאת, בשלב מסוים - חשוב לעשות את המעבר ולכתוב קוד robust יותר.

אם המערכת היא מערכת CRUD, שעיקר עיסוקה הוא לשלוף נתונים, לקבץ אותם ולהעביר לצד הלקוח - יש מצב ש RDM אינו מצדיק את התקורה הנלווית.



בואו נעשה RDM בצורה עצלה: נתחיל לכתוב קוד כ ADM, וע"פ הצורך - נעבור ל RDM.

לכאורה זהו טיעון הגיוני מאוד. מאוד אג'ייל.
התשובה שלי היא כזו:

• ככל שהאובייקט גדל, עלות ההמרה ADM->RDM תגדל גם כן. זה יכול להגיע לשעות, ואולי אפילו ימים.
• עלות שכזו, באופן מעשי, היא חסם ממשי לביצוע המעבר. למשל:
• אני עובד על פיצ'ר ואז מבין שהוספתי שדה שיכול להיות חלק מ state לא תקין.
• מה יותר טבעי? להעלים עין ולתת למפתח הבא לבצע מעבר ל RDM, או להשקיע עוד 3 שעות בלתי צפויות לקראת סיום כתיבת הפיצ'ר?
• בקיצור: לאנשים מאוד ממושמעים, זה יכול לעבוד. כישראלים - עדיף להשקיע את עלות ה RDM בעוד האובייקט קטן, כל עוד זוהי "מדרגה" קטנה ולא כ"כ מורגשת. נוסיף בכך עלות קטנה לפיתוח - אך עלות שתשתלם ככל שהמערכת תגדל ותסתבך.

העיקרון הפתוח סגור (OCP) מחזק את גישת ה ADM. נראה לי ש ADM הוא יותר SOLID מ RDM, לא?

למשל: למה לחזור ולשנות את Order שוב ושוב ולהסתכן בשבירת קוד? יותר אמין לכתוב קוד חדש ב Class A, ולאחר מכן ב Class B, וכו' - וכך להיות "open for extension, but closed for modification"!

על זה אני עונה:

• ה OCP הוא עקרון שנוי-במחלוקת. הוא מבוסס על אמיתה נכונה, אך יש בו חור גדול: חסרה בו הנחיה מתי יישום OCP הוא טוב, ומתי הוא גורם לנזק. 
• כן - הוא בהחלט עלול לגרום לנזק.
• core domain model הוא בדיוק המקום שאתם רוצים לשנות קוד שוב ושוב, תחת הסיכון ליצירת רגרסיה בהתנהגות. 
• אחרת מה? הקוד שלכם יתפזר לכל עבר?
• איך באמת נראה לכם שזה יהיה יותר SOLID?!

ADM הוא בעצם תכנות פונקציונלי (Functional Programming). תכנות פונקציונלי הוא בטוח דבר טוב, והפרדה בין נתונים לפעולה - היא בעצם Best Practice.

• יש פיל שעיר, מדיף ריחות עזים, ורועש במרכז החדר - שמשנה את התמונה מקצה לקצה. בואו לא נתעלם ממנו.
  אם לא הבחנתם בה - זוהי תכונת ה Immutability.
• בתכנות פונקציונלי ה Service Classes לא מסוגלים להגיע ל state לא תקין, כי הם לא יכולים לשנות state של אובייקט שהוא immutable.
• בנוסף, גם בתכנות פונקציונלי טוב שאובייקט המתאר state יבצע בעצמו את כל האימותים. מקום אחד + אחריות מלאה.
• להזכיר: כל רעיון טוב ניתן לממש בצורה שגויה. Functional Programming - הוא לא יוצא דופן.

ההבדל בין mutable state ל immutable state הוא תהומי כאן.
להכמסה יש גם חשיבות עבור קריאת ערכים שלא לצורך שינוי: צמצום התלויות והיכולת לשנות מבנה פנימי מבלי לזעזע את המערכת - אך היא משנית לחשיבות של שמירה על state עקבי ותקין.

סיכום

Anemic Domain Model, או בקיצור ADM, הוא דפוס שלילי (Anti-Pattern) של מבנה שעלול לגרום לנזק מתמשך והרסני למערכת שלכם, בצד הארכיטקטורה.

כמו כל כלל, יש גם לו יוצאים מן הכלל. כשהמערכת בחיתוליה ו/או כאשר יש אפליקציית CRUD [א] - RDM עשויה ליצור עלות נוספת ולא-משתלמת.

בסה"כ, אם אתם בעולם של Business Software, תוכנה המבטאת ומיישמת כללים עסקיים מורכבים - Rich Domain Model הוא כנראה הבסיס לכתיבת קוד יעיל לצמיחה ולתחזוקה.  No way around it.

נ.ב - ברשת ניתן למצוא רפרנסים ל RDM שגם אחראים על גישה לבסיס הנתונים / Persistence.

זה לא באמת RDM, אלא דפוס עיצוב אחר בשם Active Record. יש לו יתרונות, וחסרונות - אבל זה כבר דיון אחר.

שיהיה בהצלחה!


---

לינקים רלוונטיים

כמובן שגם ב Bliki יש רשומה על ADM. איך לא?

כתבה מקיפה מ msdn כיצד לזהות ADM, וכיצד לממש RDM

Anemic vs. Rich Domain Objects—Finding the Balance
כתבה שביסודה שגיאה: The Anaemic Domain Model is no Anti-Pattern, it’s a SOLID design, אך שגיאה נפוצה.


---

[א] למי שלא מכיר crud = "קקי" באמריקאית. אני משוכנע שראשי התיבות לא יצא סדר האותיות הזה במקרה.

לקחת את הביצועים ברצינות, בעזרת MySQL Performance Schema

פוסטים בסדרה:
"תסביר לי" - גרסת ה SQL
לקחת את הביצועים ברצינות, בעזרת MySQL Performance Schema
נושאים מתקדמים ב MySQL: חלק א' - עבודה עם JSON
נושאים מתקדמים ב MySQL: חלק ב' - json_each  ו Generated Columns

נושאים מתקדמים ב MySQL: חלק ג׳ - מנועי אחסון, ומבנה האינדקסים
----

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

איך יודעים אלו שאילתות רצות לאט?

הדרך הנפוצה ביותר היא בעזרת ה slow-log.

MySQL slow Query Log

• בכדי להפעיל אותו יש לקבוע 1 בפרמטר slow_query_log. הוא ירשום כל שאילתה שארכה יותר מ 10 שניות.
  
• ניתן לקבוע סף אחר בעזרת הפרמטר long_query_time, בו ניתן לקבוע גם ערכים שאינם מספרים שלמים, למשל "0.6".
• אם תקבעו בפרמטר ערך של 0 - סביר להניח שכתיבה ללוג תהיה החלק האטי במערכת שלכם 😀.
• שינוי הפרמטר ישפיע רק על connections חדשים ל DB, כך שאם שיניתם את הערך ושרת סורר מחזיק חיבורים פתוחים בעזרת ה connection pool שלו, שאילתות שעמודות בסף החדש שנקבע - לא ירשמו ללוג.
• בכדי לשלוף ערכים מה slow log פשוט בצעו שאילתה על הטבלה mysql.slow_log.
• למשל: SELECT * FROM mysql.slow_log ORDER BY start_time DESC limit 50;
• אני לא זוכר מה הם ערכי ברירת המחדל, ייתכן וצריך לשנות עוד קונפיגורציה בכדי שהלוג ייכתב לטבלה.

התוצאה נראית כך:

• user_host (הסתרתי את כתובות ה IP) - עוזר להבין איזה צרכן יצר את השאילתה. זה חשוב ב DB מונולטיים - המשרתים צרכנים רבים ומגוונים.
• lock_time (בשניות) - הזמן בו ממתינים ל"תפיסת מנעול" על מנת להתחיל ולהריץ את השאילתה. למשל: הטבלה נעולה ע"י פעולה אחרת.
• query_time (בשניות) - זמן הריצה הכולל. 
• הרצה עוקבת של אותה שאילתה אמורה להיות מהירה יותר - כאשר הנתונים טעונים כבר ל buffer pool.
• כמובן שגם השפעות חיצוניות שונות (שאילתות אחרות שרצות ברקע ומתחרות על משאבי ה DB Server) - ישפיעו על זמני הריצה. אני לא מכיר דרך פשוטה להוסיף מדדים כמו cpu ו/או disk_queue_depth לשאילתה, בכדי לקשר את זמני הביצוע שלה למה שהתרחש ב DB Server באותו הרגע.
• מספר שורות שנשלח / נסרק - בשונה מפקודת ה Explain, זהו המספר בפועל ולא הערכה. 
• ייתכנו מקרים בהם Explain יעריך תוכנית אחת - אך ה slow log יראה שבוצע משהו אחר (יקר יותר) בפועל. זה עלול לקרות.

• db - שם בסיס הנתונים (= סכמה) שבה בוצעה השאילתה. 
• למשל, אני יכול לבחור לפלטר את הסכמה של redash - כי רצות שהם הרבה שאילתות אטיות, וזה בסדר מבחינתי.

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

ה Performance Schema

אפשרות מודרנית יותר לאתר שאילתות אטיות היא על בסיס ה Performance Schema (בקיצור: ps)

מאז MySQL 5.6 ה ps מופעלת כברירת מחדל, אבל אם אתם רצים על AWS RDS - יהיה עליכם להדליק אותה ולבצע restart לשרת, לפני שתוכלו להשתמש בה.

השאילתה ה"קצרה" לשלוף נתונים של שאילתות אטיות מה ps היא:

SELECT * FROM sys.statements_with_runtimes_in_95th_percentile; 

שאילתה זו מציגה את 5% השאילתות האטיות ביותר, ללא קשר כמה זמן אבסולוטית הן ארכו (סף שניות כזה או אחר).

אתם שמים לב, בוודאי, שאנו קוראים ל system_schema  (השימוש ב FROM sys) ולא ל ps (השימוש ב FROM performance_schema).
ה ps חושפת כמות אדירה של נתונים (+ כמות גדולה של קונפיגורציה מה לאסוף ובאיזו רזולוציה) - מה שמקשה על השימוש בה עבור רוב המשתמשים.
ה system schema משמשת כשכבת הפשטה המציגה רשימה של views המרכזים מידע מתוך ה ps (וכמה מקומות אחרים) - ומנגישים את המידע המורכב למשתמש הפשוט.

נ.ב. -  על גרסה שהותקנה כ 5.7 ה system schema מגיעה כברירת-מחדל. על גרסאות ישנות יותר - ייתכן ותצטרכו להתקין אותה.

הנה תוצאה לדוגמה:

ספציפית, עניין שמציק לי הוא שבראש הטבלה נמצאת שאילתה, שאמנם לקחה כ 4 דקות לרוץ - אך התרחשה רק פעם אחת. בכלל: בראש הטבלה מככבות הרבה שאילתות שאינן מעניינות כי הן רצו פעמים בודדות בלבד. שירוצו.

יותר מעניין אותי למצוא שאילתה שגרמה להכנסה של כמיליון רשומות לאחת הטבלאות, לאורך 5 שעות שרת, גם אם כל מופע של השאילתה אורך 15 מילישניות בלבד. שאילתה כזו - לעולם לא תכנס ל slow log.

נ.ב: לא לדאוג לגבי "5 שעות שרת", גם בהינתן שזה מידע של כשבוע: השרת מריץ הרבה שאילתות במקביל. הנתונים הנ״ל נלקחו משרת שפועל בעצימות נמוכה יחסית.


את המידע הזה אני שולף בעזרת השאילתה הבאה:

SELECT `schema_name` AS db, 
       digest_text AS query, 
       IF (( ( `stmts`.`sum_no_good_index_used` > 0 ) 
         OR ( `stmts`.`sum_no_index_used` > 0 ) ), '*', '') AS `full_scan`, 
       Format(count_star, 0) AS events_count, 
       sys.Format_time(sum_timer_wait) AS total_latency, 
       sys.Format_time(avg_timer_wait) AS avg_latency, 
       sys.Format_time(max_timer_wait) AS max_latency, 
       Format(sum_rows_examined, 0) AS rows_scanned_sum, 
       Format(Round(Ifnull(( `stmts`.`sum_rows_examined` / 
         Nullif(`stmts`.`count_star`, 0) ), 0), 0), 0) AS `rows_scanned_avg`, 
       Format(Round(Ifnull(( `stmts`.`sum_rows_sent` / 
         Nullif(`stmts`.`count_star`, 0) ), 0), 0), 0) AS `rows_sent_avg`, 
       Format(sum_no_index_used, 0) AS rows_no_index_sum, 
       last_seen, 
       digest 
FROM   performance_schema.events_statements_summary_by_digest AS `stmts` 
WHERE  last_seen > ( Curdate() - INTERVAL 15 day ) 
ORDER  BY sum_timer_wait DESC; 

השאילתה הזו ממיינת את התוצאה ע"פ sum_timer_wait, כלומר - זמן ההמתנה הכולל לכל המופעים של אותה השאילתה.

השאילתה הנ״ל תשמיט מהתוצאה שאילתות שלא נראו מופעים שלהן ב 15 הימים האחרונים. מה שנפתר / השתנה - כבר לא מעניין.

ניתוח ריצה של שאילתות

שלב הבא אחרי איתור שאילתה בעייתית הוא הרצה שלה, עם Explain וכלים נוספים.

כלי שימושי במיוחד של ה ps הוא הפרוצדורה trace_statement_digest. אנו מעתיקים את תוצאת ה digest (זיהוי ייחודי לדפוס של query) מתוך העמודה האחרונה של השאילתה הנ״ל, ומעתיקים אותה לתוך הביטוי הבא:

CALL sys.ps_trace_statement_digest('1149...405b', 60, 0.1, TRUE, TRUE); 

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

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


אם אין לכם הרשאות אדמין, הנה כלים נוספים שניתן להפעיל:

ראשית יש את ה optimizer trace שניתן להפעיל על שאילתה בודדת.

-- Turn tracing on (it's off by default):
SET optimizer_trace="enabled=on";

SELECT ...; -- your query here

SELECT * FROM information_schema.optimizer_trace;

ה Optimizer trace מספק לנו פירוט דיי מדוקדק של אלו החלטות לקח ה optimizer בעת הרצת השאילתה. התיאור הוא של מה שקרה בפועל (ולא הערכה) אם כי גם ביצוע בפועל מבוסס על הערכות (למשל: סטטיסטיקות של טבלאות) שעשויות להיות מוטעות.

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

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

SET optimizer_trace="enabled=off";

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

SET profiling = 1;             -- turn on profiling

SELECT ...;                    -- your query here

SHOW profiles;                 -- list profiled queries

SHOW profile cpu FOR query 12; -- place the proper query_id

בדרך ל profile הנכסף עליכם להפעיל את איסוף ה profiling, לבצע את השאילתה, לראות את השאילתות שנאספו - ולבחור את המספר השאילתה שלכם. התוצאה נראית כך:

"מה?? כמעט 5 שניות על שליחת נתונים בחזרה ללקוח? - אני מתקשר להוט!"

כמובן שכדאי גם לבדוק מה המשמעות של כל שורה. sending data כולל את קריאת הנתונים מהדיסק, העיבוד שלהם, והשליחה חזרה ל client.

בד"כ ה Sending Data יהיה החלק הארי, ודווקא כאשר סעיף אחר תופס נפח משמעותי - יש משהו חדש ללמוד מזה.

נ.ב - ניתן לבצע profiling גם על בסיס ה ps - מה שאמור להיות מדויק יותר, ו customizable - אבל מעולם לא השתמשתי ביכול הזו.

לבסוף, אל תשכחו לסגור את איסוף ה profiling:

SET profiling = 0;  

עוד שאילתות שימושיות מתוך ה System Schema

הזכרנו את ה system schema, העוטפת את ה performance schema (ועוד קצת) בצורה נוחה יותר.

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

SELECT * FROM sys.version; 

הצגת גרסה מדויקת של שרת בסיס הנתונים, מתוך ממשק ה SQL.

SELECT * FROM sys.schema_tables_with_full_table_scans;

הצגה של רשימת הטבלאות שסרקו בהן את כל הרשמות כחלק משאילתה.

SELECT * FROM sys.schema_table_statistics;

SELECT * FROM sys.schema_index_statistics;

פרטים על הטבלאות והאינדקסים השונים - כמה ״עובד״ כל אחד.

SELECT * FROM sys.schema_unused_indexes;

SELECT * FROM sys.schema_redundant_indexes;

דרך טובה למצוא אינדקסים לא נחוצים.
אינדקסים מיותרים גורמים להכנסות (insert/update) להיות אטיות יותר - כי צריך לעדכן גם את האינדקס.

SELECT * FROM sys.statements_with_errors_or_warnings;

SELECT * FROM sys.statements_with_temp_tables;

עוד נתונים שכדאי להסתכל עליהם מדי-פעם.

SELECT * FROM sys.io_global_by_wait_by_latency;

SELECT * FROM sys.io_global_by_file_by_latency;

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

בסיס נתונים מונוליטי

אתם בוודאי מכירים את המצב בו שרת בסיס נתונים אחד מריץ loads שונים ושונים של עבודה.
בד"כ זה יהיה בסיס נתונים של מערכת מונוליטית, שמשמש גם לעבודות BI כאלו או אחרות (הוא מונוליטי, וכל הנתונים נמצאים בו - למה להשתמש במערכת אחרת?)

בבסיס נתונים מונוליטי יש מגוון רחב של workloads שרצים במקביל. כאשר בסיס הנתונים מתחיל להתנהג בצורה לא יפה (הרבה CPU, וגמגומים) - אנחנו מנסים לאתר מי מכל המשתמשים הרבים והמגוונים של בסיס הנתונים יוצר את העומס החריג. הרבה פעמים נוכל להרוג תהליך אחד (בשאיפה: לא mission critical) - ולייצב את שרת בסיס הנתונים.

כלי העבודה הבסיסי הוא השאילתה הזו:

SELECT * FROM sys.session ORDER BY command;

היא דרך טובה לדעת מי עושה מה. זוהי "גרסה משופרת" של השאילתה SHOW PROCESSLIST.
כעת נוכל לראות אלו משתמשים גורמים לעומס הרב ביותר / עומס חריג - ונתחיל לנטר אותם:

SELECT * FROM sys.user_summary;

היא שאילתה שתספק בזריזות כמה ואיזה סוג יוצר כל משתמש לבסיס הנתונים (שורה לכל משתמש). אפשר להשוות את הנתון הזה ל session data בכדי לזהות מי מתנהג בצורה חריגה כרגע.
באופן דומה, השאילתות הבאות יספקו לנו קצת יותר drill down:

SELECT * FROM sys.user_summary_by_statement_type;

SELECT * FROM sys.user_summary_by_statement_latency;

SELECT * FROM performance_schema.user_variables_by_thread;

מכאן ייתכן ונרצה לפרק את העבודה לרמת ה thread של בסיס הנתונים. אולי שרת ספציפי של האפליקציה גורם לעומס החריג?

SELECT * FROM sys.io_by_thread_by_latency;

לא מוצאים את השאילתה?

מדי פעם קורא שאני מוצא שאילתות בעייתיות בעזרת ה ps, אבל מכיוון שיש ? במקום פרמטרים - קשה לי להשלים את הערכים כך שהשאילתה תחזיק תוצאות.
וריאציה אחרת: הקוד שלי שולח שאילתות ואני רוצה לראות מה בדיוק הוא שולח.

יש כנראה דרכים מתוחכמות יותר לעשות זאת, אך אני פשוט משתמש ב  general log:

SET global general_log = 'ON';

SELECT ...; -- your query here

SELECT *
FROM mysql.general_log
WHERE argument LIKE '/*%'
AND event_time >= ( Curdate() - INTERVAL 5 minute )
ORDER BY event_time DESC 

LIMIT 50;

SET global general_log = 'OFF';

ה General Log יותר overhead כבד למדי על בסיס הנתונים, ולכן אם מדובר בסביבת production - אני מפעיל אותו לזמן קצר בלבד (בעזרת 'general_log = 'ON/OFF). על סביבת הפיתוח אני יכול לעבוד כשהוא דלוק כל הזמן.

נ.ב. גם כאן, ייתכן ותצטרכו לכוון את כתיבת הנתונים לטבלה בעזרת:

SET global log_output = 'FILE,TABLE'; 

מכיוון שה framework שאני עובד איתו, JDBI, מוסיף לשאילות מזהה המופיע כהערה בתחילת השאילתה "/* comment */" - הוספתי תנאי המסנן את הלוג לשאילות בהם מופיעה הערה (להלן ...argument LIKE).


שיהיה בהצלחה!