נתונים סטטיסטיים של שאילתות

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

מתי כדאי להשתמש בנתונים סטטיסטיים של שאילתות

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

איך ניגשים לנתונים הסטטיסטיים של השאילתות

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

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

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

למידע נוסף, ראו שיטות קריאה בודדות.

שימוש ב-CPU מקובץ לפי שאילתה

בטבלאות הבאות מוצגות השאילתות עם השימוש הגבוה ביותר ב-CPU במהלך תקופה מסוימת:

  • ‫SPANNER_SYS.QUERY_STATS_TOP_MINUTE: שאילתות במרווחים של דקה אחת
  • ‫SPANNER_SYS.QUERY_STATS_TOP_10MINUTE: שאילתות במרווחים של 10 דקות
  • ‫SPANNER_SYS.QUERY_STATS_TOP_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 מקבץ את הנתונים הסטטיסטיים לפי הטקסט של שאילתת ה-SQL. אם שאילתה משתמשת בפרמטרים של שאילתה, או אם Spanner ממיר באופן אוטומטי ערכים מילוליים לפרמטרים, אז Spanner מקבץ את כל ההפעלות של השאילתה הזו לשורה אחת. אם השאילתה משתמשת במחרוזות מילוליות שלא ניתן להמיר באופן אוטומטי לפרמטרים, Spanner מקבץ את הנתונים הסטטיסטיים רק אם הטקסט המלא של השאילתה זהה. אם יש הבדל כלשהו בטקסט, כל שאילתה מופיעה בשורה נפרדת. ב-DML באצווה, Spanner מבצע נורמליזציה של האצווה על ידי ביטול כפילויות של הצהרות זהות עוקבות לפני יצירת טביעת האצבע.

  • אם יש תג בקשה, TEXT_FINGERPRINT הוא ה-hash של תג הבקשה. אחרת, זהו הגיבוב של הערך TEXT. ב-DML מחולק למחיצות, הערך של TEXT_FINGERPRINT הוא תמיד ה-hash של הערך TEXT.

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

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

  • השאילתות במעקב כוללות שאילתות שהושלמו, נכשלו או בוטלו על ידי המשתמש.

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

    • מספר ההפעלות וזמן האחזור הממוצע בשניות בכל השאילתות שנכשלו.

    • מספר ההרצות של שאילתות שהזמן הקצוב שלהן לתפוגה הסתיים.

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

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

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

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

  • הנתונים הסטטיסטיים של ALL_FAILED_EXECUTION_COUNT,‏ ALL_FAILED_AVG_LATENCY_SECONDS,‏ CANCELLED_OR_DISCONNECTED_EXECUTION_COUNT ו-TIMED_OUT_EXECUTION_COUNT לא נשמרים ב-DML מחולק למחיצות.

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

סכמת טבלאות

שם העמודה סוג תיאור
INTERVAL_END TIMESTAMP סוף מרווח הזמן שבו התרחשו הפעלות השאילתות הכלולות.
REQUEST_TAG STRING תג הבקשה האופציונלי לפעולת השאילתה הזו. מידע נוסף על השימוש בתגים זמין במאמר פתרון בעיות באמצעות תגי בקשות.
QUERY_TYPE STRING מציין אם השאילתה היא PARTITIONED_QUERY או QUERY. PARTITIONED_QUERY היא שאילתה עם partitionToken שהתקבל מ-API של PartitionQuery, או הצהרת DML מחולקת למחיצות. כל שאר השאילתות ופקודות ה-DML מסומנות בסוג השאילתה QUERY.
TEXT STRING טקסט של שאילתת SQL, מקוצר לכ-64KB.

הנתונים הסטטיסטיים של כמה שאילתות עם אותה מחרוזת תג מקובצים בשורה אחת, והערך של REQUEST_TAG תואם למחרוזת התג הזו. רק הטקסט של אחת מהשאילתות האלה מוצג בשדה הזה, והוא נחתך לכ-64KB. ב-DML באצווה, קבוצת הצהרות ה-SQL משוטחת לשורה אחת, ומחוברת באמצעות מפריד נקודה-פסיק. טקסטים זהים של SQL שמופיעים ברצף עוברים ביטול כפילויות לפני החיתוך.
TEXT_TRUNCATED BOOL אם טקסט השאילתה נחתך או לא.
TEXT_FINGERPRINT INT64 הגיבוב של הערך REQUEST_TAG אם הוא קיים, אחרת הגיבוב של הערך TEXT. תואם לשדה query_fingerprint ביומן הביקורת
EXECUTION_COUNT INT64 מספר הפעמים ש-Spanner זיהה את השאילתה במהלך המרווח.
AVG_LATENCY_SECONDS FLOAT64 משך הזמן הממוצע, בשניות, של כל הפעלת שאילתה במסד הנתונים. הממוצע הזה לא כולל את זמן הקידוד וההעברה של קבוצת התוצאות, וגם לא את התקורה.
AVG_ROWS FLOAT64 המספר הממוצע של השורות שהשאילתה החזירה.
AVG_BYTES FLOAT64 המספר הממוצע של בייטים של נתונים שהשאילתה החזירה, לא כולל תקורה של קידוד שידור.
AVG_ROWS_SCANNED FLOAT64 מספר השורות הממוצע שהשאילתה סרקה, לא כולל ערכים שנמחקו.
AVG_CPU_SECONDS FLOAT64 מספר השניות הממוצע של זמן המעבד (CPU) ש-Spanner השקיע בכל הפעולות להרצת השאילתה.
ALL_FAILED_EXECUTION_COUNT INT64 מספר הפעמים שהשאילתה נכשלה במהלך המרווח.
ALL_FAILED_AVG_LATENCY_SECONDS FLOAT64 משך הזמן הממוצע, בשניות, של כל הרצת שאילתה שנכשלה במסד הנתונים. הממוצע הזה לא כולל את זמן הקידוד וההעברה של קבוצת התוצאות, וגם לא את התקורה.
CANCELLED_OR_DISCONNECTED_EXECUTION_COUNT INT64 מספר הפעמים שהשאילתה בוטלה על ידי המשתמש או נכשלה בגלל חיבור לרשת שהתנתק במהלך המרווח.
TIMED_OUT_EXECUTION_COUNT INT64 מספר הפעמים שהזמן הקצוב לתפוגה של השאילתה חלף במהלך המרווח.
AVG_BYTES_WRITTEN FLOAT64 מספר הבייטים הממוצע שנכתבו על ידי ההצהרה.
AVG_ROWS_WRITTEN FLOAT64 המספר הממוצע של שורות שהשתנו בעקבות ההצהרה.
STATEMENT_COUNT INT64 סכום ההצהרות שנכללו ברשומה הזו. בשאילתות רגילות וב-DML, הערך הזה שווה למספר ההרצות. ב-DML באצווה, Spanner מתעד את מספר ההצהרות באצווה.
RUN_IN_RW_TRANSACTION_EXECUTION_COUNT INT64 מספר הפעמים שהשאילתה הופעלה כחלק מעסקת קריאה-כתיבה. העמודה הזו עוזרת לכם לקבוע אם אתם יכולים להימנע ממחלוקות על נעילה על ידי העברת השאילתה לעסקה לקריאה בלבד.
LATENCY_DISTRIBUTION ARRAY<STRUCT>

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

המערך מכיל רכיב אחד מהסוג הבא:
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) שמחזירה את האחוזון ה-n המשוער. דוגמה קשורה: חיפוש זמן האחזור של שאילתות באחוזון ה-99.

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

AVG_MEMORY_PEAK_USAGE_BYTES FLOAT64

השימוש הממוצע בזיכרון בשיא (בבייטים) במהלך הרצה של שאילתה מבוזרת.

אפשר להשתמש בנתון הזה כדי לזהות אילו שאילתות או גדלים של נתוני טבלאות עלולים להגיע למגבלות הזיכרון.
AVG_MEMORY_USAGE_PERCENTAGE FLOAT64

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

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

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

זמן המעבד (CPU) הממוצע בשניות שהושקע בהידור השאילתה, כולל יצירת זמן הריצה של השאילתה.

אם הערך בעמודה הזו גבוה, השתמשו בשאילתות עם פרמטרים.
AVG_FILESYSTEM_DELAY_SECS FLOAT64

משך הזמן הממוצע שבו השאילתה קוראת ממערכת הקבצים או נחסמת בקלט/פלט (I/O).

הנתון הזה עוזר לזהות זמן אחזור ארוך שנגרם בגלל קלט/פלט של מערכת הקבצים. כדי לצמצם את הבעיה, מוסיפים אינדקס או מוסיפים פסוקית STORING (GoogleSQL) או INCLUDE (PostgreSQL) לאינדקס קיים.
AVG_REMOTE_SERVER_CALLS FLOAT64

המספר הממוצע של קריאות לשרת מרוחק (RPC) שהושלמו על ידי השאילתה.

הנתון הזה מאפשר לזהות אם לשאילתות שונות שסורקות את אותו מספר שורות יש מספר שונה מאוד של קריאות RPC. יכול להיות שכדאי להוסיף אינדקס לשאילתה עם ערך RPC גבוה יותר, או להוסיף סעיף STORING (GoogleSQL) או INCLUDE (PostgreSQL) לאינדקס קיים.
AVG_ROWS_SPOOLED FLOAT64

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

הנתון הסטטיסטי הזה עוזר לזהות שאילתות עם זמן אחזור גבוה, שצורכות הרבה זיכרון ואי אפשר להריץ אותן בזיכרון. כדי לצמצם את הבעיה, צריך לשנות את הסדר של JOIN או להוסיף אינדקס שמספק את הערך הנדרש של SORT.
AVG_DISK_IO_COST FLOAT64

העלות הממוצעת של השאילתה הזו במונחים של עומס הדיסק ב-Spanner HDD.

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

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

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

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

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

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

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

AVG_COLUMNAR_READ_SHARE FLOAT64

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

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

QUERY_OPTIMIZER_VERSIONS ARRAY<INT64>

הגרסאות של הכלי לאופטימיזציה של שאילתות ששימשו לשאילתות בחלון הזמן הזה.
STATISTICS_PACKAGE_NAMES ARRAY<STRING>

השמות של חבילות הנתונים הסטטיסטיים ששימשו לשאילתות בחלון הזמן הזה.
CPU_SECONDS_DISTRIBUTION ARRAY<STRUCT>

היסטוגרמה של זמן המעבד (CPU) ש-Spanner השקיע בכל הפעולות כדי להריץ את השאילתה. הערכים נמדדים בשניות.

המערך בנוי באופן הבא:
ARRAY<STRUCT<
  COUNT INT64,
  MEAN FLOAT64,
  SUM_OF_SQUARED_DEVIATION FLOAT64,
  NUM_FINITE_BUCKETS INT64,
  GROWTH_FACTOR FLOAT64,
  SCALE FLOAT64,
  BUCKET_COUNTS ARRAY<INT64>>>

למידע נוסף על סוגי הערכים, קראו את המאמרים התפלגות ואקספוננציאלי.

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

CPU_SECONDS_DISTRIBUTION_JSON_STRING STRING

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

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

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

ROW_SCANNED_DISTRIBUTION ARRAY<STRUCT>

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

המבנה של המערך הוא:
ARRAY<STRUCT<
  COUNT INT64,
  MEAN FLOAT64,
  SUM_OF_SQUARED_DEVIATION FLOAT64,
  NUM_FINITE_BUCKETS INT64,
  GROWTH_FACTOR FLOAT64,
  SCALE FLOAT64,
  BUCKET_COUNTS ARRAY<INT64>>>

למידע נוסף על סוגי הערכים, קראו את המאמרים התפלגות ואקספוננציאלי.

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

ROW_SCANNED_DISTRIBUTION_JSON_STRING STRING

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

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

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

‫EXECUTION_COUNT, AVG_LATENCY_SECONDS, LATENCY_DISTRIBUTION ו-LATENCY_DISTRIBUTION_JSON_STRING לשאילתות שנכשלו כוללים שאילתות שנכשלו בגלל תחביר שגוי או שנתקלו בשגיאה זמנית אבל הצליחו בניסיון חוזר. הנתונים הסטטיסטיים האלה לא כוללים פקודות DML מחולקות למחיצות שנכשלו או בוטלו.

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

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

  • ‫SPANNER_SYS.QUERY_STATS_TOTAL_MINUTE: שאילתות במרווחים של דקה אחת
  • ‫SPANNER_SYS.QUERY_STATS_TOTAL_10MINUTE: שאילתות במרווחים של 10 דקות
  • ‫SPANNER_SYS.QUERY_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

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

  • הנתונים הסטטיסטיים שנאספים בטבלאות TOTAL עשויים לכלול שאילתות ש-Spanner לא אסף בטבלאות TOP.

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

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

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

סכמת טבלאות

שם העמודה סוג תיאור
INTERVAL_END TIMESTAMP סוף מרווח הזמן שבו התרחשו הפעלות השאילתות הכלולות.
EXECUTION_COUNT INT64 מספר הפעמים ש-Spanner זיהה את השאילתה במהלך מרווח הזמן.
AVG_LATENCY_SECONDS FLOAT64 משך הזמן הממוצע, בשניות, של כל הפעלת שאילתה במסד הנתונים. הממוצע הזה לא כולל את זמן הקידוד וההעברה של קבוצת התוצאות, וגם לא את התקורה.
AVG_ROWS FLOAT64 המספר הממוצע של השורות שהשאילתה החזירה.
AVG_BYTES FLOAT64 המספר הממוצע של בייטים של נתונים שהשאילתה החזירה, לא כולל תקורה של קידוד שידור.
AVG_ROWS_SCANNED FLOAT64 מספר השורות הממוצע שהשאילתה סרקה, לא כולל ערכים שנמחקו.
AVG_CPU_SECONDS FLOAT64 מספר השניות הממוצע של זמן המעבד (CPU) ש-Spanner השקיע בכל הפעולות להרצת השאילתה.
ALL_FAILED_EXECUTION_COUNT INT64 מספר הפעמים שהשאילתה נכשלה במהלך המרווח.
ALL_FAILED_AVG_LATENCY_SECONDS FLOAT64 משך הזמן הממוצע, בשניות, של כל הרצת שאילתה שנכשלה במסד הנתונים. הממוצע הזה לא כולל את זמן הקידוד וההעברה של קבוצת התוצאות, וגם לא את התקורה.
CANCELLED_OR_DISCONNECTED_EXECUTION_COUNT INT64 מספר הפעמים שהשאילתה בוטלה על ידי המשתמש או נכשלה בגלל חיבור לרשת שהתנתק במהלך המרווח.
TIMED_OUT_EXECUTION_COUNT INT64 מספר הפעמים שהזמן הקצוב לתפוגה של השאילתה חלף במהלך המרווח.
AVG_BYTES_WRITTEN FLOAT64 מספר הבייטים הממוצע שנכתבו על ידי ההצהרה.
AVG_ROWS_WRITTEN FLOAT64 המספר הממוצע של שורות שהשתנו בעקבות ההצהרה.
RUN_IN_RW_TRANSACTION_EXECUTION_COUNT INT64 מספר הפעמים שבהן שאילתות הופעלו כחלק מעסקאות קריאה-כתיבה. העמודה הזו עוזרת לכם לקבוע אם אתם יכולים להימנע ממחלוקות על נעילה על ידי העברת חלק מהשאילתות לעסקאות לקריאה בלבד.
LATENCY_DISTRIBUTION ARRAY<STRUCT>

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

מציינים את המערך באופן הבא:
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) שמחזירה את האחוזון ה-n המשוער. דוגמה קשורה מופיעה במאמר מציאת זמן האחזור של שאילתות באחוזון ה-99.

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

LATENCY_DISTRIBUTION_JSON_STRING STRING

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

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

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

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

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

AVG_COLUMNAR_READ_SHARE FLOAT64

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

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

CPU_SECONDS_DISTRIBUTION ARRAY<STRUCT>

היסטוגרמה של זמן המעבד (CPU) ש-Spanner השקיע בכל הפעולות כדי להריץ את השאילתה. הערכים נמדדים בשניות.

המבנה של המערך הוא:
ARRAY<STRUCT<
  COUNT INT64,
  MEAN FLOAT64,
  SUM_OF_SQUARED_DEVIATION FLOAT64,
  NUM_FINITE_BUCKETS INT64,
  GROWTH_FACTOR FLOAT64,
  SCALE FLOAT64,
  BUCKET_COUNTS ARRAY<INT64>>>

למידע נוסף על סוגי הערכים, קראו את המאמרים התפלגות ואקספוננציאלי.

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

CPU_SECONDS_DISTRIBUTION_JSON_STRING STRING

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

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

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

ROW_SCANNED_DISTRIBUTION ARRAY<STRUCT>

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

המערך בנוי באופן הבא:
ARRAY<STRUCT<
  COUNT INT64,
  MEAN FLOAT64,
  SUM_OF_SQUARED_DEVIATION FLOAT64,
  NUM_FINITE_BUCKETS INT64,
  GROWTH_FACTOR FLOAT64,
  SCALE FLOAT64,
  BUCKET_COUNTS ARRAY<INT64>>>

למידע נוסף על סוגי הערכים, קראו את המאמרים התפלגות ואקספוננציאלי.

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

ROW_SCANNED_DISTRIBUTION_JSON_STRING STRING

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

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

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

שמירת נתונים

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

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

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

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

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

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

הצגת הנתונים הסטטיסטיים הבסיסיים של כל שאילתה בתקופה נתונה

השאילתה הבאה מחזירה את הנתונים הגולמיים של השאילתות המובילות בדקה הקודמת:

SELECT text,
       request_tag,
       interval_end,
       execution_count,
       avg_latency_seconds,
       avg_rows,
       avg_bytes,
       avg_rows_scanned,
       avg_cpu_seconds
FROM spanner_sys.query_stats_top_minute
ORDER BY interval_end DESC;

הצגת הנתונים הסטטיסטיים של פקודות DML מחולקות למחיצות שפועלות יותר משעה

השאילתה הבאה מחזירה את מספר ההפעלות ואת מספר השורות הממוצע שנכתבו על ידי שאילתות ה-DML המחיצתיות המובילות בשעות הקודמות:

SELECT text,
       request_tag,
       interval_end,
       sum(execution_count) as execution_count,
       sum(avg_rows_written*execution_count)/sum(execution_count) as avg_rows_written
FROM spanner_sys.query_stats_top_hour
WHERE starts_with(text, "UPDATE") AND query_type = "PARTITIONED_QUERY"
group by text, request_tag, interval_end
ORDER BY interval_end DESC;

רשימת השאילתות עם השימוש הגבוה ביותר ב-CPU

השאילתה הבאה מחזירה את השאילתות עם השימוש הגבוה ביותר ב-CPU בשעה הקודמת:

SELECT text,
       request_tag,
       execution_count AS count,
       avg_latency_seconds AS latency,
       avg_cpu_seconds AS cpu,
       execution_count * avg_cpu_seconds AS total_cpu
FROM spanner_sys.query_stats_top_hour
WHERE interval_end =
  (SELECT MAX(interval_end)
   FROM spanner_sys.query_stats_top_hour)
ORDER BY total_cpu DESC;

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

השאילתה הבאה מחזירה את המספר הכולל של השאילתות שבוצעו במרווח הזמן המלא האחרון של דקה אחת:

SELECT interval_end,
       execution_count
FROM spanner_sys.query_stats_total_minute
WHERE interval_end =
  (SELECT MAX(interval_end)
   FROM spanner_sys.query_stats_total_minute);

איך מוצאים את זמן האחזור הממוצע של שאילתה

השאילתה הבאה מחזירה את מידע זמן האחזור הממוצע של שאילתה ספציפית:

SELECT avg_latency_seconds
FROM spanner_sys.query_stats_top_hour
WHERE text LIKE "SELECT x FROM table WHERE x=@foo;";

מציאת זמן האחזור באחוזון ה-99 של שאילתות

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

השאילתות הבאות מחזירות את האחוזון ה-99 של זמן הביצוע של שאילתות שהופעלו ב-10 הדקות האחרונות.

במסדי נתונים עם ניב GoogleSQL, אפשר להשתמש בעמודה LATENCY_DISTRIBUTION:

SELECT interval_end, avg_latency_seconds, SPANNER_SYS.DISTRIBUTION_PERCENTILE(latency_distribution[OFFSET(0)], 99.0)
  AS percentile_latency
FROM spanner_sys.query_stats_total_10minute
WHERE interval_end =
  (SELECT MAX(interval_end)
   FROM spanner_sys.query_stats_total_10minute)
ORDER BY interval_end;

במסדי נתונים עם ניב PostgreSQL, משתמשים בעמודה LATENCY_DISTRIBUTION_JSON_STRING:

SELECT interval_end, avg_latency_seconds, SPANNER_SYS.DISTRIBUTION_PERCENTILE(latency_distribution_json_string, 99.0)
  AS percentile_latency
FROM spanner_sys.query_stats_total_10minute
WHERE interval_end =
  (SELECT MAX(interval_end)
   FROM spanner_sys.query_stats_total_10minute)
ORDER BY interval_end;

איך מוצאים את השאילתות שסורקות הכי הרבה נתונים

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

SELECT text,
       execution_count,
       avg_rows_scanned
FROM spanner_sys.query_stats_top_hour
WHERE interval_end =
  (SELECT MAX(interval_end)
   FROM spanner_sys.query_stats_top_hour)
ORDER BY avg_rows_scanned DESC;

חיפוש ההצהרות שכתבו הכי הרבה נתונים

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

SELECT text,
       execution_count,
       avg_rows_written
FROM spanner_sys.query_stats_top_hour
WHERE interval_end =
  (SELECT MAX(interval_end)
   FROM spanner_sys.query_stats_top_hour)
ORDER BY avg_rows_written DESC;

סך השימוש במעבד (CPU) בכל השאילתות

השאילתה הבאה מחזירה את מספר שעות המעבד (CPU) שנוצלו בשעה הקודמת:

SELECT (avg_cpu_seconds * execution_count / 60 / 60)
  AS total_cpu_hours
FROM spanner_sys.query_stats_total_hour
WHERE interval_end =
  (SELECT MAX(interval_end)
   FROM spanner_sys.query_stats_total_hour);

רשימת השאילתות שנכשלו בתקופה מסוימת

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

SELECT text,
       request_tag,
       interval_end,
       execution_count,
       all_failed_execution_count,
       all_failed_avg_latency_seconds,
       avg_latency_seconds,
       avg_rows,
       avg_bytes,
       avg_rows_scanned,
       avg_cpu_seconds
FROM spanner_sys.query_stats_top_minute
WHERE all_failed_execution_count > 0
ORDER BY interval_end;

חיפוש המספר הכולל של השגיאות בתקופה נתונה

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

SELECT interval_end,
       all_failed_execution_count
FROM spanner_sys.query_stats_total_minute
WHERE interval_end =
  (SELECT MAX(interval_end)
   FROM spanner_sys.query_stats_top_minute)
ORDER BY interval_end;

רשימת השאילתות שבהן הזמן הקצוב לתפוגה נגמר הכי הרבה פעמים

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

SELECT text,
       execution_count AS count,
       timed_out_execution_count AS timeout_count,
       avg_latency_seconds AS latency,
       avg_cpu_seconds AS cpu,
       execution_count * avg_cpu_seconds AS total_cpu
FROM spanner_sys.query_stats_top_hour
WHERE interval_end =
  (SELECT MAX(interval_end)
   FROM spanner_sys.query_stats_top_hour)
ORDER BY timed_out_execution_count DESC;

איך מוצאים את זמן האחזור הממוצע של הרצות מוצלחות והרצות שנכשלו של שאילתה

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

SELECT avg_latency_seconds AS combined_avg_latency,
       all_failed_avg_latency_seconds AS failed_execution_latency,
       ( avg_latency_seconds * execution_count -
         all_failed_avg_latency_seconds * all_failed_execution_count
       ) / (
       execution_count - all_failed_execution_count ) AS success_execution_latency
FROM   spanner_sys.query_stats_top_hour
WHERE  text LIKE "select x from table where x=@foo;";

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

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

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

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

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

כדי להתחיל את הבדיקה, חפשו את הזמן שבו התחילה עלייה בשימוש ב-CPU באפליקציה. לדוגמה, אם הבעיה התחילה בערך ב-24 ביולי 2020 בשעה 17:00 (שעון UTC).

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

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

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

SELECT interval_end,
       execution_count AS count,
       ROUND(avg_latency_seconds,2) AS latency,
       ROUND(avg_rows,2) AS rows_returned,
       ROUND(avg_bytes,2) AS bytes,
       ROUND(avg_rows_scanned,2) AS rows_scanned,
       ROUND(avg_cpu_seconds,3) AS avg_cpu
FROM spanner_sys.query_stats_total_10minute
WHERE
  interval_end >= "2020-07-24T16:30:00Z"
  AND interval_end <= "2020-07-24T17:30:00Z"
ORDER BY interval_end;

הרצת השאילתה הניבה את התוצאות הבאות.

interval_end ספירה זמן אחזור rows_returned בייטים rows_scanned avg_cpu
2020-07-24T16:30:00Z 6 0.06 5.00 536.00 16.67 0.035
2020-07-24T16:40:00Z 55 0.02 0.22 25.29 0.22 0.004
2020-07-24T16:50:00Z 102 0.02 0.30 33.35 0.30 0.004
2020-07-24T17:00:00Z 154 1.06 4.42 486.33 7792208.12 4.633
2020-07-24T17:10:00Z 94 0.02 1.68 106.84 1.68 0.006
2020-07-24T17:20:00Z 110 0.02 0.38 34.60 0.38 0.005
2020-07-24T17:30:00Z 47 0.02 0.23 24.96 0.23 0.004

בטבלה שלמעלה, שימו לב שזמן המעבד הממוצע, העמודה avg_cpu בטבלת התוצאות, הוא הגבוה ביותר במרווחים המודגשים שמסתיימים בשעה 17:00. בנוסף, שימו לב למספר הגבוה בהרבה של שורות שנסרקו בממוצע. זה מצביע על כך ששאילתות יקרות יותר רצו בין 16:50 ל-17:00. בוחרים את מרווח הזמן הזה כדי לבדוק אותו לעומק בשלב הבא.

איתור השאילתות שגורמות לשימוש גבוה ב-CPU

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

SELECT text_fingerprint AS fingerprint,
       execution_count AS count,
       ROUND(avg_latency_seconds,2) AS latency,
       ROUND(avg_cpu_seconds,3) AS cpu,
       ROUND(execution_count * avg_cpu_seconds,3) AS total_cpu
FROM spanner_sys.query_stats_top_10minute
WHERE
  interval_end = "2020-07-24T17:00:00Z"
ORDER BY total_cpu DESC;

הרצת השאילתה הזו מניבה את התוצאות הבאות.

טביעת אצבע ספירה זמן אחזור המעבד (CPU) total_cpu
5505124206529314852 30 3.88 17.635 529.039
1697951036096498470 10 4.49 18.388 183.882
2295109096748351518 1 0.33 0.048 0.048
11618299167612903606 1 0.25 0.021 0.021
10302798842433860499 1 0.04 0.006 0.006
123771704548746223 1 0.04 0.006 0.006
4216063638051261350 1 0.04 0.006 0.006
3654744714919476398 1 0.04 0.006 0.006
2999453161628434990 1 0.04 0.006 0.006
823179738756093706 1 0.02 0.005 0.0056

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

השוואה בין הרצות של שאילתות לאורך זמן

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

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

SELECT interval_end,
       ROUND(avg_latency_seconds,2) AS latency,
       avg_rows AS rows_returned,
       avg_bytes AS bytes_returned,
       avg_rows_scanned AS rows_scanned,
       ROUND(avg_cpu_seconds,3) AS cpu,
FROM spanner_sys.query_stats_top_minute
WHERE text_fingerprint = 5505124206529314852
ORDER BY interval_end DESC;

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

interval_end זמן אחזור rows_returned bytes_returned rows_scanned המעבד (CPU)
2020-07-24T17:00:00Z 4.55 21 2365 30000000 19.255
2020-07-24T16:00:00Z 3.62 21 2365 30000000 17.255
2020-07-24T15:00:00Z 4.37 21 2365 30000000 18.350
2020-07-24T14:00:00Z 4.02 21 2365 30000000 17.748
2020-07-24T13:00:00Z 3.12 21 2365 30000000 16.380
2020-07-24T12:00:00Z 3.45 21 2365 30000000 15.476
2020-07-24T11:00:00Z 4.94 21 2365 30000000 22.611
2020-07-24T10:00:00Z 6.48 21 2365 30000000 21.265
2020-07-24T09:00:00Z 0.23 21 2365 5 0.040
2020-07-24T08:00:00Z 0.04 21 2365 5 0.021
2020-07-24T07:00:00Z 0.09 21 2365 5 0.030

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

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

SELECT text,
       text_truncated
FROM spanner_sys.query_stats_top_hour
WHERE text_fingerprint = 5505124206529314852
LIMIT 1;

התוצאה שמתקבלת:

טקסט text_truncated
select * from orders where o_custkey = 36901;‎ FALSE

כשבוחנים את טקסט השאילתה שמוחזר, אפשר לראות שהשאילתה מסננת לפי שדה שנקרא o_custkey. זו עמודה שהיא לא מפתח בטבלה orders. במקרה הזה, בעבר היה אינדקס בעמודה הזו, והוא הוסר בסביבות השעה 9:00. זה מסביר את השינוי בעלות של השאילתה הזו. אפשר להוסיף את האינדקס בחזרה, או אם השאילתה לא מופעלת לעיתים קרובות, להחליט לא להשתמש באינדקס ולקבל את עלות הקריאה הגבוהה יותר.

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

בדיקת שאילתות שנכשלו

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

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

SELECT interval_end,
       all_failed_execution_count AS failed_count,
       all_failed_avg_latency_seconds AS latency
FROM spanner_sys.query_stats_total_minute
WHERE
  interval_end >= "2020-07-24T16:50:00Z"
  AND interval_end <= "2020-07-24T17:00:00Z"
ORDER BY interval_end;
interval_end failed_count זמן אחזור
2020-07-24T16:52:00Z 1 15.211391
2020-07-24T16:53:00Z 3 58.312232

כדי להמשיך בבדיקה, אפשר להשתמש בשאילתה הבאה כדי לחפש את השאילתות שהכי סביר שייכשלו.

SELECT interval_end,
       text_fingerprint,
       execution_count,
       avg_latency_seconds AS avg_latency,
       all_failed_execution_count AS failed_count,
       all_failed_avg_latency_seconds AS failed_latency,
       cancelled_or_disconnected_execution_count AS cancel_count,
       timed_out_execution_count AS to_count
FROM spanner_sys.query_stats_top_minute
WHERE all_failed_execution_count > 0
ORDER BY interval_end;
interval_end text_fingerprint execution_count failed_count cancel_count to_count
2020-07-24T16:52:00Z 5505124206529314852 3 1 1 0
2020-07-24T16:53:00Z 1697951036096498470 2 1 1 0
2020-07-24T16:53:00Z 5505124206529314852 5 2 1 1

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

SELECT interval_end,
       avg_latency_seconds AS combined_avg_latency,
       all_failed_avg_latency_seconds AS failed_execution_latency,
       ( avg_latency_seconds * execution_count -
         all_failed_avg_latency_seconds * all_failed_execution_count
       ) / (
       execution_count - all_failed_execution_count ) AS success_execution_latency
FROM   spanner_sys.query_stats_top_hour
WHERE  text_fingerprint = 5505124206529314852;
interval_end combined_avg_latency failed_execution_latency success_execution_latency
2020-07-24T17:00:00Z 3.880420 13.830709 2.774832

יישום השיטות המומלצות

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

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