נתונים סטטיסטיים של נעילה

במאמר הזה מוסבר איך להשתמש בטבלאות המובנות של נתונים סטטיסטיים על נעילות ב-Spanner כדי לזהות את מפתחות השורות ואת עמודות הטבלה שגרמו להתנגשויות בנעילת טרנזקציות במסד הנתונים במהלך תקופה מסוימת. אתם יכולים לאחזר נתונים סטטיסטיים מהטבלאות האלה של SPANNER_SYS.LOCK_STATS* באמצעות הצהרות SQL.

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

נתונים סטטיסטיים על נעילת הגישה

ב-Spanner, הנתונים הסטטיסטיים של הנעילות מופיעים בסכימה SPANNER_SYS. אפשר לגשת לנתונים של SPANNER_SYS בדרכים הבאות:

  • הדף של Spanner Studio במסוף Google Cloud למסד נתונים

  • הפקודה gcloud spanner databases execute-sql.

  • לוח הבקרה Lock insights.

  • ה-method‏ executeSql או executeStreamingSql.

    ה-methods הבאות לקריאה יחידה ש-Spanner מספק לא תומכות ב-SPANNER_SYS:

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

סטטיסטיקות של נעילות לפי מפתח שורה

בטבלאות הבאות מוצג מעקב אחרי מפתח השורה עם זמן ההמתנה הארוך ביותר:

  • ‫SPANNER_SYS.LOCK_STATS_TOP_MINUTE: מפתחות שורות עם זמני ההמתנה הארוכים ביותר לנעילה, במרווחים של דקה אחת.

  • ‫SPANNER_SYS.LOCK_STATS_TOP_10MINUTE: מפתחות שורות עם זמני ההמתנה הארוכים ביותר לנעילה במהלך מרווחים של 10 דקות.

  • ‫SPANNER_SYS.LOCK_STATS_TOP_HOUR: מפתחות שורות עם זמני ההמתנה הארוכים ביותר לנעילה במרווחים של שעה אחת

המאפיינים של הטבלאות האלה הם:

  • כל טבלה מכילה נתונים של מרווחי זמן שלא חופפים, באורך שצוין בשם הטבלה.

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

    לדוגמה, בשעה 11:59:30, המרווחים האחרונים שזמינים לשאילתות SQL הם:

    • דקה אחת: 11:58:00 עד 11:58:59
    • 10 דקות: 11:40:00 עד 11:49:59
    • שעה אחת: 10:00:00 עד 10:59:59
  • ‫Spanner מקבץ את הנתונים הסטטיסטיים לפי טווח מפתחות השורה ההתחלתי.

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

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

  • כל העמודות בטבלאות יכולות להכיל ערכי null.

סכמת טבלאות

שם העמודה סוג תיאור
INTERVAL_END TIMESTAMP סוף מרווח הזמן שבו התרחשו ההתנגשויות בנעילה.
ROW_RANGE_START_KEY BYTES(MAX) מפתח השורה שבו התרחשה ההתנגשות בנעילה. כשההתנגשות כוללת טווח של שורות, הערך הזה מייצג את המפתח ההתחלתי של הטווח הזה. סימן פלוס, +, מייצג טווח. מידע נוסף זמין במאמר מהו מפתח התחלה של טווח שורות.
LOCK_WAIT_SECONDS FLOAT64 זמן ההמתנה המצטבר לנעילה של התנגשויות נעילה שתועדו לכל העמודות בטווח מפתחות השורות, בשניות.
SAMPLE_LOCK_REQUESTS ARRAY<STRUCT<
  column STRING,
  lock_mode STRING,
   transaction_tag STRING>>
כל רשומה במערך הזה תואמת לבקשת נעילה לדוגמה שתרמה להתנגשות הנעילה, על ידי המתנה לנעילה או חסימת טרנזקציות אחרות מביצוע הנעילה, במפתח השורה (טווח) הנתון. המערך הזה יכול להכיל עד 20 דגימות.

כל דגימה מכילה את שלושת השדות הבאים:
  • ‫lock_mode: מצב הנעילה שהתבקש. מידע נוסף זמין במאמר מצבי נעילה.
  • ‫column: העמודה שבה אירעה ההתנגשות בנעילה. הפורמט של הערך הזה הוא tablename.columnname.
  • ‫transaction_tag: התג של העסקה שהנפיקה את הבקשה. מידע נוסף על השימוש בתגים זמין במאמר פתרון בעיות באמצעות תגי טרנזקציות.
כל בקשות הנעילה שתרמו להתנגשויות נעילה נדגמות באופן אחיד ואקראי, כך שיכול להיות שרק חצי מההתנגשות (המחזיק או הממתין) מתועד במערך הזה.
SAMPLE_LOCK_REQUESTS_JSON_STRING STRING ייצוג מחרוזת תואם ל-JSON של העמודה SAMPLE_LOCK_REQUESTS. מחרוזת ה-JSON היא אובייקט JSON עם אותו מבנה כמו ה-STRUCT שמוגדר בעמודה SAMPLE_LOCK_REQUESTS.

העמודה הזו נתמכת במסדי נתונים בניב GoogleSQL ובניב PostgreSQL.

LOCK_WAIT_DISTRIBUTION ARRAY<STRUCT>

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

המערך מכיל רכיב אחד מהסוג הבא:
ARRAY<STRUCT<
  COUNT INT64,
  MEAN FLOAT64,
  SUM_OF_SQUARED_DEVIATION FLOAT64,
  NUM_FINITE_BUCKETS INT64,
  GROWTH_FACTOR FLOAT64,
  SCALE FLOAT64,
  BUCKET_COUNTS ARRAY<INT64>>>

למידע נוסף על הערכים, ראו Distribution ו-Exponential.

כדי לחשב את אחוזי זמן ההמתנה לנעילה מההתפלגות, משתמשים בפונקציה SPANNER_SYS.DISTRIBUTION_PERCENTILE(distribution, n FLOAT64).

LOCK_WAIT_DISTRIBUTION_JSON_STRING STRING

ייצוג מחרוזת תואם ל-JSON של העמודה LOCK_WAIT_DISTRIBUTION. מחרוזת ה-JSON היא אובייקט JSON עם מבנה זהה ל-STRUCT באותה עמודה. כמו בעמודה LOCK_WAIT_DISTRIBUTION, הערכים בעמודה הזו הם במיקרו-שניות.

העמודה הזו נתמכת במסדי נתונים בניב GoogleSQL ובניב PostgreSQL.

מצבי נעילה

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

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

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

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

  • נעילת Exclusive – נעילה בלעדית מתקבלת כשטרנזקציית קריאה-כתיבה, שכבר קיבלה נעילת ReaderShared, מנסה לכתוב נתונים אחרי השלמת הקריאה. נעילה בלעדית היא שדרוג של נעילת ReaderShared. נעילה בלעדית היא מקרה מיוחד של טרנזקציה שכוללת גם את הנעילה ReaderShared וגם את הנעילה WriterShared בו-זמנית. טרנזקציה אחרת לא יכולה לרכוש נעילה על אותו תא.

  • נעילת WriterSharedTimestamp – סוג מיוחד של נעילת WriterShared שמתבצעת כשמוסיפים שורות חדשות לטבלה שיש בה חותמת זמן של commit כחלק מהמפתח הראשי. סוג הנעילה הזה מונע ממשתתפי הטרנזקציה ליצור את אותה שורה בדיוק, וכך מונע התנגשות ביניהם. ‫Spanner מעדכן את המפתח של השורה שנוספה כך שיתאים לחותמת הזמן של ה-commit של הטרנזקציה שביצעה את ההוספה.

למידע נוסף על סוגי עסקאות וסוגי הנעילות שזמינים, ראו עסקאות.

התנגשויות במצב נעילה

בטבלה הבאה מוצגות ההתנגשויות האפשריות בין מצבי נעילה שונים.

מצבי נעילה ReaderShared WriterShared Exclusive WriterSharedTimestamp
ReaderShared לא כן כן כן
WriterShared כן לא כן לא רלוונטי
Exclusive כן כן כן לא רלוונטי
WriterSharedTimestamp כן לא רלוונטי לא רלוונטי כן

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

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

מהו מפתח התחלה של טווח שורות?

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

CREATE TABLE Singers (
  SingerId   INT64 NOT NULL,
  FirstName  STRING(1024),
  LastName   STRING(1024),
  SingerInfo BYTES(MAX),
) PRIMARY KEY (SingerId);

CREATE TABLE Albums (
  SingerId     INT64 NOT NULL,
  AlbumId      INT64 NOT NULL,
  AlbumTitle   STRING(MAX),
) PRIMARY KEY (SingerId, AlbumId),
  INTERLEAVE IN PARENT Singers ON DELETE CASCADE;

CREATE TABLE Songs (
  SingerId     INT64 NOT NULL,
  AlbumId      INT64 NOT NULL,
  TrackId      INT64 NOT NULL,
  SongName     STRING(MAX),
) PRIMARY KEY (SingerId, AlbumId, TrackId),
  INTERLEAVE IN PARENT Albums ON DELETE CASCADE;

CREATE TABLE Users (
  UserId     INT64 NOT NULL,
  LastAccess TIMESTAMP NOT NULL OPTIONS (allow_commit_timestamp=true),
  ...
) PRIMARY KEY (UserId, LastAccess);

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

ROW_RANGE_START_KEY הסבר
זמרים (2) טבלת הזמרים במפתח SingerId=2
albums(2,1) טבלת אלבומים במפתח SingerId=2,AlbumId=1
songs(2,1,5) טבלת שירים במפתח SingerId=2,AlbumId=1,TrackId=5
שירים(2,1,5+) טווח המפתחות של טבלת השירים מתחיל ב-SingerId=2,AlbumId=1,TrackId=5
אלבומים(2,1+) טווח המפתחות של הטבלה Albums מתחיל ב-SingerId=2,AlbumId=1
users(3, 2020-11-01 12:34:56.426426+00:00) טבלת המשתמשים במפתח UserId=3, ‏ LastAccess=commit_timestamp

נתונים סטטיסטיים מצטברים

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

  • ‫SPANNER_SYS.LOCK_STATS_TOTAL_MINUTE: נתונים סטטיסטיים מצטברים של כל ההמתנות לנעילה במרווחים של דקה אחת.

  • ‫SPANNER_SYS.LOCK_STATS_TOTAL_10MINUTE: נתונים סטטיסטיים מצטברים של כל ההמתנות לנעילה במרווחים של 10 דקות.

  • ‫SPANNER_SYS.LOCK_STATS_TOTAL_HOUR: נתונים סטטיסטיים מצטברים לכל ההמתנות לנעילה במרווחים של שעה.

לטבלאות של נתונים סטטיסטיים מצטברים יש את המאפיינים הבאים:

  • כל טבלה מכילה נתונים של מרווחי זמן שלא חופפים, באורך שצוין בשם הטבלה.

  • מרווחי הזמן מבוססים על זמני השעון. מרווחים של דקה מסתיימים בדקה, מרווחים של 10 דקות מסתיימים כל 10 דקות החל מהשעה, ומרווחים של שעה מסתיימים בשעה.

    לדוגמה, בשעה 11:59:30, המרווחים האחרונים שזמינים לשאילתות SQL בנתונים הסטטיסטיים המצטברים של הנעילות הם:

    • דקה אחת: 11:58:00 עד 11:58:59
    • 10 דקות: 11:40:00 עד 11:49:59
    • שעה אחת: 10:00:00 עד 10:59:59
  • כל שורה מכילה נתונים סטטיסטיים של כל ההמתנות לנעילה במסד הנתונים במהלך פרק הזמן שצוין, כשהם נצברים יחד. יש רק שורה אחת לכל מרווח זמן.

  • הנתונים הסטטיסטיים שנאספים בטבלאות SPANNER_SYS.LOCK_STATS_TOTAL_* כוללים המתנות לנעילה ש-Spanner לא אסף בטבלאות SPANNER_SYS.LOCK_STATS_TOP_*.

  • חלק מהעמודות בטבלאות האלה מוצגות כמדדים ב-Cloud Monitoring. המדדים שמוצגים הם:

    • זמן ההמתנה לנעילה

    מידע נוסף זמין במאמר מדדי Spanner.

סכמת טבלאות

שם העמודה סוג תיאור
INTERVAL_END TIMESTAMP סיום מרווח הזמן שבו התרחשה ההתנגשות בנעילה.
TOTAL_LOCK_WAIT_SECONDS FLOAT64 זמן ההמתנה הכולל לנעילה של התנגשויות נעילה שתועדו בכל מסד הנתונים, בשניות.
LOCK_WAIT_DISTRIBUTION ARRAY<STRUCT> היסטוגרמה של זמני ההמתנה לנעילה של התנגשויות נעילה שתועדו בכל מסד הנתונים, במיקרו-שניות, לא בשניות. המבנה זהה לזה של העמודה LOCK_WAIT_DISTRIBUTION בטבלאות SPANNER_SYS.LOCK_STATS_TOP_*. מסדי נתונים עם ניב PostgreSQL לא תומכים בעמודה הזו. במקום זאת, צריך להשתמש בעמודה LOCK_WAIT_DISTRIBUTION_JSON_STRING.
LOCK_WAIT_DISTRIBUTION_JSON_STRING STRING ייצוג מחרוזת תואם ל-JSON של העמודה LOCK_WAIT_DISTRIBUTION. הערכים שלו הם במיקרו-שניות. העמודה הזו נתמכת במסדי נתונים בניב GoogleSQL ובניב PostgreSQL.

שאילתות לדוגמה

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

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

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

‫הפונקציה CAST() ממירה את השדה row_range_start_key BYTES ל-STRING.

SELECT CAST(s.row_range_start_key AS STRING) AS row_range_start_key,
       t.total_lock_wait_seconds,
       s.lock_wait_seconds,
       s.lock_wait_seconds/t.total_lock_wait_seconds frac_of_total,
       s.sample_lock_requests
FROM spanner_sys.lock_stats_total_minute t, spanner_sys.lock_stats_top_minute s
WHERE t.interval_end =
  (SELECT MAX(interval_end)
   FROM spanner_sys.lock_stats_total_minute)
AND s.interval_end = t.interval_end
ORDER BY s.lock_wait_seconds DESC;
פלט השאילתה
row_range_start_key total_lock_wait_seconds lock_wait_seconds frac_of_total sample_lock_requests
שירים(2,1,1) 2.37 1.76 0.7426 LOCK_MODE: ReaderShared

עמודה: Singers.SingerInfo

LOCK_MODE: WriterShared

עמודה: Singers.SingerInfo
‫Users(3, 2020-11-01 12:34:56.426426+00:00) 2.37 0.61 0.2573 LOCK_MODE: ReaderShared

עמודה: users._exists1

LOCK_MODE: WriterShared

עמודה: users._exists1

‫1 _exists הוא שדה פנימי שמשמש לבדיקה אם שורה מסוימת קיימת או לא.

שמירת נתונים

Spanner שומר את הנתונים של כל טבלה לפחות למשך פרקי הזמן הבאים:

  • ‫SPANNER_SYS.LOCK_STATS_TOP_MINUTE ו-SPANNER_SYS.LOCK_STATS_TOTAL_MINUTE: מרווחים שכוללים את 6 השעות הקודמות.

  • ‫SPANNER_SYS.LOCK_STATS_TOP_10MINUTE ו-SPANNER_SYS.LOCK_STATS_TOTAL_10MINUTE: מרווחים שכוללים את 4 הימים הקודמים.

  • ‫SPANNER_SYS.LOCK_STATS_TOP_HOUR ו-SPANNER_SYS.LOCK_STATS_TOTAL_HOUR: מרווחים שכוללים את 30 הימים הקודמים.

פתרון בעיות של התנגשויות נעילה במסד הנתונים באמצעות נתונים סטטיסטיים של נעילה

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

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

בוחרים את התקופה שרוצים לבדוק.

אתם בודקים את מדדי זמן האחזור של מסד הנתונים ב-Spanner, ומגלים תקופה שבה זמן האחזור והשימוש ב-CPU של האפליקציה גבוהים. לדוגמה, הבעיה התחילה ב-12 בנובמבר 2020 בסביבות השעה 22:50.

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

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

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

SELECT t.interval_end, t.avg_commit_latency_seconds, l.total_lock_wait_seconds
FROM spanner_sys.txn_stats_total_10minute t
LEFT JOIN spanner_sys.lock_stats_total_10minute l
ON t.interval_end = l.interval_end
WHERE
  t.interval_end >= "2020-11-12T21:50:00Z"
  AND t.interval_end <= "2020-11-12T23:50:00Z"
ORDER BY interval_end;

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

interval_end avg_commit_latency_seconds total_lock_wait_seconds
2020-11-12 21:40:00-07:00 0.002 0.090
2020-11-12 21:50:00-07:00 0.003 0.110
2020-11-12 22:00:00-07:00 0.002 0.100
2020-11-12 22:10:00-07:00 0.002 0.080
2020-11-12 22:20:00-07:00 0.030 0.240
2020-11-12 22:30:00-07:00 0.034 0.220
2020-11-12 22:40:00-07:00 0.034 0.218
2020-11-12 22:50:00-07:00 3.741 780.193
2020-11-12 23:00:00-07:00 0.042 0.240
2020-11-12 23:10:00-07:00 0.038 0.129
2020-11-12 23:20:00-07:00 0.021 0.128
2020-11-12 23:30:00-07:00 0.038 0.231

התוצאות הקודמות מראות עלייה דרמטית ב-avg_commit_latency_seconds וב-total_lock_wait_seconds באותה תקופה, מ-22:40:00 ב-12 בנובמבר 2020 עד 22:50:00 ב-12 בנובמבר 2020, ואחרי כן ירידה. חשוב לציין שהערך avg_commit_latency_seconds הוא הזמן הממוצע שנדרש רק לשלב ה-commit. לעומת זאת, total_lock_wait_seconds הוא זמן הנעילה המצטבר לתקופה, ולכן הזמן נראה ארוך בהרבה מזמן ה-commit של הטרנזקציה.

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

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

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

הפונקציה CAST() בשאילתה הבאה ממירה את השדה row_range_start_key BYTES ל-STRING.

SELECT CAST(s.row_range_start_key AS STRING) AS row_range_start_key,
       t.total_lock_wait_seconds,
       s.lock_wait_seconds,
       s.lock_wait_seconds/t.total_lock_wait_seconds frac_of_total,
       s.sample_lock_requests
FROM spanner_sys.lock_stats_total_10minute t, spanner_sys.lock_stats_top_10minute s
WHERE
  t.interval_end = "2020-11-12T22:50:00Z" and s.interval_end = t.interval_end;
row_range_start_key total_lock_wait_seconds lock_wait_seconds frac_of_total sample_lock_requests
זמרים (32) 780.193 780.193 1 LOCK_MODE: WriterShared

עמודה: Singers.SingerInfo

LOCK_MODE: ReaderShared

עמודה: Singers.SingerInfo

בטבלת התוצאות הזו אפשר לראות שההתנגשות התרחשה בטבלה Singers במפתח SingerId=32. העמודה Singers.SingerInfo היא העמודה שבה התרחשה ההתנגשות בנעילה בין ReaderShared ל-WriterShared.

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

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

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

  • fprint
  • read_columns
  • write_constructive_columns
  • avg_commit_latency_seconds

צריך לסנן את העמודות הנעולות שזוהו בטבלה SPANNER_SYS.LOCK_STATS_TOP_10MINUTE:

  • עסקאות שקוראות עמודה כלשהי שגרמה להתנגשות נעילה כשניסו להשיג את הנעילה ReaderShared.

  • עסקאות שכותבות לכל עמודה שגרמה להתנגשות נעילה כשניסו להשיג נעילת WriterShared.

SELECT
  fprint,
  read_columns,
  write_constructive_columns,
  avg_commit_latency_seconds
FROM spanner_sys.txn_stats_top_10minute t2
WHERE (
  EXISTS (
    SELECT * FROM t2.read_columns columns WHERE columns IN (
      SELECT DISTINCT(req.COLUMN)
      FROM spanner_sys.lock_stats_top_10minute t, t.SAMPLE_LOCK_REQUESTS req
      WHERE req.LOCK_MODE = "ReaderShared" AND t.interval_end ="2020-11-12T23:50:00Z"))
OR
  EXISTS (
    SELECT * FROM t2.write_constructive_columns columns WHERE columns IN (
      SELECT DISTINCT(req.COLUMN)
      FROM spanner_sys.lock_stats_top_10minute t, t.SAMPLE_LOCK_REQUESTS req
      WHERE req.LOCK_MODE = "WriterShared" AND t.interval_end ="2020-11-12T23:50:00Z"))
)
AND t2.interval_end ="2020-11-12T23:50:00Z"
ORDER BY avg_commit_latency_seconds DESC;

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

fprint read_columns write_constructive_columns avg_commit_latency_seconds
1866043996151916800


['Singers.SingerInfo',
'Singers.FirstName',
'Singers.LastName',
'Singers._exists']
['Singers.SingerInfo'] 4.89
4168578515815911936 [] ['Singers.SingerInfo'] 3.65

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

אחרי שבודקים את הטרנזקציה עם fprint=1866043996151916800, אפשר להשתמש בעמודות read_columns ו-write_constructive_columns כדי לזהות איזה חלק בקוד האפליקציה הפעיל את הטרנזקציה. אחר כך אפשר לראות את ה-DML הבסיסי שלא מסנן לפי המפתח הראשי, SingerId. זה גרם לסריקה של כל הטבלה ולנעילה שלה עד שהטרנזקציה בוצעה.

כדי לפתור את ההתנגשות בנעילה, אתם יכולים:

  1. משתמשים בעסקה לקריאה בלבד כדי לזהות את ערכי ה-SingerId הנדרשים.
  2. משתמשים בעסקת קריאה-כתיבה נפרדת כדי לעדכן את השורות של ערכי ה-SingerId הנדרשים.

שיטות מומלצות להפחתת התחרות על נעילות

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

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

  • הימנעו מקריאות גדולות בתוך טרנזקציות של קריאה וכתיבה.

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

  • הימנעו מסריקות של טבלאות מלאות בעסקאות קריאה-כתיבה. זה כולל כתיבת DML מותנה במפתח הראשי או הקצאת טווח מפתחות ספציפי כשמשתמשים ב-Read API.

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

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

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

  • ציינו רק את קבוצת העמודות המינימלית שנדרשת בטרנזקציית קריאה-כתיבה. מכיוון שהנעילות ב-Spanner הן לכל תא נתונים, כשעסקת קריאה-כתיבה קוראת יותר מדי עמודות, היא מקבלת נעילת ReaderShared על התאים האלה. זה עלול לגרום להתנגשויות נעילה כשטרנזקציות אחרות רוכשות נעילת WriterShared בכתיבה לעמודות המוגזמות. לדוגמה, כדאי לציין קבוצת עמודות במקום * בקריאה.

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

  • פועלים לפי השיטות המומלצות לתכנון סכימה.

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

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

המאמרים הבאים