การจับคู่ข้อมูลที่ได้จากผู้ใช้

การจับคู่ข้อมูลที่ได้จากผู้ใช้ (UPDM) จะรวมข้อมูลจากบุคคลที่หนึ่งที่คุณได้รวบรวมไว้เกี่ยวกับผู้ใช้ เช่น ข้อมูลจากเว็บไซต์ แอป หรือกิจการที่มีหน้าร้านจริง เข้ากับกิจกรรมที่มีการลงชื่อเข้าใช้ของผู้ใช้รายเดียวกันในข้อมูลในบริบทโฆษณา Google ทั้งหมด รวมถึงข้อมูลที่ Google เป็นเจ้าของและดำเนินการเอง ซึ่งรวมถึงข้อมูลที่ซื้อผ่านผลิตภัณฑ์ Google Marketing Platform (GMP) เช่น YouTube ที่ซื้อโดยใช้ Display & Video 360 ระบบไม่รองรับผลิตภัณฑ์ GMP อื่นๆ ที่ Google ไม่ได้เป็นเจ้าของและดำเนินการ

เหตุการณ์โฆษณาจะต้องลิงก์กับผู้ใช้ที่ลงชื่อเข้าใช้ในข้อมูลในบริบทโฆษณา Google จึงจะมีสิทธิ์ในการจับคู่ข้อมูลที่ได้จากผู้ใช้

เอกสารนี้อธิบายฟีเจอร์การจับคู่ข้อมูลที่ได้จากผู้ใช้ รวมถึงให้คำแนะนำเกี่ยวกับการตั้งค่าและการใช้งาน

ภาพรวมของ Private Cloud Match

การได้รับข้อมูลเชิงลึกด้านการโฆษณาที่มีคุณค่ามักต้องอาศัยการเชื่อมโยงข้อมูลจากแหล่งที่มาหลายแห่งเข้าด้วยกัน การสร้างโซลูชันของคุณเองเพื่อแก้ปัญหาไปป์ไลน์ข้อมูลนี้ ต้องใช้เวลาและการลงทุนด้านวิศวกรรมอย่างมาก Private Cloud Match ใน Ads Data Hub ช่วยปรับปรุงกระบวนการนี้ให้มีประสิทธิภาพมากขึ้นโดยการจัดเตรียมเทมเพลตการค้นหา Ads Data Hub สำหรับสร้างตารางการจับคู่ใน BigQuery ซึ่งสามารถใช้ในการค้นหา Ads Data Hub เพื่อจับคู่ข้อมูลในบริบทโฆษณากับข้อมูลจากบุคคลที่หนึ่ง การเสริมคำค้นหาด้วยข้อมูลจากบุคคลที่หนึ่งจะช่วยมอบประสบการณ์ของลูกค้าที่ดียิ่งขึ้น และทนทานต่อการเปลี่ยนแปลงการติดตามโฆษณาทั่วทั้งอุตสาหกรรมได้มากกว่า

เนื่องจากการจับคู่ข้อมูลที่ได้จากผู้ใช้จะใช้งานได้เฉพาะกับพื้นที่โฆษณาที่ Google เป็นเจ้าของและดําเนินการเองสำหรับผู้ใช้ที่ลงชื่อเข้าใช้ จึงไม่ได้รับผลกระทบจากการเลิกใช้งานคุกกี้ของบุคคลที่สามที่จะมีผลในเร็วๆ นี้ เนื่องจากข้อมูลจากบุคคลที่หนึ่งปรับข้อมูลเข้ากับการเปลี่ยนแปลงของอุตสาหกรรมได้ดีกว่าข้อมูลจากบุคคลที่สาม จึงให้ข้อมูลเชิงลึกที่สมบูรณ์ยิ่งขึ้น ซึ่งอาจนําไปสู่การมีส่วนร่วมของลูกค้าที่สูงขึ้น

สรุปกระบวนการ

1. การตั้งค่าการนำเข้าและการจับคู่ข้อมูล
   • คุณ ตรวจสอบว่าข้อมูลจากบุคคลที่หนึ่งอยู่ใน BigQuery และบัญชีบริการมีสิทธิ์อ่านข้อมูลดังกล่าว ดูหัวข้อตั้งค่าการนำเข้าข้อมูล
2. การนำเข้าและการจับคู่ข้อมูลจากบุคคลที่หนึ่ง
   • คุณจัดรูปแบบและอัปโหลดข้อมูลจากบุคคลที่หนึ่งไปยังชุดข้อมูล BigQuery
   • คุณเริ่มส่งคำขอการจับคู่ข้อมูลโดยสร้างการค้นหาการวิเคราะห์ Private Cloud Match และตั้งเวลา
   • Google จะรวมข้อมูลระหว่างโปรเจ็กต์ของคุณกับข้อมูลที่ Google เป็นเจ้าของซึ่งมีรหัสผู้ใช้ของ Google และข้อมูลที่ได้จากผู้ใช้ที่แฮชแล้วเพื่อสร้างและอัปเดตตารางการจับคู่
   • ดูหัวข้อนำเข้าข้อมูลจากบุคคลที่หนึ่ง
3. การค้นหาอย่างต่อเนื่องใน Ads Data Hub โดยอิงตามข้อมูลที่ตรงกัน
   • คุณเรียกใช้การค้นหากับตารางการจับคู่ในลักษณะเดียวกับการเรียกใช้การค้นหาปกติใน Ads Data Hub ดูค้นหาข้อมูลที่ตรงกัน

ดูข้อมูลเกี่ยวกับข้อกำหนดด้านความเป็นส่วนตัว

การเก็บรวบรวมข้อมูลลูกค้า

เมื่อใช้การจับคู่ข้อมูลที่ได้จากผู้ใช้ คุณต้องอัปโหลดข้อมูลจากบุคคลที่หนึ่ง ซึ่งอาจเป็นข้อมูลที่คุณรวบรวมจากเว็บไซต์ แอป กิจการที่มีหน้าร้านจริง หรือข้อมูลที่ลูกค้าแชร์กับคุณโดยตรง

คุณต้องปฏิบัติดังนี้

• ตรวจสอบว่านโยบายความเป็นส่วนตัวของคุณเปิดเผยว่าคุณแชร์ข้อมูลลูกค้ากับบุคคลที่สามเพื่อให้บริการในนามของคุณ และคุณได้รับความยินยอมในการแชร์ข้อมูลดังกล่าวตามที่ข้อกำหนดทางกฎหมายกำหนด
• อัปโหลดข้อมูลลูกค้าโดยใช้ API หรืออินเทอร์เฟซที่ Google อนุมัติเท่านั้น
• ปฏิบัติตามกฎหมายและกฎระเบียบที่เกี่ยวข้องทั้งหมด รวมถึงหลักเกณฑ์ในการกำกับตนเองหรือหลักเกณฑ์ของอุตสาหกรรมที่อาจมีผลบังคับใช้

การรับทราบความยินยอมของบุคคลที่หนึ่ง

เพื่อให้มั่นใจว่าคุณจะใช้ข้อมูลจากบุคคลที่หนึ่งใน Ads Data Hub ได้ คุณต้องยืนยันว่าได้รับความยินยอมที่เหมาะสมในการแชร์ข้อมูลจากผู้ใช้ปลายทางใน EEA กับ Google ตามนโยบายความยินยอมของผู้ใช้ EU และนโยบาย Ads Data Hub ข้อกำหนดนี้มีผลกับบัญชี Ads Data Hub แต่ละบัญชี และต้องอัปเดตทุกครั้งที่คุณอัปโหลดข้อมูลจากบุคคลที่หนึ่งใหม่ ผู้ใช้รายใดรายหนึ่งสามารถรับทราบในนามของทั้งบัญชีได้

โปรดทราบว่ากฎการค้นหาบริการของ Google เดียวกันกับที่ใช้กับการค้นหาเพื่อการวิเคราะห์จะมีผลกับการค้นหา UPDM ด้วย เช่น คุณไม่สามารถเรียกใช้การค้นหาข้ามบริการกับผู้ใช้ใน EEA เมื่อสร้างตารางการจับคู่

ดูวิธีรับทราบความยินยอมใน Ads Data Hub ได้ที่ข้อกำหนดด้านความยินยอมสำหรับเขตเศรษฐกิจยุโรป

ขนาดข้อมูล

เพื่อปกป้องความเป็นส่วนตัวของผู้ใช้ปลายทาง การจับคู่ข้อมูลที่ได้จากผู้ใช้จะบังคับใช้ข้อกำหนดต่อไปนี้เกี่ยวกับขนาดของข้อมูล

• คุณต้องอัปโหลดระเบียนอย่างน้อย 1,000 รายการในรายชื่อผู้ใช้

ตั้งค่าการนำเข้าข้อมูล

ก่อนเริ่มต้น ให้ตรวจสอบสิ่งต่อไปนี้

• ข้อมูลจากบุคคลที่หนึ่งต้องอยู่ใน BigQuery หากคุณมีขอบเขต VPC-SC ข้อมูลจากบุคคลที่หนึ่งนี้ต้องอยู่ภายใน VPC-SC
• บัญชีบริการ Ads Data Hub ต้องมีสิทธิ์อ่านข้อมูลจากบุคคลที่หนึ่ง
• ข้อมูลจากบุคคลที่หนึ่งต้องได้รับการจัดรูปแบบและแฮชอย่างถูกต้อง ดูรายละเอียดเพิ่มเติมได้ที่หัวข้อถัดไป

นอกจากนี้ Private Cloud Match ยังไม่มีการเตรียมความพร้อมผู้ใช้งานใหม่เพิ่มเติม หากเรียกใช้การค้นหาเพื่อการวิเคราะห์ได้ คุณจะเรียกใช้การค้นหา Private Cloud Match ได้

นำเข้าและจับคู่ข้อมูลจากบุคคลที่หนึ่ง

สิทธิ์ของแหล่งที่มาและข้อกำหนดในการเชื่อมต่อ

การเชื่อมต่อ Ads Data Hub ใช้บัญชีบริการที่แสดงในส่วนการตั้งค่า > รายละเอียด > บัญชีบริการ (โดยปกติคือ service-<number>@gcp-sa-adsdatahub.iam.gserviceaccount.com) ให้สิทธิ์บทบาทต่อไปนี้แก่บัญชีบริการ

• แหล่งที่มา BigQuery: roles/bigquery.dataViewer (ผู้ดูข้อมูล BigQuery) ในชุดข้อมูลหรือตารางต้นทาง
• แหล่งที่มาของ Cloud Storage: roles/storage.objectViewer (ผู้ดูออบเจ็กต์พื้นที่เก็บข้อมูล) ในออบเจ็กต์หรือที่เก็บข้อมูลต้นทาง
• ปลายทางการนำเข้าข้อมูลจากบุคคลที่หนึ่ง: roles/bigquery.dataEditor (ผู้แก้ไขข้อมูล BigQuery) ในชุดข้อมูลปลายทาง หากตารางไม่ได้อยู่ในชุดข้อมูลเริ่มต้น

ข้อกำหนดด้านฟิลด์และประเภทข้อมูล

1. การจับคู่ข้อมูลที่ได้จากผู้ใช้ (UPDM):
   • แมป user_id บวกกับช่อง PII อย่างน้อย 1 ช่อง (email, phone หรือที่อยู่แบบเต็ม: first_name, last_name, country, zip_code)
   • user_id, country และ zip_code: STRING ข้อความธรรมดา (ไม่ได้แฮช) สำหรับแหล่งข้อมูล BigQuery คอลัมน์เหล่านี้ต้องเป็น STRING อยู่แล้ว ส่วนประเภทอื่นๆ (เช่น INT64) จะไม่สำเร็จเมื่อสร้างการเชื่อมต่อ การเชื่อมต่อจะแคสต์ user_id เป็น BYTES ในตารางการจับคู่ country ต้องเป็นรหัส ISO 3166-1 alpha-2 แบบ 2 ตัวอักษร
   • email, phone, first_name และ last_name: HASH ต้องแฮชด้วย SHA-256 และเข้ารหัส Base64 แล้ว (ระบบยอมรับค่า SHA-256 ฐานสิบหก 64 อักขระด้วย) Connections ไม่แฮชข้อมูล ระบบจะไม่ตรวจจับค่าข้อความธรรมดาเมื่อสร้างการเชื่อมต่อ การเรียกใช้ทุกครั้งจึงล้มเหลวโดยมีข้อผิดพลาด ... must be encoded using TO_BASE64(SHA256(...))
   • การเชื่อมต่อการจับคู่ข้อมูลที่ได้จากผู้ใช้ไม่มีตารางปลายทาง การค้นหาทั้งหมดในบัญชีและการค้นหา UPDM ที่ดำเนินการด้วยตนเองจะเขียนลงในข้อมูลการจับคู่เดียวกัน ดังนั้นการเรียกใช้แต่ละครั้งจะแทนที่การเรียกใช้ก่อนหน้า การเชื่อมต่อ UPDM 1 รายการต่อบัญชีก็เพียงพอแล้ว
   • ดูกฎต่อฟิลด์ได้ที่จัดรูปแบบข้อมูลสําหรับอินพุต
2. การนำเข้าข้อมูลจากบุคคลที่หนึ่ง
   • ใช้เฉพาะประเภทข้อมูลที่มีให้ใน UI ซึ่งได้แก่ INTEGER, STRING, HASH, DOUBLE, DATE และ TIMESTAMP ระบบไม่รองรับ BigQuery ประเภทอื่นๆ
   • แหล่งข้อมูล BigQuery: ระบบจะไม่ใช้ประเภทที่แมป คอลัมน์ปลายทางแต่ละคอลัมน์จะเก็บประเภทคอลัมน์ต้นทางไว้
   • แหล่งที่มาของ Cloud Storage: ระบบจะอ่านคอลัมน์เป็น STRING และแคสต์ไปยังประเภทที่แมป ค่าที่แคสต์ไม่ได้จะกลายเป็น NULL โดยไม่ทำให้การเรียกใช้ล้มเหลว
   • การเรียกใช้แต่ละครั้งจะแทนที่ตารางปลายทางทั้งหมด ไม่ใช่การเพิ่มต่อท้าย หากแหล่งที่มาไม่มีแถว ปลายทางจะว่างเปล่า อย่าใช้ตารางต้นทางหรือตารางที่มีข้อมูลที่คุณต้องการเก็บไว้เป็นปลายทาง

ข้อกำหนดคอลัมน์ CSV ของ Cloud Storage

• รวมแถวส่วนหัว ระบบจะข้ามบรรทัดแรกและไม่ใช้ชื่อคอลัมน์ในบรรทัดนั้น
• ไฟล์ต้องมีคอลัมน์แหล่งที่มาที่แมปไว้เท่านั้น โดยไม่มีคอลัมน์อื่นเพิ่มเติมหรือขาดหายไป คอลัมน์เพิ่มเติมทำให้การเรียกใช้ไม่สำเร็จ
• นำเข้าข้อมูลจากบุคคลที่หนึ่ง: คอลัมน์ต้องอยู่ในลำดับเดียวกับการแมปฟิลด์
• การจับคู่ข้อมูลที่ได้จากผู้ใช้: คอลัมน์ต้องเรียงตามลำดับนี้ โดยเก็บเฉพาะช่องที่คุณแมปไว้ ได้แก่ user_id, email, phone, first_name, last_name, country, zip_code ลำดับของแถวการแมปไม่มีความสำคัญ
• ระบบตรวจไม่พบลำดับคอลัมน์ที่แตกต่างกัน: ค่าจะโหลดลงในช่องที่ไม่ถูกต้อง (หรืออัตราการจับคู่ลดลง) โดยไม่มีข้อผิดพลาด

แหล่งข้อมูลที่รองรับและขีดจำกัดการเชื่อมต่อ

• แหล่งข้อมูล: รองรับเฉพาะแหล่งข้อมูล BigQuery และ Cloud Storage เท่านั้น
• ชื่อตาราง BigQuery: ตาราง BigQuery ต้นทางและปลายทางต้องมีชื่อ project.dataset.table แบบเต็ม
• เส้นทางไฟล์ Cloud Storage: ระบุ URI ไฟล์เดียว (เช่น gs://bucket/path/file.csv) ระบบไม่รองรับเส้นทางไวลด์การ์ดที่มี * หรือ ?
• ชื่อการเชื่อมต่อ: การเชื่อมต่อแต่ละรายการในบัญชีต้องมีชื่อที่ไม่ซ้ำกัน

จัดรูปแบบข้อมูลสำหรับอินพุต

ข้อมูลของคุณต้องเป็นไปตามข้อกำหนดการจัดรูปแบบเหล่านี้เพื่อให้จับคู่ได้อย่างถูกต้อง

• คุณต้องอัปโหลดโดยใช้การแฮช SHA256 ตามที่ระบุไว้ในคำอธิบายช่องป้อนข้อมูลต่อไปนี้
• UPDM รองรับการเข้ารหัส Base64 ดู TO_BASE64
• ช่องป้อนข้อมูลต้องจัดรูปแบบเป็นสตริง เช่น หากคุณใช้ฟังก์ชันแฮช SHA256 ของ BigQuery ให้ใช้การแปลงต่อไปนี้ TO_BASE64(SHA256(user_data))

การตรวจสอบแฮชและการเข้ารหัสข้อมูล

คุณสามารถใช้สคริปต์การตรวจสอบความถูกต้องของแฮชต่อไปนี้เพื่อให้แน่ใจว่าข้อมูลของคุณอยู่ในรูปแบบที่ถูกต้อง

  /**
   * @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 test@gmail.com:
    // h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
    hash('test@gmail.com').then(result => console.log(result));

    // Expected hash for +18005551212:
    // YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
    hash('+18005551212').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()

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

  Supports: Python 2, Python 3

  Sample hashes:

    - Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
    - Phone '+18005551212':   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(
        'test@gmail.com', expected='h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=')
    print_hash(
        '+18005551212', expected='YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=')
    print_hash('John', expected='ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=')
    print_hash('Doe', expected='eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=')

  if __name__ == '__main__':
    main()

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

  Sample hashes:

    - Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
    - Phone '+18005551212':   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("test@gmail.com")
    PrintHash("+18005551212")
    PrintHash("John")
    PrintHash("Doe")
  }

  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 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
  *   <li>Phone '+18005551212': 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("test@gmail.com");
    printHash("+18005551212");
    printHash("John");
    printHash("Doe");
  }
  }

  /*
  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 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
    - Phone '+18005551212':   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. คลิกเพิ่ม สร้าง > รายงาน
2. เลือกเทมเพลตการสร้างตารางการจับคู่ในระบบคลาวด์ส่วนตัว ไม่บังคับ: คุณสามารถเลือกการสร้างตารางการจับคู่ในระบบคลาวด์ส่วนตัว (ที่มีการแฮช) หากข้อมูลยังไม่ได้แฮช
3. คลิกแก้ไขการค้นหา แล้วแทนที่ชื่อพารามิเตอร์ด้วยชื่อคอลัมน์เพื่อระบุนามแฝงที่เหมาะสม
4. คลิกตั้งกำหนดเวลาเพื่อกำหนดความถี่ในการรีเฟรชตารางการจับคู่ การเรียกใช้แต่ละครั้งจะเขียนทับตารางการจับคู่ปัจจุบัน

ย้ายข้อมูลการเชื่อมต่อที่มีอยู่

การเชื่อมต่อที่มีอยู่ในแท็บการเชื่อมต่อจะย้ายไปที่ประสบการณ์การเชื่อมต่อที่อัปเดตซึ่งสร้างขึ้นใน Ads Data Hub โดยตรง การเชื่อมต่อที่อัปเดตจะอ่านแหล่งที่มาและเขียนปลายทางโดยใช้บัญชีบริการที่แสดงในส่วนการตั้งค่า > รายละเอียด > บัญชีบริการ (โดยปกติคือ service-<number>@gcp-sa-adsdatahub.iam.gserviceaccount.com) แทนบัญชีบริการ Data Fusion, Dataproc และ UPDM เดิม

ดำเนินการตามรายการการทำงานเหล่านี้ก่อนที่จะย้ายการเชื่อมต่อ

1. ให้สิทธิ์บัญชีบริการ: ให้สิทธิ์บัญชีบริการที่แสดงในส่วนการตั้งค่า > รายละเอียด > บัญชีบริการ (โดยปกติคือ service-<number>@gcp-sa-adsdatahub.iam.gserviceaccount.com) สำหรับบทบาทต้นทางและปลายทางที่จำเป็น (roles/bigquery.dataViewer, roles/storage.objectViewer และ roles/bigquery.dataEditor ในชุดข้อมูลปลายทางที่ไม่ใช่ค่าเริ่มต้น) ระบบอาจยังคงย้ายการเชื่อมต่อที่มีแหล่งข้อมูลที่อ่านไม่ได้ ถูกลบ หรือมีการเปลี่ยนแปลง (โดยเฉพาะแหล่งข้อมูล Cloud Storage ซึ่งไม่ได้รับการตรวจสอบ ณ เวลาที่ย้าย) แต่การเรียกใช้จะล้มเหลวจนกว่าคุณจะให้สิทธิ์เข้าถึงหรือแก้ไขแหล่งข้อมูล
2. แปลงการเชื่อมต่อที่ไม่รองรับ: ระบบจะไม่ย้ายข้อมูลการเชื่อมต่อที่มีการกำหนดค่าต่อไปนี้ แปลงเป็น BigQuery หรือการเชื่อมต่อ Cloud Storage ที่รองรับโดยทำดังนี้
   • แหล่งข้อมูลอื่นๆ (Amazon S3, Snowflake, MySQL, PostgreSQL, Amazon Redshift, sFTP หรือ Salesforce): จัดเตรียมข้อมูลใน BigQuery หรือ Cloud Storage ก่อน จากนั้นจึงสร้างการเชื่อมต่อ BigQuery หรือ Cloud Storage
   • การแมปฟิลด์หรือประเภทข้อมูลที่ไม่รองรับ: อัปเดตหรือสร้างการเชื่อมต่อใหม่เพื่อให้เป็นไปตามข้อกำหนดของฟิลด์และประเภทข้อมูล
   • เส้นทางไวลด์การ์ดของ Cloud Storage (* หรือ ?): แทนที่ URI ไวลด์การ์ดด้วย URI ไฟล์เดียว หรือโหลดไฟล์ลงใน BigQuery ก่อน
   • ชื่อการเชื่อมต่อซ้ำกัน: เปลี่ยนชื่อหรือลบการเชื่อมต่อที่ซ้ำกันเพื่อให้การเชื่อมต่อแต่ละรายการในบัญชีมีชื่อที่ไม่ซ้ำกัน
3. ลบการเชื่อมต่อที่ไม่ได้ใช้: ลบการเชื่อมต่อที่ล้าสมัยซึ่งคุณไม่ต้องการอีกต่อไป

ค้นหาข้อมูลที่ตรงกัน

ค้นหาตารางที่ตรงกัน

เมื่อตารางการจับคู่มีข้อมูลเพียงพอที่จะผ่านการตรวจสอบความเป็นส่วนตัว คุณก็พร้อมที่จะเรียกใช้การค้นหากับตารางแล้ว

ตารางเดิมสำหรับข้อมูลจากบุคคลที่หนึ่ง (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_network Ads Data Hub จะสร้างตารางการจับคู่ที่ชื่อว่า adh.google_ads_impressions_policy_isolated_network_updm ซึ่งมีรหัสผู้ใช้ของคุณด้วย

ตารางเหล่านี้มีชุดย่อยของผู้ใช้ที่พร้อมใช้งานในตารางเดิม ซึ่งมีการจับคู่ใน user_id เช่น หากตารางเดิมมีข้อมูลของผู้ใช้ A และผู้ใช้ B แต่มีเพียงผู้ใช้ A เท่านั้นที่ตรงกัน ผู้ใช้ B จะไม่อยู่ในตารางการจับคู่

ตารางการจับคู่มีคอลัมน์เพิ่มเติมชื่อ customer_data_user_id ซึ่งจัดเก็บตัวระบุผู้ใช้เป็น BYTES

คุณควรคำนึงถึงประเภทของช่องเมื่อเขียนคำค้นหา โอเปอเรเตอร์การเปรียบเทียบ SQL คาดหวังว่าลิเทอรัลที่คุณเปรียบเทียบจะเป็นประเภทเดียวกัน คุณอาจต้องเข้ารหัสค่าในตารางก่อนจับคู่ข้อมูล ทั้งนี้ขึ้นอยู่กับวิธีจัดเก็บ user_id ในตารางข้อมูลจากบุคคลที่หนึ่ง คุณต้องแคสต์คีย์การรวมเป็น BYTES เพื่อให้จับคู่สำเร็จ ดังนี้

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

นอกจากนี้ การเปรียบเทียบสตริงใน SQL จะคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ ดังนั้นคุณอาจต้องเข้ารหัสสตริงทั้ง 2 ด้านของการเปรียบเทียบเพื่อให้แน่ใจว่าสามารถเปรียบเทียบได้อย่างถูกต้อง

ตัวอย่างการค้นหา

นับผู้ใช้ที่ตรงกัน

การค้นหานี้จะนับจำนวนผู้ใช้ที่ตรงกันในตารางการแสดงผล 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)

รวมข้อมูลจากบุคคลที่หนึ่งและข้อมูลในบริบทโฆษณาของ Google Ads

การค้นหานี้แสดงวิธีรวมข้อมูลจากบุคคลที่หนึ่งกับข้อมูลในบริบทโฆษณาของ 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