תצוגת משרות

התצוגה INFORMATION_SCHEMA.JOBS מכילה מטא-נתונים כמעט בזמן אמת על כל המשימות ב-BigQuery בפרויקט הנוכחי.

הערה: שמות התצוגות INFORMATION_SCHEMA.JOBS ו-INFORMATION_SCHEMA.JOBS_BY_PROJECT הם שמות נרדפים ואפשר להשתמש בהם לסירוגין.

התפקיד הנדרש

כדי לקבל את ההרשאה שנדרשת לשליחת שאילתות לתצוגה INFORMATION_SCHEMA.JOBS, צריך לבקש מהאדמין להקצות לכם את תפקיד ה-IAM‏ BigQuery Resource Viewer (roles/bigquery.resourceViewer) בפרויקט. להסבר על מתן תפקידים, קראו איך מנהלים את הגישה ברמת הפרויקט, התיקייה והארגון.

התפקיד שמוגדר מראש מכיל את ההרשאה bigquery.jobs.listAll, שנדרשת כדי לבצע שאילתות בתצוגה INFORMATION_SCHEMA.JOBS.

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

מידע נוסף על הרשאות ב-BigQuery זמין במאמר בקרת גישה באמצעות IAM.

סכימה

הנתונים הבסיסיים מחולקים למחיצות לפי העמודה creation_time ומקובצים לפי project_id ו-user_email. העמודה query_info מכילה מידע נוסף על עבודות השאילתה.

לתצוגה INFORMATION_SCHEMA.JOBS יש את הסכימה הבאה:

שם העמודה	סוג הנתונים	ערך
bi_engine_statistics	RECORD	אם הפרויקט מוגדר לשימוש ב-BI Engine, השדה הזה מכיל BiEngineStatistics. אחרת NULL.
cache_hit	BOOLEAN	האם תוצאות השאילתה של העבודה הזו הגיעו ממטמון. אם יש לכם עבודת הצהרה עם כמה שאילתות, cache_hit עבור שאילתת האב היא NULL.
creation_time	TIMESTAMP	(עמודת חלוקה למחיצות (partitioning)) מועד היצירה של העבודה הזו. החלוקה למחיצות מבוססת על זמן UTC של חותמת הזמן הזו.
destination_table	RECORD	טבלת היעד של התוצאות, אם יש כאלה.
dml_statistics	RECORD	אם העבודה היא שאילתה עם פקודת DML, הערך הוא רשומה עם השדות הבאים: ‫inserted_row_count: מספר השורות שהוכנסו. ‫deleted_row_count: מספר השורות שנמחקו. ‫updated_row_count: מספר השורות שעודכנו. לכל שאר המשרות, הערך הוא NULL. העמודה הזו מופיעה בתצוגות INFORMATION_SCHEMA.JOBS_BY_USER ו-INFORMATION_SCHEMA.JOBS_BY_PROJECT.
end_time	TIMESTAMP	שעת הסיום של העבודה הזו, באלפיות השנייה מאז התקופה. השדה הזה מייצג את הזמן שבו העבודה נכנסה למצב DONE.
error_result	RECORD	פרטים של שגיאות כאובייקטים מסוג ErrorProto.
job_creation_reason.code	STRING	מציין את הסיבה ברמה גבוהה ליצירת המשימה. הערכים האפשריים הם: ‫REQUESTED: נשלחה בקשה ליצירת משימה. ‫LONG_RUNNING: השאילתה פעלה מעבר לזמן קצוב לתפוגה מוגדר במערכת שצוין בשדה timeoutMs ב-QueryRequest. כתוצאה מכך, היא נחשבה לפעולה ממושכת, ולכן נוצרה משימה. ‫LARGE_RESULTS: התוצאות מהשאילתה לא יכולות להיכנס לתגובה בגוף ההודעה. ‫OTHER: המערכת קבעה שצריך להריץ את השאילתה כמשימה.
job_id	STRING	המזהה של המשרה אם היא נוצרה. אחרת, מזהה השאילתה של שאילתה שמשתמשת במצב יצירה אופציונלי של משימות. לדוגמה, bquxjob_1234.
job_stages	RECORD	שלבי שאילתה של המשרה. הערה: הערכים בעמודה הזו ריקים בשאילתות שקוראות מטבלאות עם מדיניות גישה ברמת השורה. מידע נוסף זמין במאמר בנושא שיטות מומלצות לאבטחה ברמת השורה ב-BigQuery.
job_type	STRING	סוג המשרה. יכול להיות QUERY, LOAD, EXTRACT, COPY או NULL. הערך NULL מציין עבודה ברקע.
labels	RECORD	מערך של תוויות שמוחלות על העבודה כצמדי מפתח/ערך.
parent_job_id	STRING	המזהה של עבודת ההורה, אם יש כזו.
priority	STRING	העדיפות של העבודה הזו. הערכים התקפים כוללים INTERACTIVE ו-BATCH.
project_id	STRING	‫(Clustering column) מזהה הפרויקט.
project_number	INTEGER	מספר הפרויקט.
query	STRING	טקסט של שאילתת SQL.
referenced_tables	RECORD	מערך של ערכי STRUCT שמכילים את השדות הבאים של STRING לכל טבלה שהשאילתה מפנה אליה: project_id, dataset_id ו-table_id. השדה הזה מאוכלס רק עבור משימות של שאילתות שלא נמצאות במטמון.
reservation_id	STRING	שם ההזמנה הראשית שהוקצתה לעבודה הזו, בפורמט RESERVATION_ADMIN_PROJECT:RESERVATION_LOCATION.RESERVATION_NAME. בפלט הזה: ‫RESERVATION_ADMIN_PROJECT: השם של הפרויקט בענן של Google שבו מנוהלת ההזמנה ‫RESERVATION_LOCATION: המיקום של ההזמנה ‫RESERVATION_NAME: השם של ההזמנה
edition	STRING	המהדורה שמשויכת להזמנה שהוקצתה למשרה הזו. מידע נוסף על מהדורות זמין במאמר מבוא למהדורות של BigQuery.
session_info	RECORD	פרטים על הסשן שבו המשימה הזו הופעלה, אם יש כזה.
start_time	TIMESTAMP	שעת ההתחלה של העבודה הזו, באלפיות השנייה מאז התקופה. השדה הזה מייצג את הזמן שבו המשימה עוברת מהסטטוס PENDING לסטטוס RUNNING או DONE.
state	STRING	מצב ההפעלה של העבודה. מדינות תקפות כוללות את PENDING, RUNNING ו-DONE.
statement_type	STRING	סוג הצהרת השאילתה. לדוגמה, DELETE, INSERT, SCRIPT, SELECT או UPDATE. רשימת הערכים התקינים מופיעה בקטע QueryStatementType.
timeline	RECORD	ציר הזמן של השאילתה של העבודה. מכיל תמונות מצב של הרצת שאילתות.
total_bytes_billed	INTEGER	אם הפרויקט מוגדר לשימוש בתמחור על פי דרישה, השדה הזה מכיל את סך הבייטים שחויבו על העבודה. אם הפרויקט מוגדר לשימוש בתמחור לפי תעריף קבוע, לא מחייבים אתכם על בייטים והשדה הזה הוא רק לצורכי מידע. הערה: הערכים בעמודה הזו ריקים בשאילתות שקוראות מטבלאות עם מדיניות גישה ברמת השורה. מידע נוסף זמין במאמר בנושא שיטות מומלצות לאבטחה ברמת השורה ב-BigQuery.
total_bytes_processed	INTEGER	המספר הכולל של בייטים שעובדו על ידי העבודה. הערה: הערכים בעמודה הזו ריקים בשאילתות שקוראות מטבלאות עם מדיניות גישה ברמת השורה. מידע נוסף זמין במאמר בנושא שיטות מומלצות לאבטחה ברמת השורה ב-BigQuery.
total_modified_partitions	INTEGER	המספר הכולל של המחיצות שהעבודה שינתה. השדה הזה מאוכלס עבור משרות LOAD וQUERY.
total_slot_ms	INTEGER	משבצת הזמן באלפיות השנייה של העבודה במהלך כל משך הזמן שלה במצב RUNNING, כולל ניסיונות חוזרים.
total_services_sku_slot_ms	INTEGER	סך אלפיות השנייה של משבצות הזמן של המשימה שמופעלת בשירותים חיצוניים ושמחויבת לפי המק"ט של השירותים. השדה הזה מאוכלס רק עבור משימות שכוללות עלויות של שירותים חיצוניים, והוא מכיל את סך העלויות של השימוש ששיטת החיוב שלו היא "SERVICES_SKU".
transaction_id	STRING	המזהה של העסקה שבה המשימה הזו הופעלה, אם יש כזה.
user_email	STRING	(Clustering column) כתובת האימייל או חשבון השירות של המשתמש שביצע את העבודה.
principal_subject	STRING	ייצוג מחרוזת של הזהות של חשבון המשתמש שהפעיל את העבודה.
query_info.resource_warning	STRING	הודעת האזהרה שמופיעה אם השימוש במשאבים במהלך עיבוד השאילתה חורג מהסף הפנימי של המערכת. אם עבודת השאילתה הושלמה בהצלחה, השדה resource_warning יאוכלס. בעזרת resource_warning, אתם מקבלים נקודות נתונים נוספות כדי לבצע אופטימיזציה של השאילתות ולהגדיר מעקב אחר מגמות הביצועים של קבוצה שוות ערך של שאילתות באמצעות query_hashes.
query_info.query_hashes.normalized_literals	STRING	מכיל את ערך הגיבוב של השאילתה. ‫normalized_literals הוא גיבוב הקסדצימלי שמתעלם מהערות, מערכי פרמטרים, מפונקציות מוגדרות על ידי המשתמש וממילוליים.STRING ערך הגיבוב יהיה שונה אם התצוגות הבסיסיות ישתנו, או אם השאילתה מפנה באופן מרומז לעמודות, כמו SELECT *, וסכימת הטבלה משתנה. השדה הזה מופיע בשאילתות GoogleSQL שבוצעו בהצלחה ולא נמצאו במטמון.
query_info.performance_insights	RECORD	תובנות לגבי הביצועים של המשימה.
query_info.optimization_details	STRUCT	אופטימיזציות מבוססות-היסטוריה של המשרה. העמודה הזו מופיעה רק בתצוגה JOBS_BY_PROJECT.
transferred_bytes	INTEGER	המספר הכולל של בייטים שהועברו בשאילתות בין עננים, כמו משימות העברה בין עננים ב-BigQuery Omni.
materialized_view_statistics	RECORD	נתונים סטטיסטיים של תצוגות חומריות שנלקחים בחשבון בעבודת שאילתה. (תצוגה מקדימה)
metadata_cache_statistics	RECORD	נתונים סטטיסטיים על השימוש באינדקס של עמודות מטא-נתונים בטבלאות שהופנו אליהן בעבודת שאילתה.
search_statistics	RECORD	נתונים סטטיסטיים של שאילתת חיפוש.
query_dialect	STRING	השדה הזה יהיה זמין במהלך מאי 2025. ניב השאילתה שמשמש לעבודה. הערכים התקפים כוללים: ‫GOOGLE_SQL: נשלחה בקשה לעבודה לשימוש ב-GoogleSQL. ‫LEGACY_SQL: הבקשה לעבודה הייתה להשתמש ב-LegacySQL. ‫DEFAULT_LEGACY_SQL: לא צוין דיאלקט שאילתה בבקשת העבודה. המערכת של BigQuery השתמשה בערך ברירת המחדל של LegacySQL. ‫DEFAULT_GOOGLE_SQL: לא צוין דיאלקט שאילתה בבקשת העבודה. מערכת BigQuery השתמשה בערך ברירת המחדל של GoogleSQL. השדה הזה מאוכלס רק עבור משימות של שאילתות. אפשר לשלוט בבחירה של דיאלקט השאילתה שמוגדר כברירת מחדל באמצעות הגדרות התצורה.
continuous	BOOLEAN	האם העבודה היא שאילתה מתמשכת.
continuous_query_info.output_watermark	TIMESTAMP	מייצג את הנקודה שעד אליה השאילתה המתמשכת עיבדה נתונים בהצלחה.
vector_search_statistics	RECORD	נתונים סטטיסטיים של שאילתת חיפוש וקטורי.

כששולחים שאילתה אל INFORMATION_SCHEMA.JOBS כדי למצוא סיכום של עלויות של עבודות שאילתה, צריך להחריג את סוג ההצהרה SCRIPT, אחרת יכול להיות שחלק מהערכים ייספרו פעמיים. השורה SCRIPT כוללת ערכי סיכום של כל עבודות הצאצא שהופעלו כחלק מהעבודה הזו.

כדי לשמור על יציבות, מומלץ לציין במפורש את העמודות בשאילתות של סכימת המידע, במקום להשתמש בתו כל כללי (SELECT *). ציון מפורש של העמודות מונע את השבירה של השאילתות אם הסכימה הבסיסית משתנה.

משימות של שאילתות עם כמה הצהרות

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

• ‫statement_type = SCRIPT
• ‫reservation_id = NULL

משרות לילדים

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

אם אתם שולחים שאילתה של INFORMATION_SCHEMA.JOBS כדי למצוא סיכום של עלויות של עבודות שאילתה, אתם צריכים להחריג את סוג ההצהרה SCRIPT. אחרת, יכול להיות שערכים מסוימים כמו total_slot_ms ייספרו פעמיים.

שמירת נתונים

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

היקף ותחביר

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

שם התצוגה	היקף המשאבים	היקף האזור
[PROJECT_ID.]`region-REGION`.INFORMATION_SCHEMA.JOBS[_BY_PROJECT]	ברמת הפרויקט	REGION

מחליפים את מה שכתוב בשדות הבאים:

• אופציונלי: PROJECT_ID: מזהה הפרויקט ב- Google Cloud . אם לא מציינים פרויקט, המערכת משתמשת בפרויקט שמוגדר כברירת מחדל.
• ‫REGION: כל שם של אזור במערך נתונים. לדוגמה, `region-us`.
  הערה: כדי לשלוח שאילתה לגבי נתוני הצפיות ב-INFORMATION_SCHEMA, צריך להשתמש במסנן אזור. המיקום של הרצת השאילתה צריך להיות זהה לאזור של התצוגה INFORMATION_SCHEMA.

דוגמאות

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

`PROJECT_ID`.`region-REGION_NAME`.INFORMATION_SCHEMA.JOBS

מחליפים את מה שכתוב בשדות הבאים:

• ‫PROJECT_ID: מזהה הפרויקט
• ‫REGION_NAME: האזור של הפרויקט.

לדוגמה, `myproject`.`region-us-central1`.INFORMATION_SCHEMA.JOBS.

השוואה בין נתוני השימוש בעבודות לפי דרישה לבין נתוני החיוב

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

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

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

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

• ‫START_DATE: התאריך המוקדם ביותר לסיכום הנתונים (כולל).
• END_DATE: התאריך האחרון לסיכום הנתונים (כולל).
• ‫PRICE_PER_TIB: המחיר על פי דרישה לכל TiB שמשמש להערכות חיוב.

CREATE TEMP FUNCTION isBillable(error_result ANY TYPE)
AS (
  -- You aren't charged for queries that return an error.
  error_result IS NULL
  -- However, canceling a running query might incur charges.
  OR error_result.reason = 'stopped'
);

-- BigQuery hides the number of bytes billed on all queries against tables with
-- row-level security.
CREATE TEMP FUNCTION isMaybeUsingRowLevelSecurity(
  job_type STRING, tib_billed FLOAT64, error_result ANY TYPE)
AS (
  job_type = 'QUERY'
  AND tib_billed IS NULL
  AND isBillable(error_result)
);

WITH
  query_params AS (
    SELECT
      date 'START_DATE' AS start_date,  -- inclusive
      date 'END_DATE' AS end_date,  -- inclusive
  ),
  usage_with_multiplier AS (
    SELECT
      job_type,
      error_result,
      creation_time,
      -- Jobs are billed by end_time in PST8PDT timezone, regardless of where
      -- the job ran.
      EXTRACT(date FROM end_time AT TIME ZONE 'PST8PDT') billing_date,
      total_bytes_billed / 1024 / 1024 / 1024 / 1024 total_tib_billed,
      CASE statement_type
        WHEN 'SCRIPT' THEN 0
        WHEN 'CREATE_MODEL' THEN 50 * PRICE_PER_TIB
        ELSE PRICE_PER_TIB
        END AS multiplier,
    FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
    WHERE statement_type <> 'SCRIPT'
  )
SELECT
  billing_date,
  sum(total_tib_billed * multiplier) estimated_charge,
  sum(total_tib_billed) estimated_usage_in_tib,
  countif(isMaybeUsingRowLevelSecurity(job_type, total_tib_billed, error_result))
    AS jobs_using_row_level_security,
FROM usage_with_multiplier, query_params
WHERE
  1 = 1
  -- Filter by creation_time for partition pruning.
  AND date(creation_time) BETWEEN date_sub(start_date, INTERVAL 2 day) AND date_add(end_date, INTERVAL 1 day)
  AND billing_date BETWEEN start_date AND end_date
  AND isBillable(error_result)
GROUP BY billing_date
ORDER BY billing_date;

מגבלות

• ‫BigQuery מסתיר נתונים סטטיסטיים מסוימים לגבי שאילתות על טבלאות עם אבטחה ברמת השורה. מספר השאילתות שסופקו הוא jobs_using_row_level_security, אבל אין גישה לשימוש שניתן לחיוב.

• התמחור של שאילתות על פי דרישה ב-BigQuery ML תלוי בסוג המודל שנוצר. ‫INFORMATION_SCHEMA.JOBS לא עוקב אחרי סוג המודל שנוצר, ולכן השאילתה שמוצגת מניחה שכל הצהרות CREATE_MODEL יצרו את סוגי המודלים היקרים יותר.

• התמחור של פרוצדורות Apache Spark דומה, אבל החיובים מדווחים כמק"ט של BigQuery Enterprise Edition בתשלום לפי שימוש. ‫INFORMATION_SCHEMA.JOBS מתעד את השימוש הזה כ-INFORMATION_SCHEMA.JOBS, אבל לא יכול לקבוע איזה מק"ט מייצג השימוש.total_bytes_billed

חישוב ממוצע השימוש במשבצות זמן

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

כדי להריץ את השאילתה:

SELECT
  SUM(total_slot_ms) / (1000 * 60 * 60 * 24 * 7) AS avg_slots
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  -- Filter by the partition column first to limit the amount of data scanned.
  -- Eight days allows for jobs created before the 7 day end_time filter.
  creation_time BETWEEN TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 8 DAY) AND CURRENT_TIMESTAMP()
  AND job_type = 'QUERY'
  AND statement_type != 'SCRIPT'
  AND end_time BETWEEN TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 DAY) AND CURRENT_TIMESTAMP();

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

INFORMATION_SCHEMA

התוצאה אמורה להיראות כך:

+------------+
| avg_slots  |
+------------+
| 3879.1534  |
+------------+

אפשר לבדוק את השימוש במקום שמור מסוים באמצעות WHERE reservation_id = "…". הנתונים האלה יכולים לעזור לכם לקבוע את אחוז השימוש בהזמנה לאורך תקופה מסוימת. במשימות של סקריפטים, משימת האב מדווחת גם על השימוש הכולל במשבצות מתוך משימות הצאצא. כדי למנוע ספירה כפולה, משתמשים בפונקציה WHERE statement_type != "SCRIPT" כדי להחריג את עבודת ההורה.

אם רוצים לבדוק את ממוצע השימוש במשבצות זמן למשימות ספציפיות, משתמשים ב-total_slot_ms / TIMESTAMP_DIFF(end_time, start_time, MILLISECOND).

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

בדוגמה הבאה מוצג מספר השאילתות, מקובצות לפי עדיפות (אינטראקטיביות או אצווה), שהופעלו ב-7 השעות האחרונות:

SELECT
  priority,
  COUNT(*) active_jobs
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  creation_time > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 hour)
  AND job_type = 'QUERY'
GROUP BY priority;

התוצאה אמורה להיראות כך:

+-------------+-------------+
| priority    | active_jobs |
+-------------+-------------+
| INTERACTIVE |           2 |
| BATCH       |           3 |
+-------------+-------------+

השדה priority מציין אם השאילתה היא INTERACTIVE או BATCH.

הצגת היסטוריית טעינת הנתונים

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

SELECT
  user_email AS user,
  COUNT(*) num_jobs
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  job_type = 'LOAD'
GROUP BY
  user_email;

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

INFORMATION_SCHEMA

התוצאה אמורה להיראות כך:

+--------------+
| user         |
+--------------+
| [e-mail]  |
| [e-mail]  |
| [e-mail]  |
+--------------+

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

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

SELECT
    DATE(creation_time) as day,
    destination_table.project_id as project_id,
    destination_table.dataset_id as dataset_id,
    destination_table.table_id as table_id,
    COUNT(job_id) AS load_job_count
 FROM
   `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
 WHERE
    creation_time BETWEEN TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 8 DAY) AND CURRENT_TIMESTAMP()
    AND job_type = "LOAD"
GROUP BY
    day,
    project_id,
    dataset_id,
    table_id
ORDER BY
    day DESC;

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

INFORMATION_SCHEMA

התוצאה אמורה להיראות כך:

+-------------+------------+-------------+----------+-----------------+
|day          | project_id | dataset_id  | table_id | load_job_count  |
+-------------+------------+-------------+----------+-----------------+
| 2020-10-10  | my_project | dataset1    | orders   | 58              |
| 2020-10-10  | my_project | dataset1    | product  | 20              |
| 2020-10-10  | my_project | dataset1    | sales    | 11              |
+-------------+------------+-------------+----------+-----------------+

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

בדוגמה הבאה אפשר לראות את שלוש המשימות האחרונות שנכשלו:

SELECT
   job_id,
  creation_time,
  user_email,
   error_result
 FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE
  error_result.reason != "Null"
ORDER BY
  creation_time DESC
LIMIT 3;

התוצאות אמורות להיראות כך:

+------------+--------------------------+------------------+-------------------------------------+
| job_id     | creation_time            | user_email       | error_result                        |
+------------+--------------------------+------------------+-------------------------------------+
| bquxjob_1  | 2020-10-10 00:00:00 UTC  | [e-mail]  | Column 'col1' has mismatched type...|
| bquxjob_2  | 2020-10-11 00:00:00 UTC  | [e-mail]  | Column 'col1' has mismatched type...|
| bquxjob_3  | 2020-10-11 00:00:00 UTC  | [e-mail]  | Column 'col1' has mismatched type...|
+------------+--------------------------+------------------+-------------------------------------+

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

בדוגמה הבאה מוצגת רשימת המשימות ארוכות הטווח שנמצאות במצב RUNNING או PENDING במשך יותר מ-30 דקות:

SELECT
  job_id,
  job_type,
  state,
  creation_time,
  start_time,
  user_email
 FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
 WHERE
  state!="DONE" AND
  creation_time <= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 30 MINUTE)
ORDER BY
  creation_time ASC;

התוצאה אמורה להיראות כך:

+-----------+----------+---------+--------------------------------+--------------------------------+------------------+
| job_id    | job_type | state   | creation_time                  | start_time                     | user_email       |
+-----------+----------+---------+--------------------------------+--------------------------------+------------------+
| bquxjob_1 | QUERY    | RUNNING | 2023-05-03 05:07:22.818000 UTC | 2023-05-03 05:07:22.905000 UTC | [e-mail]  |
| bquxjob_2 | QUERY    | PENDING | 2023-05-01 02:05:47.925000 UTC | 2023-05-01 02:05:47.998000 UTC | [e-mail]  |
| bquxjob_3 | QUERY    | PENDING | 2023-05-01 02:05:47.925000 UTC | 2023-05-01 02:05:47.998000 UTC | [e-mail]  |
+-----------+----------+---------+--------------------------------+--------------------------------+------------------+

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

בדוגמה הבאה מוצגת רשימה של שאילתות שהופעלו במצב אופציונלי של יצירת משימות, ש-BigQuery לא יצר עבורן משימות.

SELECT
 job_id,
FROM
 `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
 TIMESTAMP_TRUNC(creation_time, DAY) = '2024-06-12'
 AND job_creation_reason.code IS NULL
LIMIT 3;

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

+-----------+
| job_id    |                                          |
+-----------+
| bquxjob_1 |
| bquxjob_2 |
| bquxjob_3 |
+-----------+

בדוגמה הבאה מוצג מידע על שאילתה שהופעלה במצב יצירה אופציונלית של משימות, ש-BigQuery לא יצר עבורה משימה.

SELECT
 job_id,
 statement_type,
 priority,
 cache_hit,
 job_creation_reason.code AS job_creation_reason_code,
 total_bytes_billed,
 total_bytes_processed,
 total_slot_ms,
 state,
 error_result.message AS error_result_message,
FROM
 `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
 TIMESTAMP_TRUNC(creation_time, DAY) = '2024-06-12'
 AND job_id = '2Lm09bHxDEsoVK8zwzWJomLHU_Ud%1910479b151' -- queryId

הערה: השדה job_id מכיל את queryId של השאילתה אם לא נוצרה משימה עבור השאילתה הזו.

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

+-----------+----------------+-------------+-----------+--------------------------+--------------------+---------------------+---------------+-------+----------------------+
| job_id    | statement_type | priority    | cache_hit | job_creation_reason_code | total_bytes_billed | total_bytes_processed | total_slot_ms | state | error_result_message |
+-----------+----------------+-------------+-----------+--------------------------+--------------------+---------------------+---------------+-------+----------------------+
| bquxjob_1 | SELECT         | INTERACTIVE | false     | null                     | 161480704          | 161164718             | 3106          | DONE  | null                 |
+-----------+----------------+-------------+-----------+--------------------------+--------------------+---------------------+---------------+-------+----------------------+

בדוגמה הבאה מוצגת רשימה של שאילתות שהופעלו במצב אופציונלי של יצירת עבודות, שעבורן BigQuery יצר עבודות.

SELECT
 job_id,
 job_creation_reason.code AS job_creation_reason_code
FROM
 `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
 TIMESTAMP_TRUNC(creation_time, DAY) = '2024-06-12'
 AND job_creation_reason.code IS NOT NULL
 AND job_creation_reason.code != 'REQUESTED'
LIMIT 3

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

+-----------+--------------------------+
| job_id    | job_creation_reason_code |
+-----------+--------------------------+
| bquxjob_1 | LARGE_RESULTS            |
| bquxjob_2 | LARGE_RESULTS            |
| bquxjob_3 | LARGE_RESULTS            |
+-----------+--------------------------+

בייטים שעובדו לכל זהות משתמש

בדוגמה הבאה מוצגים הבייטים הכוללים שחויבו על עבודות של שאילתות לכל משתמש:

SELECT
  user_email,
  SUM(total_bytes_billed) AS bytes_billed
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  job_type = 'QUERY'
  AND statement_type != 'SCRIPT'
GROUP BY
  user_email;

הערה: כדאי לעיין בהערה לגבי העמודה total_bytes_billed במסמכי התיעוד של הסכימה לתצוגות JOBS.

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

+---------------------+--------------+
| user_email          | bytes_billed |
+---------------------+--------------+
| [e-mail]     | 2847932416   |
| [e-mail]   | 1184890880   |
| [e-mail] | 10485760     |
+---------------------+--------------+

צבירת נתוני השימוש בגיליונות מקושרים לפי משתמש ברמת הפרויקט

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

SELECT
  user_email,
  COUNT(*) AS total_queries,
  SUM(total_bytes_billed) AS total_bytes_billed,
  SUM(total_slot_ms) AS total_slot_ms
FROM
  -- This view queries the project you are currently running the query in.
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE
  -- Filter for jobs created in the last 30 days
  creation_time >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 30 DAY)
  -- Filter for jobs originating from Connected Sheets
  AND job_id LIKE 'sheets_dataconnector%'
  -- Filter for completed jobs
  AND state = 'DONE'
  AND (statement_type IS NULL OR statement_type <> 'SCRIPT')
GROUP BY
  user_email
ORDER BY
  total_bytes_billed DESC
LIMIT
  10;

מחליפים את REGION_NAME באזור של הפרויקט. לדוגמה, region-us.

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

התוצאה אמורה להיראות כך:

+---------------------+---------------+--------------------+-----------------+
| user_email          | total_queries | total_bytes_billed | total_slot_ms   |
+---------------------+---------------+--------------------+-----------------+
| [e-mail]   | 152           | 12000000000        | 3500000         |
| [e-mail]     | 45            | 8500000000         | 2100000         |
| [e-mail] | 210           | 1100000000         | 1800000         |
+---------------------+---------------+--------------------+-----------------+

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

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

SELECT
  job_id,
  creation_time,
  user_email,
  total_bytes_billed,
  total_slot_ms,
  query
FROM
  -- This view queries the project you are currently running the query in.
  `region-REGION_NAME.INFORMATION_SCHEMA.JOBS_BY_PROJECT`
WHERE
  creation_time >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 30 DAY)
  AND job_id LIKE 'sheets_dataconnector%'
  AND state = 'DONE'
  AND (statement_type IS NULL OR statement_type <> 'SCRIPT')
ORDER BY
  creation_time DESC;

מחליפים את REGION_NAME באזור של הפרויקט. לדוגמה, region-us.

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

התוצאה אמורה להיראות כך:

+---------------------------------+---------------------------------+------------------+--------------------+-----------------+---------------------------------+
| job_id                          | creation_time                   | user_email       | total_bytes_billed | total_slot_ms   |  query                          |
+---------------------------------+---------------------------------+------------------+--------------------+-----------------+---------------------------------+
| sheets_dataconnector_bquxjob_1  | 2025-11-06 00:26:53.077000 UTC  | [e-mail]  | 12000000000        | 3500000         |  SELECT ... FROM dataset.table1 |
| sheets_dataconnector_bquxjob_2  | 2025-11-06 00:24:04.294000 UTC  | [e-mail]  | 8500000000         | 2100000         |  SELECT ... FROM dataset.table2 |
| sheets_dataconnector_bquxjob_3  | 2025-11-03 23:17:25.975000 UTC  | [e-mail]  | 1100000000         | 1800000         |  SELECT ... FROM dataset.table3 |
+---------------------------------+---------------------------------+------------------+--------------------+-----------------+---------------------------------+

פירוט שעתי של בייטים שעובדו

בדוגמה הבאה מוצגים סה"כ הבייטים שחויבו על עבודות שאילתה, במרווחי זמן של שעה:

SELECT
  TIMESTAMP_TRUNC(end_time, HOUR) AS time_window,
  SUM(total_bytes_billed) AS bytes_billed
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  job_type = 'QUERY'
  AND statement_type != 'SCRIPT'
GROUP BY
  time_window
ORDER BY
  time_window DESC;

התוצאה אמורה להיראות כך:

+-------------------------+--------------+
| time_window             | bytes_billed |
+-------------------------+--------------+
| 2022-05-17 20:00:00 UTC | 1967128576   |
| 2022-05-10 21:00:00 UTC | 0            |
| 2022-04-15 17:00:00 UTC | 41943040     |
+-------------------------+--------------+

משימות של שאילתות לכל טבלה

בדוגמה הבאה מוצג כמה פעמים כל טבלה שנשאלה ב-my_project הוזכרה בעבודת שאילתה:

SELECT
  t.project_id,
  t.dataset_id,
  t.table_id,
  COUNT(*) AS num_references
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS, UNNEST(referenced_tables) AS t
GROUP BY
  t.project_id,
  t.dataset_id,
  t.table_id
ORDER BY
  num_references DESC;

התוצאה אמורה להיראות כך:

+------------+------------+----------+----------------+
| project_id | dataset_id | table_id | num_references |
+------------+------------+----------+----------------+
| my_project | dataset1   | orders   | 58             |
| my_project | dataset1   | products | 40             |
| other_proj | dataset1   | accounts | 12             |
+------------+------------+----------+----------------+

מספר משימות של שאילתות SQL מדור קודם לכל פרויקט

השדה query_dialect ב-INFORMATION_SCHEMA זמין מאז מאי 2025. בדוגמה הבאה אפשר לראות כמה עבודות של שאילתות SQL מדור קודם מבוצעות על ידי פרויקטים.

SELECT
  project_id,
  -- Implicitly defaulted to LegacySQL since the query dialect was not specified
  -- in the request.
  COUNTIF(query_dialect = 'DEFAULT_LEGACY_SQL') AS default_legacysql_query_jobs,
  -- Explicitly requested LegacySQL.
  COUNTIF(query_dialect = 'LEGACY_SQL') AS legacysql_query_jobs,
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  query_dialect = 'DEFAULT_LEGACY_SQL'
  OR query_dialect = 'LEGACY_SQL'
GROUP BY
  project_id
ORDER BY
  default_legacysql_query_jobs DESC,
  legacysql_query_jobs DESC;

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

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

SELECT
  destination_table.table_id,
  SUM(total_modified_partitions) AS total_modified_partitions
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  DATE(creation_time, "America/Los_Angeles") = CURRENT_DATE()
GROUP BY
  table_id
ORDER BY
  total_modified_partitions DESC

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

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

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

SELECT ROUND(SAFE_DIVIDE(total_slot_ms,TIMESTAMP_DIFF(end_time, start_time, MILLISECOND)), 1) as avg_slots_per_ms
FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE job_id = 'JOB_ID'

מחליפים את JOB_ID ב-job_id שאתם בודקים.

הערה: שמות התצוגות המפורטות INFORMATION_SCHEMA הם תלויי אותיות רישיות.

התוצאה תהיה דומה לתוצאה הבאה:

+------------------+
| avg_slots_per_ms |
+------------------+
|             17.0 |
+------------------+

השאילתות הכי יקרות לפי פרויקט

בדוגמה הבאה מוצגת רשימה של השאילתות הכי יקרות ב-my_project לפי זמן השימוש במשבצת:

SELECT
 job_id,
 query,
 user_email,
 total_slot_ms
FROM `my_project`.`region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE EXTRACT(DATE FROM  creation_time) = current_date()
ORDER BY total_slot_ms DESC
LIMIT 3

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

SELECT
 job_id,
 query,
 user_email,
 total_bytes_processed
FROM `my_project`.`region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE EXTRACT(DATE FROM  creation_time) = current_date()
ORDER BY total_bytes_processed DESC
LIMIT 3

התוצאה של כל אחת מהדוגמאות אמורה להיראות כך:

+-----------+---------------------------------+-----------------------+---------------+
| job_id    | query                           | user_email            | total_slot_ms |
+-----------+---------------------------------+-----------------------+---------------+
| bquxjob_1 | SELECT ... FROM dataset.table1  | [e-mail]       | 80,000        |
| bquxjob_2 | SELECT ... FROM dataset.table2  | [e-mail]     | 78,000        |
| bquxjob_3 | SELECT ... FROM dataset.table3  | [e-mail]   | 75,000        |
+-----------+---------------------------------+-----------------------+---------------+

קבלת פרטים על אזהרה לגבי משאב

אם קיבלתם את הודעת השגיאה Resources exceeded, תוכלו לשלוח שאילתה לגבי השאילתות בחלון זמן:

SELECT
  query,
  query_info.resource_warning
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
 creation_time BETWEEN TIMESTAMP("2022-12-01")
 AND TIMESTAMP("2022-12-08")
 AND query_info.resource_warning IS NOT NULL
LIMIT 3;

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

אם מקבלים את הודעת השגיאה Resources exceeded, אפשר לעקוב אחרי המספר הכולל של אזהרות לגבי משאבים שמקובצות לפי תאריך, כדי לדעת אם יש שינויים בעומס העבודה:

WITH resource_warnings AS (
  SELECT
    EXTRACT(DATE FROM creation_time) AS creation_date
  FROM
    `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
  WHERE
    creation_time >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 14 DAY)
    AND query_info.resource_warning IS NOT NULL
)
SELECT
  creation_date,
  COUNT(1) AS warning_counts
FROM
  resource_warnings
GROUP BY creation_date
ORDER BY creation_date DESC;

הערכת השימוש במשבצות והעלות של שאילתות

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

הערך של reservation_id הוא NULL אם אין לכם הזמנות.

SELECT
  project_id,
  job_id,
  reservation_id,
  EXTRACT(DATE FROM creation_time) AS creation_date,
  TIMESTAMP_DIFF(end_time, start_time, SECOND) AS job_duration_seconds,
  job_type,
  user_email,
  total_bytes_billed,

  -- Average slot utilization per job is calculated by dividing total_slot_ms by the millisecond duration of the job

  SAFE_DIVIDE(job.total_slot_ms,(TIMESTAMP_DIFF(job.end_time, job.start_time, MILLISECOND))) AS job_avg_slots,
  query,

  -- Determine the max number of slots used at ANY stage in the query.
  -- The average slots might be 55. But a single stage might spike to 2000 slots.
  -- This is important to know when estimating number of slots to purchase.

  MAX(SAFE_DIVIDE(unnest_job_stages.slot_ms,unnest_job_stages.end_ms - unnest_job_stages.start_ms)) AS jobstage_max_slots,

  -- Check if there's a job that requests more units of works (slots). If so you need more slots.
  -- estimated_runnable_units = Units of work that can be scheduled immediately.
  -- Providing additional slots for these units of work accelerates the query,
  -- if no other query in the reservation needs additional slots.

  MAX(unnest_timeline.estimated_runnable_units) AS estimated_runnable_units
FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS AS job
  CROSS JOIN UNNEST(job_stages) as unnest_job_stages
  CROSS JOIN UNNEST(timeline) AS unnest_timeline
WHERE
  DATE(creation_time) BETWEEN DATE_SUB(CURRENT_DATE(), INTERVAL 7 DAY) AND CURRENT_DATE()
  AND project_id = 'my_project'
  AND (statement_type != 'SCRIPT' OR statement_type IS NULL)
GROUP BY 1,2,3,4,5,6,7,8,9,10
ORDER BY job_id;

לדוגמה, התוצאה תהיה דומה לזו:

+-----------+-----------+----------------+---------------+----------------------+----------+-----------------+--------------------+--------------+--------------------------------+--------------------+--------------------------+
|project_id | job_id    | reservation_id | creation_date | job_duration_seconds | job_type | user_email      | total_bytes_billed | job_avg_slots| query                          | jobstage_max_slots | estimated_runnable_units |
+-----------+-----------+----------------+---------------+----------------------+----------+-----------------+--------------------+--------------+--------------------------------+--------------------+--------------------------+
| project1  | bquxjob1  | reservation1   | 2020-10-10    | 160                  | LOAD     | [e-mail] | 161480704          | 2890         | SELECT ... FROM dataset.table1 | 2779.1534          | 1000                     |
| project1  | bquxjob2  | reservation2   | 2020-12-10    | 120                  | LOAD     | [e-mail] | 161480704          | 2890         | SELECT ... FROM dataset.table1 | 2779.1534          | 1000                     |
| project1  | bquxjob3  | reservation1   | 2020-12-10    | 120                  | LOAD     | [e-mail] | 161480704          | 2890         | SELECT ... FROM dataset.table1 | 1279.1534          | 998                     |
+-----------+-----------+----------------+---------------+----------------------+----------+-----------------+--------------------+--------------+--------------------------------+--------------------+--------------------------+

הצגת תובנות לגבי הביצועים של שאילתות

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

SELECT
  `bigquery-public-data`.persistent_udfs.job_url(
    project_id || ':us.' || job_id) AS job_url,
  query_info.performance_insights
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE
  DATE(creation_time) >= CURRENT_DATE - 30 -- scan 30 days of query history
  AND job_type = 'QUERY'
  AND state = 'DONE'
  AND error_result IS NULL
  AND statement_type != 'SCRIPT'
  AND EXISTS ( -- Only include queries which had performance insights
    SELECT 1
    FROM UNNEST(
      query_info.performance_insights.stage_performance_standalone_insights
    )
    WHERE
      slot_contention
      OR insufficient_shuffle_quota
      OR bi_engine_reasons IS NOT NULL
      OR high_cardinality_joins IS NOT NULL
      OR partition_skew IS NOT NULL
    UNION ALL
    SELECT 1
    FROM UNNEST(
      query_info.performance_insights.stage_performance_change_insights
    )
    WHERE input_data_change.records_read_diff_percentage IS NOT NULL
  );

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

בדוגמה הבאה מפורטות משימות רענון המטא-נתונים ב-6 השעות האחרונות:

SELECT
 *
FROM
 `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE
 job_id LIKE '%metadata_cache_refresh%'
 AND creation_time > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 6 HOUR)
ORDER BY start_time desc
LIMIT 10;

מחליפים את REGION_NAME באזור שלכם.

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

בדוגמה הבאה מוחזרות 10 המשימות הכי איטיות ב-7 הימים האחרונים שהריצו את אותה שאילתה:

DECLARE querytext STRING DEFAULT(
  SELECT query
  FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
  WHERE job_id = 'JOB_ID'
  LIMIT 1
);

SELECT
  start_time,
  end_time,
  project_id,
  job_id,
  TIMESTAMP_DIFF(end_time, start_time, SECOND) AS run_secs,
  total_bytes_processed / POW(1024, 3) AS total_gigabytes_processed,
  query
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE
  query = querytext
  AND total_bytes_processed > 0
  AND creation_time >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 DAY)
ORDER BY 5 DESC
LIMIT 3;

מחליפים את JOB_ID בכל job_id שהריץ את השאילתה שאתם מנתחים.

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

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

SELECT
  job_id,
  creation_time,
  query_info.performance_insights,
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS j,
  UNNEST(query_info.performance_insights.stage_performance_standalone_insights) i
WHERE
  (j.statement_type != "SCRIPT" OR j.statement_type IS NULL)
  AND i IS NOT NULL
  AND i.slot_contention

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

+------------+-------------------------+-------------------------------------------------+----------------------------------------------------------------------------+
| job_id     | creation_time           | performance_insights.avg_previous_execution_ms  | performance_insightsstage_performance_standalone_insights.slot_contention  |
+------------+-------------------------+-------------------------------------------------+----------------------------------------------------------------------------+
| bquxjob_1  | 2025-08-08 00:00:00 UTC | null                                            | true                                                                       |
| bquxjob_2  | 2025-08-08 00:00:00 UTC | 42689                                           | true                                                                       |
| bquxjob_3  | 2025-08-08 00:00:00 UTC | 42896                                           | true                                                                       |
+------------+-------------------------+-------------------------------------------------+----------------------------------------------------------------------------+

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

השאילתה הבאה מחזירה את מזהי המשימות עם אותו גיבוב של שאילתה כמו של משימה ספציפית:

SELECT
  j.job_id,
  j.creation_time,
  j.query
FROM
  `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS j
WHERE
  j.job_id != "JOB_IDENTIFIER"
  AND j.query_info.query_hashes.normalized_literals = (
    SELECT
      sub.query_info.query_hashes.normalized_literals
    FROM
      `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS sub
    WHERE
      sub.job_id = "JOB_IDENTIFIER"
    LIMIT 1
  )
ORDER BY
  j.creation_time DESC;

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

INFORMATION_SCHEMA

התוצאה אמורה להיראות כך:

+--------------+---------------------------+------------------------------------------------+
| job_id       |  creation_time            |  query                                         |
+--------------+---------------------------+------------------------------------------------+
| bquxjob_1    |  2019-10-10 00:00:00 UTC  |  SELECT ... FROM dataset.table1 WHERE x = "a"  |
| bquxjob_2    |  2019-10-10 00:00:01 UTC  |  SELECT ... FROM dataset.table1 WHERE x = "b"  |
| bquxjob_3    |  2019-10-10 00:00:02 UTC  |  SELECT ... FROM dataset.table1 WHERE x = "c"  |
+--------------+---------------------------+------------------------------------------------+

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

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

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

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

WITH job_metadata AS (
 SELECT creation_time, end_time, job_type
 FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
 WHERE job_id = 'JOB_ID'
-- If you know the date the job was created, add the following line to speed up the query by providing the date in UTC:
-- AND DATE(creation_time) = 'YYYY-MM-DD'
),
intervals AS (
 SELECT TIMESTAMP_ADD(creation_time, INTERVAL (seconds_offset) SECOND) AS ts,
 job_type
 FROM job_metadata,
 UNNEST (GENERATE_ARRAY(0, IF(TIMESTAMP_DIFF(end_time, creation_time, SECOND) > 0, TIMESTAMP_DIFF(end_time, creation_time, SECOND), 1))) as seconds_offset
),
concurrent_jobs AS (
 SELECT int.ts, COUNT(*) as concurrent_jobs_count
 FROM intervals int JOIN
 `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS_BY_PROJECT j
 ON int.ts BETWEEN j.creation_time and j.end_time
 WHERE job_id != 'JOB_ID'
 AND j.job_type = int.job_type
 GROUP BY int.ts)

SELECT ROUND(AVG(concurrent_jobs_count),1) as average_concurrent_jobs FROM concurrent_jobs

הערה: רמת הפירוט של צבירת המטא-נתונים מוגדרת לשניות. אם אתם צריכים רמת פירוט מדויקת יותר למשימות קצרות יותר, אתם יכולים להחליף את SECOND ב-MILLISECOND בגוף השאילתה כדי לדגום אלפיות שנייה.

מחליפים את מה שכתוב בשדות הבאים:

• ‫JOB_ID: מזהה העבודה של השאילתה שאתם מנתחים

• ‫REGION_NAME: האזור של הפרויקט

התוצאה אמורה להיראות כך:

+-------------------------+
| average_concurrent_jobs |
+-------------------------+
|                     2.8 |
+-------------------------+

קבלת בייטים שעובדו על ידי משימות חילוץ

בדוגמה הבאה מחושב הערך total_bytes_processed עבור סוגי המשרות EXTRACT. מידע על מכסות של עבודות חילוץ זמין במאמר בנושא מדיניות המכסות לעבודות חילוץ. אפשר להשתמש בסך הבייטים שעברו עיבוד כדי לעקוב אחרי השימוש הכולל ולוודא שעבודות החילוץ לא חורגות מהמגבלה של 50TB ליום:

SELECT
    DATE(creation_time) as day,
    project_id as source_project_id,
    SUM(total_bytes_processed) AS total_bytes_processed
 FROM
   `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
 WHERE
    creation_time BETWEEN TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 8 DAY) AND CURRENT_TIMESTAMP()
    AND job_type = "EXTRACT"
GROUP BY
    day,
    source_project_id
ORDER BY
    day DESC;

קבלת נתוני שימוש בעבודות העתקה

מידע על פעולות העתקה זמין במאמר העתקת טבלה. בדוגמה הבאה מוצג שימוש במשימות העתקה:

SELECT
    DATE(creation_time) as day,
    project_id as source_project_id,
CONCAT(destination_table.project_id,":",destination_table.dataset_id,".",destination_table.table_id) as destination_table,
    COUNT(job_id) AS copy_job_count
 FROM
   `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
 WHERE
    creation_time BETWEEN TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 8 DAY) AND CURRENT_TIMESTAMP()
    AND job_type = "COPY"
GROUP BY
    day,
    source_project_id,
    destination_table
ORDER BY
    day DESC;

קבלת נתוני שימוש בטבלאות BigLake ל-Apache Iceberg באופטימיזציה של אחסון ב-BigQuery

בדוגמה הבאה מוסבר על השימוש בטבלת BigLake Iceberg באופטימיזציה של אחסון ב-BigQuery.

SELECT
    job_id, reservation_id, edition,
    total_slot_ms, total_bytes_processed, state
FROM `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
WHERE creation_time > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 6 HOUR)
    AND user_email = "[e-mail]"
    AND query LIKE "CALL BQ.OPTIMIZE_STORAGE(%)";

קבלת נתוני שימוש בטבלת BigLake Iceberg במטא-נתונים של טבלת הייצוא ב-BigQuery

בדוגמה הבאה מוצג השימוש ב-Iceberg EXPORT TABLE METADATA FROM.

SELECT
   job_id,
   user_email,
   start_time,
   end_time,
   TIMESTAMP_DIFF(end_time, start_time, SECOND) AS duration_seconds,
   total_bytes_processed,
   reservation_id,
   CASE
     WHEN reservation_id IS NULL THEN 'PAYG (On-demand)'
     WHEN reservation_id != '' THEN 'Reservation'
     ELSE 'Unknown'
   END AS compute_type,
   query
 FROM
   `region-REGION_NAME`.INFORMATION_SCHEMA.JOBS
 WHERE
   job_type = 'QUERY'
   AND end_time IS NOT NULL
   -- Filter for queries containing the specified pattern (case-insensitive)
   AND REGEXP_CONTAINS(LOWER(query), r"export table metadata from")
 ORDER BY
   start_time DESC
 LIMIT 3;

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

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