התאמה לפרטים שהמשתמשים סיפקו (UPDM)

התכונה UPDM (התאמה לפרטים שהמשתמשים סיפקו) מאפשרת לצרף את הנתונים מאינטראקציה ישירה (First-Party) שנאספו לגבי משתמש – כמו מידע מהאתרים, מהאפליקציות או מהחנויות הפיזיות – לפעילות של אותו המשתמש המחובר, שנאספה בכל נתוני המודעות מ-Google, כולל נתונים שבבעלות Google ובניהול Google. הנתונים האלה כוללים נתונים שנרכשו דרך מוצרי Google Marketing Platform‏ (GMP), למשל נתונים של YouTube שנרכשו באמצעות Display & Video 360. אין תמיכה במוצרים אחרים של GMP שאינם בבעלות Google ולא מופעלים על ידה.

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

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

Private Cloud Match כרטיסייה Connections

סקירה כללית על התאמה לענן פרטי

כדי לקבל תובנות פרסום חשובות, לרוב צריך לשלב נתונים ממקורות שונים. פיתוח פתרון משלכם לבעיה הזו בצינור הנתונים מחייב השקעה משמעותית של זמן והנדסה. התכונה Private Cloud Match ב-Ads Data Hub משפרת את התהליך הזה על ידי מתן תבנית של שאילתה ב-Ads Data Hub ליצירת טבלת התאמה ב-BigQuery, שאפשר להשתמש בה בשאילתות ב-Ads Data Hub כדי להתאים את נתוני המודעות לנתונים מאינטראקציה ישירה (First-Party). העשרת השאילתות בנתונים מאינטראקציה ישירה (First-Party) יכולה לספק חוויות שימוש עשירות יותר ללקוחות, והיא עמידה יותר לשינויים בתחום המעקב אחר מודעות.

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

סיכום התהליך

1. הגדרה של הטמעת נתונים והתאמה שלהם
   • צריך לוודא שהנתונים מאינטראקציה ישירה (First-Party) נמצאים ב-BigQuery ושלחשבון השירות יש גישה לקריאה אליהם. הגדרת הטמעת נתונים
2. הטמעה והתאמה של נתונים מאינטראקציה ישירה (First-Party)
   • אתם צריכים לעצב את הנתונים מהאינטראקציה הישירה (First-Party) ולהעלות אותם למערך הנתונים ב-BigQuery.
   • אתם מפעילים בקשה להתאמת נתונים על ידי יצירת שאילתת ניתוח התאמה בענן פרטי והגדרת לוח זמנים.
   • Google משלבת נתונים בין הפרויקט שלכם לבין נתונים שבבעלות Google, שמכילים את מזהה המשתמש של Google ונתונים שהמשתמשים סיפקו ועבר גיבוב, כדי ליצור ולעדכן טבלאות התאמה.
   • הטמעת נתונים מאינטראקציה ישירה
3. שאילתות מתמשכות ב-Ads Data Hub, על סמך נתונים מותאמים
   • אתם מריצים שאילתות לטבלאות ההתאמה באותו אופן שבו אתם מריצים שאילתות רגילות ב-Ads Data Hub. שאילתות לנתונים שהותאמו

מידע על דרישות הפרטיות

איסוף נתוני לקוחות

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

פעולות שצריך לבצע:

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

אישור להסכמה מאינטראקציה ישירה

אזהרה: אם לא תאשרו את ההסכמה או תסרבו לאשר את ההסכמה, לא תוכלו להשתמש בנתונים מאינטראקציה ישירה (First-Party) ב-Ads Data Hub. לדוגמה, אי אפשר לייבא נכסי 1PD חדשים או לצרף נכסי 1PD קיימים לנתוני המודעות המקושרים. כל תרחישי השימוש, כמו התאמה של נתונים שהמשתמשים סיפקו והפעלה של קהלים באמצעות 1PD, לא זמינים. זה כולל גם ייבוא מתוזמן של 1PD.

כדי לוודא שתוכלו להשתמש בנתונים מאינטראקציה ישירה (First-Party) ב-Ads Data Hub, עליכם לאשר שקיבלת הסכמה מתאימה לשיתוף נתונים ממשתמשי קצה באזור הכלכלי האירופי (EEA) עם Google, בהתאם למדיניות Google בנושא הסכמת משתמשים באיחוד האירופי ולמדיניות של Ads Data Hub. הדרישה הזו חלה על כל חשבון ב-Ads Data Hub, וצריך לעדכן אותה בכל פעם שמעלים נתונים חדשים מאינטראקציה ישירה (First-Party). כל משתמש יכול להביע את הסכמתו בשם החשבון כולו.

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

במאמר הדרישות לקבלת הסכמה באזור הכלכלי האירופי (EEA) מוסבר איך מאשרים הסכמה ב-Ads Data Hub.

גודל הנתונים

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

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

---

הגדרת הטמעת נתונים

לפני שמתחילים, חשוב לוודא:

• הנתונים מהצד הראשון חייבים להיות ב-BigQuery. אם יש לכם גבול VPC-SC, נתוני הצד הראשון האלה צריכים להיות ממוקמים ב-VPC-SC.
• לחשבון השירות של Ads Data Hub צריכה להיות הרשאת קריאה לנתונים מאינטראקציה ישירה (First-Party).
• נתונים מאינטראקציה ישירה חייבים להיות בפורמט הנכון ועם גיבוב תקין. פרטים נוספים מופיעים בקטע הבא.

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

הטמעה והתאמה של נתונים מאינטראקציה ישירה (First-Party)

פורמט הנתונים לקלט

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

• במקרים שמפורטים בתיאורים הבאים של שדות הקלט, צריך להעלות את הנתונים באמצעות גיבוב SHA256.
• שדות הקלט חייבים להיות בפורמט של מחרוזות. לדוגמה, אם משתמשים בפונקציית הגיבוב SHA256 של BigQuery עם פונקציית הקידוד Base64‏ (TO_BASE64), צריך להשתמש בטרנספורמציה הבאה: TO_BASE64(SHA256(user_data)).
• UPDM תומך בקידוד Base64. צריך להתאים את הקידוד של הנתונים מאינטראקציה ישירה (First-Party) לפענוח שנעשה בשאילתה ב-Ads Data Hub. אם משנים את קידוד הנתונים מהצד הראשון, צריך לעדכן את השאילתה ב-Ads Data Hub כדי לפענח מאותה בסיס. בדוגמאות הבאות נעשה שימוש בקידוד Base64.

מזהה המשתמש

• טקסט רגיל
• גיבוב (hashing): ללא

אימייל

• מסירים רווחים לבנים בתחילת הטקסט ובסופו.
• יש להשתמש באותיות קטנות בלבד
• כל כתובות האימייל צריכות לכלול שמות דומיינים, כמו gmail.com או hotmail.co.jp
• מסירים סימנים דיאקריטיים – לדוגמה, משנים את è,‏ é,‏ ê או ë ל-e
• מסירים את כל הנקודות (.) שלפני שם הדומיין בכתובות אימייל עם הסיומת gmail.com ו-googlemail.com.
• גיבוב: SHA256 בקידוד Base64

תקף: TO_BASE64(SHA256("[e-mail]"))

לא תקין: TO_BASE64(SHA256(" Jéfferson.Lô[e-mail] "))

טלפון

• הסרת רווחים לבנים
• הפורמט צריך להיות E.164 – דוגמה לארה"ב: ‎[phone], דוגמה לבריטניה: ‎[phone]
• מסירים את כל התווים המיוחדים מלבד הסימן '+' לפני קידומת המדינה
• גיבוב: SHA256 בקידוד Base64

תקף: TO_BASE64(SHA256("[phone]"))

לא תקין: TO_BASE64(SHA256("[phone]"))

שם פרטי

• הסרת רווחים לבנים
• יש להשתמש באותיות קטנות בלבד
• מסירים את כל הקידומות, למשל: גב', מר., גב', ד"ר
• לא מסירים סימנים דיאקריטיים – לדוגמה, è,‏ é,‏ ê או ë
• גיבוב: SHA256 בקידוד Base64

תקף: TO_BASE64(SHA256("daní"))

לא תקין: TO_BASE64(SHA256("Mrs. Daní"))

שם משפחה

• הסרת רווחים לבנים
• יש להשתמש באותיות קטנות בלבד
• מסירים את כל הסיומת, למשל 'Jr.', Sr., 2nd, 3rd, II, III, PHD, MD
• לא מסירים סימנים דיאקריטיים – לדוגמה, è,‏ é,‏ ê או ë
• גיבוב: SHA256 בקידוד Base64

תקף: TO_BASE64(SHA256("délacruz"))

לא תקין: TO_BASE64(SHA256("dé la Cruz, Jr."))

מדינה

• צריך לכלול את קוד המדינה גם אם כל נתוני הלקוחות הם מאותה מדינה.
• אין לבצע גיבוב של נתוני המדינה
• צריך להשתמש בקודי מדינה לפי תקן ISO 3166-1 alpha-2
• גיבוב (hashing): ללא

תקף: US

לא תקף: United States of America או USA

מיקוד

• אין לבצע גיבוב של נתוני המיקוד
• אפשר להזין מיקוד של ארה"ב וגם של מדינות אחרות
• בארה"ב:
  • מותר להזין מיקוד בן 5 ספרות – לדוגמה, 94043
  • מותר גם להזין מיקוד בן 5 ספרות עם תוספת של 4 ספרות. לדוגמה, 94043-1351 או 940431351
• בכל שאר המדינות:
  • אין צורך בפורמט (אין צורך להשתמש באותיות קטנות או להסיר רווחים ותווים מיוחדים)
  • אין לכלול תוספות למיקוד
• גיבוב (hashing): ללא

אימות גיבוב וקידוד נתונים

אפשר להשתמש בסקריפטים הבאים לאימות גיבוב (hash) כדי לוודא שהפורמט של הנתונים נכון.

JavaScript

  /**
   * @fileoverview Provides the hashing algorithm, as well as some valid hashes of
   * sample data for testing.
  */

  async function hash(token) {
    // Removes leading or trailing spaces and converts all characters to lowercase.
    const formattedToken = token.trim().toLowerCase();
    // Hashes the formatted string using the SHA-256 hashing algorithm.
    const hashBuffer = await crypto.subtle.digest(
        'SHA-256', (new TextEncoder()).encode(formattedToken));
    // Converts the hash buffer to a base64-encoded string and returns it.
    const base64Str = btoa(String.fromCharCode(...new Uint8Array(hashBuffer)));
    return base64Str;
  }

  function main() {
    // Expected hash for [e-mail]:
    // h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
    hash('[e-mail]').then(result => console.log(result));

    // Expected hash for [phone]:
    // YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
    hash('[phone]').then(result => console.log(result));

    // Expected hash for John: ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
    hash('John').then(result => console.log(result));

    // Expected hash for Doe: eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
    hash('Doe').then(result => console.log(result));
  }

  main()

Python

  """Provides the hashing algorithm, as well as some valid hashes of sample data for testing.

  Supports: Python 2, Python 3

  Sample hashes:

    - Email '[e-mail]': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
    - Phone '[phone]':   YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
    - First name 'John':      ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
    - Last name 'Doe':        eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
  """

  import base64
  import hashlib

  def hash(token):
  # Generates a base64-encoded SHA-256 hash of a normalized input string.
    return base64.b64encode(
        hashlib.sha256(
            token.strip().lower().encode('utf-8')).digest()).decode('utf-8')

  def print_hash(token, expected=None):
  # Computes and displays the hash of a token, with optional validation.
    hashed = hash(token)

    if expected is not None and hashed != expected:
      print(
          'ERROR: Incorrect hash for token "{}". Expected "{}", got "{}"'.format(
              token, expected, hashed))
      return

    print('Hash: "{}"\t(Token: {})'.format(hashed, token))

  def main():
  # Tests the hash function with sample tokens and expected results.
    print_hash(
        '[e-mail]', expected='h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=')
    print_hash(
        '[phone]', expected='YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=')
    print_hash('John', expected='ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=')
    print_hash('Doe', expected='eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=')

  if __name__ == '__main__':
    main()

Go

  /*
  Provides the hashing algorithm, as well as some valid hashes of sample data for testing.

  Sample hashes:

    - Email '[e-mail]': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
    - Phone '[phone]':   YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
    - First name 'John':      ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
    - Last name 'Doe':        eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
  */
  package main

  import (
    "crypto/sha256"
    "encoding/base64"
    "fmt"
    "strings"
  )

  // Hash hashes an email, phone, first name, or last name into the correct format.
  func Hash(token string) string {
    formatted := strings.TrimSpace(strings.ToLower(token))
    hashed := sha256.Sum256([]byte(formatted))
    encoded := base64.StdEncoding.EncodeToString(hashed[:])
    return encoded
  }

  // PrintHash prints the hash for a token.
  func PrintHash(token string) {
    fmt.Printf("Hash: \"%s\"\t(Token: %s)\n", Hash(token), token)

  }

  func main() {
    PrintHash("[e-mail]")
    PrintHash("[phone]")
    PrintHash("John")
    PrintHash("Doe")
  }

Java

  package updm.hashing;

  import static java.nio.charset.StandardCharsets.UTF_8;

  import java.security.MessageDigest;
  import java.security.NoSuchAlgorithmException;
  import java.util.Base64;

  /**
  * Example of the hashing algorithm.
  *
  * <p>Sample hashes:
  *
  * <ul>
  *   <li>Email '[e-mail]': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
  *   <li>Phone '[phone]': YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
  *   <li>First name 'John': ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
  *   <li>Last name 'Doe': eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
  * </ul>
  */
  public final class HashExample {

  private HashExample() {}

  public static String hash(String token) {
    // Normalizes and hashes the input token using SHA-256 and Base64 encoding.
    String formattedToken = token.toLowerCase().strip();

    byte[] hash;
    try {
      hash = MessageDigest.getInstance("SHA-256").digest(formattedToken.getBytes(UTF_8));
    } catch (NoSuchAlgorithmException e) {
      throw new IllegalStateException("SHA-256 not supported", e);
    }

    return Base64.getEncoder().encodeToString(hash);
  }

  public static void printHash(String token) {
    // Calculates and prints the hash for the given token.
    System.out.printf("Hash: \"%s\"\t(Token: %s)\n", hash(token), token);
  }

  public static void main(String[] args) {
    // Executes hash calculations and prints results for sample tokens.
    printHash("[e-mail]");
    printHash("[phone]");
    printHash("John");
    printHash("Doe");
  }
  }

SQL

  /*
  Provides the hashing algorithm, as well as some valid hashes of sample data for testing.

  The following code uses Google Standard SQL and can be run on BigQuery to generate match tables from unhashed data.

  Sample hashes:

    - Email '[e-mail]': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
    - Phone '[phone]':   YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
    - First name 'John':      ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
    - Last name 'Doe':        eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=

  The unhashed input table schema is assumed to be:

  - Column name: UserID, Type: String
  - Column name: Email, Type: String
  - Column name: Phone, Type: String
  - Column name: FirstName, Type: String
  - Column name: LastName, Type: String
  - Column name: PostalCode, Type: String
  - Column name: CountryCode, Type: String
  */

  -- Creates a new table with Base64-encoded SHA-256 hashes of specified columns.
  CREATE TABLE `your_project_name.your_dataset_name.output_hashed_table_name`
  AS
  SELECT
    UserID,
    TO_BASE64(SHA256(LOWER(Email))) AS Email,
    TO_BASE64(SHA256(Phone)) AS Phone,
    TO_BASE64(SHA256(LOWER(FirstName))) AS FirstName,
    TO_BASE64(SHA256(LOWER(LastName))) AS LastName,
    PostalCode,
    CountryCode,
  FROM
    `your_project_name.your_dataset_name.input_unhashed_table_name`;

מפתחות איחוד

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

1. אימייל, טלפון, כתובת (החזק ביותר)
2. טלפון, כתובת
3. אימייל, כתובת
4. אימייל, טלפון
5. כתובת
6. טלפון
7. אימייל (האפשרות החלשה ביותר)

יצירת טבלת התאמות

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

   // Create a new match table using your first party data with this template.
   
   /* Parameters:
   Manually remove all the parameters tagged with @ prefix and replace them with
   column names from your first party table:
   *   @user_id
   *   @email
   *   @phone
   *   @first_name
   *   @last_name
   *   @country_code
   *   @postal_code
   
   And your BigQuery table information:
   *   @my_project: Your BigQuery project where the first party table is.
   *   @my_dataset: Your dataset where the first party table is.
   *   @my_first_party_table: Your first party table.
   */
   
   CREATE OR REPLACE TABLE adh.updm_match_table AS (
   SELECT CAST(@user_id AS BYTES) AS user_id,
         @email AS email,
         @phone AS phone,
         @first_name AS first_name,
         @last_name AS last_name,
         @country_code AS country,
         @postal_code AS zip_code
   FROM `@my_project.@my_dataset.@my_first_party_table`
   );
   

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

3. משנים את ההגדרה של הרעש להגנה על הפרטיות ל'שימוש בבדיקות diff'.

4. לוחצים על Set schedule (הגדרת לוח זמנים) כדי להגדיר את התדירות שבה רוצים לרענן את טבלת ההתאמות. כל הפעלה תחליף את טבלת ההתאמות הנוכחית.

שאילתות של נתונים תואמים

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

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

הטבלה המקורית של נתונים מאינטראקציה ישירה (First-Party) (1PD) מיוצגת על ידי my_data. הנתונים האלה כוללים פרטים אישיים מזהים (PII) ונתונים שאינם PII. שימוש בטבלה המקורית יכול לשפר את הדוחות ולספק תובנות נוספות, כי היא מייצגת את כל נתוני ה-1PD בהיקף, בהשוואה לטבלת התאמה.

לכל טבלה בסכימה של Ads Data Hub שמכילה את השדה user_id מצורפת טבלת התאמות. לדוגמה, לטבלה adh.google_ads_impressions, מערכת Ads Data Hub יוצרת גם טבלת התאמה שנקראת adh.google_ads_impressions_updm שמכילה את מזהי המשתמשים. נוצרות טבלאות התאמה נפרדות לטבלאות מבודדות מדיניות. לדוגמה, לטבלה adh.google_ads_impressions_policy_isolated_youtube, מערכת Ads Data Hub יוצרת גם טבלת התאמות שנקראת adh.google_ads_impressions_policy_isolated_youtube_updm ומכילה את מזהי המשתמשים.

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

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

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

JOIN ON
  adh.google_ads_impressions_updm.customer_data_user_id = CAST(my_data.user_id AS BYTES)

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

הערה: השוואות בין בייטים למחרוזות מקודדות בייטים באופן משתמע ל-Base64.

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

ספירת משתמשים תואמים

השאילתה הזו סופרת את מספר המשתמשים שתואמים בטבלת החשיפות ב-Google Ads.

/* Count matched users in Google Ads impressions table */

SELECT COUNT(DISTINCT user_id)
FROM adh.google_ads_impressions_updm

חישוב שיעור ההתאמה

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

/* Calculate the UPDM match rate */

CREATE TEMP TABLE total_events OPTIONS(privacy_checked_export=TRUE) AS
SELECT
  customer_id,
  COUNT(*) AS n
FROM adh.google_ads_impressions
WHERE is_updm_eligible
GROUP BY 1;

CREATE TEMP TABLE matched_events OPTIONS(privacy_checked_export=TRUE) AS
SELECT
  customer_id,
  COUNT(*) AS n
FROM adh.google_ads_impressions_updm
GROUP BY 1;

SELECT
  customer_id,
  SAFE_DIVIDE(matched_events.n, total_events.n) AS match_rate
FROM total_events
LEFT JOIN matched_events
  USING (customer_id)

איחוד נתונים מאינטראקציה ישירה (First-Party) ונתונים מ-Google Ads

השאילתה הזו מדגימה איך לחבר בין נתונים מאינטראקציה ישירה (First-Party) לנתונים מ-Google Ads:

/* Join first-party data with Google Ads data. The customer_data_user_id field
contains your ID as BYTES. You need to cast your join key into BYTES for
successful matches. */

SELECT
  inventory_type,
  COUNT(*) AS impressions
FROM
  adh.yt_reserve_impressions_updm AS google_data_imp
LEFT JOIN
  `my_data`
ON
  google_data_imp.customer_data_user_id = CAST(my_data.user_id AS BYTES)
GROUP BY
  inventory_type

שאלות נפוצות בנושא UPDM

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