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

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

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

คุณสามารถนําเข้าข้อมูลจากแหล่งข้อมูลต่อไปนี้

  • BigQuery
  • Cloud Storage
  • Secure FTP (SFTP)
  • เกล็ดหิมะ
  • MySQL
  • PostgreSQL
  • Amazon Redshift
  • Amazon S3

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

ดูคำศัพท์

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

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

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

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

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

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

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

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

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

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

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

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

ขนาดข้อมูล

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

  • คุณต้องอัปโหลดระเบียนอย่างน้อย 1,000 รายการในรายการผู้ใช้
  • การอัปเดตตารางการจับคู่ที่สำเร็จทุกครั้งต้องมีผู้ใช้ที่จับคู่ใหม่เป็นจํานวนขั้นต่ำ ลักษณะการทํางานนี้คล้ายกับการตรวจสอบความแตกต่าง
  • รายการของคุณต้องไม่เกินจำนวนระเบียนสูงสุด หากต้องการทราบข้อมูลเกี่ยวกับขีดจำกัดการรับส่งข้อมูลสูงสุด โปรดติดต่อตัวแทนของ Google

ตั้งค่าการส่งผ่านข้อมูล

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

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

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

ระบบจะให้สิทธิ์ใดสำหรับ BigQuery และ Cloud Storage

หากคุณตั้งค่า UPDM เพื่อใช้กับ BigQuery หรือ Cloud Storage ให้ใช้ข้อมูลอ้างอิงนี้เพื่อทำความเข้าใจสิทธิ์ที่มอบให้กับบัญชีบริการ Ads Data Hub

BigQuery

บัญชีบริการของ Data Fusion
วัตถุประสงค์ ใช้บัญชีบริการของ Data Fusion เพื่อแสดงรายการของช่องแหล่งที่มาใน UI ของ Ads Data Hub
รูปแบบ service-some-number@gcp-sa-datafusion.iam.gserviceaccount.com
สิทธิ์เข้าถึงที่จําเป็น
BigQuery Data Viewer
roles/bigquery.dataViewer
 สำหรับชุดข้อมูลเฉพาะในโปรเจ็กต์แหล่งข้อมูลและปลายทาง
Storage Admin
roles/storage.admin
 สำหรับโปรเจ็กต์แหล่งข้อมูลหรือที่เก็บข้อมูลเฉพาะ
บัญชีบริการของ Dataproc
วัตถุประสงค์ บัญชีบริการของ Dataproc มีหน้าที่ในการเรียกใช้ไปป์ไลน์ข้อมูลในการทํางานเบื้องหลัง
รูปแบบ some-number-compute@developer.gserviceaccount.com
สิทธิ์เข้าถึงที่จําเป็น
BigQuery Data Viewer
roles/bigquery.dataViewer
 สำหรับชุดข้อมูลเฉพาะในโปรเจ็กต์แหล่งข้อมูลและปลายทาง
BigQuery Data Editor
roles/bigquery.dataEditor
 สำหรับชุดข้อมูลที่ต้องการในโปรเจ็กต์ปลายทาง
BigQuery Job User
roles/bigquery.jobUser
 สําหรับทั้งโปรเจ็กต์แหล่งข้อมูลและปลายทาง
Storage Admin
roles/storage.admin
 สําหรับทั้งโปรเจ็กต์แหล่งข้อมูลและปลายทาง หรือที่เก็บข้อมูลเฉพาะ
บัญชีบริการ UPDM
วัตถุประสงค์ ระบบจะใช้บัญชีบริการ UPDM เพื่อเรียกใช้งานที่ตรงกัน
รูปแบบ service-some-number@gcp-sa-adsdataconnector.iam.gserviceaccount.com
สิทธิ์เข้าถึงที่จําเป็น
BigQuery Data Viewer
roles/bigquery.dataViewer
 สำหรับโปรเจ็กต์ปลายทาง
BigQuery Job User
roles/bigquery.jobUser
 สำหรับโปรเจ็กต์ปลายทาง

Cloud Storage

บัญชีบริการของ Data Fusion
วัตถุประสงค์ ใช้บัญชีบริการของ Data Fusion เพื่อแสดงรายการของช่องแหล่งที่มาใน UI ของ Ads Data Hub
รูปแบบ service-some-number@gcp-sa-datafusion.iam.gserviceaccount.com
สิทธิ์เข้าถึงที่จําเป็น
Storage Object Viewer
roles/storage.objectViewer
 สำหรับที่เก็บข้อมูลเฉพาะในโปรเจ็กต์แหล่งข้อมูล
BigQuery Data Viewer
roles/bigquery.dataViewer
 สำหรับโปรเจ็กต์แหล่งข้อมูลหรือที่เก็บข้อมูลเฉพาะ
Storage Admin
roles/storage.admin
 สำหรับโปรเจ็กต์แหล่งข้อมูลหรือที่เก็บข้อมูลเฉพาะ
บัญชีบริการของ Dataproc
วัตถุประสงค์ บัญชีบริการของ Dataproc มีหน้าที่ในการเรียกใช้ไปป์ไลน์ข้อมูลในการทํางานเบื้องหลัง
รูปแบบ some-number-compute@developer.gserviceaccount.com
สิทธิ์เข้าถึงที่จําเป็น
Storage Admin
roles/storage.admin
 สําหรับทั้งโปรเจ็กต์แหล่งข้อมูลและปลายทาง หรือที่เก็บข้อมูลเฉพาะ
BigQuery Job User
roles/bigquery.jobUser
 สำหรับโปรเจ็กต์ปลายทาง
บัญชีบริการ UPDM
วัตถุประสงค์ ระบบจะใช้บัญชีบริการ UPDM เพื่อเรียกใช้งานที่ตรงกัน
รูปแบบ service-some-number@gcp-sa-adsdataconnector.iam.gserviceaccount.com
สิทธิ์เข้าถึงที่จําเป็น
BigQuery Data Viewer
roles/bigquery.dataViewer
 สำหรับโปรเจ็กต์ปลายทาง
BigQuery Job User
roles/bigquery.jobUser
 สำหรับโปรเจ็กต์ปลายทาง

แหล่งข้อมูลอื่นๆ

ไม่จําเป็นสําหรับแหล่งข้อมูลอื่นๆ

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

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

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

  • คุณต้องอัปโหลดโดยใช้การแฮช SHA256 ตามที่ระบุไว้ในคำอธิบายช่องป้อนข้อมูลต่อไปนี้
  • ช่องป้อนข้อมูลต้องอยู่ในรูปแบบสตริง เช่น หากคุณใช้ฟังก์ชันแฮช SHA256 ของ BigQuery กับฟังก์ชันการเข้ารหัส Base16 (TO_HEX) ให้ใช้การเปลี่ยนรูปแบบ TO_HEX(SHA256(user_data))
  • UPDM รองรับทั้งการเข้ารหัส Base16 และ Base64 คุณต้องปรับการเข้ารหัสข้อมูลจากบุคคลที่หนึ่งให้สอดคล้องกับการถอดรหัสที่ใช้ในการค้นหาใน Ads Data Hub หากเปลี่ยนการเข้ารหัสข้อมูลจากบุคคลที่หนึ่ง คุณต้องอัปเดตการค้นหา Ads Data Hub เพื่อถอดรหัสจากฐานเดียวกัน ตัวอย่างต่อไปนี้ใช้การเข้ารหัสฐาน 16

User ID

  • ข้อความธรรมดา
  • การแฮช: ไม่มี

อีเมล

  • นําช่องว่างขึ้นต้นและต่อท้ายออก
  • อักขระทั้งหมดต้องเป็นตัวพิมพ์เล็ก
  • รวมชื่อโดเมนของอีเมลทั้งหมด เช่น gmail.com หรือ hotmail.co.jp
  • นำเครื่องหมายกำกับการออกเสียงออก เช่น เปลี่ยน è, é, ê หรือ ë เป็น e
  • นําจุด (.) ที่อยู่ก่อนชื่อโดเมนในอีเมล gmail.com และ googlemail.com ออกทั้งหมด
  • การแฮช: SHA256 ที่เข้ารหัสฐาน 16

ใช้ได้: TO_HEX(SHA256("jeffersonloveshiking@gmail.com"))

ไม่ถูกต้อง: TO_HEX(SHA256("JéffersonLôvesHiking@gmail.com"))

โทรศัพท์

  • ตัดช่องว่าง
  • อยู่ในรูปแบบ E.164 เช่น ตัวอย่างของสหรัฐอเมริกา: +14155552671 ตัวอย่างของสหราชอาณาจักร: +442071838750
  • นำสัญลักษณ์พิเศษทั้งหมดออก ยกเว้นเครื่องหมาย "+" ก่อนรหัสประเทศ
  • การแฮช: SHA256 ที่เข้ารหัสฐาน 16

ใช้ได้: TO_HEX(SHA256("+18005550101"))

ไม่ถูกต้อง: TO_HEX(SHA256("(800) 555-0101"))

ชื่อ

  • ตัดช่องว่าง
  • อักขระทั้งหมดต้องเป็นตัวพิมพ์เล็ก
  • นำคำนำหน้าทั้งหมดออก เช่น Mrs. นาย นางสาว ควายแดง
  • อย่านำเครื่องหมายกำกับการออกเสียงออก เช่น è, é, ê หรือ ë
  • การแฮช: SHA256 ที่เข้ารหัสฐาน 16

ใช้ได้: TO_HEX(SHA256("daní"))

ไม่ถูกต้อง: TO_HEX(SHA256("Daní"))

นามสกุล

  • ตัดช่องว่าง
  • อักขระทั้งหมดต้องเป็นตัวพิมพ์เล็ก
  • นำส่วนต่อท้ายทั้งหมดออก เช่น Jr., Sr. 2nd, 3rd, II, III, PHD, MD
  • อย่านำเครื่องหมายกำกับการออกเสียงออก เช่น è, é, ê หรือ ë
  • การแฮช: SHA256 ที่เข้ารหัสฐาน 16

ใช้ได้: TO_HEX(SHA256("delacruz"))

ไม่ถูกต้อง: TO_HEX(SHA256("de la Cruz, Jr."))

ประเทศ

  • ใส่รหัสประเทศด้วยแม้ว่าข้อมูลลูกค้าทั้งหมดจะมาจากประเทศเดียวกัน
  • อย่าแฮชข้อมูลประเทศ
  • ใช้รหัสประเทศ ISO 3166-1 alpha-2
  • การแฮช: ไม่มี

ใช้ได้: US

ไม่ถูกต้อง: United States of America หรือ USA

รหัสไปรษณีย์

  • อย่าแฮชข้อมูลรหัสไปรษณีย์
  • อนุญาตให้ใช้รหัสไปรษณีย์ทั้งของสหรัฐอเมริกาและต่างประเทศ
  • สำหรับสหรัฐอเมริกา
    • อนุญาตให้ใช้รหัส 5 หลัก เช่น 94043
    • อนุญาตให้ใช้รหัส 5 หลักตามด้วยส่วนขยาย 4 หลักได้ เช่น 94043-1351 หรือ 940431351
  • สำหรับประเทศอื่นๆ ทั้งหมด
    • ไม่ต้องจัดรูปแบบ (ไม่จําเป็นต้องเปลี่ยนเป็นอักษรตัวพิมพ์เล็ก หรือนําการเว้นวรรคและสัญลักษณ์พิเศษออก)
    • เว้นส่วนขยายรหัสไปรษณีย์ไว้
  • การแฮช: ไม่มี

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

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

JavaScript

Base16

/**
 * @fileoverview Provides the hashing algorithm for User-Provided Data Match, 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 hashArrayBuffer = await crypto.subtle.digest(
      'SHA-256', (new TextEncoder()).encode(formattedToken));
  // Converts the hash buffer to a hexadecimal string.
  return Array.from(new Uint8Array(hashArrayBuffer))
      .map((b) => b.toString(16).padStart(2, '0'))
      .join('');
}

function main() {
  // Expected hash for test@gmail.com:
  // 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674
  hash('test@gmail.com').then(result => console.log(result));

  // Expected hash for +18005551212:
  // 61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44
  hash('+18005551212').then(result => console.log(result));

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

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

main()

Base64

/**
 * @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()

Python

Base16

"""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': 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674
  - Phone '+18005551212':   61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44
  - First name 'John':      96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a
  - Last name 'Doe':        799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f
"""

import base64
import hashlib

def updm_hash(token):
# Generates a SHA-256 hash of the input token after normalization.
  return hashlib.sha256(token.strip().lower().encode('utf-8')).hexdigest()

def print_updm_hash(token):
# Prints the SHA-256 hash and the original token.
  print('Hash: "{}"\t(Token: {})'.format(updm_hash(token), token))

def main():
# Hashes and prints sample tokens.
  print_updm_hash('test@gmail.com')
  print_updm_hash('+18005551212')
  print_updm_hash('John')
  print_updm_hash('Doe')

if __name__ == '__main__':
  main()

Base64

"""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()

Go

Base16

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

Sample hashes:

  - Email 'test@gmail.com': 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674
  - Phone '+18005551212':   61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44
  - First name 'John':      96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a
  - Last name 'Doe':        799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f
*/
package main

import (
  "crypto/sha256"
  "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 := fmt.Sprintf("%x", 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")
}

Base64

/*
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")
}

Java

Base16

package updm.hashing;

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

import com.google.common.base.Ascii;
import com.google.common.hash.Hashing;

/**
 * Example of the UPDM hashing algorithm using hex-encoded SHA-256.
*
* <p>This uses the Guava Hashing to generate the hash: https://github.com/google/guava
*
* <p>Sample valid hashes:
*
* <ul>
*   <li>Email "test@gmail.com": "87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674"
*   <li>Phone "+18005551212": "61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44"
*   <li>First name "John": "96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a"
*   <li>Last name "Doe": "799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f"
* </ul>
*/
public final class HashExample {

  private HashExample() {}

  public static String hash(String token) {
    // Normalizes and hashes the input token.
    String formattedToken = Ascii.toLowerCase(token).strip();
    return Hashing.sha256().hashString(formattedToken, UTF_8).toString();
  }

  public static void printHash(String token) {
    // Calculates and prints the token's hash.
    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");
  }
}

Base64

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");
}
}

SQL

Base16

/*
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': 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674
  - Phone '+18005551212':   61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44
  - First name 'John':      96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a
  - Last name 'Doe':        799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f

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 hashed versions of specified columns from the input table.
CREATE TABLE `your_project_name.your_dataset_name.output_hashed_table_name`
AS
SELECT
  UserID,
  TO_HEX(SHA256(LOWER(Email))) AS Email,
  TO_HEX(SHA256(Phone)) AS Phone,
  TO_HEX(SHA256(LOWER(FirstName))) AS FirstName,
  TO_HEX(SHA256(LOWER(LastName))) AS LastName,
  PostalCode,
  CountryCode,
FROM
  `your_project_name.your_dataset_name.input_unhashed_table_name`;

Base64

/*
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 สำหรับที่เก็บข้อมูลที่เกี่ยวข้อง

    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. คลิกการดําเนินการ > > เปลี่ยนรูปแบบ
    2. ในแผงแบบป๊อปอัป ให้คลิกเพิ่มการเปลี่ยนรูปแบบหรือเพิ่มการเปลี่ยนรูปแบบอื่น
    3. เลือกประเภทการเปลี่ยนรูปแบบจากเมนูแบบเลื่อนลง แล้วป้อนข้อกําหนด
    4. คลิกบันทึก
  7. เลือกคีย์การรวมอย่างน้อย 1 รายการ แล้วแมปฟิลด์ที่จะใช้ Ads Data Hub จะแมปช่องที่มีชื่อเหมือนกันโดยอัตโนมัติ ซึ่งระบุด้วย แก้ไขที่จำเป็น แล้วคลิกถัดไป
  8. ตั้งกำหนดเวลา
    1. ตั้งชื่อการเชื่อมต่อ
    2. ตั้งค่าความถี่ ซึ่งจะกําหนดความถี่ในการนําเข้าข้อมูลไปยังชุดข้อมูลที่เลือกในขั้นตอนก่อนหน้า การเรียกใช้แต่ละครั้งจะเขียนทับข้อมูลในตารางปลายทาง
    3. ระบุวิธีที่คุณต้องการให้จัดการรหัสผู้ใช้ที่ซ้ำกัน คุณเลือกได้ว่าจะเก็บการจับคู่ที่มีอยู่หรือเขียนทับด้วยข้อมูลใหม่
  9. คลิกเสร็จสิ้น โดยทั่วไปแล้วตารางการจับคู่จะพร้อมให้ค้นหาได้ภายใน 12 ชั่วโมงหลังจากสร้าง

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

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

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

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

รายละเอียดต่อไปนี้แก้ไขได้

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

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

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

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

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

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

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

ตารางเดิมสําหรับข้อมูลจากบุคคลที่หนึ่ง (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 จะคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ คุณจึงอาจต้องเข้ารหัสสตริงทั้ง 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