2018-06-30

נושאים מתקדמים ב MySQL: חלק א' - עבודה עם JSON

MySQL הוא בסיס-נתונים פשוט.

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

גרסה 8 שיצאה לא מכבר הייתה עשויה להיקרא גרסה 5.8 - היא הוסיפה כמות נאה של תוספות, אבל בוודאי לא מהפיכה. (במיוחד לאחר שכמה שינויים זכו ל down-port לגרסה 5.7). לא ניתן להשוות אותה לחידושים של גרסה 5.

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


מקור: DB-engines.com


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

הרבה פעמים נתקלתי בטיעונים שעדיף להשתמש ב MongoDB או PostgreSQL על פני MySQL.
כשניסיתי לחקור מדוע, קיבלתי מגוון תשובות שלא שיכנעו אותי:
  • "בסיסי-נתונים רלציונים הם העבר"
  • "ל PostgresSQL יש יותר שיטות לבצע join - אז הביצועים שלו טובים יותר"
  • "בכנס חשוב-כלשהו היו 3 הרצאות על PostgreSQL ורק אחת על MySQL"
  • "ל MySQL אין רפליקציה טובה (כמו ל Mongo, לכאורה)". "הוא לא בנוי ל Scale".
  • "ל Postgres יש פי 3 יכולות מאשר ל MySQL".
אלו דוגמאות לטיעונים לא לא עקרוניים. יש הרבה רצון לחדש ולעבוד עם "בסיס נתונים חדש יותר" - אבל גם המוכר והלא buzzy יכול להיות מוצלח מאוד.

נוכחתי לאורך הקריירה בכמה יוזמות אימוץ של "בסיס נתונים מתקדם יותר" - שנגמרו במפח-נפש.

שלא תבינו לא נכון: PostgreSQL ו MongoDB (ועוד אחרים) הם Databases מרשימים וטובים - אבל גם להם יש חסרונות, ואם אתם עושים מעבר - חשוב מאוד שתהינה לכן סיבות עמוקות ומבוססות. חבל להשקיע חודשים במעבר ואז לגלות שחיסרון חדש מעיב על כל המאמץ שהושקע. מעבר של בסיס נתונים במערכת "חיה" הוא שינוי לא-קל. הכלל הזה נכון גם לגבי מעבר ל MySQL - כמובן.


דיאגרמה (לא בהכרח מאלה) של Databases בתחום הרלציוני. מקור: 451 Research.


בכמה פוסטים הקרובים הייתי רוצה להתעמק קצת ביכולות של MySQL. יחסית לפופולריות השימוש שבו, MySQL לא "מסופר" בצורה טובה , כבר כמה שנים טובות. הרבה יכולות טובות נוספו בכמה שנים הללו - אך נראה שחלק נכבד מקהל השמתמשים לא מכיר אותן.
אמנם עכשיו עם השחרור של MySQL גרסה 8, הולכים ויוצאים ספרים חדשים - אך חלק גדול מהפוקוס שלהם הוא על מה שחדש בגרסה החדשה, ופחות במה שאפשר לעשות עם גרסה 5.7 - שהיא כנראה תישאר הגרסה הדומיננטית בשנתיים הקרובות (בסיס נתונים לא משדרגים כ"כ מהר - וטוב שכך).

הנה רשימת של נושאים שנראים לי מעניינים:
  • עבודה עם JSON וה Document Store.
  • Generated columns
  • פיצוי על יכולות חסרות ב MySQL כמו json_each או fist_value/last_value - איך אפשר להסתדר בלעדיהם.
  • מנועי Storage וההבדלים ביניהם: InnoDB ל MyISAM, וכו' (לא חדש בכלל - אך ידע חסר, ממה שנתקלתי).
  • סטטיסטיקות של אינדקסים וטבלאות - ואיך זה משפיע עלינו (גם לא חדש).
  • Full Text indexes
  • Partitioning
  • Large Hadron Migrator- https://github.com/soundcloud/lhm, ביצוע migrations גדולים ללא downtime.
כל הנושאים הנ"ל הם נושאים שלי יצא באופן אישי, או לאנשים מסביבי להשתמש בהם. הם נושאים ישימים ופרקטיים - עד כמה שאני יכול לומר.

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

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



JSON וה MySql Document Store


לפני כעשור, עולם ה Databases התחלק ל-2 קבוצות דומיננטיות של שימוש עיקרי:
  • בסיסי-נתונים רלציוניים
  • בסיסי-נתונים מבוססי-מסמכים (Document-Based)
* נכון, יש גם K/V DB שנמצאים בשימוש נרחב, וגם columnar, wide-column, וגם graph ו time series - אך עדיין בסיסי נתונים רלציוניים ו document-based אחראים למגוון הגדול יותר של הנתונים והשימושים.
ההרכב הנפוץ הוא שארגון מחזיק את רוב האובייקטים בבסיס נתונים רלציוני / מסמכים, והיכן שצריך scale גבוה יותר - פונה לפתרונות יותר ממוקדים לצורך הספציפי.

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

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

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

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

מאז MySQL גרסה 5.7.12 (אמצע 2016, בעזרת plugin) יש ל MySQL ממשק עבודה שדומה מאוד לעבודה מול בסיס-נתונים מבוסס מסמכים, מה שנקרא The MySQL Document Store:
  • "מסמכים" (כלומר: JSON), מאוחסנים ב Collections.
    • מאחורי הקלעים, לאכסון collection של מסמכים, נוצרות טבלאות בנות שתי-עמודות id_ ו doc (כמו שהיינו עושים פעם, בעצמנו...)
  • בעזרת API (או ה shell החדש, mysqlsh) ניתן לגשת ל"מסמכים" ב API המוכר מבסיסי-נתונים מבוססי-מסמכים. למשל:
    • ("db.product.find('_id = "iphone XI
    • (...)db.createCollection
    • (...)add(...), sort(...), modify, וכו'
  • את המסמכים ניתן לאנקס
    • מאחורי הקלעים MySQL יוצר generated columns - נושא שארצה לכסות בהרחבה.
  • ל API יש clients זמינים ל JavaScript ול Python - אם כי כמה פעולות, תחזוקה וטיפול בעיקר, עדיין יש לעשות ב SQL.

אף פעם לא "נפלתי" מהממשק של ה Documents Stores ולכן מעולם משך אותי לנסות ולהשתמש ב MySQL Document Store. 

אני אישית מעדיף בהרבה לעבוד בסגנון מעורב (רלציוני-Document).

הייתי שמח מאוד להיות מסוגל לעשות מניפולציות על json ב js או פייטון המקונן בתוך שאילתת SQL - אך לצערי לא נראה שהשוק הולך לשם...
עדכון: תודה לנדב נווה שעדכון אותי שכן יש plugin ל User Defined Functions ב js עבור MySQL. מעניין!
עדיין, לא נראה שה plugin הזה נתמך ע"י AWS RDS. חבל...



JSON ב MySQL דרך SQL


column מטיפוס JSON הוסף ב MySQL גרסה 5.7.8 (אוג' 2015), אם כי ניתן להשתמש ביכולות ה JSON שנוספו לבסיס הנתונים גם על גבי עמודות מסוג text, varchar, BLOB וכו'. עמודות טקסטואליות.

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

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

החיסרון הגדול של JSON הוא הקושי לבצע שאילתות הנוגעות לערכים המקוננים בתוך ה JSON והביצועים שנובעים מכך:
  • יש ב MySQL תחביר המאפשר לאמוד אם שדה x בתוך אובייקט o שבתוך ה JSON כחלק מפקודת WHERE.
    כמו שנראה בהמשך, כשמבנה ה json הוא מורכב יותר - זה הולך והופך להיות קשה יותר.
  • ביצועים: כאשר אנו רוצים להשוות שדה אחד מתוך אובייקט עם 50 שדות - עלינו לטעון לזיכרון את כל 50 השדות בכל פעם, שזה הרבה I/O מיותר (מדד חשוב מאוד בביצועים של בסיסי-נתונים).
    הגישה המקובלת להתמודד עם בעיית הביצועים היא להוציא לעמודות מקבילות לעמודת ה JSON "שכפול" של שדות אותן נרצה לתשאל בצורה תדירה (ולכן גם לאנדקס).
    בהמשך נראה כיצד MySQL יכול לסייע להפוך לעשות את התהליך הזה לפשוט יותר בעזרת Generated Columns.

טיפוס ה json ב MySQL שונה מ text בשתי תכונות עיקריות:
  1. בהכנסת ערך לעמודה מסוג json - בסיס הנתונים יוודא את תקינות ה format של ה json.
  2. בעמודה מסוג json ולא text - בסיס הנתונים ידחוס את ה json לפורמט בינארי דחוס יותר, בו המפתחות ממוינים (בדומה לפורמט bson שנעשה בו שימוש ב MongoDB).
json תקין הוא כמובן אובייקט ({}), מערך ([]), מחרוזת (""), או null.

שווה לציין שמחרוזת ה json שהוכנסה לעמודה מסוג json לא תחזור כמחרוזת זהה: במעבר לפורמט בינארי ינקו את ה whitespace וסדר המפתחות ישתנה.
כמו כן, אם יש אובייקטים עם מפתחות "כפולים" - אזי המפתח הראשון הוא זה שישמר, עד לגרסה 8.0.3 ממנה המפתח האחרון הוא זה שישמר (מה שיותר עקבי עם רוב המימושים של javaScript).
כל עוד אנחנו עובדים עם json בצורה תקינה - זה פרט שלא נשים אליו לב.

טיפוס ה json של mySQL הוא optimized לקריאות, כך שאם אנחנו הולכים לכתוב יותר (למשל: audit) - יכול להיות שיהיה עדיף, מבחינת ביצועים, להשתמש בעמודה מסוג text.


הפקודה הבסיסית בעבודה עם json ב MySQL היא JSON_EXTRACT:

SELECT c, JSON_EXTRACT(c, "$.id"), g 
FROM some_table
WHERE JSON_EXTRACT(c, "$.id") > 1 
ORDER BY JSON_EXTRACT(c, "$.name");

+-------------------------------+-----------+------+ | c | c->"$.id" | g | +-------------------------------+-----------+------+ | {"id": "3", "name": "Barney"} | "3" | 3 | | {"id": "4", "name": "Betty"} | "4" | 4 | | {"id": "2", "name": "Wilma"} | "2" | 2 | +-------------------------------+-----------+------+



יש גם תחביר מקוצר:

SELECT c, c->>'$.id', g 
FROM some_table 
WHERE c->"$.id" > 1 
ORDER BY c->'$.name';

+-------------------------------+-----------+------+ | c | c->"$.id" | g | +-------------------------------+-----------+------+ | {"id": "3", "name": "Barney"} | 3 | 3 | | {"id": "4", "name": "Betty"} | 4 | 4 | | {"id": "2", "name": "Wilma"} | 2 | 2 | +-------------------------------+-----------+------+


כאשר <<- הוא תחליף ל  ((JSON_UNQUOTE( JSON_EXTRACT(column, path. הפונקציה JSON_UNQUOTE מסירה את ה quotes - אם קיימים.

ניתן להשתמש בביטויים מורכבים יותר כמו 'column->'$[2].person.pets[1].name
  • את כל הביטוי יש לעטוף במירכאות בודדות או כפולות - כי זו מחרוזת ב SQL.
  • יש לציין את ה $ - המתאר את ה root של ה json (לפי תקן ה json path - ה $ נקרא "context").
  • כאשר יש שמות של keys המשתמשים בסימנים מסוימים - יש לעטוף אותם ב quotes, למשל:
     'column->'$[2].person."my-pets"[1].name
  • ניתן להשתמש ב * בכמה מצבים:
    • [*]$ - יחזיר את כל האיברים במערך (או null אם הפעלתם על אובייקט או מחרוזת)
    • price.*.$ יחזיר מערך של כל שדות ה price בכל האובייקטים שבתוך העמודה.
    • price.**.$ יחזיר מערך של כל שדות ה price בכל האובייקטים, או תתי-האובייקטים, שבתוך העמודה.
  • יש פונקציות כגון ()JSON_KEYS ו ()JSON_SEARCH - שיחזירו בהתאמה את רשימת ה keys באובייקט, או רשימת האובייקטים המכילים ערכים מסוימים.

יש פעולות שלא ניתן להשיג בעזרת ה path כפי שמתאפשר היום ב MySQL 5.7.x. דוגמה נפוצה בשימוש: בחירת האיבר האחרון מתוך רשימה, או פעולות מיון / סינון על מפתחות מסוימים.

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

יכולות ה JSON של PostgreSQL הן מתקדמות יותר משל MySQL - אך נראה ש PostgreSQL הוא פשוט פחות סטנדרטי. מקור/2016.


ישנן עוד סדרה של פונקציות המאפשרות פעולות על json ב MySQL - אני רק אזכיר אותן בקצרה, בידיעה שתמיד אפשר לפנות לתיעוד (שהוא ברמה טובה):
  • יצירה של אובייקטי json כחלק משאילתה, בעזרת הפונקציות ()JSON_ARRAY(), JSON_OBJECT ו ()JSON_MERGE_PRESERVE.
  • שינוי של ה json מתוך SQL בעזרת הפונקציות:
    JSON_APPEND(), JSON_ARRAY_APPEND() JSON_ARRAY_INSERT(), JSON_INSERT(), JSON_REMOVE(), JSON_REPLACE(), JSON_SET.
  • פונקציות עזר שימושיות הן:
    ()JSON_UNQUOTE(), JSON_QUOTE(), JSON_DEPTH(), JSON_PRETTY(), JSON_LENGTH(), JSON_TYPE ו ()JSON_VALID

פונקציה שלי מאוד חסרה ב MySQL אך קיימת ב PostgreSQL היא json_each ההופכת מערך או זוגות מתוך עמודת json לרשומות רלציוניות עליהן ניתן לבצע פעולות ב SQL שונות.

בפוסט המשך אני אראה "תרגיל" ב SQL בו אני משתמש בכדי לעשות זאת גם על MySQL. 

הערה: יש פתרון לשליפת האיבר האחרון במערך ב MySQL 8 בצורת:
JSON_EXTRACT(JsonData, '$[last]')

או שליפת האיבר לפני האחרון בעזרת last-1.
אני אראה גם "תרגיל" איך ניתן לעשות זאת גם בגרסה 5.7, וללא התמיכה של operator ה last.



סיכום


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


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




6 תגובות:

  1. אנונימי30/6/18 23:28

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

    השבמחק
  2. אנונימי2/7/18 00:45

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

    השבמחק
    תשובות
    1. אנונימי2/7/18 00:47

      מחדד... דוקומנט סטור של מייסיקוול דוקומנט בייסד...

      מחק
    2. למה להעדיף בסיס נתונים אחד על שני? - יש הרבה פרמטרים, ולא נראה לי שאתן תשובה טובה בצורה כ"כ כללית.
      חלק גדול מהמידע שלנו נוח לנהל ונוח לעבד דווקא בטבלאות - גם כשאפשר לייצג אותו באופנים אחרים (למשל: documents). המודל הרצליוני הוא פשוט, וצבר הרבה ניסיון - מה שמווה ייתרון יחסי למודלים אחרים.
      אלו היתרונות העיקריים של שימוש ב Relational DB על פני pure Document DB - אם עליך לבחור בסיס נתונים אחד (אפשר לעבוד גם וגם). שוב - אין תשובה גנרית נכונה, כל מערכת - עם השיקולים שלה.

      איפה MongoDB יחסית ל MySQL בנושא של Document Store? - הרבה קדימה, ברוב היכולות.
      מצד שני, למשל, מונגו הציגו רק בגרסה 3.6 (סוף 2017) יכולות של טרנזקציות (בערך) - יכולת שקיימת שנים בבסיסי נתונים רלציוניים - כך שזה לא ממש clear cut. אין ספק ש MongoDB מתמחה בפרדיגמה של Documents - ולא סביר שבסיס-נתונים רלציוני יעקוף אותו בתחום שלו.
      MySQL מספק יכולות Document בסיסיות בלבד - אך הן יכולות להספיק לארגונים רבים.

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

      סה"כ מונגו וMySQL מאחסנים את הנתונים וניגשים אליהם - בצורה דומה למדי.
      שניהם open source - כך שאם לאחד היה פתרון קדם לצוואר בקבוק עיקרי (I/O) - השני היה משלים את הקסם תוך שנה-שנתיים.

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

      אם מדובר על כל אחד שימדל את הנתונים בצורה שמתאימה לבסיס-הנתונים - לא בטוח בכלל שמערכת שנבנתה על גבי Mongo תהיה מהירה יותר.

      בקיצור: לא נראה לי שיש פה clear cut.

      מקווה שעזרתי

      מחק
  3. אנונימי9/7/18 17:20

    חח.. השמועות פה ב Gett אומרות שאתה יזמת את המעבר ל Postgres

    השבמחק