Abgleich der von Nutzern bereitgestellten Daten

Beim Abgleich der von Nutzern bereitgestellten Daten (user-provided data matching, UPDM) werden selbst erhobene Daten zu einem bestimmten Nutzer, etwa Informationen von Websites, aus Apps oder aus Geschäften, mit den Aktivitäten genau dieses angemeldeten Nutzers in allen Google-Anzeigendaten zusammengeführt, einschließlich Daten, die Google gehören und von Google betrieben werden. Dazu gehören Daten, die über Google Marketing Platform-Produkte (GMP) gekauft wurden, z. B. YouTube-Inventar, das über Display & Video 360 gekauft wurde. Andere GMP-Produkte, die nicht von Google betrieben werden, werden nicht unterstützt.

Damit von Nutzern bereitgestellte Daten abgeglichen werden können, muss das Anzeigenereignis mit einem angemeldeten Nutzer in Google-Anzeigendaten verknüpft sein.

In diesem Dokument wird die Funktion zum Abgleichen von nutzerbereitgestellten Daten beschrieben. Außerdem finden Sie hier eine Anleitung zur Einrichtung und Verwendung.

Private Cloud Match Tab „Verbindungen“

Private Cloud Match – Übersicht

Um wertvolle Werbeinformationen zu erhalten, müssen oft Daten aus verschiedenen Quellen zusammengeführt werden. Die Entwicklung einer eigenen Lösung für dieses Datenpipeline-Problem erfordert einen erheblichen Zeit- und Entwicklungsaufwand. Mit Private Cloud Match in Ads Data Hub wird dieser Prozess vereinfacht. Sie erhalten eine Ads Data Hub-Abfragevorlage zum Erstellen einer Abgleichstabelle in BigQuery, die dann in Ihren Ads Data Hub-Abfragen verwendet werden kann, um Ihre Anzeigen- mit Ihren selbst erhobenen Daten abzugleichen. Wenn Sie selbst erhobene Daten für Ihre Abfragen verwenden, können Sie Kunden noch mehr bieten. Außerdem sind Sie dann besser auf branchenweite Änderungen beim Anzeigen-Tracking vorbereitet.

Da der Abgleich der von Nutzern bereitgestellten Daten nur für Nutzer verfügbar ist, die in Inventar angemeldet sind, das Google gehört und von Google betrieben wird, ist er nicht von der bevorstehenden Einstellung von Drittanbieter-Cookies betroffen. Da sie widerstandsfähiger gegen branchenbezogene Änderungen als Drittanbieterdaten sind, können sie umfassendere Informationen liefern, die zu mehr Kundeninteraktionen führen können.

Zusammenfassung des Prozesses

1. Einrichtung von Datenaufnahme und ‑abgleich
   • Ihre selbst erhobenen Daten müssen sich in BigQuery befinden und Ihr Dienstkonto muss Lesezugriff darauf haben. Weitere Informationen finden Sie unter Datenaufnahme einrichten.
2. Aufnahme und Abgleich selbst erhobener Daten
   • Sie formatieren Ihre selbst erhobenen Daten und laden sie in Ihr BigQuery-Dataset hoch.
   • Sie initiieren eine Anfrage zum Datenabgleich, indem Sie eine Private Cloud Match-Analyseabfrage erstellen und einen Zeitplan festlegen.
   • Google führt Daten aus Ihrem Projekt und Google-eigene Daten mit der Google-Nutzer-ID und gehashten, von Nutzern bereitgestellten Daten zusammen, um Abgleichstabellen zu erstellen und zu aktualisieren.
   • Weitere Informationen
3. Laufende Abfragen in Ads Data Hub auf Grundlage abgeglichener Daten
   • Sie führen Abfragen für die Match-Tables auf dieselbe Weise aus wie reguläre Abfragen in Ads Data Hub. Weitere Informationen finden Sie unter Abgleichsdaten abfragen.

Datenschutzanforderungen

Kundendaten erheben

Wenn Sie den Abgleich der von Nutzern bereitgestellten Daten verwenden, müssen Sie selbst erhobene Daten hochladen. Das können Daten sein, die Sie auf Ihren Websites, in Ihren Apps oder in Ihren Geschäften erhoben haben, oder Daten, die ein Kunde direkt mit Ihnen geteilt hat.

Die folgenden Anforderungen müssen erfüllt sein:

• Legen Sie in Ihrer Datenschutzerklärung offen, dass Sie Kundendaten an Dritte weitergeben, damit diese in Ihrem Auftrag Dienstleistungen erbringen können. Holen Sie außerdem, soweit gesetzlich erforderlich, die Einwilligung des entsprechenden Kunden für die Weitergabe der Daten ein.
• Laden Sie Kundendaten nur über APIs oder Schnittstellen hoch, die von Google zugelassen sind.
• Alle anwendbaren Gesetze und Bestimmungen einhalten, einschließlich aller eventuellen Selbstregulierungs- und Branchenkodizes

Einholen der Einwilligung für selbst erhobene Daten bestätigen

Warnung: Wenn Sie nicht bestätigen, dass Sie die Einwilligung eingeholt haben, oder sich weigern, dies zu bestätigen, dürfen Sie Ihre selbst erhobenen Daten nicht in Ads Data Hub nutzen. Sie können dann z. B. keine neuen selbst erhobenen Daten importieren und vorhandene selbst erhobene Daten auch nicht mit verknüpften Anzeigendaten zusammenführen. Sämtliche Anwendungsfälle, darunter der Abgleich der von Nutzern bereitgestellten Daten und die Zielgruppenaktivierung mit selbst erhobenen Daten, sind nicht verfügbar. Das umfasst auch geplante Importe selbst erhobener Daten.

Damit Sie Ihre selbst erhobenen Daten in Ads Data Hub nutzen können, müssen Sie bestätigen, dass Sie die entsprechende Einwilligung zur Weitergabe von Daten von Endnutzern im EWR an Google gemäß der Richtlinie zur Einwilligung der Nutzer in der EU und den Ads Data Hub-Richtlinien eingeholt haben. Die Bestätigung ist für jedes Ads Data Hub-Konto und bei jedem Upload neuer selbst erhobener Daten erforderlich. Jeder Nutzer kann die Bestätigung für das gesamte Konto abgeben.

Hinweis: Für UPDM-Abfragen gelten dieselben Regeln für Google-Dienst-Abfragen wie für Analyseabfragen. So sind z. B. keine dienstübergreifenden Abfragen für Nutzer im EWR möglich, wenn Sie eine Match-Table erstellen.

Informationen dazu, wie Sie in Ads Data Hub bestätigen, dass Sie die Einwilligung eingeholt haben, finden Sie unter Einwilligungsanforderungen für den Europäischen Wirtschaftsraum.

Datengröße

Zum Schutz der Privatsphäre von Endnutzern gelten für den Abgleich von von Nutzern bereitgestellten Daten die folgenden Anforderungen an die Größe Ihrer Daten:

• Sie müssen mindestens 1.000 Datensätze in Ihre Nutzerliste hochladen.

---

Datenaufnahme einrichten

Bevor Sie beginnen, müssen folgende Voraussetzungen erfüllt sein:

• Ihre selbst erhobenen Daten müssen sich in BigQuery befinden. Wenn Sie einen VPC-SC-Perimeter haben, müssen sich diese Erstanbieterdaten in Ihrer VPC-SC befinden.
• Ihr Ads Data Hub-Dienstkonto muss Lesezugriff auf die selbst erhobenen Daten haben.
• Ihre selbst erhobenen Daten müssen richtig formatiert und gehasht sein. Weitere Informationen finden Sie im nächsten Abschnitt.

Darüber hinaus ist für Private Cloud Match kein zusätzliches Onboarding erforderlich. Wenn Sie eine Analyseabfrage ausführen können, können Sie auch eine Private Cloud Match-Abfrage ausführen.

Selbst erhobene Daten aufnehmen und abgleichen

Daten für die Eingabe formatieren

Ihre Daten müssen die folgenden Formatierungsanforderungen erfüllen, damit sie richtig zugeordnet werden können:

• Wie in den folgenden Beschreibungen der Eingabefelder angegeben, müssen Sie SHA256-Hashing verwenden.
• Eingabefelder müssen als Strings formatiert sein. Wenn Sie beispielsweise die SHA256-Hash-Funktion von BigQuery mit der Base64-Codierungsfunktion (TO_BASE64) verwenden, nutzen Sie die folgende Transformation: TO_BASE64(SHA256(user_data)).
• UPDM unterstützt die Base64-Codierung. Die Codierung Ihrer selbst erhobenen Daten muss mit der Decodierung in Ihrer Ads Data Hub-Abfrage übereinstimmen. Wenn Sie die Codierung Ihrer eigenen Daten ändern, müssen Sie Ihre Ads Data Hub-Abfrage aktualisieren, damit die Daten aus derselben Basis decodiert werden. In den folgenden Beispielen wird die Base64-Codierung verwendet.

Nutzer-ID

• Nur Text
• Hashing: Keine

E-Mail

• Entfernen von voran- und nachgestellten Leerzeichen
• Alle Zeichen kleinschreiben
• Geben Sie einen Domainnamen für alle E-Mail-Adressen an, z. B. gmail.com oder hotmail.de.
• Akzente entfernen, z. B. è, é, ê oder ë in e ändern
• Entfernen Sie alle Punkte (.) vor dem Domainnamen in gmail.com- und googlemail.com-E-Mail-Adressen.
• Hashing: Base64-codierter SHA256-Hash

Gültig:TO_BASE64(SHA256("[e-mail]"))

Ungültig:TO_BASE64(SHA256(" Jéfferson.Lô[e-mail] "))

Telefon

• Leerzeichen entfernen
• Format im E.164-Format – Beispiel für die USA: [phone], Beispiel für das Vereinigte Königreich: [phone]
• Entfernen Sie alle Sonderzeichen mit Ausnahme des „+“ vor dem Ländercode.
• Hashing: Base64-codierter SHA256-Hash

Gültig:TO_BASE64(SHA256("[phone]"))

Ungültig:TO_BASE64(SHA256("[phone]"))

Vorname

• Leerzeichen entfernen
• Alle Zeichen kleinschreiben
• Entfernen Sie alle Präfixe, z. B. „Frau“. Herr Frau, Dr.
• Entfernen Sie keine Akzente, z. B. è, é, ê oder ë.
• Hashing: Base64-codierter SHA256-Hash

Gültig:TO_BASE64(SHA256("daní"))

Ungültig:TO_BASE64(SHA256("Mrs. Daní"))

Nachname

• Leerzeichen entfernen
• Alle Zeichen kleinschreiben
• Entfernen Sie alle Suffixe, z. B. „Jr.“ Sr., 2., 3., II, III, PHD, MD
• Entfernen Sie keine Akzente, z. B. è, é, ê oder ë.
• Hashing: Base64-codierter SHA256-Hash

Gültig:TO_BASE64(SHA256("délacruz"))

Ungültig:TO_BASE64(SHA256("dé la Cruz, Jr."))

Land

• Geben Sie den Ländercode auch dann an, wenn Ihre gesamten Kundendaten aus demselben Land stammen.
• Länderdaten nicht hashen
• Verwenden Sie ISO 3166-1 Alpha-2-Ländercodes.
• Hashing: Keine

Gültig:US

Ungültig:United States of America oder USA

Postleitzahl

• Postleitzahlen nicht hashen
• Sowohl US-amerikanische als auch internationale Postleitzahlen sind zulässig
• Für die USA:
  • 5-stellige Codes sind zulässig, z. B. 94043
  • Fünf Ziffern, gefolgt von einer 4-stelligen Erweiterung, sind ebenfalls zulässig, z. B. 94043-1351 oder 940431351.
• Für alle anderen Länder:
  • Keine Formatierung erforderlich (keine Kleinbuchstaben, keine Leerzeichen und keine Sonderzeichen)
  • Lassen Sie Postleitzahlerweiterungen weg.
• Hashing: Keine

Hash-Validierung und Datenverschlüsselung

Mit den folgenden Hash-Validierungsskripts können Sie prüfen, ob Ihre Daten richtig formatiert sind.

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`;

JOIN-Schlüssel

Einige Kombinationen von von Nutzern bereitgestellten Daten sind aussagekräftiger als andere. Im Folgenden finden Sie eine Liste mit verschiedenen Kombinationen von von Nutzern bereitgestellten Daten, sortiert nach relativer Stärke. Wenn Sie eine Adresse verwenden, müssen Sie Folgendes angeben: Vorname, Nachname, Land und Postleitzahl.

1. E-Mail-Adresse, Telefonnummer, Adresse (am stärksten)
2. Telefon, Adresse
3. E‑Mail-Adresse, Adresse
4. E‑Mail, Telefon
5. Adresse
6. Telefon
7. E‑Mail-Adresse (am wenigsten sicher)

Match-Table erstellen

1. Klicken Sie auf Berichte > Bericht erstellen > Match-Table-Generierung in privater Cloud > Vorlage verwenden. Optional: Wenn Ihre Daten noch nicht gehasht sind, können Sie Match-Table-Generierung in privater Cloud (mit Hash-Technologie) auswählen.

   // 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. Ersetzen Sie die Parameternamen durch Ihre Spaltennamen, um die richtigen Aliase zu verwenden.

3. Klicken Sie auf Zeitplan festlegen, um festzulegen, wie oft die Abgleichstabelle aktualisiert werden soll. Bei jedem Lauf wird die aktuelle Abgleichstabelle überschrieben.

Abfrage von abgeglichenen Daten

Match-Tabellen abfragen

Wenn die Match-Tables genügend Daten enthalten, um die Datenschutzprüfungen zu bestehen, können Sie Abfragen dafür ausführen.

Die Originaltabelle für selbst erhobene Daten wird durch my_data dargestellt. Dazu gehören sowohl personenidentifizierbare Informationen als auch nicht personenidentifizierbare Daten. Wenn Sie die Originaltabelle verwenden, können Sie Ihre Berichte mit zusätzlichen Statistiken verbessern, da sie im Vergleich zu einer Match-Table alle selbst erhobenen Daten im entsprechenden Umfang enthält.

Für jede Tabelle im Ads Data Hub-Schema, die ein user_id-Feld enthält, gibt es eine entsprechende Match-Tabelle. Beispielsweise wird für die Tabelle adh.google_ads_impressions in Ads Data Hub auch eine Match-Table mit dem Namen adh.google_ads_impressions_updm erstellt, die Ihre Nutzer-IDs enthält. Für richtlinienkonform isolierte Netzwerk-Tabellen werden separate Match-Tables erstellt. Beispielsweise wird für die Tabelle adh.google_ads_impressions_policy_isolated_network in Ads Data Hub auch eine Match-Table mit dem Namen adh.google_ads_impressions_policy_isolated_network_updm erstellt, die Ihre Nutzer-IDs enthält.

Warnung :Aufgrund von EU-Verordnungen ist UPDM nicht mehr für richtlinienisolierte Tabellen ohne Netzwerkbezug wie adh.google_ads_impressions_policy_isolated_youtube verfügbar. Wenn Sie diese Abfragen weiterhin ausführen möchten, entfernen Sie _policy_isolated_youtube, um sie auf Nutzer mit Einwilligung zu beschränken.

Diese Tabellen enthalten eine Teilmenge der in den ursprünglichen Tabellen verfügbaren Nutzer, bei denen es eine Übereinstimmung mit der user_id gibt. Wenn die ursprüngliche Tabelle beispielsweise Daten für Nutzer A und Nutzer B enthält, aber nur Nutzer A abgeglichen werden kann, ist Nutzer B nicht in der Match-Table enthalten.

Die Match-Tables enthalten die zusätzliche Spalte customer_data_user_id, in der die Nutzer-ID als BYTES gespeichert wird.

Beim Erstellen von Abfragen ist es wichtig, den Feldtyp zu berücksichtigen. Für SQL-Vergleichsoperatoren ist es erforderlich, dass die zu vergleichenden Literale denselben Typ haben. Je nachdem, wie die user_id in der Tabelle mit selbst erhobenen Daten gespeichert wird, müssen Sie die Werte in der Tabelle möglicherweise codieren, bevor die Daten abgeglichen werden. Für erfolgreiche Übereinstimmungen müssen Sie den Join-Schlüssel in BYTES umwandeln:

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

Außerdem wird bei Stringvergleichen in SQL die Groß- und Kleinschreibung berücksichtigt. Eventuell müssen Sie also Strings auf beiden Seiten des Vergleichs entsprechend codieren, damit sie richtig verglichen werden können.

Hinweis: Beim Vergleich von Bytes und Strings werden Bytes implizit mit Base64 codiert.

Beispielabfragen

Anzahl der übereinstimmenden Nutzer

Mit dieser Abfrage wird die Anzahl der übereinstimmenden Nutzer in Ihrer Google Ads-Tabelle „Impressionen“ gezählt.

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

SELECT COUNT(DISTINCT user_id)
FROM adh.google_ads_impressions_updm

Abgleichsrate berechnen

Nicht alle Nutzer kommen für den Abgleich infrage. Abgemeldete Nutzer, Kinder und Nutzer, die keine Einwilligung erteilt haben, werden beispielsweise nicht über UPDM abgeglichen. Mit dem Feld is_updm_eligible lassen sich genauere Abgleichsraten für von Nutzern bereitgestellte Daten berechnen. Das Feld is_updm_eligible ist seit dem 1. Oktober 2024 verfügbar. Vor diesem Datum können Sie dieses Feld nicht verwenden, um Abgleichsraten zu berechnen.

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

Selbst erhobene Daten und Google Ads-Daten zusammenführen

In dieser Abfrage wird gezeigt, wie Sie selbst erhobene Daten mit Google Ads-Daten verknüpfen:

/* 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

Häufig gestellte Fragen zu UPDM

Eine Liste mit häufig gestellten Fragen zu UPDM finden Sie unter Häufig gestellte Fragen zu UPDM.