Dopasowywanie danych własnych i przekazywanych przez użytkowników

Dopasowywanie danych własnych i przekazywanych przez użytkowników (UPDM) łączy zebrane przez Ciebie dane własne o użytkowniku (np. informacje z Twoich witryn, aplikacji lub sklepów stacjonarnych) z aktywnością tego samego zalogowanego użytkownika we wszystkich danych reklam Google, w tym z danymi należącymi do Google i zarządzanymi przez tę firmę. Obejmuje to dane kupowane w ramach usług Google Marketing Platform (GMP), np. w YouTube kupowane za pomocą Display & Video 360. Inne usługi GMP, które nie są własnością Google ani nie są przez nią obsługiwane, nie są obsługiwane.

Aby kwalifikować się do dopasowywania danych własnych i przekazywanych przez użytkowników, zdarzenie reklamy musi być powiązane z zalogowanym użytkownikiem w danych reklam Google.

Ten dokument opisuje funkcję dopasowywania danych użytkownika oraz zawiera wskazówki dotyczące jej konfiguracji i użytkowania.

Dopasowanie w Private Cloud Karta Połączenia

Omówienie dopasowywania w chmurze prywatnej

Aby uzyskać cenne statystyki reklamowe, często trzeba połączyć dane z różnych źródeł. Stworzenie własnego rozwiązania tego problemu wymaga znacznych nakładów czasu i zasobów inżynieryjnych. Prywatna usługa w chmurze do dopasowywania danych w Centrum danych reklam upraszcza ten proces, udostępniając szablon zapytania Centrum danych reklam do tworzenia w BigQuery tabeli dopasowywania, której można używać w zapytaniach Centrum danych reklam do dopasowywania danych reklam do Twoich danych własnych. Wzbogacanie zapytań za pomocą danych własnych może zwiększać komfort klientów i jest bardziej odporne na ogólnobranżowe zmiany sposobów śledzenia reklam.

jest dostępne tylko w zasobach reklamowych należących do Google i zarządzanych przez Google, więc zbliżające się wycofanie plików cookie innych firm nie będzie miało na nie wpływu; Jest bardziej odporne na zmiany zachodzące w branży niż dane innych firm, dzięki czemu może zapewniać bardziej szczegółowe statystyki, co może prowadzić do większego zaangażowania klientów.

Podsumowanie

1. Konfigurowanie przetwarzania i dopasowywania danych
   • Upewnij się, że dane własne znajdują się w BigQuery i że Twoje konto usługi ma do nich dostęp tylko do odczytu. Zobacz Konfigurowanie przetwarzania danych.
2. Pozyskiwanie i dopasowywanie danych własnych
   • Ty formatujesz i przesyłasz dane własne do zbioru danych BigQuery.
   • Ty inicjujesz żądanie dopasowania danych, tworząc zapytanie analizy dopasowania w chmurze Private Cloud i ustanawiając harmonogram.
   • Google łączy dane z Twojego projektu z danymi Google, które zawierają identyfikator użytkownika Google i zaszyfrowane dane przekazane przez użytkownika, aby tworzyć i aktualizować tabele dopasowań.
   • Zobacz przetwarzanie danych własnych.
3. Trwałe zapytania w Centrum danych reklam oparte na dopasowanych danych
   • Zapytania do tabel odpowiedników możesz wykonywać w taki sam sposób jak zwykłe zapytania w Centrum danych reklam. Zobacz Wysyłanie zapytań o dopasowane dane.

Więcej informacji o wymaganiach dotyczących prywatności

Zbieranie danych o klientach

Jeśli korzystasz z dopasowywania danych przekazywanych przez użytkowników, musisz przesłać dane własne. Mogą to być informacje zebrane przez Ciebie w Twoich witrynach, aplikacjach, sklepach stacjonarnych lub wszelkie informacje, które klient udostępnił Ci bezpośrednio.

Musisz:

• zadbać o to, aby w polityce prywatności znalazła się informacja o tym, że dane klientów udostępniasz innym firmom, które świadczą usługi w Twoim imieniu, a jeśli wymaga tego prawo, uzyskać zgodę na udostępnianie danych w ten sposób;
• do przesyłania danych klientów używać wyłącznie interfejsów lub API zatwierdzonych przez Google;
• przestrzegać wszystkich obowiązujących przepisów i regulacji prawnych, w tym wszelkich regulacji wewnętrznych i wytycznych branżowych;

Potwierdzenie samodzielnie uzyskanej zgody użytkowników

Ostrzeżenie: jeśli nie potwierdzisz uzyskania zgody użytkowników lub odmówisz takiego potwierdzenia, nie będziesz mieć możliwości używania w Centrum danych reklam danych własnych. Nie możesz wtedy na przykład pobierać nowych danych własnych ani złączać dotychczasowych danych własnych z połączonymi danymi reklam. Wszystkie przypadki użycia w rodzaju dopasowywania danych własnych i przekazywanych przez użytkowników oraz aktywacji list odbiorców za pomocą danych własnych są wówczas niedostępne. Obejmuje to wszelkie zaplanowane importy danych własnych.

Aby móc używać w Centrum danych reklam danych własnych, musisz potwierdzić, że masz uzyskaną prawidłową zgodę użytkowników z Europejskiego Obszaru Gospodarczego na udostępnianie danych Google, która została otrzymana w sposób określony przez politykę w zakresie zgody użytkownika z UE i zasady Centrum danych reklam. To wymaganie obowiązuje w przypadku każdego konta Centrum danych reklam, a swoje potwierdzenie uzyskania zgody użytkowników musisz aktualizować za każdym razem, gdy przesyłasz nowe dane własne. Potwierdzenie to może przekazać w imieniu całego konta dowolny jego użytkownik.

Pamiętaj, że te same reguły dotyczące zapytań kierowanych do usług Google, które obowiązują w przypadku zapytań analitycznych, mają zastosowanie do zapytań UPDM. Na przykład, gdy tworzysz tabelę odpowiedników, nie możesz wykonywać zapytań dotyczących użytkowników z Europejskiego Obszaru Gospodarczego i obejmujących różne usługi.

Aby dowiedzieć się, jak potwierdzić w Centrum danych reklam uzyskanie zgody użytkowników, zapoznaj się z artykułem Wymagania dotyczące uzyskiwania zgody użytkowników w Europejskim Obszarze Gospodarczym.

Rozmiar danych

Aby chronić prywatność użytkowników, dopasowywanie danych przekazywanych przez użytkowników wymusza te wymagania dotyczące rozmiaru danych:

• Lista użytkowników musi zawierać co najmniej 1000 rekordów.
• Lista nie może przekraczać maksymalnej liczby rekordów. Aby dowiedzieć się więcej o maksymalnym limicie danych, skontaktuj się z przedstawicielem Google.

---

Konfigurowanie przetwarzania danych

Zanim zaczniesz:

• Dane własne muszą znajdować się w BigQuery. Jeśli masz obwód VPC-SC, te dane własne muszą się znajdować w VPC-SC.
• Konto usługi Centrum danych reklam musi mieć dostęp do odczytu danych własnych.
• Dane własne muszą być prawidłowo sformatowane i zaszyfrowane. Więcej informacji znajdziesz w następnej sekcji.

Poza tym usługa Private Cloud Match nie wymaga dodatkowego wdrożenia. Jeśli możesz wykonać zapytanie analityczne, możesz też wykonać zapytanie dopasowania w Private Cloud.

Przetwarzanie i dopasowywanie danych własnych

Formatowanie danych na potrzeby wprowadzania

Aby dane były prawidłowo dopasowywane, muszą spełniać te wymagania dotyczące formatowania:

• W przypadku, gdy w opisie pola podano taką informację, musisz przesłać dane za pomocą szyfrowania SHA256.
• Pola wejściowe muszą być sformatowane jako ciągi znaków. Jeśli na przykład używasz funkcji skrótu SHA256 z BigQuery z funkcją kodowania Base64 (TO_BASE64), użyj tej transformacji: TO_BASE64(SHA256(user_data)).
• UPDM obsługuje kodowanie Base64. Musisz dostosować kodowanie danych własnych do dekodowania używanego w zapytaniu Centrum danych reklam. Jeśli zmienisz kodowanie danych własnych, musisz zaktualizować zapytanie Centrum danych reklam, aby dekodowanie odbywało się z tej samej bazy. W podanych niżej przykładach użyto kodowania Base64.

Identyfikator użytkownika

• Zwykły tekst
• Haszowanie: brak

E-mail

• usuwanie odstępów na początku i na końcu ciągu,
• Używaj tylko małych liter.
• Każdy adres e-mail musi zawierać domenę, np. gmail.com lub hotmail.co.jp
• usuwanie akcentów, np. zamienianie è, é, ê lub ë na e;
• usunąć wszystkie kropki (.) poprzedzające nazwę domeny w adresach e-mail w domenach gmail.com i googlemail.com.
• Szyfrowanie: kodowanie w formacie Base64 algorytmu SHA256

Prawidłowy: TO_BASE64(SHA256("[e-mail]"))

Nieprawidłowy: TO_BASE64(SHA256(" Jéfferson.Lô[e-mail] "))

Telefon

• Usuwanie spacji
• Format E.164 – przykład w Stanach Zjednoczonych: [phone], przykład w Wielkiej Brytanii: [phone]
• Usuń wszystkie znaki specjalne oprócz „+” przed kodem kraju.
• Szyfrowanie: kodowanie w formacie Base64 algorytmu SHA256

Prawidłowy: TO_BASE64(SHA256("[phone]"))

Nieprawidłowy: TO_BASE64(SHA256("[phone]"))

Imię

• Usuwanie spacji
• Używaj tylko małych liter.
• Usuń wszystkie przedrostki, np. Panu, Pani Dr
• Nie usuwaj znaków diakrytycznych, takich jak è, é, ê lub ë.
• Szyfrowanie: kodowanie Base64 SHA256

Prawidłowy: TO_BASE64(SHA256("daní"))

Nieprawidłowy: TO_BASE64(SHA256("Mrs. Daní"))

Nazwisko

• Usuwanie spacji
• Używaj tylko małych liter.
• Usuń wszystkie przyrostki, na przykład Jr., Sr., 2nd, 3rd, II, III, PHD, MD
• Nie usuwaj znaków diakrytycznych, takich jak è, é, ê lub ë.
• Szyfrowanie: kodowanie w formacie Base64 algorytmu SHA256

Prawidłowy: TO_BASE64(SHA256("délacruz"))

Nieprawidłowy: TO_BASE64(SHA256("dé la Cruz, Jr."))

Kraj

• Podaj kod kraju, nawet jeśli wszyscy Twoi klienci pochodzą z tego samego kraju
• Nie szyfruj danych kraju
• Używaj kodów kraju w formacie ISO 3166-1 alfa-2.
• Haszowanie: brak

Prawidłowy: US

Nieprawidłowy: United States of America lub USA

Kod pocztowy

• Nie szyfruj danych kodu pocztowego
• Dopuszczalne są zarówno amerykańskie, jak i międzynarodowe kody pocztowe
• W przypadku Stanów Zjednoczonych:
  • Dozwolone są 5-cyfrowe kody, np. 94043.
  • Format 5-cyfrowy z 4-cyfrowym rozszerzeniem też jest dozwolony, np. 94043-1351 lub 940431351.
• W przypadku pozostałych krajów:
  • Nie wymaga formatowania (nie trzeba zmieniać znaków na małe ani usuwać spacji i znaków specjalnych)
  • Nie dodawaj rozszerzeń kodu pocztowego
• Haszowanie: brak

Sprawdzanie poprawności hasha i kodowanie danych

Aby mieć pewność, że dane są prawidłowo sformatowane, możesz użyć tych skryptów weryfikacji hasha.

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

Przeczytaj

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

Połącz klucze

Niektóre kombinacje danych przekazywanych przez użytkowników są skuteczniejsze niż inne. Poniżej znajduje się lista różnych kombinacji danych przekazywanych przez użytkowników, uporządkowanych według względnej siły. Jeśli używasz adresu, musisz podać imię, nazwisko, kraj i kod pocztowy.

1. E-mail, telefon, adres (najsilniejsze).
2. Telefon, adres
3. E-mail, adres
4. E-mail, telefon
5. Adres
6. Telefon
7. E-mail (najsłabszy)

Tworzenie tabeli dopasowań

1. Kliknij Raporty > Utwórz raport > Generowanie tabeli odpowiedników dla chmury prywatnej > Użyj szablonu. Opcjonalnie: jeśli Twoje dane nie są jeszcze zahaszowane, możesz wybrać Generowanie tabeli odpowiedników dla chmury prywatnej z haszowaniem.

   // 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. Zastąp nazwy parametrów nazwami kolumn, aby zapewnić prawidłowe aliasowanie.

3. Przełącz ustawienie szumu do ochrony prywatności na „Użyj sprawdzania różnic”.

4. Aby określić częstotliwość odświeżania tabeli dopasowań, kliknij Ustaw harmonogram. Każde uruchomienie spowoduje zastąpienie bieżącej tabeli dopasowań.

Wykonywanie zapytań dotyczących dopasowanych danych

Wykonywanie zapytań dotyczących tabel odpowiedników

Gdy tabele odpowiedników zawierają wystarczającą ilość danych, aby spełnić wymagania mechanizmów kontroli prywatności, możesz wykonywać zapytania dotyczące tych tabel.

Pierwotna tabela danych własnych (1PD) jest reprezentowana przez my_data. Obejmuje to zarówno informacje umożliwiające identyfikację osoby, jak i dane niebędące informacjami umożliwiającymi identyfikację. Korzystanie z pierwotnej tabeli może wzbogacić Twoje raporty o dodatkowe statystyki, ponieważ zawiera ona wszystkie dane 1PD w zakresie, w którym są one dostępne w tabeli odpowiedników.

Każdej tabeli w schemacie Centrum danych reklam, która zawiera pole user_id, towarzyszy tabela odpowiedników. Na przykład w przypadku tabeli adh.google_ads_impressions Centrum danych reklam generuje też tabelę odpowiedników o nazwie adh.google_ads_impressions_updm, która zawiera Twoje identyfikatory użytkowników. W przypadku tabel odseparowanych zgodnie z zasadami tworzone są osobne tabele odpowiedników. Na przykład w przypadku tabeli adh.google_ads_impressions_policy_isolated_youtube Centrum danych reklam generuje też tabelę odpowiedników o nazwie adh.google_ads_impressions_policy_isolated_youtube_updm, która zawiera Twoje identyfikatory użytkowników.

Te tabele obejmują podzbiór użytkowników dostępnych w pierwotnych tabelach dopasowanych do identyfikatorów user_id. Jeśli na przykład pierwotna tabela zawiera dane dotyczące użytkowników A i B, ale dopasowane zostanie tylko konto użytkownika A, użytkownik B nie znajdzie się w tabeli odpowiedników.

Tabele odpowiedników zawierają dodatkową kolumnę o nazwie customer_data_user_id, która przechowuje identyfikator użytkownika w postaci bajtów.

Podczas tworzenia zapytań należy zwracać uwagę na typ pola. Operatory porównania SQL wymagają, aby porównywane literały były tego samego typu. Ostrzeżenie: w zależności od sposobu, w jaki w tabeli danych własnych przechowywane są dane (user_id), przed przystąpieniem do dopasowywania danych może być konieczne zakodowanie wartości w tabeli. Aby zapewnić prawidłowe dopasowanie, musisz przeformatować klucz łączenia na bajty:

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

Poza tym porównania ciągów znaków w języku SQL uwzględniają wielkość liter, więc dokładne porównywanie ciągów znaków może wymagać ich zakodowania po obu stronach porównania.

Uwaga: porównywanie bajtów z ciągami znaków powoduje zakodowanie bajtów w formacie Base64.

Przykładowe zapytania

Liczba dopasowanych użytkowników

To zapytanie zlicza liczbę dopasowanych użytkowników w tabeli wyświetleń Google Ads.

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

SELECT COUNT(DISTINCT user_id)
FROM adh.google_ads_impressions_updm

Obliczanie współczynnika dopasowania

Nie wszyscy użytkownicy kwalifikują się do dopasowania. Na przykład niezalogowani użytkownicy, dzieci i użytkownicy, którzy nie wyrazili zgody, nie są dopasowywani za pomocą UPDM. Za pomocą pola is_updm_eligible możesz obliczyć dokładniejsze współczynniki dopasowania UPDM. Pamiętaj, że pole is_updm_eligible było dostępne od 1 października 2024 r. Przed tą datą nie możesz używać tego pola do obliczania współczynników dopasowania.

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

Złączanie danych własnych i Google Ads

To zapytanie pokazuje, jak złączyć dane własne z danymi 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

Najczęstsze pytania dotyczące UPDM

Listę najczęstszych pytań dotyczących UPDM znajdziesz w artykule Odpowiedzi na najczęstsze pytania dotyczące UPDM.