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

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

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

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

ภาพรวมของแท็บการเชื่อมต่อ

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

หน้าการเชื่อมต่อสร้างขึ้นด้วยเครื่องมือที่ช่วยให้คุณเข้ารหัสและแชร์ข้อมูลส่วนบุคคลที่ระบุตัวบุคคลนั้นได้ (PII) กับพาร์ทเนอร์ในลักษณะที่เน้นความเป็นส่วนตัว หลังจากเลือกคอลัมน์ที่มี PII แล้ว Ads Data Hub จะเข้ารหัสข้อมูลเพื่อให้มั่นใจว่าข้อมูลจากบุคคลที่หนึ่งจะส่งออกหรืออ่านได้โดยผู้ที่มีสิทธิ์เท่านั้น การทราบว่าข้อมูลจากบุคคลที่หนึ่งใดที่จำเป็นสำหรับกรณีการใช้งานการวัดผลหรือการเปิดใช้งานอาจเป็นเรื่องยาก Ads Data Hub จึงมีรายการกรณีการใช้งานที่กำหนดไว้ล่วงหน้าอย่างครอบคลุม จากนั้นจะแนะนำคุณตลอดกระบวนการดึงข้อมูล แปลงข้อมูล และโหลดข้อมูล แม้ว่าคุณจะสร้างการเชื่อมต่อได้หลายประเภท แต่เอกสารนี้จะถือว่าคุณใช้หน้าการเชื่อมต่อสําหรับการจับคู่ข้อมูลที่ได้จากผู้ใช้

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

ดูคำศัพท์

• การเชื่อมต่อข้อมูลที่ได้จากผู้ใช้: ตั้งค่าการเชื่อมต่อข้อมูลที่ได้จากผู้ใช้เพื่อนำเข้าและจับคู่ข้อมูล กำหนดเวลานำเข้าข้อมูล เปลี่ยนรูปแบบข้อมูล และจับคู่ข้อมูลในบริบทโฆษณาโดยใช้รหัสผู้ใช้ เหตุการณ์โฆษณาจะต้องลิงก์กับผู้ใช้ที่ลงชื่อเข้าใช้ในข้อมูลในบริบทโฆษณา Google ต้องใช้โปรเจ็กต์ Google Cloud หลายโปรเจ็กต์
• การเชื่อมต่อข้อมูลจากบุคคลที่หนึ่ง: ตั้งค่าการเชื่อมต่อข้อมูลจากบุคคลที่หนึ่งเป็นเครื่องมือเตรียมข้อมูล เพื่อกำหนดเวลานำเข้าข้อมูลและเปลี่ยนรูปแบบข้อมูลโดยไม่ต้องใช้ฟีเจอร์ขั้นสูงของ UPDM การเชื่อมต่อประเภทนี้ต้องใช้โปรเจ็กต์ Google Cloud เพียงโปรเจ็กต์เดียว
• แหล่งข้อมูล: ผลิตภัณฑ์ที่เชื่อมต่อ ไฟล์ที่นำเข้า หรือการผสานรวมกับบุคคลที่สาม เช่น BigQuery
• ปลายทาง: กรณีการใช้งาน โดยทั่วไปเป็นผลิตภัณฑ์ของ Google หรือฟีเจอร์ผลิตภัณฑ์ที่มีการเปิดใช้งานข้อมูลที่นำเข้า เช่น การจับคู่ข้อมูลที่ได้จากผู้ใช้ของ Ads Data Hub
• โปรเจ็กต์ผู้ดูแลระบบ: โปรเจ็กต์ที่อยู่ในระบบคลาวด์ของ Google ที่มีข้อมูลโฆษณาที่เป็นกรรมสิทธิ์ของคุณในรูปแบบข้อมูลดิบ
• ชุดข้อมูลเอาต์พุต: ชุดข้อมูล BigQuery ที่ Ads Data Hub เขียนลงไป โดยค่าเริ่มต้น ชุดข้อมูลนี้จะอยู่ภายใต้โปรเจ็กต์ผู้ดูแลระบบ หากต้องการเปลี่ยนเป็นโปรเจ็กต์ Google Cloud อื่น โปรดดูหัวข้อกำหนดค่าบัญชีบริการ

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

1. การตั้งค่าการนำเข้าและการจับคู่ข้อมูล
   • คุณ ตรวจสอบว่าข้อมูลจากบุคคลที่หนึ่งอยู่ใน BigQuery และบัญชีบริการมีสิทธิ์อ่านข้อมูลดังกล่าว ดูหัวข้อตั้งค่าการนำเข้าข้อมูล
2. การนำเข้าและการจับคู่ข้อมูลจากบุคคลที่หนึ่ง
   • คุณจัดรูปแบบและอัปโหลดข้อมูลจากบุคคลที่หนึ่งไปยังชุดข้อมูล BigQuery หากต้องการตั้งค่าที่ง่ายที่สุด ให้ใช้โปรเจ็กต์ผู้ดูแลระบบ อย่างไรก็ตาม คุณสามารถใช้ชุดข้อมูล BigQuery ที่คุณเป็นเจ้าของได้
   • คุณเริ่มส่งคำขอการจับคู่ข้อมูลโดยสร้างการเชื่อมต่อ และตั้งเวลา
   • 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 รายการในรายชื่อผู้ใช้
• การอัปเดตตารางการจับคู่ที่สําเร็จทุกครั้งต้องมีจํานวนผู้ใช้ที่จับคู่ใหม่ขั้นต่ำ ลักษณะการทำงานนี้คล้ายกับการตรวจหาข้อมูลที่ต่างกัน
• รายการต้องมีจำนวนระเบียนไม่เกินจำนวนสูงสุด หากต้องการทราบข้อมูลเกี่ยวกับขีดจำกัดข้อมูลสูงสุด โปรดติดต่อตัวแทนของ Google

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

ก่อนเริ่มต้น คุณต้องกำหนดค่าบัญชี Ads Data Hub เพื่อสร้างการเชื่อมต่อข้อมูล ซึ่งเป็นวิธีสร้างไปป์ไลน์การจับคู่ข้อมูล คุณต้องทำตามขั้นตอนเหล่านี้เพียงครั้งเดียว

จากหน้าการเชื่อมต่อ ให้คลิกเริ่มการตั้งค่าเพื่อเปิดวิซาร์ดการตั้งค่าบัญชีในขั้นตอนการเปิดใช้ UPDM

ไปที่การเชื่อมต่อ

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

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

การเชื่อมต่อ 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. ตรวจสอบสิทธิ์ หากมีข้อความแจ้ง แล้วคลิกถัดไป

   BigQuery

   คลิก "ใช้" เพื่อให้สิทธิ์เข้าถึง BigQuery

   Cloud Storage

   คลิกใช้เพื่อให้สิทธิ์เข้าถึง Cloud Storage

   MySQL

   ป้อนตำแหน่งฐานข้อมูล พอร์ต ชื่อผู้ใช้ และรหัสผ่านของ MySQL

   S3

   ป้อนคีย์การเข้าถึงลับของ Amazon S3

   PostgreSQL

   ป้อนตำแหน่งฐานข้อมูล พอร์ต ชื่อผู้ใช้ รหัสผ่าน และฐานข้อมูลของ PostgreSQL

   Redshift

   ป้อนตำแหน่งฐานข้อมูล พอร์ต ชื่อผู้ใช้ รหัสผ่าน และฐานข้อมูลของ Redshift

   sFTP

   ป้อนตำแหน่งเซิร์ฟเวอร์ SFTP, ชื่อผู้ใช้ และรหัสผ่าน

   เกล็ดหิมะ

   ป้อนตัวระบุบัญชี ชื่อผู้ใช้ และรหัสผ่านของ Snowflake

4. กำหนดค่าแหล่งข้อมูล แล้วคลิกถัดไป ดังนี้

   BigQuery

   เลือกตาราง BigQuery ที่จะนำเข้า

   Cloud Storage

   ป้อนเส้นทาง gsutil เช่น gs://my-bucket/folder/ และเลือกการจัดรูปแบบไฟล์

   การแจ้งเตือนจะปรากฏขึ้นหากเชื่อมต่อแหล่งข้อมูลนี้เป็นครั้งแรก คลิกใช้เพื่อให้สิทธิ์เข้าถึง แล้วคลิกถัดไป หมายเหตุ: คุณต้องมีบทบาทที่มีสิทธิ์เพื่อมอบสิทธิ์ storage.buckets.setIamPolicy สำหรับ Bucket ที่เกี่ยวข้อง

   MySQL

   เลือกฐานข้อมูล MySQL และตารางที่ต้องการใช้

   S3

   ป้อน URI ไปยังไฟล์ที่ต้องการอัปโหลดโดยสัมพันธ์กับที่อยู่โฮสต์

   PostgreSQL

   ป้อนชื่อสคีมาและตาราง (หรือมุมมอง) ของ PostgreSQL

   Redshift

   ป้อนชื่อสคีมาและตาราง (หรือมุมมอง) ของ Redshift โดยค่าเริ่มต้น Redshift จะใช้ URL ตำแหน่งฐานข้อมูลที่เป็นไปตามเทมเพลตนี้ cluster-identifier.account-number.aws-region.redshift.amazonaws.com

   sFTP

   ป้อนเส้นทางและชื่อไฟล์ในรูปแบบ /PATH/FILENAME.csv

   เกล็ดหิมะ

   ป้อนฐานข้อมูล สคีมา และตาราง (หรือมุมมอง) ของ Snowflake ที่ต้องการใช้

5. เลือกชุดข้อมูล BigQuery เพื่อใช้เป็นปลายทางสื่อกลาง แล้วคลิกถัดไป ขั้นตอนนี้ช่วยให้มั่นใจได้ว่าข้อมูลอยู่ในรูปแบบที่ถูกต้อง
6. ไม่บังคับ: แก้ไขรูปแบบของข้อมูล การเปลี่ยนรูปแบบรวมถึงการคำนวณแฮช การจัดรูปแบบตัวพิมพ์เล็ก/ใหญ่ และการผสาน/แยกช่อง
   1. คลิกการดำเนินการ > more_vert > เปลี่ยนรูปแบบ
   2. ในแผงที่ปรากฏขึ้น ให้คลิกเพิ่มการเปลี่ยนรูปแบบหรือเพิ่มการเปลี่ยนรูปแบบอื่น
   3. เลือกประเภทการเปลี่ยนรูปแบบจากเมนูแบบเลื่อนลง แล้วป้อนข้อกำหนด
   4. คลิกบันทึก
7. เลือกคีย์การรวมอย่างน้อย 1 รายการและแมปช่องที่คุณจะใช้ Ads Data Hub จะจับคู่ฟิลด์ที่มีชื่อเหมือนกันโดยอัตโนมัติ ซึ่งระบุด้วย auto_fix_high แก้ไขตามความจำเป็น แล้วคลิกถัดไป
8. ตั้งกำหนดเวลาโดยทำดังนี้
   1. ตั้งชื่อการเชื่อมต่อ
   2. กำหนดความถี่ ซึ่งจะกำหนดความถี่ในการนำเข้าข้อมูลไปยังชุดข้อมูลที่คุณเลือกในขั้นตอนก่อนหน้า การเรียกใช้แต่ละครั้งจะเขียนทับข้อมูลในตารางปลายทาง
   3. ระบุวิธีที่คุณต้องการจัดการกับการชนกันของรหัสผู้ใช้ คุณเลือกได้ว่าจะเก็บการจับคู่ที่มีอยู่หรือเขียนทับด้วยข้อมูลใหม่
9. คลิกเสร็จสิ้น โดยทั่วไป ตารางการจับคู่จะพร้อมให้ค้นหาหลังจากสร้างแล้ว 12 ชั่วโมง

ดูรายละเอียดการเชื่อมต่อ

หน้ารายละเอียดการเชื่อมต่อจะแสดงข้อมูลเกี่ยวกับการเรียกใช้และข้อผิดพลาดล่าสุดของการเชื่อมต่อหนึ่งๆ วิธีดูรายละเอียดของการเชื่อมต่อที่เฉพาะเจาะจง

1. คลิกการเชื่อมต่อ
2. คลิกชื่อการเชื่อมต่อเพื่อดูรายละเอียด
3. ตอนนี้คุณจะเห็นรายละเอียดและการเรียกใช้ล่าสุดของการเชื่อมต่อ แต่ละรายการจะแสดงข้อผิดพลาดที่เป็นไปได้ 2 ประเภท ได้แก่ ข้อผิดพลาดระดับการเชื่อมต่อ (การเชื่อมต่อไม่ทำงาน) และข้อผิดพลาดระดับแถว (ระบบไม่ได้นำเข้าแถว)
   1. สถานะไม่สำเร็จบ่งบอกว่าการเชื่อมต่อทั้งหมดทำงานไม่สำเร็จ (เช่น ปัญหาเกี่ยวกับสิทธิ์ของบัญชีบริการ) คลิกสถานะข้อผิดพลาดเพื่อดูว่าข้อผิดพลาดใดส่งผลต่อการเชื่อมต่อ
   2. สถานะเสร็จสมบูรณ์หมายความว่าการเชื่อมต่อทำงานสำเร็จ อย่างไรก็ตาม อาจยังมีข้อผิดพลาดระดับแถว ซึ่งระบุด้วยค่าที่ไม่ใช่ 0 ในคอลัมน์ "แถวที่มีข้อผิดพลาด" คลิกค่าเพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับระเบียนที่ล้มเหลว

แก้ไขการเชื่อมต่อ

รายละเอียดที่แก้ไขได้มีดังนี้

• ชื่อการเชื่อมต่อ
• กำหนดเวลา
• ตารางปลายทาง
• การแมปฟิลด์

ระบบไม่รองรับการแก้ไขแหล่งข้อมูล หากต้องการเปลี่ยนแหล่งข้อมูล ให้สร้างการเชื่อมต่อใหม่และลบการเชื่อมต่อเก่า

วิธีแก้ไขรายละเอียดการเชื่อมต่อ

1. คลิกการเชื่อมต่อ
2. คลิกชื่อการเชื่อมต่อที่ต้องการแก้ไข
3. แก้ไขรายละเอียดที่ต้องการเปลี่ยนแปลง ดังนี้
   • ชื่อการเชื่อมต่อ: คลิกแก้ไข ป้อนชื่อใหม่ แล้วกด Enter
   • กำหนดเวลา: คลิกแก้ไข ตั้งกำหนดเวลาใหม่ แล้วคลิกบันทึก
   • ตารางปลายทาง: คลิกแก้ไข ป้อนชื่อปลายทางใหม่ แล้วคลิกบันทึก
   • การแมปฟิลด์: คลิก navigate_next ทำการเปลี่ยนแปลงในฟิลด์ แล้วคลิกบันทึก
4. คลิก close

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

การเชื่อมต่อที่มีอยู่ในแท็บการเชื่อมต่อจะย้ายไปที่ประสบการณ์การเชื่อมต่อที่อัปเดตซึ่งสร้างขึ้นใน 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