Corrispondenza dei dati forniti dall'utente

La corrispondenza dei dati forniti dagli utenti (UPDM) unisce 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, all'attività dello stesso utente che ha eseguito l'accesso in tutti i dati pubblicitari di 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 tramite Display & Video 360. Altri prodotti GMP non di proprietà e gestiti da Google non sono supportati.

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 degli annunci Google.

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

Panoramica di Private Cloud Match

Per ottenere informazioni preziose sulla pubblicità, spesso è necessario unire i dati provenienti da più fonti. La creazione di una soluzione personalizzata per questo problema della pipeline di dati richiede un investimento significativo in termini di tempo e di ingegneria. Cloud privato Match in Ads Data Hub semplifica questo processo fornendo un modello di query di Ads Data Hub per creare una tabella delle corrispondenze in BigQuery che può essere utilizzata nelle query di Ads Data Hub per abbinare i dati pubblicitari 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 dagli utenti è 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é resistono meglio ai cambiamenti del settore rispetto ai dati di terze parti, possono fornire informazioni più approfondite, che possono portare a un maggiore coinvolgimento dei clienti.

Riepilogo del processo

1. Configurazione dell'importazione e della corrispondenza dei dati
   • Tu Assicurati che i tuoi dati proprietari si trovino in BigQuery e che il tuo service account disponga dell'accesso in lettura. Consulta Configura l'importazione dei dati.
2. Importazione e corrispondenza dei dati proprietari
   • Tu formatti e carichi i tuoi dati proprietari nel tuo set di dati BigQuery.
   • Tu avvii una richiesta di corrispondenza dei dati creando una Query di analisi di cloud privato Match 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 dagli utenti sottoposti ad hashing per creare e aggiornare le tabelle di corrispondenza.
   • Consulta Importa i dati proprietari
3. Query in corso in Ads Data Hub, basate sui dati corrispondenti
   • Puoi eseguire query sulle tabelle delle corrispondenze nello stesso modo in cui esegui le query normali in Ads Data Hub. Consulta Esegui query sui dati corrispondenti.

Scopri di più sui requisiti di privacy

Raccogliere i dati dei clienti

Quando utilizzi la corrispondenza dei dati forniti dagli utenti, devi caricare dati proprietari. Potrebbe trattarsi di informazioni raccolte dai tuoi siti web, dalle tue app e dai tuoi negozi fisici o di qualsiasi informazione che un cliente ha condiviso direttamente con te.

Devi:

• Assicurati che le tue norme sulla privacy segnalino la condivisione dei dati dei clienti con terze parti che forniscono servizi per tuo conto e di ottenere il consenso per questa condivisione, ove legalmente richiesto.
• 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

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 condivisi 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).

Dimensioni dei dati

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

• Devi caricare almeno 1000 record nell'elenco di utenti.

Configura l'acquisizione dei dati

Prima di iniziare, assicurati che:

• I tuoi dati proprietari devono essere in BigQuery. Se hai un perimetro VPC-SC, questi dati proprietari devono trovarsi all'interno del VPC-SC.
• Il tuo service account Ads Data Hub deve disporre dell'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, Private Cloud Match non prevede ulteriori passaggi di onboarding. Se puoi eseguire una query di analisi, puoi eseguire una query Private Cloud Match.

Importa e abbina i dati proprietari

Autorizzazioni di origine e requisiti di connessione

Ads Data Hub Connections utilizza il service account mostrato in Impostazioni > Dettagli > Service account (di solito service-<number>@gcp-sa-adsdatahub.iam.gserviceaccount.com). Concedigli questi ruoli:

• Origine BigQuery: roles/bigquery.dataViewer (BigQuery Data Viewer) sul set di dati o sulla tabella di origine.
• Origine Cloud Storage: roles/storage.objectViewer (Storage Object Viewer) sul bucket o sull'oggetto di origine.
• Destinazione di importazione dei dati proprietari:roles/bigquery.dataEditor (BigQuery Data Editor) nel set di dati di destinazione, se la tabella non si trova nel set di dati predefinito.

Requisiti per i campi e i tipi di dati

1. Corrispondenza dei dati forniti dagli utenti (UPDM):
   • Mappa user_id più almeno un campo PII (email, phone o indirizzo completo: first_name, last_name, country, zip_code).
   • user_id, country e zip_code: STRING in testo normale (non sottoposto ad hashing). Per un'origine BigQuery, queste colonne devono essere già STRING; altri tipi (ad esempio INT64) non riescono quando viene creata la connessione. Connections esegue il cast di user_id in BYTES nella tabella di corrispondenza. country deve essere un codice ISO 3166-1 alpha-2 di due lettere.
   • email, phone, first_name e last_name: HASH deve essere già sottoposto ad hashing SHA-256 e codificato in Base64 (è accettato anche un valore SHA-256 esadecimale di 64 caratteri). Connections non esegue l'hashing dei dati. I valori in testo normale non vengono rilevati quando viene creata la connessione; ogni esecuzione non va a buon fine con ... must be encoded using TO_BASE64(SHA256(...)).
   • Le connessioni di corrispondenza dei dati forniti dagli utenti non hanno una tabella di destinazione. Tutti gli account e le query UPDM eseguite manualmente scrivono negli stessi dati di corrispondenza, quindi ogni esecuzione sostituisce quella precedente. È sufficiente una connessione UPDM per account.
   • Consulta Formatta i dati per l'input per le regole per campo.
2. Importazione di dati proprietari:
   • Utilizza solo i tipi di dati offerti nell'interfaccia utente: INTEGER, STRING, HASH, DOUBLE, DATE e TIMESTAMP. Gli altri tipi di BigQuery non sono supportati.
   • Origine BigQuery: il tipo mappato non viene applicato; ogni colonna di destinazione mantiene il tipo della colonna di origine.
   • Origine Cloud Storage: le colonne vengono lette come STRING e viene eseguito il cast al tipo mappato. I valori di cui non è possibile eseguire il cast diventano NULL senza che l'esecuzione non vada a buon fine.
   • Ogni esecuzione sostituisce l'intera tabella di destinazione, non aggiunge dati. Se l'origine non contiene righe, la destinazione diventa vuota. Non utilizzare come destinazione la tabella di origine o una tabella i cui dati devono essere conservati.

Requisiti delle colonne CSV di Cloud Storage

• Includi una riga di intestazione. La prima riga viene saltata e i nomi delle colonne non vengono utilizzati.
• Il file deve contenere esattamente le colonne di origine mappate, né più né meno. Le colonne aggiuntive causano l'errore dell'esecuzione.
• Importazione di dati proprietari:le colonne devono essere nello stesso ordine delle mappature dei campi.
• Corrispondenza dei dati forniti dagli utenti:le colonne devono essere in questo ordine, mantenendo solo i campi mappati: user_id, email, phone, first_name, last_name, country, zip_code. L'ordine delle righe di mappatura non è importante.
• Un ordine delle colonne diverso non viene rilevato: i valori vengono caricati nei campi sbagliati (o i tassi di corrispondenza diminuiscono) senza un errore.

Origini dati supportate e limiti di connessione

• Origini dati: sono supportate solo le origini BigQuery e Cloud Storage.
• Nomi delle tabelle BigQuery:le tabelle BigQuery di origine e di destinazione devono avere il nome project.dataset.table completo.
• Percorsi file di Cloud Storage: fornisci un singolo URI file (ad esempio gs://bucket/path/file.csv). I percorsi con caratteri jolly * o ? non sono supportati.
• Nomi delle connessioni:ogni connessione in un account deve avere un nome univoco.

Formatta i dati per l'input

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

• Dove indicato nelle seguenti descrizioni dei campi di immissione, devi caricare i dati utilizzando l'hashing SHA256.
• UPDM supporta la codifica Base64. Consulta TO_BASE64.
• I campi di immissione devono essere formattati come stringhe. Ad esempio, se utilizzi la funzione hash SHA256 di BigQuery, utilizza la seguente trasformazione: TO_BASE64(SHA256(user_data)).

Convalida dell'hash e codifica dei dati

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

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

  async function hash(token) {
    // Removes leading or trailing spaces and converts all characters to lowercase.
    const formattedToken = token.trim().toLowerCase();
    // Hashes the formatted string using the SHA-256 hashing algorithm.
    const hashBuffer = await crypto.subtle.digest(
        'SHA-256', (new TextEncoder()).encode(formattedToken));
    // Converts the hash buffer to a base64-encoded string and returns it.
    const base64Str = btoa(String.fromCharCode(...new Uint8Array(hashBuffer)));
    return base64Str;
  }

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

    // Expected hash for +18005551212:
    // YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
    hash('+18005551212').then(result => console.log(result));

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

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

  main()

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

  Supports: Python 2, Python 3

  Sample hashes:

    - Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
    - Phone '+18005551212':   YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
    - First name 'John':      ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
    - Last name 'Doe':        eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
  """

  import base64
  import hashlib

  def hash(token):
  # Generates a base64-encoded SHA-256 hash of a normalized input string.
    return base64.b64encode(
        hashlib.sha256(
            token.strip().lower().encode('utf-8')).digest()).decode('utf-8')

  def print_hash(token, expected=None):
  # Computes and displays the hash of a token, with optional validation.
    hashed = hash(token)

    if expected is not None and hashed != expected:
      print(
          'ERROR: Incorrect hash for token "{}". Expected "{}", got "{}"'.format(
              token, expected, hashed))
      return

    print('Hash: "{}"\t(Token: {})'.format(hashed, token))

  def main():
  # Tests the hash function with sample tokens and expected results.
    print_hash(
        'test@gmail.com', expected='h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=')
    print_hash(
        '+18005551212', expected='YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=')
    print_hash('John', expected='ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=')
    print_hash('Doe', expected='eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=')

  if __name__ == '__main__':
    main()

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

  Sample hashes:

    - Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
    - Phone '+18005551212':   YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
    - First name 'John':      ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
    - Last name 'Doe':        eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
  */
  package main

  import (
    "crypto/sha256"
    "encoding/base64"
    "fmt"
    "strings"
  )

  // Hash hashes an email, phone, first name, or last name into the correct format.
  func Hash(token string) string {
    formatted := strings.TrimSpace(strings.ToLower(token))
    hashed := sha256.Sum256([]byte(formatted))
    encoded := base64.StdEncoding.EncodeToString(hashed[:])
    return encoded
  }

  // PrintHash prints the hash for a token.
  func PrintHash(token string) {
    fmt.Printf("Hash: \"%s\"\t(Token: %s)\n", Hash(token), token)

  }

  func main() {
    PrintHash("test@gmail.com")
    PrintHash("+18005551212")
    PrintHash("John")
    PrintHash("Doe")
  }

  package updm.hashing;

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

  import java.security.MessageDigest;
  import java.security.NoSuchAlgorithmException;
  import java.util.Base64;

  /**
  * Example of the hashing algorithm.
  *
  * <p>Sample hashes:
  *
  * <ul>
  *   <li>Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
  *   <li>Phone '+18005551212': YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
  *   <li>First name 'John': ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
  *   <li>Last name 'Doe': eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
  * </ul>
  */
  public final class HashExample {

  private HashExample() {}

  public static String hash(String token) {
    // Normalizes and hashes the input token using SHA-256 and Base64 encoding.
    String formattedToken = token.toLowerCase().strip();

    byte[] hash;
    try {
      hash = MessageDigest.getInstance("SHA-256").digest(formattedToken.getBytes(UTF_8));
    } catch (NoSuchAlgorithmException e) {
      throw new IllegalStateException("SHA-256 not supported", e);
    }

    return Base64.getEncoder().encodeToString(hash);
  }

  public static void printHash(String token) {
    // Calculates and prints the hash for the given token.
    System.out.printf("Hash: \"%s\"\t(Token: %s)\n", hash(token), token);
  }

  public static void main(String[] args) {
    // Executes hash calculations and prints results for sample tokens.
    printHash("test@gmail.com");
    printHash("+18005551212");
    printHash("John");
    printHash("Doe");
  }
  }

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

  The following code uses Google Standard SQL and can be run on BigQuery to generate match tables from unhashed data.

  Sample hashes:

    - Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
    - Phone '+18005551212':   YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
    - First name 'John':      ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
    - Last name 'Doe':        eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=

  The unhashed input table schema is assumed to be:

  - Column name: UserID, Type: String
  - Column name: Email, Type: String
  - Column name: Phone, Type: String
  - Column name: FirstName, Type: String
  - Column name: LastName, Type: String
  - Column name: PostalCode, Type: String
  - Column name: CountryCode, Type: String
  */

  -- Creates a new table with Base64-encoded SHA-256 hashes of specified columns.
  CREATE TABLE `your_project_name.your_dataset_name.output_hashed_table_name`
  AS
  SELECT
    UserID,
    TO_BASE64(SHA256(LOWER(Email))) AS Email,
    TO_BASE64(SHA256(Phone)) AS Phone,
    TO_BASE64(SHA256(LOWER(FirstName))) AS FirstName,
    TO_BASE64(SHA256(LOWER(LastName))) AS LastName,
    PostalCode,
    CountryCode,
  FROM
    `your_project_name.your_dataset_name.input_unhashed_table_name`;

Chiavi di unione

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

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

Crea una tabella di corrispondenza

1. Fai clic su add Crea > Query.

2. Copia il modello di query Generazione della tabella delle corrispondenze nel cloud privato e incollalo nell'editor di query. (Facoltativo) Puoi utilizzare il modello Generazione della tabella delle corrispondenze nel cloud privato (con hashing) se i tuoi dati non sono già sottoposti ad hashing.

   /* Private cloud match table generation
   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`
   );
   

   /* Private cloud match table generation (with 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,
         TO_BASE64(SHA256(LOWER(@email))) AS email,
         TO_BASE64(SHA256(@phone)) AS phone,
         TO_BASE64(SHA256(LOWER(@first_name))) AS first_name,
         TO_BASE64(SHA256(LOWER(@last_name))) AS last_name,
         @country_code AS country,
         @postal_code AS zip_code
   FROM `@my_project.@my_dataset.@my_first_party_table`
   );
   

3. Sostituisci i nomi dei parametri con i nomi delle colonne per fornire l'aliasing corretto.

4. Fai clic su Salva.

5. Fai clic su Esegui. Devi eseguire manualmente questa query per aggiornare la tabella di corrispondenza. Ogni esecuzione sovrascriverà la tabella delle corrispondenze corrente.

Esegui la migrazione delle connessioni esistenti

I collegamenti esistenti nella scheda Collegamenti verranno spostati in un'esperienza di collegamento aggiornata integrata direttamente in Ads Data Hub. Le connessioni aggiornate leggono le origini e scrivono le destinazioni utilizzando il service account mostrato in Impostazioni > Dettagli > Service account (di solito service-<number>@gcp-sa-adsdatahub.iam.gserviceaccount.com) anziché i service account legacy di Data Fusion, Dataproc e UPDM.

Completa queste attività prima che le tue connessioni vengano spostate:

1. Concedi le autorizzazioni per il service account: concedi al service account mostrato in Impostazioni > Dettagli > Service account (di solito service-<number>@gcp-sa-adsdatahub.iam.gserviceaccount.com) i ruoli di origine e di destinazione richiesti (roles/bigquery.dataViewer, roles/storage.objectViewer e roles/bigquery.dataEditor sui set di dati di destinazione non predefiniti). Le connessioni con origini illeggibili, eliminate o modificate potrebbero comunque essere spostate (soprattutto le origini Cloud Storage, che non vengono convalidate al momento dello spostamento), ma le esecuzioni non andranno a buon fine finché non concedi l'accesso o correggi l'origine.
2. Converti le connessioni non supportate: non verrà eseguita la migrazione delle connessioni con le seguenti configurazioni. Convertile in connessioni BigQuery o Cloud Storage supportate:
   • Altre origini dati (Amazon S3, Snowflake, MySQL, PostgreSQL, Amazon Redshift, sFTP o Salesforce): prepara i dati in BigQuery o Cloud Storage, quindi crea una connessione BigQuery o Cloud Storage.
   • Mappature dei campi o tipi di dati non supportati:aggiorna o ricrea la connessione per soddisfare i requisiti dei campi e dei tipi di dati.
   • Percorsi con caratteri jolly di Cloud Storage (* o ?): sostituisci l'URI con caratteri jolly con un URI di un singolo file o carica prima i file in BigQuery.
   • Nomi di connessione duplicati:rinomina o elimina le connessioni duplicate in modo che ogni connessione nell'account abbia un nome univoco.
3. Elimina le connessioni inutilizzate:elimina le connessioni obsolete che non ti servono più.

Esegui query sui dati con corrispondenza

Esegui 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 (1PD) è rappresentata da my_data. Sono inclusi sia i dati che consentono l'identificazione personale (PII) sia quelli che non la consentono. L'utilizzo della tabella originale può migliorare i report con più 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. Tabelle delle corrispondenze separate vengono create per 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.

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 dell'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.

Query di esempio

Conteggio degli utenti corrispondenti

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

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

SELECT COUNT(DISTINCT user_id)
FROM adh.google_ads_impressions_updm

Calcola il tasso di corrispondenza

Non tutti gli utenti sono idonei per la corrispondenza. Ad esempio, gli utenti che non hanno eseguito l'accesso, i bambini e gli utenti che hanno negato il consenso non vengono abbinati tramite UPDM. Puoi utilizzare il campo is_updm_eligible per calcolare tassi di corrispondenza UPDM più precisi. Tieni presente che il campo is_updm_eligible è disponibile 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)

Unisci i dati proprietari e i dati pubblicitari di Google Ads

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