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

שימוש ב-JavaScript ב-Dataform

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

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

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

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

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

בנוסף, אתם צריכים להכיר את התחביר של JavaScript ואת המושגים הבאים ב-JavaScript:

משתנים
מערכים
משפטי תנאי
לולאות for
מפות
פונקציות
Objects
ייצוא וייבוא של מודולים

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

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

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

הוספת קוד JavaScript לקובץ SQLX

יש שתי דרכים להוסיף קוד JavaScript לקובץ SQLX: בשורה או בתוך בלוק JavaScript.

אפשר להשתמש בבלוק JavaScript כדי להגדיר פונקציות או קבועים בקובץ SQLX. אפשר להשתמש ב-JavaScript מוטבע כדי לשנות באופן דינמי שאילתת SQLX או SQL.

בדוגמת הקוד הבאה מוצגת פונקציית JavaScript מובנית של self Dataform core שנוספה בשורה לבלוק post_operations בקובץ SQLX:

config {type: "table"}

SELECT * FROM ...

post_operations {
  GRANT `roles/bigquery.dataViewer`
  ON
  TABLE ${self()}
  TO "group:allusers@example.com", "user:otheruser@example.com"
}

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

js {
  const columnName = "foo";
}

SELECT 1 AS ${columnName} FROM "..."

שימוש חוזר בקוד בקובץ SQLX יחיד באמצעות JavaScript encapsulation

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

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

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

js {
 const foo = 1;
 function bar(number){
     return number+1;
 }
}

select
 ${foo} as one,
 ${bar(foo)} as two

שימוש חוזר בקוד במאגר יחיד באמצעות כוללים

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

בדוגמת הקוד הבאה מוצגת ההגדרה של הקבוע launch_date בקובץ includes/constants.js:

// filename is includes/constants.js
const launch_date = "11.11.2011";
module.exports = { launch_date };

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

config {type: "table"}

SELECT * FROM source_table WHERE date > ${constants.launch_date}

יצירת קובץ JavaScript להכללות

כדי ליצור קובץ JavaScript חדש בספרייה includes/, פועלים לפי השלבים הבאים:

בחלונית קבצים, לצד includes/, לוחצים על סמל האפשרויות הנוספות.
לוחצים על יצירת קובץ.
בחלונית Create new file:
1. בשדה הוספת נתיב קובץ, אחרי includes/, מזינים את שם הקובץ ואחריו .js. לדוגמה, includes/constants.js.
  
  שמות הקבצים יכולים לכלול רק מספרים, אותיות, מקפים וקווים תחתונים.
2. לוחצים על יצירת קובץ.

יצירת קבוע JavaScript

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

עוברים לסביבת הפיתוח.
בחלונית Files, מרחיבים את includes/.
יוצרים או בוחרים קובץ JavaScript עם הסיומת .js.
מזינים את קטע הקוד הבא בקובץ:
```
 const CONSTANT_NAME = CONSTANT_VALUE;
 module.exports = { CONSTANT_NAME };
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫CONSTANT_NAME: השם של הקבוע
- ‫CONSTANT_VALUE: הערך של הקבוע
אופציונלי: לוחצים על עיצוב.

בדוגמה הבאה של קוד מוגדרת הקבוע PROJECT_ID בקובץ includes/constants.js:

  // filename is includes/constants.js
  const PROJECT_ID = "my_project_name";
  module.exports = { PROJECT_ID };

בדוגמת הקוד הבאה יש הפניה לקבוע PROJECT_ID בשאילתת הגדרת טבלה בקובץ SQLX:

  config { type: "table" }
  SELECT * FROM ${constants.PROJECT_ID}.my_schema_name.my_table_name

בדוגמת הקוד הבאה מוצגת שאילתת ההגדרה של טבלת הליבה הקודמת של Dataform שעברה קומפילציה ל-SQL:

  SELECT * FROM my_project_name.my_schema_name.my_table_name

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

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

עוברים לסביבת הפיתוח.
בחלונית Files, מרחיבים את includes/.
יוצרים או בוחרים קובץ JavaScript עם הסיומת .js.
כותבים את פונקציית ה-JavaScript המותאמת אישית בקובץ.
מזינים את קטע הקוד הבא בקובץ:
```
 module.exports = { FUNCTION_NAME }
```
מחליפים את FUNCTION_NAME בשם הפונקציה.
אופציונלי: לוחצים על עיצוב.

בדוגמה הבאה של קוד מוצגת פונקציית JavaScript מותאמת אישית שנקראת renderScript ומאוחסנת בקובץ includes/functions.js. הפונקציה יוצרת סקריפט SQL:

  function renderScript(table, dimensions, metrics) {
    return `
        select
        ${dimensions.map(field => `${field} as ${field}`).join(",")},
        ${metrics.map(field => `sum(${field}) as ${field}`).join(",\n")}
        from ${table}
        group by ${dimensions.map((field, i) => `${i + 1}`).join(", ")}
      `;
  }

  module.exports = { renderScript };

בדוגמת הקוד הבאה אפשר לראות איך משתמשים בפונקציית ה-JavaScript המותאמת אישית renderScript בשאילתה להגדרת טבלת ליבה ב-Dataform:

  config {
      type: "table",
      tags: ["advanced", "hourly"],
      disabled: true
  }

  ${functions.renderScript(ref("source_table"),
                                ["country", "device_type"],
                                ["revenue", "pageviews", "sessions"]
                                )}

בדוגמת הקוד הבאה מוצגת שאילתת ההגדרה של טבלת הליבה הקודמת של Dataform אחרי הידור ל-SQL:

  select
    country as country,
    device_type as device_type,
    sum(revenue) as revenue,
    sum(pageviews) as pageviews,
    sum(sessions) as sessions

  from "dataform"."source_table"

  group by 1, 2

הפניה לקובץ include בקובץ SQLX

אפשר להפנות לכל פונקציית include או לקבוע בתוך קובץ SQLX. התחביר של הפניה לקובץ include תלוי במיקום של קובץ ה-include. קובץ include ברמה העליונה נמצא ישירות בספרייה includes/. קובץ nested includes נמצא בספריית משנה של includes/.

הפניה להכללה ברמה העליונה בקובץ SQLX

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

בדוגמה הבאה של קוד, הקבוע firstDate, שמוגדר בקובץ includes/constants.js, מופיע בהגדרה של טבלה בקובץ SQLX:

  config {type: "table"}
  select * from source_table where date > ${constants.firstDate}

הפניה להכללה מקוננת בקובץ SQLX

כדי להפנות לקבצים שמוכללים בספריות משנה של definitions, מייבאים את הקבצים באמצעות הפונקציה require של JavaScript ובלוק js {}.

כדי להפנות אל תג include מקונן באמצעות הפונקציה require ב-JavaScript: פועלים לפי השלבים הבאים:

עוברים לסביבת הפיתוח.
בחלונית Files, מרחיבים את definitions/.
בוחרים קובץ SQLX.
בבלוק config, מזינים את קטע הקוד הבא:
```
 js {
   var { VARIABLE_NAME } = require("SUBDIRECTORY_INCLUDE");
 }
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫VARIABLE_NAME: השם של הקבוע או הפונקציה שרוצים לייבא
- ‫SUBDIRECTORY_INCLUDE: הנתיב של קובץ includes המקונן
אופציונלי: לוחצים על עיצוב.

בדוגמת הקוד הבאה יש הפניה לקבוע firstDate, שמוגדר בקובץ includes/allConstants/constants.js המקונן, בקובץ SQLX של הגדרת טבלה:

  config {type: "table"}
  js {
    var { firstDate } = require("includes/allConstants/constants");
  }
  select * from source_table where date > ${firstDate}

שימוש בפונקציית include של JavaScript עם הפונקציה `ref` של Dataform Core

כדי להשתמש בפונקציית include של JavaScript עם הפונקציה ref של Dataform Core, צריך להעביר את ref כארגומנט של פונקציית include של JavaScript בתוך קובץ SQLX.

בדוגמת הקוד הבאה מוצג קובץ includes/script_builder.js עם פונקציית JavaScript‏ renderScript שמצברת מדדים באמצעות SUM ומקבצת אותם לפי מאפיין:

function renderScript(table, dimensions, metrics) {
  return `
      SELECT
      ${dimensions.map((field) => `${field} AS ${field}`).join(",\\n")},
      ${metrics.map((field) => `SUM(${field}) AS ${field}`).join(",\\n")}
      FROM ${table}
      GROUP BY ${dimensions.map((field, i) => `${i + 1}`).join(", ")}
    `;
}
module.exports = { renderScript };

בדוגמה הבאה של קוד JavaScript מוצגת הפונקציה renderScript שמשמשת בקובץ definitions/stats_per_country_and_device.sqlx עם הפונקציה ref של Dataform core שמועברת כארגומנט:

${script_builder.renderScript(
  ref("source_table"),
  ["country", "device_type"],
  ["revenue", "pageviews", "sessions"])}

בדוגמת הקוד הבאה אפשר לראות את שאילתת definitions/stats_per_country_and_device.sqlx שעברה קומפילציה ל-SQL:

SELECT country AS country,
       device_type AS device_type,
       SUM(revenue) AS revenue,
       SUM(pageviews) AS pageviews,
       SUM(sessions) AS sessions
FROM my_schema.source_table
GROUP BY 1, 2

מידע נוסף על הפונקציה ref של Dataform core זמין במאמר בנושא Dataform core.

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

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

אתם יכולים ליצור חבילה מותאמת אישית משלכם ב-Dataform או להשתמש באחת מחבילות הקוד הפתוח של Dataform שזמינות בדף הקוד הפתוח של Dataform ב-GitHub.

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

כדי להתקין חבילת NPM פרטית במאגר Dataform, צריך לאמת את החבילה.

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

בקטע הזה מוסבר איך להשתמש ב-JavaScript כדי ליצור פעולות בתהליך העבודה ב-Dataform. יכול להיות שתרצו להשתמש ב-JavaScript במקום ב-Dataform core כדי ליצור רכיבים דומים שוב ושוב בתהליך העבודה.

במקום לפתח תהליכי עבודה ב-SQLX, או ב-SQLX בשילוב עם JavaScript, אפשר ליצור פעולות של תהליכי עבודה בקובצי .js באמצעות JavaScript בלבד. אפשר ליצור כמה פעולות בתהליך העבודה בקובץ JavaScript אחד באמצעות שיטות גלובליות של Dataform וקוד JavaScript ES5 שרירותי, כמו לולאות וקבועים. כל אחת מהשיטות הגלובליות של JavaScript ב-Dataform מכילה מאפיינים שבהם אפשר להשתמש כדי להגדיר את האובייקטים שנוצרו.

אפשר ליצור את פעולות תהליך העבודה הבאות באמצעות JavaScript בלבד ב-Dataform:

הצהרות על מקורות נתונים
Tables
הצהרות ידניות
פעולות SQL בהתאמה אישית

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

דוגמת קוד ה-JavaScript הבאה מאפשרת ליצור תצוגה של כל טבלה שבה הערך של השדה user_id לא תואם לאחד מהערכים ברשימה blocked_user_ids:

  const tableNames = ["user_events", "user_settings", "user_logs"];

  tableNames.forEach(tableName => {
    publish(tableName + "_blocked_removed").query(
      ctx => `
        SELECT * FROM ${ctx.ref(tableName)}
        WHERE user_id NOT IN (
          SELECT user_id
          FROM ${ctx.ref("blocked_user_ids")}
        )`
    );
  });

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

אפשר ליצור כמה פעולות בקובץ JavaScript אחד באמצעות שיטות גלובליות של Dataform וקוד JavaScript ES5 שרירותי, כמו לולאות וקבועים.

אפשר להגדיר את הפעולות הבאות באמצעות JavaScript ב-Dataform:

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

יצירת קובץ JavaScript

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

בחלונית קבצים, לצד definitions/, לוחצים על סמל האפשרויות הנוספות.
לוחצים על יצירת קובץ.
בחלונית Create new file:
1. בשדה הוספת נתיב קובץ, אחרי definitions/, מזינים את שם הקובץ ואחריו .js. לדוגמה, definitions/definitions.js.
  
  שמות הקבצים יכולים לכלול רק מספרים, אותיות, מקפים וקווים תחתונים.
2. לוחצים על יצירת קובץ.

הגדרת מאפיינים של פעולות בתהליך עבודה באמצעות JavaScript

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

‫declare. משמש להצהרה על מקור נתונים.
‫publish. משמש להגדרת טבלה.
‫assert. משמש ליצירת הצהרה.
‫operate. משמש להגדרת פעולת SQL מותאמת אישית.

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

בשיטה publish() שיוצרת טבלה, אפשר להגדיר את מאפייני הטבלה על ידי העברתם כארגומנט השני של השיטה.

כדי להעביר מאפייני טבלה כארגומנט השני של publish(), פועלים לפי השלבים הבאים:

בסביבת העבודה לפיתוח, בחלונית Files (קבצים), מרחיבים את definitions/.
בוחרים קובץ JavaScript.

בקובץ, מוסיפים מאפייני טבלה לשיטה publish() בפורמט הבא:

 method("first_method_argument", {
   property1: "property1_value",
   property2: "property2_value",
   property3: "property3_value",
 });

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

בדוגמת הקוד הבאה אפשר לראות איך מגדירים מאפיינים למתודה publish() על ידי העברת המאפיינים כארגומנט שני של המתודה:

  publish("table1", {
    type: "table",
    dependencies: ["other_table"],
    description: {
      "Value is 1"
    }
  }).query(ctx => "SELECT 1 AS test");

הפניה כוללת בקובץ JavaScript

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

התחביר להפניה לקובץ include בתוך קובץ JavaScript תלוי במיקום של קובץ ה-include. ‫Dataform מאחסן קבצים כאלה בספריית includes.

הפניה לרכיבים ברמה העליונה

כדי להפנות לקובץ includes ברמה העליונה, צריך להפנות לשם הקובץ כשמצהירים על המשתנים.

בדוגמת הקוד הבאה יש הפניה למשתנים serviceName ו-serviceId מהקובץ includes/service.js:

  const {serviceName, serviceId} = service;

הפניה להכללות מקוננות

כדי להפנות לקובץ include מקונן, מזינים את שם הקובץ בפונקציית require של JavaScript.

בדוגמת הקוד הבאה יש הפניה למשתנים serviceName ו-serviceId מהקובץ includes/allServices/service.js:

  const {serviceName, serviceId} = require("includes/allServices/service.js");

שימוש בפונקציות של שאילתות Dataform בשיטות JavaScript

‫Dataform מספק מספר פונקציות מובְנות שאפשר להשתמש בהן בתוך שאילתות, כמו ref ו-self. מידע נוסף על פונקציות מובנות ב-Dataform זמין במאמר הפניית API של Dataform.

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

בסביבת העבודה לפיתוח, בחלונית Files (קבצים), מרחיבים את definitions/.
בוחרים קובץ JavaScript.
בקובץ, מזינים שיטה גלובלית של JavaScript ב-Dataform.
בשיטה, מזינים ארגומנט ctx שאפשר להוסיף לו הקשר.
אופציונלי: אם אתם משתמשים במחרוזות תבנית של JavaScript, עליכם להקיף את הארגומנט contextable בגרשיים הפוכים ``.
בארגומנט contextable, מזינים את פונקציית השאילתה עם הפרמטר שלה כאובייקט הקשר.
אופציונלי: לוחצים על עיצוב.

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

  publish("example").query(ctx => `SELECT * FROM ${ctx.ref("other_table")}`);

הצהרה על מקור נתונים של תהליך עבודה באמצעות JavaScript

אפשר להצהיר על כמה מקורות נתונים בקובץ הצהרת JavaScript אחד באמצעות שיטת ה-JavaScript של Dataform‏ declare. מידע נוסף על השיטה declare זמין במאמר Dataform core reference. מידע נוסף על מקורות נתונים ב-Dataform זמין במאמר הצהרה על מקור נתונים.

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

בסביבת העבודה לפיתוח, בחלונית Files (קבצים), מרחיבים את definitions/.
בוחרים קובץ JavaScript.
מזינים את קטע הקוד הבא בקובץ:
```
 declare({
   database: "DATABASE_PROJECT_ID",
   schema: "BIGQUERY_SCHEMA",
   name: "RELATION_NAME",
 });
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫DATABASE_PROJECT_ID: מזהה הפרויקט שמכיל את מקור הנתונים
- ‫BIGQUERY_SCHEMA: מערך הנתונים ב-BigQuery שבו קיים הקשר החיצוני
- ‫RELATION_NAME: השם של היחס שאפשר להשתמש בו בהמשך כדי להפנות למקור הנתונים ב-Dataform
כדי להצהיר על מקור נתונים נוסף באותו קובץ, מוסיפים לקובץ בלוק declare נוסף.
אופציונלי: לוחצים על עיצוב.

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

אפשר ליצור טבלה באמצעות שיטת JavaScript‏ publish של Dataform. מידע נוסף על שיטת הפרסום זמין במאמר בנושא Dataform Core.

אפשר להגדיר את סוגי הטבלאות הבאים:

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

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

כדי להגדיר טבלה בקובץ JavaScript, פועלים לפי השלבים הבאים:

בסביבת העבודה לפיתוח, בחלונית Files (קבצים), מרחיבים את definitions/.
בוחרים קובץ JavaScript.
מזינים את קטע הקוד הבא בקובץ:
```
 publish("TABLE_NAME").query(ctx => "SELECT_QUERY");
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫TABLE_NAME: שם הטבלה
- ‫SELECT_QUERY: הצהרת SQL SELECT שמגדירה את הטבלה
כדי להגדיר את סוג הטבלה, להוסיף תלות בטבלה ולהוסיף תיאור לטבלה, צריך להגדיר את מאפייני האובייקט של שיטת publish.
כדי להגדיר עוד טבלה באותו קובץ, חוזרים על שלבים 3 ו-4.
אופציונלי: לוחצים על עיצוב.

הגדרת הצהרות ידניות באמצעות JavaScript

אפשר ליצור טענות SQL ידניות בקובץ JavaScript באמצעות השיטה Dataform assert JavaScript. מידע נוסף על השיטה assert זמין במאמר Dataform core reference.

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

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

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

בסביבת העבודה לפיתוח, בחלונית Files (קבצים), מרחיבים את definitions/.
בוחרים קובץ JavaScript.
מזינים את קטע הקוד הבא בקובץ:
```
 assert("ASSERTION_NAME").query(ctx => "CUSTOM_ASSERTION_QUERY");
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫ASSERTION_NAME: השם של הצהרת הזהות המותאמת אישית
- ‫CUSTOM_ASSERTION_QUERY: שאילתת טענת ה-SQL
כדי ליצור עוד הצהרה באותו קובץ, חוזרים על שלב 3.
אופציונלי: לוחצים על עיצוב.

בדוגמת הקוד הבאה מוצגת טענת JavaScript שקובעת שאף ערך ב-source_table הוא לא NULL:

  assert("assertion1").query(ctx => "SELECT * FROM source_table WHERE value IS NULL");

הגדרת פעולות SQL מותאמות אישית באמצעות JavaScript

אפשר להגדיר פעולות SQL מותאמות אישית בקובץ JavaScript באמצעות השיטה Dataform operate JavaScript. מידע נוסף על פעולות SQL בהתאמה אישית ב-Dataform זמין במאמר בנושא יצירת פעולות.

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

בסביבת העבודה לפיתוח, בחלונית Files (קבצים), מרחיבים את definitions/.
בוחרים קובץ JavaScript.
מזינים את קטע הקוד הבא בקובץ:
```
 operate("OPERATION_NAME").queries(ctx => "CUSTOM_SQL_QUERY");
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫OPERATION_NAME: השם של הפעולה המותאמת אישית
- ‫CUSTOM_SQL_QUERY: שאילתת ה-SQL בהתאמה אישית
כדי להגדיר עוד פעולת SQL מותאמת אישית באותו קובץ, חוזרים על שלב 3.
אופציונלי: לוחצים על עיצוב.

בדוגמת הקוד הבאה מוצגת פעולת SQL מותאמת אישית בקובץ JavaScript שמוסיפה שורה חדשה אחת לטבלה some_table ומגדירה את הערך test_column של השורה החדשה ל-2:

  operate("operation1").queries("INSERT INTO some_table (test_column) VALUES (2)");

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

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

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