Corrispondenza dei dati forniti dall'utente

La corrispondenza dei dati forniti dall'utente (UPDM) combina i dati proprietari che hai raccolto su un utente, ad esempio le informazioni provenienti dai tuoi siti web, dalle tue app o dai tuoi negozi fisici, con l'attività dello stesso utente che ha eseguito l'accesso in tutti i dati degli annunci Google, inclusi i dati di proprietà e gestiti da Google. Sono inclusi i dati acquistati tramite i prodotti Google Marketing Platform (GMP), ad esempio YouTube acquistato utilizzando Display & Video 360. Non sono supportati altri prodotti GMP che non sono di proprietà e gestiti da Google.

Per consentire la corrispondenza dei dati forniti dall'utente, l'evento dell'annuncio deve essere collegato a un utente che ha eseguito l'accesso nei dati pubblicitari di Google.

Questo documento descrive la funzionalità di corrispondenza dei dati forniti dagli utenti e fornisce indicazioni sulla configurazione e sull'utilizzo.

Private Cloud Match Scheda Connessioni

Panoramica di Private Cloud Match

Per ottenere informazioni preziose sulla pubblicità, spesso è necessario combinare i dati di più origini. Creare una soluzione personalizzata per questo problema della pipeline di dati richiede un investimento significativo di tempo e risorse di ingegneria. Private Cloud Match in Ads Data Hub semplifica questo processo fornendo un modello di query Ads Data Hub per creare una tabella di corrispondenza in BigQuery che può essere utilizzata nelle query Ads Data Hub per abbinare i dati degli annunci ai dati proprietari. Arricchire le query con dati proprietari può offrire ai clienti esperienze più complete ed è un processo più resistente alle modifiche apportate al monitoraggio degli annunci a livello di settore.

Poiché la corrispondenza dei dati forniti dall'utente è disponibile solo per l'inventario di proprietà e gestito da Google per gli utenti che hanno eseguito l'accesso, non è interessata dall'imminente ritiro dei cookie di terze parti. Poiché è più resistente ai cambiamenti del settore rispetto ai dati di terze parti, può fornire approfondimenti più ricchi, che possono portare a un maggiore coinvolgimento dei clienti.

Riepilogo della procedura

1. Configurazione dell'importazione e della corrispondenza dei dati
   • Assicurati che i dati proprietari si trovino in BigQuery e che il service account abbia accesso in lettura. Vedi Configurare l'importazione dei dati.
2. Importazione e corrispondenza dei dati proprietari
   • Tu formatti e carichi i dati proprietari nel tuo set di dati BigQuery.
   • Tu avvii una richiesta di corrispondenza dei dati creando una query di analisi della corrispondenza di Private Cloud e impostando una pianificazione.
   • Google unisce i dati del tuo progetto e i dati di proprietà di Google contenenti l'ID utente di Google e i dati forniti dall'utente sottoposti ad hashing per creare e aggiornare le tabelle di corrispondenza.
   • Vedi Importare dati proprietari
3. Query in corso in Ads Data Hub, in base ai dati corrispondenti
   • Tu esegui query sulle tabelle delle corrispondenze nello stesso modo in cui esegui le query regolari in Ads Data Hub. Consulta Dati corrispondenti alla query.

Scopri di più sui requisiti di privacy

Raccolta dei dati dei clienti

Quando utilizzi la corrispondenza dei dati forniti dall'utente, devi caricare i dati proprietari. Questi potrebbero essere dati che hai raccolto dai tuoi siti web, dalle tue app, dai tuoi negozi fisici o qualsiasi informazione che un cliente ha condiviso direttamente con te.

Devi:

• Assicurarti che nelle tue norme sulla privacy sia indicato che i dati dei clienti vengono condivisi con terze parti per l'erogazione di servizi per tuo conto e di aver ottenuto il consenso per tale condivisione, laddove previsto dalla legge.
• Utilizzare esclusivamente l'interfaccia o l'API approvata da Google per caricare i dati dei clienti.
• Rispettare tutte le leggi e normative vigenti, inclusi tutti i codici di settore o autoregolamentati applicabili.

Conferma del consenso in relazione ai dati proprietari

Avviso: la mancata conferma del consenso o il rifiuto a confermare il consenso comporta l'incapacità di utilizzare i dati proprietari (dati di prima parte) con Ads Data Hub. Ad esempio, non puoi importare nuovi dati di prima parte o unire quelli esistenti ai tuoi dati pubblicitari collegati. Non sono disponibili tutti i casi d'uso, come la corrispondenza dei dati forniti dall'utente e l'attivazione di segmenti di pubblico che usano dati di prima parte. Ciò include eventuali importazioni di dati di prima parte pianificate.

Per assicurarti di poter utilizzare i tuoi dati proprietari in Ads Data Hub, devi confermare di aver ottenuto dagli utenti finali del SEE l'apposito consenso a condividere i dati con Google ai sensi delle Norme relative al consenso degli utenti dell'UE e delle Norme di Ads Data Hub. Questo requisito si applica a ciascun account Ads Data Hub e deve essere aggiornato ogni volta che vengono caricati nuovi dati proprietari. Questa conferma può essere data da qualsiasi utente per conto dell'intero account.

Tieni presente che le stesse regole per le query dei servizi Google che si applicano alle query di analisi valgono anche per le query UPDM. Ad esempio, non puoi eseguire query su più servizi sugli utenti nel SEE quando crei una tabella delle corrispondenze.

Per sapere come confermare il consenso in Ads Data Hub, consulta Requisiti per il consenso per lo Spazio economico europeo (SEE).

Dimensione dei dati

Per proteggere la privacy degli utenti finali, la corrispondenza dei dati forniti dagli utenti impone i seguenti requisiti relativi alle dimensioni dei dati:

• Devi caricare almeno 1000 record nell'elenco utenti.

---

Configura l'importazione dei dati

Prima di iniziare, assicurati che:

• I dati proprietari devono trovarsi in BigQuery. Se hai un perimetro VPC-SC, questi dati proprietari devono trovarsi all'interno del VPC-SC.
• Il service account Ads Data Hub deve avere accesso in lettura ai dati proprietari.
• I dati proprietari devono essere formattati e sottoposti ad hashing correttamente. Per ulteriori dettagli, consulta la sezione successiva.

Oltre a questo, la corrispondenza nel cloud privato non richiede ulteriori procedure di onboarding. Se puoi eseguire una query di analisi, puoi eseguire una query Private Cloud Match.

Importare e abbinare i dati proprietari

Formattare i dati per l'input

Per essere abbinati correttamente, i dati devono rispettare i seguenti requisiti di formattazione:

• Dove indicato nelle descrizioni dei campi di immissione seguenti, devi caricare utilizzando l'hashing SHA256.
• I campi di input devono essere formattati come stringhe. Ad esempio, se utilizzi la funzione hash SHA256 di BigQuery con la funzione di codifica Base64 (TO_BASE64), utilizza la seguente trasformazione: TO_BASE64(SHA256(user_data)).
• UPDM supporta la codifica Base64. Devi allineare la codifica dei tuoi dati proprietari con la decodifica utilizzata nella query Ads Data Hub. Se modifichi la codifica dei dati proprietari, devi aggiornare la query Ads Data Hub per decodificare dalla stessa base. I seguenti esempi utilizzano la codifica Base64.

ID utente

• Testo normale
• Hashing: nessuno

Email

• Rimuovi gli spazi vuoti iniziali e finali
• Scrivi tutti i caratteri in minuscolo.
• Includi un nome di dominio per tutti gli indirizzi email, ad esempio gmail.com o hotmail.co.jp
• Rimuovi gli accenti, ad esempio cambia è, é, ê o ë in e
• Rimuovi tutti i punti (.) che precedono il nome di dominio negli indirizzi email gmail.com e googlemail.com.
• Hashing: SHA256 con codifica Base64

Valido: TO_BASE64(SHA256("[e-mail]"))

Non valido: TO_BASE64(SHA256(" Jéfferson.Lô[e-mail] "))

Telefono

• Rimuovi spazio vuoto
• Formato E.164. Esempio per gli Stati Uniti: [phone]. Esempio per il Regno Unito: [phone]
• Rimuovi tutti i caratteri speciali, tranne il segno "+" prima del codice paese.
• Hashing: SHA256 con codifica Base64

Valido: TO_BASE64(SHA256("[phone]"))

Non valido: TO_BASE64(SHA256("[phone]"))

Nome

• Rimuovi spazio vuoto
• Scrivi tutti i caratteri in minuscolo.
• Rimuovi tutti i prefissi, ad esempio Sig.ra, Sig., Sig.na, dott.
• Non rimuovere gli accenti, ad esempio è, é, ê o ë.
• Hashing: SHA256 con codifica Base64

Valido: TO_BASE64(SHA256("daní"))

Non valido: TO_BASE64(SHA256("Mrs. Daní"))

Cognome

• Rimuovi spazio vuoto
• Scrivi tutti i caratteri in minuscolo.
• Rimuovi tutti i suffissi, ad esempio Jr., Sr., 2°, 3°, II, III, PHD, MD
• Non rimuovere gli accenti, ad esempio è, é, ê o ë.
• Hashing: SHA256 con codifica Base64

Valido: TO_BASE64(SHA256("délacruz"))

Non valido: TO_BASE64(SHA256("dé la Cruz, Jr."))

Paese

• Includi il codice paese anche se tutti i dati dei tuoi clienti provengono dallo stesso paese.
• Non sottoporre ad hashing i dati relativi al paese
• Utilizza i codici paese ISO 3166-1 alpha-2
• Hashing: nessuno

Valido: US

Non valido: United States of America o USA

CAP

• Non sottoporre ad hashing i dati relativi ai codici postali
• Sono consentiti i codici postali internazionali e quelli degli Stati Uniti
• Per gli Stati Uniti:
  • Sono consentiti codici a cinque cifre, ad esempio 94043.
  • Sono consentiti anche i codici a cinque cifre seguiti da estensioni a quattro cifre, ad esempio 94043-1351 o 940431351.
• Per tutti gli altri paesi:
  • Nessuna formattazione necessaria (non è necessario convertire in minuscolo o rimuovere spazi e caratteri speciali)
  • Non inserire le estensioni del codice postale
• Hashing: nessuno

Convalida dell'hash e codifica dei dati

Puoi utilizzare i seguenti script di convalida dell'hash per assicurarti che i dati siano formattati correttamente.

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

Chiavi di unione

Alcune combinazioni di dati forniti dall'utente sono più efficaci di altre. Di seguito è riportato un elenco di diverse combinazioni di dati forniti dall'utente, classificate in base alla forza relativa. Se utilizzi un indirizzo, devi includere: nome, cognome, paese e codice postale.

1. Email, telefono, indirizzo (più forte)
2. Telefono, indirizzo
3. Email, indirizzo
4. Email, telefono
5. Indirizzo
6. Telefono
7. Email (più debole)

Creare una tabella delle corrispondenze

1. Fai clic su Report > Crea report > Generazione della tabella delle corrispondenze nel cloud privato > Usa modello (facoltativo) Puoi selezionare Generazione della tabella delle corrispondenze nel cloud privato con hashing se i tuoi dati non sono già sottoposti ad hashing.

   // 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. Sostituisci i nomi dei parametri con i nomi delle colonne per fornire alias appropriati.

3. Fai clic su Imposta pianificazione per impostare la frequenza con cui vuoi aggiornare la tabella delle corrispondenze. Ogni esecuzione sovrascriverà la tabella delle corrispondenze attuale.

Query sui dati corrispondenti

Eseguire query sulle tabelle delle corrispondenze

Quando le tabelle delle corrispondenze contengono dati sufficienti a soddisfare i controlli di privacy, puoi eseguire query sulle tabelle.

La tabella originale per i dati proprietari (dati di prima parte) è rappresentata da my_data. Sono inclusi sia i dati che consentono l'identificazione personale (PII) sia i dati non PII. L'utilizzo della tabella originale può migliorare i report con ulteriori approfondimenti, in quanto rappresenta tutti i dati proprietari nell'ambito, rispetto a una tabella delle corrispondenze.

Ogni tabella nello schema di Ads Data Hub contenente un campo user_id è accompagnata da una tabella delle corrispondenze. Ad esempio, per la tabella adh.google_ads_impressions, Ads Data Hub genera anche una tabella delle corrispondenze denominata adh.google_ads_impressions_updm contenente i tuoi ID utente. Vengono create tabelle delle corrispondenze separate per le tabelle di rete isolate in conformità alle norme. Ad esempio, per la tabella adh.google_ads_impressions_policy_isolated_network, Ads Data Hub genera anche una tabella delle corrispondenze denominata adh.google_ads_impressions_policy_isolated_network_updm contenente i tuoi ID utente.

Avviso :a causa dei regolamenti dell'UE, UPDM non è più disponibile per le tabelle non di rete isolate in base alle norme, ad esempio adh.google_ads_impressions_policy_isolated_youtube. Per continuare a eseguire queste query, rimuovi _policy_isolated_youtube per limitare i risultati ai soli utenti che hanno dato il consenso.

Queste tabelle contengono un sottoinsieme degli utenti disponibili nelle tabelle originali, in cui è presente una corrispondenza con user_id. Ad esempio, se la tabella originale contiene dati per l'utente A e l'utente B, ma presenta una corrispondenza solo con l'utente A, l'utente B non apparirà nella tabella delle corrispondenze.

Le tabelle delle corrispondenze contengono una colonna aggiuntiva denominata customer_data_user_id, che memorizza l'identificatore utente come BYTES.

Quando scrivi le query, è importante considerare il tipo di campo. Gli operatori di confronto SQL si aspettano che i valori letterali confrontati siano dello stesso tipo. A seconda di come user_id viene archiviato nella tabella dei dati proprietari, potrebbe essere necessario codificare i valori nella tabella prima di creare corrispondenze tra i dati. Per creare corrispondenze tra i dati, devi trasmettere la tua chiave di join in BYTES:

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

Inoltre, i confronti di stringhe in SQL sono sensibili alle lettere maiuscole, pertanto potresti dover codificare le stringhe su entrambi i lati per poterle confrontare in modo accurato.

Nota: i confronti tra byte e stringhe codificano implicitamente i byte in formato Base64.

Query di esempio

Conteggio degli utenti corrispondenti

Questa query conteggia il numero di utenti corrispondenti nella tabella delle impressioni di Google Ads.

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

SELECT COUNT(DISTINCT user_id)
FROM adh.google_ads_impressions_updm

Calcolare il tasso di corrispondenza

Non tutti gli utenti sono idonei alla corrispondenza. Ad esempio, gli utenti che non hanno eseguito l'accesso, i bambini e gli utenti che non hanno dato il consenso non vengono abbinati tramite UPDM. Puoi utilizzare il campo is_updm_eligible per calcolare tassi di corrispondenza UPDM più accurati. Tieni presente che il campo is_updm_eligible è disponibile a partire dal 1° ottobre 2024. Non puoi utilizzare questo campo per calcolare i tassi di corrispondenza prima di questa data.

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

Unire i dati proprietari e di Google Ads

Questa query mostra come unire i dati proprietari ai dati 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

Domande frequenti su UPDM

Per un elenco di domande frequenti relative a UPDM, consulta le domande frequenti su UPDM.