Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

יצירת טבלאות

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

אפשר ליצור את סוגי הטבלאות הבאים בקובץ type: "table" SQLX:

‫table: טבלה רגילה.
‫incremental: טבלה מצטברת.
‫view: תצוגת טבלה. מידע נוסף זמין במאמר מבוא לתצוגות.
- ‫materialized: תצוגת טבלה מהותית. מידע נוסף זמין במאמר בנושא מבוא לתצוגות חומריות.

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

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

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

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

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

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

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

בנוסף להגדרת טבלאות בקובץ type: "table" SQLX, אפשר ליצור טבלאות ריקות על ידי הגדרת שאילתת SQL מותאמת אישית בקובץ type: "operations" SQLX. יכול להיות שתרצו ליצור טבלה ריקה כדי ששירות אחר יוכל לאכלס אותה בנתונים.

לפני שמתחילים

נכנסים לדף Dataform במסוף Google Cloud .

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

התפקידים הנדרשים

כדי לקבל את ההרשאות שנדרשות לביצוע המשימות שמתוארות במסמך הזה, צריך לבקש מהאדמין להקצות לכם את תפקיד ה-IAM‏ Dataform Editor (roles/dataform.editor) בסביבות עבודה. כדי לקרוא הסבר על מתן תפקידים, ראו איך מנהלים את הגישה ברמת הפרויקט, התיקייה והארגון.

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

צור טבלה

בקטע הזה מוסבר איך ליצור טבלאות באמצעות Dataform core ב-Dataform.

מידע על הגדרות טבלאות

כדי להגדיר טבלה, מגדירים את סוג הטבלה וכותבים משפט SELECT בקובץ type: "table" SQLX. לאחר מכן, Dataform מהדר את קוד הליבה של Dataform ל-SQL, מריץ את קוד ה-SQL ויוצר את הטבלאות שהגדרתם ב-BigQuery.

בהצהרת Dataform core SELECT, מגדירים את מבנה הטבלה ומפנים לאובייקטים אחרים בתהליך העבודה.

בנוסף להגדרת טבלאות בקובץ type: "table" SQLX, אפשר ליצור טבלאות ריקות על ידי הגדרת שאילתת SQL מותאמת אישית בקובץ type: "operations" SQLX. מידע נוסף זמין במאמר יצירת טבלה ריקה.

הפניה ליחסי תלות באמצעות `ref`

כדי להפנות לפעולה בתהליך עבודה בהצהרת SELECT ולהוסיף אותה אוטומטית כתלות, משתמשים בפונקציה ref. מערכת Dataform מריצה תלויות לפני טבלאות שתלויות בהן, כדי לוודא שהסדר של צינור הנתונים נכון.

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

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

‫Dataform משתמש בפונקציה ref כדי ליצור עץ תלות של כל הטבלאות שצריך ליצור או לעדכן.

אחרי ההידור, Dataform מוסיף הצהרות boilerplate להצהרת ה-SQL, כמו CREATE,‏ REPLACE,‏ INSERT או MERGE.

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

config { type: "table" }

SELECT
  order_date AS date,
  order_id AS order_id,
  order_status AS order_status,
  SUM(item_count) AS item_count,
  SUM(amount) AS revenue

FROM ${ref("store_clean")}

GROUP BY 1, 2

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

אם שם הטבלה מוחלף, צריך להשתמש בשם המוחלף בפונקציה ref. לדוגמה, אם רוצים להפנות לטבלה עם config { name: "overridden_name" }, צריך להשתמש ב-ref("overridden_name"). מידע נוסף זמין במאמרים שינוי הגדרות של טבלה והפניה לטבלה עם שם טבלה שהוגדר מחדש.

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

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

config { type: "table" }
SELECT * FROM ${ref("schema", "store_clean")}

אפשר גם להוסיף ידנית תלות בטבלה לבלוק config של טבלאות, הצהרות, הצהרות על מקורות נתונים או פעולות SQL בהתאמה אישית שלא מוזכרות בפונקציה ref בהצהרה SELECT. ‫Dataform מפעיל את התלויות האלה לפני טבלאות תלויות.

בדוגמת הקוד הבאה מוצגת תלות בטבלה בבלוק config:

config { dependencies: [ "unreferenced_table" ] }
SELECT * FROM ...

מידע נוסף על ניהול יחסי תלות בתהליך העבודה זמין במאמר הגדרת יחסי תלות.

הפניה לטבלאות אחרות באמצעות `resolve`

הפונקציה resolve מאפשרת להפנות להצהרה על טבלה או על מקור נתונים בהצהרת SELECT, כמו הפונקציה ref, אבל היא לא מוסיפה את ההפניה כתלות. המשמעות היא שהאובייקט שאליו מתייחסים באמצעות הפונקציה resolve לא משפיע על הביצוע של הטבלה שמשתמשת בפונקציה resolve.

מידע נוסף על פונקציות מובנות של Dataform Core זמין במאמר Dataform Core reference.

יצירת קובץ SQLX להגדרת טבלה

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

נכנסים לדף Dataform במסוף Google Cloud .

מעבר אל Dataform
כדי לפתוח מאגר, לוחצים על שם המאגר.
כדי לפתוח סביבת עבודה לפיתוח, לוחצים על השם שלה.
בחלונית קבצים, לצד definitions/, לוחצים על סמל האפשרויות הנוספות.
לוחצים על יצירת קובץ.
בשדה הוספת נתיב קובץ, מזינים את שם הקובץ ואחריו את התו .sqlx אחרי definitions/. לדוגמה, definitions/my-table.sqlx.

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

הגדרת סוג הטבלה

כדי ליצור הגדרה חדשה של סוג טבלה:

בסביבת העבודה לפיתוח, בחלונית Files, מרחיבים את הספרייה definitions/.
בוחרים את קובץ ה-SQLX של הגדרת הטבלה שרוצים לערוך.
מזינים את קטע הקוד הבא בקובץ:
```
config { type: "TABLE_TYPE" }
```
מחליפים את TABLE_TYPE באחד מסוגי הטבלאות הבאים:
- table
- incremental
- view
אופציונלי: כדי להגדיר תצוגה חומרית, מזינים את המאפיין materialized מתחת ל-type: "view" בפורמט הבא:
```
config {
  type: "view",
  materialized: true
}
```
מידע נוסף זמין במאמר בנושא ITableConfig.
אופציונלי: לוחצים על עיצוב.

הגדרת מבנה הטבלה ויחסי התלות

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

בסביבת העבודה לפיתוח, בחלונית Files, מרחיבים את הספרייה definitions/.
בוחרים את קובץ ה-SQLX של הגדרת הטבלה שרוצים לערוך.
מתחת לconfig בלוק, כותבים SELECT הצהרה.
אופציונלי: לוחצים על עיצוב.

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

config { type: "table" }
SELECT
  customers.id AS id,
  customers.first_name AS first_name,
  customers.last_name AS last_name,
  customers.email AS email,
  customers.country AS country,
  COUNT(orders.id) AS order_count,
  SUM(orders.amount) AS total_spent
FROM
  dataform-samples.dataform_sample.crm_customers AS customers
  LEFT JOIN ${ref('order_stats')} orders
    ON customers.id = orders.customer_id

WHERE
  customers.id IS NOT NULL
  AND customers.first_name <> 'Internal account'
  AND country IN ('UK', 'US', 'FR', 'ES', 'NG', 'JP')

GROUP BY 1, 2, 3, 4, 5

הוספת יחסי תלות ידניים בין טבלאות

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

בסביבת העבודה לפיתוח, בחלונית Files, מרחיבים את הספרייה definitions/.
בוחרים את קובץ ה-SQLX של הגדרת הטבלה שרוצים לערוך.
בבלוק config של הטבלה, מזינים את קטע הקוד הבא:
```
dependencies: [ "DEPENDENCY_TABLE", ]
```
מחליפים את DEPENDENCY_TABLE בשם הקובץ של הטבלה שרוצים להוסיף כתלות. אפשר להזין כמה שמות של קבצים.
אופציונלי: לוחצים על עיצוב.

בדוגמת הקוד הבאה אפשר לראות שתי טבלאות שנוספו כתלות ידנית של טבלה לבלוק config של קובץ הגדרת טבלה:

config { dependencies: [ "some_table", "some_other_table" ] }

שינוי הגדרות הטבלה

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

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

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

עוברים לסביבת הפיתוח.
בחלונית Files, מרחיבים את definitions/.
פותחים קובץ הגדרת טבלה מסוג SQLX.
בבלוק config, מזינים את קטע הקוד הבא:
```
 {
   schema: "OVERRIDDEN_SCHEMA",
   database: "OVERRIDDEN_DATABASE",
   name: "OVERRIDDEN_NAME"
 }
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫OVERRIDDEN_SCHEMA: מערך הנתונים ב-BigQuery שבו רוצים ליצור את הטבלה.
- ‫OVERRIDDEN_DATABASE: מזהה הפרויקט ב-BigQuery שבו רוצים ליצור את הטבלה.
- ‫OVERRIDDEN_NAME: השם של הטבלה, ששונה משם הקובץ של הגדרת הטבלה ב-SQLX.
אופציונלי: לוחצים על עיצוב.

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

יצירת טבלאות מנוהלות של Apache Iceberg

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

יצירת הגדרת טבלת Iceberg

כדי ליצור את הטבלאות, מגדירים את התצורה של Iceberg בקטע bigquery של קובץ הגדרת הטבלה.

כדי להגדיר את הטבלאות:

עוברים לסביבת הפיתוח.
בחלונית Files, מרחיבים את definitions/.
פותחים קובץ SQLX של הגדרת טבלה.
בבלוק config, מוסיפים בלוק bigquery שמכיל בלוק iceberg בפורמט הבא:
```
config {
  type: "table",
  name: "my_table",
  uniqueKey: ["uniquekey"],
  bigquery: {
    iceberg: {
      bucket_name: "BUCKET_NAME"
    }
  }
}
```
מחליפים את BUCKET_NAME בשם של קטגוריה של Cloud Storage שבה נשמרים נתוני הטבלה.

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

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

יצירה של מחיצות וקלאסטרים בטבלה

בקטע הזה נסביר איך להשתמש ב-Dataform core כדי ליצור מחיצות וקלאסטרים של טבלאות. ‫BigQuery תומך בטבלאות מחולקות למחיצות ובסידור באשכולות של טבלאות. מידע נוסף זמין במאמרים מבוא לטבלאות עם חלוקה למחיצות ויצירה ושימוש בטבלאות מקובצות.

יצירת מחיצה בטבלה

כדי ליצור חלוקה של טבלה, פועלים לפי השלבים הבאים:

עוברים לסביבת הפיתוח.
בחלונית Files, מרחיבים את definitions/.
פותחים קובץ SQLX של הגדרת טבלה.
בבלוק config, מוסיפים את הבלוק bigquery מתחת להצהרה על סוג הטבלה בפורמט הבא:
```
config {
  type: "table",
  bigquery: {
  }
}
```
בבלוק bigquery, מזינים את קטע הקוד הבא:
```
    partitionBy: "PARTITION_EXPRESSION"
```
מחליפים את PARTITION_EXPRESSION בביטוי לחלוקת הטבלה למחיצות.
אופציונלי: לוחצים על עיצוב.

בדוגמת הקוד הבאה מוצג תהליך החלוקה של טבלה למחיצות לפי שעה בקובץ SQLX של הגדרת טבלה:

config {
  type: "table",
  bigquery: {
    partitionBy: "DATETIME_TRUNC(<timestamp_column>, HOUR)"
  }
}

בדוגמת הקוד הבאה מוצג איך מחלקים טבלה לפי ערך של מספר שלם בקובץ SQLX של הגדרת טבלה:

config {
  type: "table",
  bigquery: {
    partitionBy: "RANGE_BUCKET(<integer_column>, GENERATE_ARRAY(0, 1000000, 1000))"
  }
}

הגדרת מסנן מחיצות

כדי להגדיר מסנן מחיצות:

עוברים לסביבת הפיתוח.
בחלונית Files, מרחיבים את definitions/.
פותחים קובץ SQLX של הגדרת טבלה עם חלוקה למחיצות.
בבלוק bigquery, מזינים את קטע הקוד הבא:
```
requirePartitionFilter : true
```
אופציונלי: לוחצים על עיצוב.

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

config {
  type: "table",
  bigquery: {
    partitionBy: "DATE(ts)",
    requirePartitionFilter : true
  }
}
SELECT CURRENT_TIMESTAMP() AS ts

מידע נוסף על מסנן המחיצות ב-BigQuery זמין במאמר הגדרת המאפיין require partition filter בטבלה מחולקת למחיצות.

הגדרת תקופת שמירה למחיצות

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

עוברים לסביבת הפיתוח.
בחלונית Files, מרחיבים את definitions/.
פותחים קובץ SQLX של הגדרת טבלה עם חלוקה למחיצות.
בבלוק bigquery, מזינים את קטע הקוד הבא:
```
partitionExpirationDays: NUMBER_OF_DAYS
```
מחליפים את NUMBER_OF_DAYS במספר הימים שבהם רוצים לשמור את המחיצות.
אופציונלי: לוחצים על עיצוב.

בדוגמת הקוד הבאה מוצג תקופת שמירה של מחיצות שהוגדרה ל-14 ימים בבלוק bigquery של קובץ SQLX של טבלה עם מחיצות:

config {
  type: "table",
  bigquery: {
    partitionBy: "DATE(ts)",
    partitionExpirationDays: 14,
  }
}
SELECT CURRENT_TIMESTAMP() AS ts

יצירת אשכול טבלאות

כדי ליצור אשכול טבלאות:

עוברים לסביבת הפיתוח.
בחלונית Files, מרחיבים את definitions/.
פותחים קובץ SQLX של הגדרת טבלה.
בבלוק bigquery, מזינים את קטע הקוד הבא:
```
    clusterBy: ["CLUSTER_COLUMN"]
```
מחליפים את CLUSTER_COLUMN בשם העמודה שלפיה רוצים לאגד את הטבלה. מידע נוסף זמין במאמר בנושא clustering_column_list.
אופציונלי: לוחצים על עיצוב.

בדוגמת הקוד הבאה מוצגת טבלה עם מחיצות שמקובצת לפי העמודות name ו-revenue:

config {
  type: "table",
  bigquery: {
    partitionBy: "DATE(ts)",
    clusterBy: ["name", "revenue"]
  }
}
SELECT CURRENT_TIMESTAMP() as ts, name, revenue

הגדרה של טבלה מצטברת

בקטע הזה נסביר איך להשתמש ב-Dataform core כדי להגדיר טבלה מצטברת.

מידע על טבלאות מצטברות

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

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

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

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

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

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

כדי לקבוע קבוצת משנה של שורות ש-Dataform יעבד במהלך כל הרצה, מוסיפים פסקה מותנית WHERE לקובץ ההגדרה של טבלת ה-SQLX המצטברת. בסעיף WHERE, אפשר לציין תנאי מצטבר ותנאי לא מצטבר. ‫Dataform מחיל את התנאי המצטבר במהלך ההרצה של הטבלה בלי לבצע רענון מלא, ואת התנאי הלא מצטבר במהלך ההרצה עם רענון מלא.

כדי להגדיר טבלה מצטברת:

עוברים לסביבת הפיתוח.
בחלונית Files, מרחיבים את definitions/.
פותחים קובץ SQLX של הגדרת טבלה מצטברת.
מזינים סעיף WHERE בפורמט הבא:
```
config { type: "incremental" }

SELECT_STATEMENT

${when(incremental(), `WHERE INCREMENTAL_CONDITION`, `WHERE NON_INCREMENTAL_CONDITION`) }
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫SELECT_STATEMENT: הצהרת SELECT שמגדירה את הטבלה.
- ‫INCREMENTAL_CONDITION: התנאי שאתם מציינים בפסוקית WHERE כדי לבחור שורות לעיבוד ב-Dataform במהלך ההרצה של הטבלה, בלי רענון מלא.
- ‫NON_INCREMENTAL_CONDITION: התנאי שאתם מציינים בסעיף WHERE כדי לבחור שורות ש-Dataform יעבד במהלך הפעלת הטבלה עם רענון מלא.
אופציונלי: לוחצים על עיצוב.

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

config { type: "incremental" }

SELECT timestamp, message FROM ${ref("productiondb", "logs")}

${when(incremental(),
   `WHERE date > (SELECT MAX(date) FROM ${self()}) AND country = "UK"`,
   `WHERE country = "UK"`)}

בדוגמה הבאה של דוגמת קוד מוצגת טבלה מצטברת שיוצרת תמונת מצב של הטבלה productiondb.customers:

config { type: "incremental" }

SELECT CURRENT_DATE() AS snapshot_date, customer_id, name, account_settings FROM ${ref("productiondb", "customers")}

${when(incremental(), `WHERE snapshot_date > (SELECT MAX(snapshot_date) FROM ${self()})`) }

מיזוג שורות בטבלה מצטברת

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

כדי להגדיר מיזוג בטבלה מצטברת:

עוברים לסביבת הפיתוח.
בחלונית Files, מרחיבים את definitions/.
בחירת קובץ SQLX של הגדרת טבלה מצטברת
בבלוק config, מגדירים את העמודות שנבחרו כ-uniqueKey בפורמט הבא:
```
uniqueKey: ["COLUMN_NAME"]
```
מחליפים את COLUMN_NAME בשם של עמודה שנבחרה.
אופציונלי: לוחצים על עיצוב.

בדוגמת הקוד הבאה מוצגת טבלה מצטברת עם העמודה transaction_id שהוגדרה כ-uniqueKey כדי לוודא שהיא תמיד מכילה שורה אחת:

config {
  type: "incremental",
  uniqueKey: ["transaction_id"]
}

SELECT timestamp, action FROM weblogs.user_actions
${ when(incremental(), `WHERE timestamp > (SELECT MAX(timestamp) FROM ${self()})`) }

סינון שורות בטבלה מצטברת

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

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

סינון של טבלת היעד באמצעות המאפיין updatePartitionFilter: מגביל את המחיצות שנסרקות בטבלת היעד במהלך פעולת MERGE כדי למצוא שורות שתואמות ל-uniqueKey.
הסרת מקורות באמצעות פסקה WHERE: מגבילה את השורות שאוחזרו מטבלת המקור במהלך הרצה מצטברת. אפשר לעשות את זה באמצעות הפונקציה ${when(incremental(), ...)}.

config {
  type: "incremental",
  uniqueKey: ["transaction_id"],
  bigquery: {
    partitionBy: "DATE(timestamp)",
    updatePartitionFilter:
        "timestamp >= timestamp_sub(current_timestamp(), interval 24 hour)"
  }
}

SELECT timestamp, action FROM weblogs.user_actions
${ when(incremental(), `WHERE timestamp > (SELECT MAX(timestamp) FROM ${self()})`) }

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

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

כדי להגביל את מספר המחיצות ש-BigQuery סורק כדי לעדכן את הטבלה המצטברת, אפשר להשתמש בביטוי קבוע בשאילתת הטבלה. כדי להפוך ערך מטבלה מחולקת לביטוי קבוע, משתמשים בסקריפטים של BigQuery כדי להצהיר על הערך כמשתנה בבלוק pre_operations. אחר כך משתמשים במשתנה כביטוי קבוע בסעיף WHERE בשאילתת SELECT.

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

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

עוברים לסביבת הפיתוח.
בחלונית Files, מרחיבים את definitions/.
בחירת קובץ SQLX של הגדרת טבלה מצטברת
בבלוק pre_operations, מצהירים על משתנה באמצעות סקריפטים של BigQuery.
מסננים את משפט SELECT שמגדיר את הטבלה באמצעות פסקה WHERE שמפנה למשתנה שהוגדר.
אופציונלי: לוחצים על עיצוב.

בדוגמת הקוד הבאה מוצגת טבלה מצטברת שבה הטבלה raw_events שאליה יש הפניה מחולקת למחיצות לפי event_timestamp:

config {
  type: "incremental",
}

pre_operations {
  DECLARE event_timestamp_checkpoint DEFAULT (
    ${when(incremental(),
    `SELECT max(event_timestamp) FROM ${self()}`,
    `SELECT timestamp("2000-01-01")`)}
  )
}

SELECT
  *
FROM
  ${ref("raw_events")}
WHERE event_timestamp > event_timestamp_checkpoint

בדוגמת הקוד שצוינה למעלה, המשתנה event_timestamp_checkpoint מוגדר בבלוק pre_operations. לאחר מכן, המשתנה event_timestamp_checkpoint משמש כביטוי קבוע בסעיף WHERE.

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

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

כשבוחרים באפשרות של רענון מלא, בסביבת העבודה לפיתוח או באמצעות Dataform CLI, ‏ Dataform מתעלם מהפרמטר ${when(incremental(), ... } במהלך ההפעלה ויוצר מחדש את הטבלה באמצעות הצהרה CREATE OR REPLACE.

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

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

כדי לסמן טבלה מצטברת כ-protected, פועלים לפי השלבים הבאים:

עוברים לסביבת הפיתוח.
בחלונית Files, מרחיבים את definitions/.
בוחרים קובץ SQLX של הגדרת טבלה מצטברת.
בבלוק config, מזינים protected: true.
אופציונלי: לוחצים על עיצוב.

בדוגמת הקוד הבאה מוצגת טבלה מצטברת שמסומנת בתווית protected:

config {
  type: "incremental",
  protected: true
}
SELECT ...

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

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

כדי להשתמש בתכונה הזו, צריך להתקין את Dataform core מגרסה 3.0.11 ואילך.

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

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

עוברים לסביבת הפיתוח.
בחלונית Files, מרחיבים את definitions/.
בוחרים קובץ SQLX של הגדרת טבלה מצטברת.
בבלוק config, מזינים את קטע הקוד הבא:
```
onSchemaChange: "ON_CHANGE_ACTION"
```
מחליפים את ON_CHANGE_ACTION באחת מהפעולות הבאות:
- ‫IGNORE (ברירת מחדל): מתעלם מעמודות שנוספו ומציג שגיאה לגבי עמודות חסרות. אם ההגדרה onSchemaChange לא מוגדרת, זוהי התנהגות ברירת המחדל כשמתבצע שינוי בסכימה.
- ‫FAIL: מפסיק את הפעולה אם Dataform מזהה שינוי בסכימה, כדי לשמור על עקביות הסכימה.
- ‫EXTEND: מוסיף עמודות חדשות מהשאילתה לטבלה המצטברת, ומוסיף ערכי NULL לרשומות קודמות. מוצגת שגיאה אם עמודה הוסרה או חסרה בסכימה המקורית בשאילתה. אתם יכולים להשתמש בהגדרה הזו כדי להוסיף עמודות חדשות לטבלאות המצטברות במהלך זמן הריצה.
- ‫SYNCHRONIZE: מוסיף עמודות חדשות מהשאילתה לטבלה המצטברת, ומוסיף ערכי NULL לרשומות קודמות. הפונקציה מסירה עמודות שהיו בסכימה המקורית אבל חסרות עכשיו בשאילתה הנוכחית.
  
  זהירות: אי אפשר לבטל את הפעולה SYNCHRONIZE, ויכול להיות שתאבדו נתונים אם תסירו עמודות באמצעות האפשרות הזו.
  הערה: אי אפשר למחוק עמודות עם חלוקה למחיצות ועמודות עם אשכולות, כי למחיקה של העמודות האלה יכולות להיות השלכות שליליות.
  אם עדיין מוחקים עמודה עם חלוקה למחיצות או עמודה מסודרת באשכולות, המחיקה מטופלת באמצעות ההצהרה ALTER TABLE DROP COLUMN. ‫Dataform לא מבצע בדיקות או אימותים כדי למנוע הפעלה של הצהרות ALTER TABLE DROP COLUMN בעמודות מחולקות או מקובצות. לכן, אם אתם מסירים עמודות כאלה,
אופציונלי: לוחצים על עיצוב.

בדוגמת הקוד הבאה מוצגת טבלה מצטברת עם EXTEND פעולה שהוגדרה למאפיין onSchemaChange:

config {
    type: "incremental",
    onSchemaChange: "EXTEND",
}
SELECT ...

הוספת תיעוד לטבלה

בקטע הזה מוסבר איך להוסיף תיאורים לטבלה, לעמודות ולרשומות שלה בקובץ SQLX של Dataform Core.

אפשר להוסיף תיאורים של טבלאות, עמודות ורשומות לכל סוגי הטבלאות ב-Dataform: טבלאות, טבלאות מצטברות ותצוגות.

כדאי לתעד את הפרטים הבאים:

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

הוספת תיאור לטבלה

כדי להוסיף תיאור לטבלה בקובץ SQLX, פועלים לפי השלבים הבאים:

נכנסים לדף Dataform במסוף Google Cloud .

מעבר אל Dataform
בוחרים מאגר.
בוחרים סביבת עבודה לפיתוח.
בחלונית קבצים, לוחצים על קובץ ה-SQLX של הגדרת הטבלה שרוצים לערוך.
בבלוק config של הקובץ, מזינים את תיאור הטבלה בפורמט הבא:
```
description: "Description of the table",
```
אופציונלי: לוחצים על עיצוב.

בדוגמת הקוד הבאה מוצג תיאור של טבלה שנוסף לבלוק config של קובץ הגדרת טבלה ב-SQLX:

config {
  type: "table",
  description: "Description of the table",
 }

הוספת תיאורים של עמודות ורשומות

כדי להוסיף תיאורים של עמודות ורשומות ספציפיות לקובץ SQLX, פועלים לפי השלבים הבאים:

בבלוק config של קובץ הגדרת הטבלה, מזינים columns: {}.
בתוך columns: {}, מזינים תיאורים של העמודות בפורמט הבא:
```
column_name: "Description of the column",
```

בתוך columns: {}, מזינים תיאורי רשומות בפורמט הבא:

  record_name: {
      description: "Description of the record",
      columns: {
        record_column_name: "Description of the record column"
      }
}

אופציונלי: לוחצים על עיצוב.

בדוגמת קוד הבאה מוצגים תיאורים של טבלה, עמודה ורשומה בבלוק config של קובץ הגדרת טבלה ב-SQLX:

config {
  type: "table",
  description: "Description of the table.",
  columns: {
    column1_name: "Description of the first column",
    column2_name: "Description of the second column",
    column3_name: "Description of the third column",
    record_name: {
      description: "Description of the record.",
      columns: {
       record_column1_name: "Description of the first record column",
       record_column2_name: "Description of the second record column",
      }
    }
  }
}
SELECT
  "first_column_value" AS column_1_name,
  "second_column_value" AS column_2_name,
  "third_column_value" AS column_3_name,
  STRUCT("first" AS record_column1_name,
    "second" AS record_column2_name) AS record_name

שימוש חוזר בתיעוד של עמודות באמצעות include

אפשר לעשות שימוש חוזר בתיאורים של עמודות ב-Dataform בכל תהליך העבודה של SQL באמצעות JavaScript includes. אם יש לכם כמה עמודות עם אותו שם ותיאור בתהליך העבודה של SQL, כדאי להשתמש מחדש בתיעוד של העמודה.

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

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

בדוגמת הקוד הבאה מוצגים כמה קבועים עם תיאורים של עמודות נפרדות שמוגדרות בקובץ includes/docs.js JavaScript:


// filename is includes/docs.js

const user_id = `A unique identifier for a user`;
const age = `The age of a user`;
const creation_date = `The date this user signed up`;
const user_tenure = `The number of years since the user's creation date`;
const badge_count = `The all-time number of badges the user has received`;
const questions_and_answer_count = `The all-time number of questions and answers the user has created`;
const question_count = `The all-time number of questions the user has created`;
const answer_count = `The all-time number of answers the user has created`;
const last_badge_received_at = `The time the user received their most recent badge`;
const last_posted_at = `The time the user last posted a question or answer`;
const last_question_posted_at = `The time the user last posted an answer`;
const last_answer_posted_at = `The time the user last posted a question`;

module.exports = {
   user_id,
   age,
   creation_date,
   user_tenure,
   badge_count,
   questions_and_answer_count,
   question_count,
   answer_count,
   last_badge_received_at,
   last_posted_at,
   last_question_posted_at,
   last_answer_posted_at,
};

דוגמת הקוד הבאה מציגה את הקבועים user_id ו-age, שמוגדרים ב-includes/docs.js, ומשמשים בקובץ ההגדרה של טבלת SQLX‏ definitions/my_table.sqlx כדי ליצור תיעוד לעמודות שנבחרו בטבלה:

config {
  type: "table",
  description: "Table description.",
  columns: {
    user_id: docs.user_id,
    column2_name: "Description of the second column",
    column3_name: "Description of the third column",
    age: docs.age,
  }
}

SELECT ...

בדוגמה הבאה של קוד מוצג קבוע עם קבוצה של תיאורי עמודות שמוגדרים בקובץ includes/docs.js JavaScript:


// filename is includes/docs.js

const columns = {
    user_id = `A unique identifier for a user`,
    age = `The age of a user`,
    creation_date = `The date this user signed up`,
    user_tenure = `The number of years since the user's creation date`,
    badge_count = `The all-time number of badges the user has received`,
    questions_and_answer_count = `The all-time number of questions and answers the user has created`,
    question_count = `The all-time number of questions the user has created`,
    answer_count = `The all-time number of answers the user has created`,
    last_badge_received_at = `The time the user received their most recent badge`,
    last_posted_at = `The time the user last posted a question or answer`,
    last_question_posted_at = `The time the user last posted an answer`,
    last_answer_posted_at = `The time the user last posted a question`,
}


module.exports = {
  columns
};

בדוגמת הקוד הבאה מוצג הקבוע columns, שמוגדר ב-includes/table_docs.js ומשמש בקובץ ההגדרה של טבלת SQLX‏ definitions/my_table.sqlx כדי ליצור תיעוד לכל העמודות בטבלה:

config { type: "table",
description: "My table description",
columns: docs.columns
}

SELECT 1 AS one

הוספת תוויות BigQuery

בקטע הזה מוסבר איך להוסיף תוויות לטבלאות ב-Dataform.

‫BigQuery תומך בהוספת תוויות למשאבים. מידע נוסף על תוויות ב-BigQuery זמין במאמר מבוא לתוויות.

כדי להוסיף תווית BigQuery לטבלה ב-Dataform, מוסיפים את התווית לבלוק bigquery בבלוק config בקובץ ה-SQLX של הגדרת הטבלה.

כדי להוסיף תווית BigQuery לקובץ הגדרת טבלה, פועלים לפי השלבים הבאים:

עוברים לסביבת הפיתוח.
בחלונית Files, מרחיבים את definitions/.
בוחרים קובץ הגדרת טבלה מסוג SQLX.
בבלוק config, מוסיפים תווית בפורמט הבא:
```
bigquery: {
    labels: {
      LABEL1: "VALUE_OF_LABEL1"
    }
  }
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫LABEL1: השם של התווית
- ‫VALUE_OF_LABEL1: הערך של התווית
אופציונלי: כדי להוסיף תווית עם שם שמכיל תווים מיוחדים, מזינים את שם התווית במירכאות ("").
אופציונלי: לוחצים על עיצוב.

בדוגמת הקוד הבאה מוצגות התוויות department:shipping ו-cost-center:logistics שנוספו לבלוק bigquery בקובץ SQLX של הגדרת טבלה עם חלוקה למחיצות:

config {
  type: "table",
  bigquery: {
    partitionBy: "DATE(ts)",
    labels: {
      department: "shipping",
      "cost-center": "logistics"
    }
  }
}

SELECT CURRENT_TIMESTAMP() AS ts

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

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