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.
Panoramica della scheda Connessioni
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. La pagina Connessioni in Ads Data Hub semplifica questo processo fornendo un'interfaccia guidata passo passo per importare, trasformare e abbinare i dati pubblicitari in BigQuery, in modo da poterli utilizzare nelle query di Ads Data Hub o in qualsiasi altro prodotto che legge da BigQuery. 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.
La pagina Connessioni è creata con strumenti che ti consentono di criptare e condividere informazioni che consentono l'identificazione personale (PII) con i partner in modo rispettoso della privacy. Dopo aver selezionato le colonne che contengono PII, Ads Data Hub cripta i dati, garantendo che i tuoi dati proprietari possano essere esportati o letti solo da persone che dispongono dell'autorizzazione. Sapere quali dati proprietari sono necessari per il tuo caso d'uso di misurazione o attivazione può essere difficile, quindi Ads Data Hub fornisce un elenco completo di casi d'uso predefiniti, quindi ti guida nell'intera esperienza di estrazione, trasformazione e caricamento dei dati. Sebbene sia possibile creare più tipi di connessioni, questo documento presuppone che tu stia utilizzando la pagina Connessioni per la corrispondenza dei dati forniti dall'utente.
Origini dati proprietari supportate
Puoi importare dati da queste origini dati:
- BigQuery
- Cloud Storage
- FTP protetto (SFTP)
- Snowflake
- MySQL
- PostgreSQL
- Amazon Redshift
- Amazon S3
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.
Apprendi la terminologia
- Connessione dei dati forniti dall'utente:configura una connessione dei dati forniti dall'utente per importare e abbinare i dati, pianificare le importazioni di dati, trasformare i dati e abbinare i dati pubblicitari utilizzando un ID utente. L'evento dell'annuncio deve essere collegato a un utente che ha eseguito l'accesso nei dati pubblicitari di Google. Richiede più progetti Google Cloud.
- Connessione dei dati proprietari:configura una connessione dei dati proprietari come strumento di preparazione dei dati per pianificare le importazioni di dati e trasformarli senza le funzionalità avanzate di UPDM. Questo tipo di connessione richiede un solo progetto Google Cloud.
- Origine dati:un prodotto collegato, un file importato o un'integrazione di terze parti, ad esempio BigQuery.
- Destinazione:un caso d'uso; in genere, una funzionalità di prodotto o un prodotto Google in cui sono attivati i dati importati, ad esempio la corrispondenza dei dati forniti dall'utente di Ads Data Hub.
- Progetto amministrativo:il progetto Google Cloud che contiene i tuoi dati pubblicitari proprietari nel formato non elaborato.
- Set di dati di output:il set di dati BigQuery in cui scrive Ads Data Hub. Per impostazione predefinita, si tratta di un set di dati nel progetto amministratore. Per modificarlo e impostare un altro progetto Google Cloud, consulta Configurare i service account.
Riepilogo della procedura
- Configurazione dell'importazione e della corrispondenza dei dati
- Tu concedi le autorizzazioni richieste ai service account nel tuo progetto amministrativo. Vedi Configurare l'importazione dei dati.
- Importazione e corrispondenza dei dati proprietari
- Tu formatti e carichi i dati proprietari nel tuo set di dati BigQuery. Per una configurazione più semplice, utilizza il progetto amministrativo. Tuttavia, puoi utilizzare qualsiasi set di dati BigQuery di tua proprietà.
- Tu avvii una richiesta di corrispondenza dei dati creando una connessione e impostando una pianificazione di importazione.
- 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
- 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
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.
- Ogni aggiornamento riuscito della tabella delle corrispondenze deve includere un numero minimo di nuovi utenti corrispondenti. Questo comportamento è simile ai controlli delle differenze.
- L'elenco non deve superare il numero massimo di record. Per informazioni sul limite massimo di dati, contatta il tuo rappresentante di Google.
Configura l'importazione dei dati
Prima di iniziare, devi configurare il tuo account Ads Data Hub per creare connessioni ai dati, che è il modo in cui stabilirai la pipeline di corrispondenza dei dati. Devi eseguire questi passaggi una sola volta.
Nella pagina Connessioni, fai clic su Inizia configurazione per aprire la procedura guidata di configurazione dell'account nella fase di attivazione di UPDM.
Quali autorizzazioni vengono concesse per BigQuery e Cloud Storage?
Se configuri UPDM per l'utilizzo con BigQuery o Cloud Storage, utilizza questo riferimento per comprendere le autorizzazioni concesse agli account di servizio Ads Data Hub.
BigQuery
| Account di servizio Data Fusion | |||||||||
| Finalità | L'account di servizio Data Fusion viene utilizzato per visualizzare un elenco di campi di origine nell'interfaccia utente di Ads Data Hub. | ||||||||
| Formato | service-some-number@gcp-sa-datafusion.iam.gserviceaccount.com |
||||||||
| Accesso richiesto |
|
||||||||
| Service account Dataproc | |||||||||
| Finalità | L'account di servizio Dataproc è responsabile dell'esecuzione delle pipeline di dati in background. | ||||||||
| Formato | some-number-compute@developer.gserviceaccount.com |
||||||||
| Accesso richiesto |
|
||||||||
| Service account UPDM | |||||||||
| Finalità | Il service account UPDM viene utilizzato per eseguire il job di corrispondenza. | ||||||||
| Formato | service-some-number@gcp-sa-adsdataconnector.iam.gserviceaccount.com |
||||||||
| Accesso richiesto |
|
||||||||
Cloud Storage
| Account di servizio Data Fusion | |||||||
| Finalità | L'account di servizio Data Fusion viene utilizzato per visualizzare un elenco di campi di origine nell'interfaccia utente di Ads Data Hub. | ||||||
| Formato | service-some-number@gcp-sa-datafusion.iam.gserviceaccount.com |
||||||
| Accesso richiesto |
|
||||||
| Service account Dataproc | |||||||
| Finalità | L'account di servizio Dataproc è responsabile dell'esecuzione delle pipeline di dati in background. | ||||||
| Formato | some-number-compute@developer.gserviceaccount.com |
||||||
| Accesso richiesto |
|
||||||
| Service account UPDM | |||||||
| Finalità | Il service account UPDM viene utilizzato per eseguire il job di corrispondenza. | ||||||
| Formato | service-some-number@gcp-sa-adsdataconnector.iam.gserviceaccount.com |
||||||
| Accesso richiesto |
|
||||||
Altre origini dati
Non necessario per altre origini dati
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 Base16
(TO_HEX),
utilizza la seguente trasformazione:
TO_HEX(SHA256(user_data)). - UPDM supporta la codifica Base16 e Base64. Devi allineare la codifica dei tuoi dati proprietari alla decodifica utilizzata nella query Ads Data Hub. Se modifiche la codifica dei dati proprietari, devi aggiornare la query Ads Data Hub per decodificare dalla stessa base. Gli esempi seguenti utilizzano la codifica Base16.
ID utente
- Testo normale
- Hashing: nessuno
- 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.comegooglemail.com. - Hashing: SHA256 con codifica Base16
Valido: TO_HEX(SHA256("jeffersonloveshiking@gmail.com"))
Non valido: TO_HEX(SHA256("JéffersonLôvesHiking@gmail.com"))
Telefono
- Rimuovi spazio vuoto
- Formato E.164. Ad esempio, Stati Uniti: +14155552671, Regno Unito: +442071838750
- Rimuovi tutti i caratteri speciali, tranne il segno "+" prima del codice paese.
- Hashing: SHA256 con codifica Base16
Valido: TO_HEX(SHA256("+18005550101"))
Non valido: TO_HEX(SHA256("(800) 555-0101"))
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 Base16
Valido: TO_HEX(SHA256("daní"))
Non valido: TO_HEX(SHA256("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 Base16
Valido: TO_HEX(SHA256("delacruz"))
Non valido: TO_HEX(SHA256("de 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
Base16
/**
* @fileoverview Provides the hashing algorithm for User-Provided Data Match, as
* well as some valid hashes of sample data for testing.
*/
async function hash(token) {
// Removes leading or trailing spaces and converts all characters to lowercase.
const formattedToken = token.trim().toLowerCase();
// Hashes the formatted string using the SHA-256 hashing algorithm.
const hashArrayBuffer = await crypto.subtle.digest(
'SHA-256', (new TextEncoder()).encode(formattedToken));
// Converts the hash buffer to a hexadecimal string.
return Array.from(new Uint8Array(hashArrayBuffer))
.map((b) => b.toString(16).padStart(2, '0'))
.join('');
}
function main() {
// Expected hash for test@gmail.com:
// 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674
hash('test@gmail.com').then(result => console.log(result));
// Expected hash for +18005551212:
// 61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44
hash('+18005551212').then(result => console.log(result));
// Expected hash for John:
// 96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a
hash('John').then(result => console.log(result));
// Expected hash for Doe:
// 799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f
hash('Doe').then(result => console.log(result));
}
main()
Base64
/**
* @fileoverview Provides the hashing algorithm, as well as some valid hashes of
* sample data for testing.
*/
async function hash(token) {
// Removes leading or trailing spaces and converts all characters to lowercase.
const formattedToken = token.trim().toLowerCase();
// Hashes the formatted string using the SHA-256 hashing algorithm.
const hashBuffer = await crypto.subtle.digest(
'SHA-256', (new TextEncoder()).encode(formattedToken));
// Converts the hash buffer to a base64-encoded string and returns it.
const base64Str = btoa(String.fromCharCode(...new Uint8Array(hashBuffer)));
return base64Str;
}
function main() {
// Expected hash for test@gmail.com:
// h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
hash('test@gmail.com').then(result => console.log(result));
// Expected hash for +18005551212:
// YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
hash('+18005551212').then(result => console.log(result));
// Expected hash for John: ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
hash('John').then(result => console.log(result));
// Expected hash for Doe: eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
hash('Doe').then(result => console.log(result));
}
main()
Python
Base16
"""Provides the hashing algorithm, as well as some valid hashes of sample data for testing.
Supports: Python 2, Python 3
Sample hashes:
- Email 'test@gmail.com': 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674
- Phone '+18005551212': 61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44
- First name 'John': 96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a
- Last name 'Doe': 799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f
"""
import base64
import hashlib
def updm_hash(token):
# Generates a SHA-256 hash of the input token after normalization.
return hashlib.sha256(token.strip().lower().encode('utf-8')).hexdigest()
def print_updm_hash(token):
# Prints the SHA-256 hash and the original token.
print('Hash: "{}"\t(Token: {})'.format(updm_hash(token), token))
def main():
# Hashes and prints sample tokens.
print_updm_hash('test@gmail.com')
print_updm_hash('+18005551212')
print_updm_hash('John')
print_updm_hash('Doe')
if __name__ == '__main__':
main()
Base64
"""Provides the hashing algorithm, as well as some valid hashes of sample data for testing.
Supports: Python 2, Python 3
Sample hashes:
- Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
- Phone '+18005551212': YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
- First name 'John': ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
- Last name 'Doe': eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
"""
import base64
import hashlib
def hash(token):
# Generates a base64-encoded SHA-256 hash of a normalized input string.
return base64.b64encode(
hashlib.sha256(
token.strip().lower().encode('utf-8')).digest()).decode('utf-8')
def print_hash(token, expected=None):
# Computes and displays the hash of a token, with optional validation.
hashed = hash(token)
if expected is not None and hashed != expected:
print(
'ERROR: Incorrect hash for token "{}". Expected "{}", got "{}"'.format(
token, expected, hashed))
return
print('Hash: "{}"\t(Token: {})'.format(hashed, token))
def main():
# Tests the hash function with sample tokens and expected results.
print_hash(
'test@gmail.com', expected='h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=')
print_hash(
'+18005551212', expected='YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=')
print_hash('John', expected='ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=')
print_hash('Doe', expected='eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=')
if __name__ == '__main__':
main()
Go
Base16
/*
Provides the hashing algorithm, as well as some valid hashes of sample data for testing.
Sample hashes:
- Email 'test@gmail.com': 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674
- Phone '+18005551212': 61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44
- First name 'John': 96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a
- Last name 'Doe': 799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f
*/
package main
import (
"crypto/sha256"
"fmt"
"strings"
)
// Hash hashes an email, phone, first name, or last name into the correct format.
func Hash(token string) string {
formatted := strings.TrimSpace(strings.ToLower(token))
hashed := sha256.Sum256([]byte(formatted))
encoded := fmt.Sprintf("%x", hashed[:])
return encoded
}
// PrintHash prints the hash for a token.
func PrintHash(token string) {
fmt.Printf("Hash: \"%s\"\t(Token: %s)\n", Hash(token), token)
}
func main() {
PrintHash("test@gmail.com")
PrintHash("+18005551212")
PrintHash("John")
PrintHash("Doe")
}
Base64
/*
Provides the hashing algorithm, as well as some valid hashes of sample data for testing.
Sample hashes:
- Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
- Phone '+18005551212': YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
- First name 'John': ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
- Last name 'Doe': eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
*/
package main
import (
"crypto/sha256"
"encoding/base64"
"fmt"
"strings"
)
// Hash hashes an email, phone, first name, or last name into the correct format.
func Hash(token string) string {
formatted := strings.TrimSpace(strings.ToLower(token))
hashed := sha256.Sum256([]byte(formatted))
encoded := base64.StdEncoding.EncodeToString(hashed[:])
return encoded
}
// PrintHash prints the hash for a token.
func PrintHash(token string) {
fmt.Printf("Hash: \"%s\"\t(Token: %s)\n", Hash(token), token)
}
func main() {
PrintHash("test@gmail.com")
PrintHash("+18005551212")
PrintHash("John")
PrintHash("Doe")
}
Java
Base16
package updm.hashing;
import static java.nio.charset.StandardCharsets.UTF_8;
import com.google.common.base.Ascii;
import com.google.common.hash.Hashing;
/**
* Example of the UPDM hashing algorithm using hex-encoded SHA-256.
*
* <p>This uses the Guava Hashing to generate the hash: https://github.com/google/guava
*
* <p>Sample valid hashes:
*
* <ul>
* <li>Email "test@gmail.com": "87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674"
* <li>Phone "+18005551212": "61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44"
* <li>First name "John": "96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a"
* <li>Last name "Doe": "799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f"
* </ul>
*/
public final class HashExample {
private HashExample() {}
public static String hash(String token) {
// Normalizes and hashes the input token.
String formattedToken = Ascii.toLowerCase(token).strip();
return Hashing.sha256().hashString(formattedToken, UTF_8).toString();
}
public static void printHash(String token) {
// Calculates and prints the token's hash.
System.out.printf("Hash: \"%s\"\t(Token: %s)\n", hash(token), token);
}
public static void main(String[] args) {
// Executes hash calculations and prints results for sample tokens.
printHash("test@gmail.com");
printHash("+18005551212");
printHash("John");
printHash("Doe");
}
}
Base64
package updm.hashing;
import static java.nio.charset.StandardCharsets.UTF_8;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
/**
* Example of the hashing algorithm.
*
* <p>Sample hashes:
*
* <ul>
* <li>Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
* <li>Phone '+18005551212': YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
* <li>First name 'John': ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
* <li>Last name 'Doe': eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
* </ul>
*/
public final class HashExample {
private HashExample() {}
public static String hash(String token) {
// Normalizes and hashes the input token using SHA-256 and Base64 encoding.
String formattedToken = token.toLowerCase().strip();
byte[] hash;
try {
hash = MessageDigest.getInstance("SHA-256").digest(formattedToken.getBytes(UTF_8));
} catch (NoSuchAlgorithmException e) {
throw new IllegalStateException("SHA-256 not supported", e);
}
return Base64.getEncoder().encodeToString(hash);
}
public static void printHash(String token) {
// Calculates and prints the hash for the given token.
System.out.printf("Hash: \"%s\"\t(Token: %s)\n", hash(token), token);
}
public static void main(String[] args) {
// Executes hash calculations and prints results for sample tokens.
printHash("test@gmail.com");
printHash("+18005551212");
printHash("John");
printHash("Doe");
}
}
SQL
Base16
/*
Provides the hashing algorithm, as well as some valid hashes of sample data for testing.
The following code uses Google Standard SQL and can be run on BigQuery to generate match tables from unhashed data.
Sample hashes:
- Email 'test@gmail.com': 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674
- Phone '+18005551212': 61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44
- First name 'John': 96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a
- Last name 'Doe': 799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f
The unhashed input table schema is assumed to be:
- Column name: UserID, Type: String
- Column name: Email, Type: String
- Column name: Phone, Type: String
- Column name: FirstName, Type: String
- Column name: LastName, Type: String
- Column name: PostalCode, Type: String
- Column name: CountryCode, Type: String
*/
-- Creates a new table with hashed versions of specified columns from the input table.
CREATE TABLE `your_project_name.your_dataset_name.output_hashed_table_name`
AS
SELECT
UserID,
TO_HEX(SHA256(LOWER(Email))) AS Email,
TO_HEX(SHA256(Phone)) AS Phone,
TO_HEX(SHA256(LOWER(FirstName))) AS FirstName,
TO_HEX(SHA256(LOWER(LastName))) AS LastName,
PostalCode,
CountryCode,
FROM
`your_project_name.your_dataset_name.input_unhashed_table_name`;
Base64
/*
Provides the hashing algorithm, as well as some valid hashes of sample data for testing.
The following code uses Google Standard SQL and can be run on BigQuery to generate match tables from unhashed data.
Sample hashes:
- Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
- Phone '+18005551212': YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
- First name 'John': ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
- Last name 'Doe': eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
The unhashed input table schema is assumed to be:
- Column name: UserID, Type: String
- Column name: Email, Type: String
- Column name: Phone, Type: String
- Column name: FirstName, Type: String
- Column name: LastName, Type: String
- Column name: PostalCode, Type: String
- Column name: CountryCode, Type: String
*/
-- Creates a new table with Base64-encoded SHA-256 hashes of specified columns.
CREATE TABLE `your_project_name.your_dataset_name.output_hashed_table_name`
AS
SELECT
UserID,
TO_BASE64(SHA256(LOWER(Email))) AS Email,
TO_BASE64(SHA256(Phone)) AS Phone,
TO_BASE64(SHA256(LOWER(FirstName))) AS FirstName,
TO_BASE64(SHA256(LOWER(LastName))) AS LastName,
PostalCode,
CountryCode,
FROM
`your_project_name.your_dataset_name.input_unhashed_table_name`;
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.
- Email, telefono, indirizzo (più forte)
- Telefono, indirizzo
- Email, indirizzo
- Email, telefono
- Indirizzo
- Telefono
- Email (più debole)
Creare una tabella delle corrispondenze
- Fai clic su Connessioni > Crea connessione > Corrispondenza dei dati forniti dall'utente.
- Scegli un'origine dati, quindi fai clic su Connetti.
- Esegui l'autenticazione, se richiesto, quindi fai clic su Avanti:
BigQuery
Fai clic su Applica per concedere l'accesso a BigQuery.
Cloud Storage
Fai clic su Applica per concedere l'accesso a Cloud Storage.
MySQL
Inserisci la posizione, la porta, il nome utente e la password del database MySQL.
S3
Inserisci la chiave di accesso segreta di Amazon S3.
PostgreSQL
Inserisci la posizione, la porta, il nome utente, la password e il database del database PostgreSQL.
Redshift
Inserisci la posizione, la porta, il nome utente, la password e il database del database Redshift.
sFTP
Inserisci la posizione, il nome utente e la password del server SFTP.
Snowflake
Inserisci l'identificatore dell'account Snowflake, il nome utente e la password.
- Configura l'origine dati, poi fai clic su Avanti:
BigQuery
Seleziona la tabella BigQuery da importare.
Cloud Storage
Inserisci il percorso gsutil, ad esempio
gs://my-bucket/folder/e seleziona la formattazione del file.Se è la prima volta che connetti questa risorsa, viene visualizzato un avviso. Fai clic su Applica per concedere l'accesso e poi fai clic su Avanti. Nota: devi avere un ruolo con l'autorizzazione a delegare
storage.buckets.setIamPolicyper il bucket pertinente.MySQL
Seleziona il database e la tabella MySQL da utilizzare.
S3
Inserisci l'URI del file da caricare relativo all'indirizzo host.
PostgreSQL
Inserisci il nome dello schema e della tabella (o della vista) PostgreSQL.
Redshift
Inserisci il nome dello schema e della tabella (o della vista) Redshift. Per impostazione predefinita, Redshift utilizza gli URL delle posizioni del database che seguono questo modello:
cluster-identifier.account-number.aws-region.redshift.amazonaws.com.sFTP
Inserisci il percorso e il nome del file, formattati come
/PATH/FILENAME.csvSnowflake
Inserisci il database, lo schema e la tabella (o la vista) Snowflake da utilizzare.
- Seleziona un set di dati BigQuery da utilizzare come destinazione intermedia, poi fai clic su Avanti. Questo passaggio garantisce la corretta formattazione dei dati.
- (Facoltativo) Modifica il formato dei dati. Le trasformazioni includono l'hash di calcolo, la formattazione in minuscolo/maiuscolo e l'unione/divisione dei campi.
- Fai clic su Azione > > Trasforma.
- Nel riquadro visualizzato, fai clic su Aggiungi trasformazione o Aggiungi un'altra trasformazione.
- Scegli un tipo di trasformazione dal menu a discesa e inserisci i requisiti.
- Fai clic su Salva.
- Scegli almeno una chiave di unione e mappa i campi che utilizzerai. Ads Data Hub mapperà automaticamente i campi con nomi identici, indicati da un . Apporta le modifiche necessarie, quindi fai clic su Avanti.
- Imposta una pianificazione:
- Assegna un nome alla connessione.
- Imposta una frequenza, che determina la frequenza con cui i dati verranno importati nel set di dati selezionato nel passaggio precedente. Ogni esecuzione sovrascriverà i dati nella tabella destinazione.
- Specifica come vuoi che vengano gestite le collisioni degli ID utente. Puoi scegliere se mantenere la corrispondenza esistente o sovrascriverla con nuovi dati.
- Fai clic su Fine. In genere le tabelle delle corrispondenze sono pronte per le query 12 ore dopo la creazione.
Visualizzazione dei dettagli della connessione
La pagina dei dettagli della connessione fornisce informazioni sulle esecuzioni e sugli errori recenti di una determinata connessione. Per visualizzare i dettagli di una coincidenza specifica:
- Fai clic su Connessioni.
- Fai clic sul nome della connessione per visualizzarne i dettagli.
- Ora puoi visualizzare i dettagli e le esecuzioni recenti della connessione. Ognuno mostra due
possibili tipi di errori: a livello di connessione (la connessione non è stata eseguita) e
a livello di riga (una riga non è stata importata).
- Lo stato Non riuscito indica che l'intera connessione non è stata eseguita (ad es. problema di autorizzazione dell'account di servizio). Fai clic sullo stato dell'errore per vedere quali errori hanno influito sulla connessione.
- Lo stato Completato indica che la connessione è stata eseguita correttamente. Tuttavia, potrebbero essere ancora presenti errori a livello di riga, indicati da un valore diverso da zero nella colonna "Righe con errori". Fai clic sul valore per scoprire di più sui record non riusciti.
Modificare una connessione
È possibile modificare i seguenti dettagli:
- Nome connessione
- Pianificazione
- Tabella di destinazione
- Mappatura campi
La modifica dell'origine dati non è supportata. Per modificare un'origine dati, crea una nuova connessione ed elimina quella precedente.
Per modificare i dettagli della connessione:
- Fai clic su Connessioni.
- Fai clic sul nome della connessione da modificare.
- Modifica i dettagli che vuoi cambiare:
- Nome connessione: fai clic su Modifica, inserisci il nuovo nome e premi Invio.
- Pianificazione: fai clic su Modifica, imposta la nuova pianificazione e poi fai clic su Salva.
- Tabella di destinazione: fai clic su Modifica, inserisci il nuovo nome della destinazione e poi fai clic su Salva.
- Mappatura dei campi: fai clic su , apporta le modifiche ai campi, poi fai clic su Salva.
- Fai clic su .
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.
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.
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.