La corrispondenza dei dati forniti dall'utente (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, 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. Gli 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 pubblicitari di Google.
Questo documento descrive la funzionalità di corrispondenza dei dati forniti dall'utente e fornisce indicazioni sulla configurazione e sull'utilizzo.
Panoramica
Per ottenere informazioni pubblicitarie preziose, spesso è necessario unire i dati provenienti da più origini. La creazione di una soluzione personalizzata per questo problema della pipeline di dati richiede un investimento significativo in termini di tempo e di risorse ingegneristiche. La pagina Connessioni in Ads Data Hub semplifica questa procedura fornendo un'interfaccia guidata passo passo per l'importazione, la trasformazione e l'associazione dei dati a 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 è stata creata con strumenti che ti consentono di criptare e condividere informazioni che consentono l'identificazione personale (PII) con i partner in modo incentrato sulla privacy. Dopo aver selezionato le colonne contenenti PII, Ads Data Hub cripta i dati, garantendo che i dati proprietari possano essere esportati o letti solo da persone che dispongono dell'autorizzazione. È difficile sapere quali dati proprietari sono necessari per il tuo caso d'uso di misurazione o attivazione, pertanto Ads Data Hub fornisce un elenco completo di casi d'uso predefiniti e ti guida nell'intera esperienza di estrazione, trasformazione e caricamento dei dati. Sebbene sia possibile creare più tipi di connessioni, questo documento assume che tu stia utilizzando la pagina Connessioni per la corrispondenza dei dati forniti dall'utente.
Origini dati proprietari supportate
Puoi importare i dati da queste origini dati:
- BigQuery
- Cloud Storage
- SFTP (Secure FTP)
- Fiocco di neve
- 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é sono più resistenti ai cambiamenti del settore rispetto ai dati di terze parti, possono fornire approfondimenti più completi, che possono portare a un maggiore coinvolgimento dei clienti.
Apprendi la terminologia
- Connessione dati forniti dall'utente:configura una connessione dati forniti dall'utente per importare e abbinare i dati, pianificare le importazioni dei 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 dei 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 amministrazione: il progetto Google Cloud che contiene i tuoi dati pubblicitari di proprietà 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 tuo progetto amministratore. Per modificarlo in un altro progetto Google Cloud, consulta Configurare gli account di servizio.
Riepilogo della procedura
- Configurazione dell'importazione e della corrispondenza dei dati
- Tu concedi le autorizzazioni richieste agli account di servizio nel tuo progetto amministrativo. Vedi Configurare l'importazione dei dati.
- Importazione e corrispondenza dei dati proprietari
- Tu formatti e carichi i tuoi dati proprietari nel set di dati BigQuery. Per la configurazione più semplice, utilizza il tuo progetto amministratore. 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 dell'importazione.
- Google unisce i dati del tuo progetto a quelli di proprietà di Google contenente l'ID utente di Google e i dati forniti dall'utente sottoposti ad hashing per creare e aggiornare le tabelle delle corrispondenze.
- Consulta Importare i dati proprietari
- Query in corso in Ads Data Hub, in base ai dati corrispondenti
- Esegui query sulle tabelle delle corrispondenze nello stesso modo in cui esegui query regolari in Ads Data Hub. Consulta Eseguire query sui dati corrispondenti.
Informazioni sui requisiti relativi alla privacy
Raccolta dei dati dei clienti
Quando utilizzi la corrispondenza dei dati forniti dall'utente, devi caricare i dati proprietari. Potrebbero essere informazioni raccolte dai tuoi siti web, dalle tue app, dai tuoi negozi fisici o qualsiasi informazione che un cliente ha condiviso direttamente con te.
Devi:
- Assicurati che nelle tue norme sulla privacy sia indicato che i dati dei clienti vengono condivisi con terne 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).
Dimensioni dei dati
Per proteggere la privacy degli utenti finali, la corrispondenza dei dati forniti dall'utente applica i seguenti requisiti relativi alle dimensioni dei dati:
- Devi caricare almeno 1000 record nell'elenco di 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 di dati, in modo da stabilire la pipeline di corrispondenza dei dati. Dovrai seguire questa procedura soltanto una volta.
Nella pagina Connessioni, fai clic su Inizia la 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 l'UPDM per l'utilizzo con BigQuery o Cloud Storage, utilizza questa documentazione di 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 |
|
||||||||
| Account di servizio 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 |
|
||||||||
| Account di servizio UPDM | |||||||||
| Finalità | L'account di servizio 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 |
|
||||||
| Account di servizio 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 |
|
||||||
| Account di servizio UPDM | |||||||
| Finalità | L'account di servizio 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
Importa e abbina 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 riportate di seguito, devi eseguire il caricamento utilizzando l'hashing SHA256.
- I campi di immissione devono essere formattati come stringhe. Ad esempio, se utilizzi la funzione di hashing SHA256 di BigQuery con la funzione di codifica Base16 (TO_HEX), utilizza la seguente trasformazione:
TO_HEX(SHA256(user_data)). - UPDM supporta sia la codifica Base16 che la codifica Base64. Devi allineare la codifica dei tuoi dati proprietari alla decodifica utilizzata nella query di Ads Data Hub. Se modifichi la codifica dei dati proprietari, devi aggiornare la query di Ads Data Hub per decodificare dalla stessa base. Gli esempi riportati di seguito utilizzano la codifica Base16.
ID utente
- Testo normale
- Hashing: nessuno
- Eliminare gli spazi vuoti
- 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 sostituisci è, é, ê o ë con e
- Hashing: SHA256 con codifica Base16
Valido: TO_HEX(SHA256("jeffersonloveshiking@gmail.com"))
Non valido: TO_HEX(SHA256("JéffersonLôvesHiking@gmail.com"))
Telefono
- Eliminare gli spazi vuoti
- Formato in formato E.164, ad esempio, esempio per gli Stati Uniti: +14155552671, esempio per il Regno Unito: +442071838750
- Includi il codice paese (inclusi gli Stati Uniti)
- Rimuovi tutti i caratteri speciali tranne il "+" prima del codice paese
- Hashing: SHA256 con codifica Base16
Valido: TO_HEX(SHA256("+18005550101"))
Non valido: TO_HEX(SHA256("(800) 555-0101"))
Nome
- Elimina gli spazi vuoti
- Scrivi tutti i caratteri in minuscolo.
- Rimuovi tutti i prefissi, ad esempio Sig.ra.
- Non rimuovere gli accenti, ad esempio è, é, ê o ë
- Hashing: SHA256 con codifica Base16
Valido: TO_HEX(SHA256("daní"))
Non valido: TO_HEX(SHA256("Daní"))
Cognome
- Eliminare gli spazi vuoti
- Scrivi tutti i caratteri in minuscolo.
- Rimuovi tutti i prefissi, ad esempio Jr.
- 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 5 cifre, ad esempio 94043
- Sono consentiti anche i codici a cinque cifre seguiti da un'estensione a quattro cifre, ad esempio 94043-1351 o 940431351
- Per tutti gli altri paesi:
- Non è necessaria la formattazione (non è necessario usare le lettere minuscole 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) {
const formattedToken = token.trim().toLowerCase();
const hashArrayBuffer = await crypto.subtle.digest(
'SHA-256', (new TextEncoder()).encode(formattedToken));
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) {
const formattedToken = token.trim().toLowerCase();
const hashBuffer = await crypto.subtle.digest(
'SHA-256', (new TextEncoder()).encode(formattedToken));
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):
return hashlib.sha256(token.strip().lower().encode('utf-8')).hexdigest()
def print_updm_hash(token):
print('Hash: "{}"\t(Token: {})'.format(updm_hash(token), token))
def main():
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):
return base64.b64encode(
hashlib.sha256(
token.strip().lower().encode('utf-8')).digest()).decode('utf-8')
def print_hash(token, expected=None):
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():
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()
Vai
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) {
String formattedToken = Ascii.toLowerCase(token).strip();
return Hashing.sha256().hashString(formattedToken, UTF_8).toString();
}
public static void printHash(String token) {
System.out.printf("Hash: \"%s\"\t(Token: %s)\n", hash(token), token);
}
public static void main(String[] args) {
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) {
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) {
System.out.printf("Hash: \"%s\"\t(Token: %s)\n", hash(token), token);
}
public static void main(String[] args) {
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
*/
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
*/
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 relativa solidità. Se utilizzi un indirizzo, devi includere: nome, cognome, paese e codice postale.
- Email, telefono, indirizzo (più affidabile)
- Telefono, indirizzo
- Email, indirizzo
- Email, telefono
- Indirizzo
- Telefono
- Email (meno sicura)
Creare una tabella delle corrispondenze
- Fai clic su Connessioni > Crea connessione > Corrispondenza dei dati forniti dall'utente.
- Scegli un'origine dati e poi fai clic su Connetti.
- Se richiesto, esegui l'autenticazione e poi 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.
Fiocco di neve
Inserisci l'identificatore dell'account Snowflake, il nome utente e la password.
- Configura l'origine dati e 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 lo schema e il nome della tabella (o della vista) PostgreSQL.
Redshift
Inserisci lo schema e il nome 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, formattato come
/PATH/FILENAME.csvFiocco di neve
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 e poi fai clic su Avanti. Questo passaggio garantisce la corretta formattazione dei dati.
- (Facoltativo) Modifica il formato dei dati. Le trasformazioni includono il calcolo dell'hash, la formattazione in lettere minuscole/maiuscole e l'unione/la suddivisione 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 join e mappa i campi che utilizzerai. Ads Data Hub mappa automaticamente i campi con nomi identici, indicati da un . Apporta le modifiche necessarie, quindi fai clic su Avanti.
- Imposta una programmazione:
- Assegna un nome alla connessione.
- Imposta una frequenza che indichi 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 tra mantenere la corrispondenza esistente o sostituirla con nuovi dati.
- Fai clic su Fine. In genere, le tabelle delle corrispondenze sono pronte per essere sottoposte a query 12 ore dopo la loro 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 connessione specifica:
- Fai clic su Connessioni.
- Fai clic sul nome della connessione per visualizzarne i dettagli.
- Ora puoi vedere i dettagli della connessione e le esecuzioni recenti. 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).
- Uno stato Failed indica che l'intera connessione non è riuscita (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 saperne di più su quali record non sono riusciti.
Modificare una connessione
È possibile modificare i seguenti dettagli:
- Nome connessione
- Pianificazione
- Tabella di destinazione
- Mappatura dei 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 modificare:
- Nome connessione: fai clic su Modifica, inserisci il nuovo nome e premi Invio.
- Programma: 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 .
Esegui query sui dati corrispondenti
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 le informazioni 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 di corrispondenza.
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 isolate in conformità alle norme. Ad esempio, per la tabella adh.google_ads_impressions_policy_isolated_youtube, Ads Data Hub genera anche una tabella delle corrispondenze denominata adh.google_ads_impressions_policy_isolated_youtube_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
Contare gli 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
Questa query mostra come unire i dati proprietari ai dati 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 sul tasso di corrispondenza UPDM
Per un elenco di domande frequenti relative al tasso di corrispondenza UPDM, consulta Domande frequenti sul tasso di corrispondenza UPDM.