La mise en correspondance des données fournies par l'utilisateur associe les données first party que vous avez collectées sur un utilisateur, telles que les informations issues de vos sites Web, applications ou magasins physiques, à l'activité de ce même utilisateur (lorsqu'il est connecté) dans toutes les données sur les annonces Google, y compris les données détenues et gérées par Google. Cela inclut les données achetées via les produits Google Marketing Platform (GMP), par exemple, YouTube acheté via Display & Video 360. Les autres produits GMP qui ne sont pas détenus ni gérés par Google ne sont pas compatibles.
Pour être éligible à la MCDFU, l'événement d'annonce doit être associé à un utilisateur connecté dans les données sur les annonces Google.
Ce document décrit la fonctionnalité de mise en correspondance des données fournies par l'utilisateur et fournit des conseils sur la configuration et l'utilisation.
Présentation
Pour obtenir des insights publicitaires précieux, vous devez souvent assembler des données provenant de plusieurs sources. Créer votre propre solution à ce problème de pipeline de données nécessite un investissement en temps et en ingénierie important. La page "Connexions" d'Ads Data Hub simplifie ce processus en fournissant une interface guidée par étapes pour importer, transformer et faire correspondre des données à BigQuery. Vous pouvez ainsi les utiliser dans vos requêtes Ads Data Hub ou dans tout autre produit lu à partir de BigQuery. En enrichissant vos requêtes avec des données first party, vous pouvez proposer des expériences client plus riches et mieux vous adapter aux changements dans l'ensemble du secteur concernant le suivi des annonces.
La page "Connexions" est conçue avec des outils qui vous permettent de chiffrer et de partager des informations permettant d'identifier personnellement l'utilisateur (PII) avec des partenaires de manière respectueuse de la confidentialité. Après avoir sélectionné les colonnes contenant des informations personnelles, Ads Data Hub chiffre les données, ce qui garantit que vos données first party ne peuvent être exportées ou lues que par les personnes autorisées à le faire. Il peut être difficile de savoir quelles données first party sont nécessaires pour votre cas d'utilisation de mesure ou d'activation. Ads Data Hub fournit donc une liste complète de cas d'utilisation prédéfinis, puis vous guide tout au long du processus d'extraction, de transformation et de chargement de vos données. Bien que vous puissiez créer plusieurs types de connexions, ce document suppose que vous utilisez la page "Connexions" pour la mise en correspondance des données fournies par l'utilisateur.
Sources de données first party acceptées
Vous pouvez importer des données à partir des sources de données suivantes:
- BigQuery
- Cloud Storage
- FTP sécurisé (SFTP)
- Snowflake
- MySQL
- PostgreSQL
- Amazon Redshift
- Amazon S3
Étant donné que la mise en correspondance des données fournies par l'utilisateur n'est disponible que sur l'inventaire détenu et géré par Google pour les utilisateurs connectés, elle n'est pas affectée par l'abandon à venir des cookies tiers. Comme elles résistent mieux aux évolutions du secteur que les données tierces, elles peuvent fournir des insights plus riches, ce qui peut entraîner un meilleur engagement client.
Apprendre la terminologie
- Connexion de données fournie par l'utilisateur:configurez une connexion de données fournie par l'utilisateur pour importer et mettre en correspondance vos données, planifier des importations de données, transformer des données et mettre en correspondance vos données publicitaires à l'aide d'un ID utilisateur. L'événement d'annonce doit être associé à un utilisateur connecté dans les données sur les annonces Google. Nécessite plusieurs projets Google Cloud.
- Connexion de données first party:configurez une connexion de données first party en tant qu'outil de préparation des données pour planifier les importations de données et les transformer sans les fonctionnalités avancées de la mise en correspondance des données fournies par l'utilisateur. Ce type de connexion ne nécessite qu'un seul projet Google Cloud.
- Source de données:produit connecté, fichier importé ou intégration tierce (BigQuery, par exemple)
- Destination:cas d'utilisation (généralement un produit ou une fonctionnalité de produit Google) où les données importées sont activées (par exemple, la mise en correspondance des données fournies par l'utilisateur dans Ads Data Hub)
- Projet administrateur:projet Google Cloud contenant vos données publicitaires propriétaires au format brut.
- Ensemble de données de sortie:ensemble de données BigQuery dans lequel Ads Data Hub écrit. Par défaut, il s'agit d'un ensemble de données dans votre projet administrateur. Pour le remplacer par un autre projet Google Cloud, consultez la section Configurer des comptes de service.
Résumé du processus
- Configuration de l'ingestion et de la mise en correspondance des données
- Vous accordez les autorisations requises aux comptes de service de votre projet administrateur. Consultez Configurer l'ingestion de données.
- Ingestion et mise en correspondance des données first party
- Vous mettez en forme et importez vos données first party dans votre ensemble de données BigQuery. Pour une configuration la plus simple possible, utilisez votre projet d'administration. Toutefois, vous pouvez utiliser n'importe quel ensemble de données BigQuery dont vous êtes propriétaire.
- Vous lancez une requête de mise en correspondance des données en créant une connexion et en définissant un calendrier d'importation.
- Google joint les données de votre projet aux données appartenant à Google contenant l'ID utilisateur de Google et les données hachées fournies par l'utilisateur pour créer et mettre à jour des tables de correspondance.
- Consultez Ingérer des données first party.
- Requêtes en cours dans Ads Data Hub, basées sur les données mises en correspondance
- Vous exécutez des requêtes sur les tables des correspondances de la même manière que vous exécutez des requêtes régulières dans Ads Data Hub. Consultez la section Interroger les données mises en correspondance.
En savoir plus sur les exigences en matière de confidentialité
Collecter des données client
Lorsque vous utilisez la mise en correspondance des données fournies par l'utilisateur, vous devez importer des données first party. Il peut s'agir d'informations que vous avez collectées sur vos sites Web, applications ou magasins physiques, ou encore de toute information qu'un client vous a communiquée directement.
Vous devez respecter les points suivants :
- Dans vos règles de confidentialité, vous devez indiquer que vous partagez les données client avec des tiers pour qu'ils réalisent des services à votre place. Vous devez également spécifier que vous demandez le consentement des utilisateurs concernés lorsque la législation l'impose.
- Vous ne devez utiliser que l'interface ou l'API approuvée de Google pour importer des données client.
- Respectez l'ensemble des lois et règlements applicables, y compris les consignes d'autorégulation ou normes sectorielles qui peuvent s'appliquer.
Confirmation de l'obtention du consentement pour les données first party
Pour vous assurer de pouvoir utiliser vos données first party dans Ads Data Hub, vous devez confirmer avoir obtenu le consentement approprié pour transmettre à Google les données des utilisateurs finaux dans l'EEE conformément aux Règles relatives au consentement de l'utilisateur dans l'UE et aux Règles Ads Data Hub. Cette exigence s'applique à chaque compte Ads Data Hub et vous devez réeffectuer cette confirmation chaque fois que vous importez de nouvelles données first party. Tout utilisateur peut effectuer cette confirmation au nom de l'intégralité du compte.
Notez que les règles d'interrogation des services Google qui s'appliquent aux requêtes d'analyse s'appliquent aussi aux requêtes UPDM. Par exemple, vous ne pouvez pas exécuter de requêtes multiservices sur des utilisateurs dans l'EEE lorsque vous créez une table des correspondances.
Pour découvrir comment confirmer l'obtention du consentement dans Ads Data Hub, consultez Exigences de consentement pour l'Espace économique européen.
Taille des données
Pour protéger la confidentialité des utilisateurs finaux, la mise en correspondance des données fournies par l'utilisateur applique ces exigences concernant la taille de vos données:
- Vous devez importer au moins 1 000 enregistrements dans votre liste d'utilisateurs.
- Chaque mise à jour réussie de votre table de correspondance doit inclure un nombre minimal d'utilisateurs nouvellement mis en correspondance. Ce comportement est semblable aux vérifications des différences.
- Votre liste ne doit pas dépasser le nombre maximal d'enregistrements. Pour en savoir plus sur la limite de données maximale, contactez votre représentant Google.
Configurer l'ingestion de données
Avant de commencer, vous devez configurer votre compte Ads Data Hub pour créer des connexions de données. C'est ainsi que vous établirez votre pipeline de mise en correspondance des données. Vous n'avez besoin de suivre cette procédure qu'une seule fois.
Sur la page Connexions, cliquez sur Commencer la configuration pour ouvrir l'assistant de configuration du compte à l'étape d'activation de l'UPDM.
Quelles autorisations sont accordées pour BigQuery et Cloud Storage ?
Si vous configurez UPDM pour l'utiliser avec BigQuery ou Cloud Storage, utilisez cette référence pour comprendre les autorisations accordées aux comptes de service Ads Data Hub.
BigQuery
| Compte de service Datafusion | |||||||||
| Objectif | Le compte de service Data Fusion permet d'afficher une liste de champs sources dans l'UI Ads Data Hub. | ||||||||
| Format | service-some-number@gcp-sa-datafusion.iam.gserviceaccount.com |
||||||||
| Accès requis |
|
||||||||
| Compte de service Dataproc | |||||||||
| Objectif | Le compte de service Dataproc est chargé d'exécuter les pipelines de données en arrière-plan. | ||||||||
| Format | some-number-compute@developer.gserviceaccount.com |
||||||||
| Accès requis |
|
||||||||
| Compte de service UPDM | |||||||||
| Objectif | Le compte de service UPDM est utilisé pour exécuter la tâche de mise en correspondance. | ||||||||
| Format | service-some-number@gcp-sa-adsdataconnector.iam.gserviceaccount.com |
||||||||
| Accès requis |
|
||||||||
Cloud Storage
| Compte de service Datafusion | |||||||
| Objectif | Le compte de service Data Fusion permet d'afficher une liste de champs sources dans l'UI Ads Data Hub. | ||||||
| Format | service-some-number@gcp-sa-datafusion.iam.gserviceaccount.com |
||||||
| Accès requis |
|
||||||
| Compte de service Dataproc | |||||||
| Objectif | Le compte de service Dataproc est chargé d'exécuter les pipelines de données en arrière-plan. | ||||||
| Format | some-number-compute@developer.gserviceaccount.com |
||||||
| Accès requis |
|
||||||
| Compte de service UPDM | |||||||
| Objectif | Le compte de service UPDM est utilisé pour exécuter la tâche de mise en correspondance. | ||||||
| Format | service-some-number@gcp-sa-adsdataconnector.iam.gserviceaccount.com |
||||||
| Accès requis |
|
||||||
Autres sources de données
Non nécessaire pour les autres sources de données
Ingestion et mise en correspondance des données first party
Mettre en forme les données pour l'entrée
Pour être correctement mises en correspondance, vos données doivent respecter les exigences de mise en forme suivantes:
- Lorsque cela est indiqué dans les descriptions des champs de saisie suivantes, vous devez effectuer l'importation à l'aide du hachage SHA256.
- Les champs de saisie doivent être au format chaîne. Par exemple, si vous utilisez la fonction de hachage SHA256 de BigQuery avec la fonction d'encodage en base 16 (TO_HEX), utilisez la transformation suivante:
TO_HEX(SHA256(user_data)). - L'UPDM est compatible avec les encodages en base16 et en base64. Vous devez aligner l'encodage de vos données first party sur le décodage utilisé dans votre requête Ads Data Hub. Si vous modifiez l'encodage de vos données first party, vous devez mettre à jour votre requête Ads Data Hub pour la décoder à partir de la même base. Les exemples suivants utilisent l'encodage en base 16.
User-ID
- Texte brut
- Hachage: aucun
- Supprimer les espaces blancs
- N'utilisez que des minuscules.
- Incluez un nom de domaine pour chaque adresse e-mail (par exemple, gmail.com ou hotmail.co.jp).
- Supprimez les accents (par exemple, remplacez è, é, ê ou ë par e).
- Hachage: SHA256 encodé en base16
Valide:TO_HEX(SHA256("jeffersonloveshiking@gmail.com"))
Non valide: TO_HEX(SHA256("JéffersonLôvesHiking@gmail.com"))
Téléphone
- Supprimer les espaces blancs
- Format au format E.164 (par exemple, aux États-Unis: +14155552671, au Royaume-Uni: +442071838750)
- Incluez le code pays (y compris les États-Unis).
- Supprimez tous les caractères spéciaux, à l'exception du signe "+" avant le code pays.
- Hachage: SHA256 encodé en base16
Valide: TO_HEX(SHA256("+18005550101"))
Non valide: TO_HEX(SHA256("(800) 555-0101"))
Prénom
- Supprimer les espaces blancs
- N'utilisez que des minuscules.
- Supprimez tous les préfixes, comme "Mme".
- Ne supprimez pas les accents (par exemple, è, é, ê ou ë).
- Hachage: SHA256 encodé en base16
Valide:TO_HEX(SHA256("daní"))
Non valide: TO_HEX(SHA256("Daní"))
Nom
- Supprimer les espaces blancs
- N'utilisez que des minuscules.
- Supprimez tous les préfixes, comme "Jr.".
- Ne supprimez pas les accents (par exemple, è, é, ê ou ë).
- Hachage: SHA256 encodé en base16
Valide:TO_HEX(SHA256("delacruz"))
Non valide: TO_HEX(SHA256("de la Cruz, Jr."))
Pays
- Incluez le code pays même si toutes vos données client proviennent du même pays.
- Ne hachez pas les données de pays.
- Utiliser les codes pays ISO 3166-1 alpha-2
- Hachage: aucun
Valide: US
Non valide:United States of America ou USA
Code postal
- Ne hachez pas les données de code postal.
- Les codes postaux internationaux et ceux des États-Unis sont acceptés.
- Pour les États-Unis :
- Les codes à cinq chiffres sont acceptés (par exemple, 94043).
- Les codes à cinq chiffres suivis d'une extension de quatre chiffres sont également autorisés (par exemple, 94043-1351 ou 940431351).
- Pour tous les autres pays :
- Aucune mise en forme n'est requise (pas besoin de mettre en minuscules, ni de supprimer les espaces et les caractères spéciaux)
- N'indiquez pas l'extension de code postal.
- Hachage: aucun
Validation des hachages et codage des données
Vous pouvez utiliser les scripts de validation de hachage suivants pour vous assurer que vos données sont correctement formatées.
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()
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) {
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`;
Clés de jointure
Certaines combinaisons de données fournies par l'utilisateur sont plus efficaces que d'autres. Vous trouverez ci-dessous une liste des différentes combinaisons de données fournies par l'utilisateur, classées par force relative. Si vous utilisez une adresse, vous devez inclure les éléments suivants: prénom, nom, pays et code postal.
- E-mail, téléphone, adresse (plus efficace)
- Téléphone, adresse
- Adresse e-mail, adresse
- E-mail, téléphone
- Adresse
- Téléphone
- E-mail (le moins sécurisé)
Créer un tableau de correspondance
- Cliquez sur Connexions > Créer une connexion > Mise en correspondance des données fournies par l'utilisateur.
- Choisissez une source de données, puis cliquez sur Connecter.
- Si vous y êtes invité, authentifiez-vous, puis cliquez sur Suivant:
BigQuery
Cliquez sur "Appliquer" pour accorder l'accès à BigQuery.
Cloud Storage
Cliquez sur "Appliquer" pour accorder l'accès à Cloud Storage.
MySQL
Saisissez l'emplacement, le port, le nom d'utilisateur et le mot de passe de votre base de données MySQL.
S3
Saisissez votre clé d'accès secrète Amazon S3.
PostgreSQL
Saisissez l'emplacement, le port, le nom d'utilisateur, le mot de passe et la base de données de votre base de données PostgreSQL.
Redshift
Saisissez l'emplacement, le port, le nom d'utilisateur, le mot de passe et la base de données de votre base de données Redshift.
sFTP
Saisissez l'emplacement, le nom d'utilisateur et le mot de passe de votre serveur SFTP.
Snowflake
Saisissez votre identifiant de compte, votre nom d'utilisateur et votre mot de passe Snowflake.
- Configurez votre source de données, puis cliquez sur Suivant:
BigQuery
Sélectionnez la table BigQuery à importer.
Cloud Storage
Saisissez le chemin d'accès gsutil, par exemple
gs://my-bucket/folder/, puis sélectionnez le formatage de votre fichier.Si vous connectez cette ressource pour la première fois, une alerte s'affiche. Cliquez sur "Appliquer" pour accorder l'accès, puis sur "Suivant". Remarque : vous devez disposer d'un rôle autorisant la délégation de
storage.buckets.setIamPolicypour le bucket concerné.MySQL
Sélectionnez la base de données et la table MySQL que vous souhaitez utiliser.
S3
Saisissez l'URI du fichier à importer (par rapport à l'adresse de l'hôte).
PostgreSQL
Indiquez le schéma PostgreSQL et le nom de la table (ou vue).
Redshift
Indiquez le schéma Redshift et le nom de la table (ou de la vue). Par défaut, Redshift utilise les URL d'emplacement de base de données qui suivent ce modèle :
cluster-identifier.account-number.aws-region.redshift.amazonaws.com.sFTP
Saisissez le chemin d'accès et le nom du fichier, au format :
/PATH/FILENAME.csvSnowflake
Indiquez la base de données, le schéma et la table (ou vue) Snowflake à utiliser.
- Sélectionnez un ensemble de données BigQuery à utiliser comme destination intermédiaire, puis cliquez sur Suivant. Cette étape permet de s'assurer que vos données sont correctement formatées.
- Facultatif: modifiez le format de vos données. Les transformations incluent le hachage de calcul, la mise en forme en minuscules/majuscules et la fusion/division des champs.
- Cliquez sur Action > > Transformer.
- Dans le panneau qui s'affiche, cliquez sur Ajouter une transformation ou Ajouter une autre transformation.
- Choisissez un type de transformation dans le menu déroulant, puis saisissez les exigences.
- Cliquez sur Enregistrer.
- Choisissez au moins une clé d'association et mappez les champs que vous utiliserez. Ads Data Hub mappe automatiquement les champs aux noms identiques, indiqués par un . Apportez les modifications nécessaires, puis cliquez sur Suivant.
- Définissez un planning :
- Nommez votre connexion
- Définissez une fréquence, qui indique la fréquence d'importation des données dans l'ensemble de données que vous avez sélectionné à l'étape précédente. Chaque exécution écrase les données de la table de destination.
- Indiquez comment gérer les conflits d'ID utilisateur. Vous pouvez choisir de conserver la correspondance existante ou de l'écraser avec de nouvelles données.
- Cliquez sur Terminer. Les tables des correspondances sont généralement prêtes à être interrogées 12 heures après leur création.
Afficher les informations sur la connexion
La page "Détails de la connexion" vous fournit des informations sur les exécutions et les erreurs récentes d'une connexion donnée. Pour afficher les détails d'une connexion spécifique:
- Cliquez sur Connexions.
- Cliquez sur le nom de la connexion pour en afficher les détails.
- Vous pouvez désormais voir les détails de la connexion et les exécutions récentes. Chacune d'elles affiche deux types d'erreurs possibles: des erreurs au niveau de la connexion (la connexion n'a pas été exécutée) et des erreurs au niveau de la ligne (une ligne n'a pas été importée).
- Un état Failed (Échec) indique que l'ensemble de la connexion n'a pas pu s'exécuter (par exemple, problème d'autorisation du compte de service). Cliquez sur l'état de l'erreur pour voir quelles erreurs ont affecté la connexion.
- L'état Terminé indique que la connexion a bien été établie. Toutefois, il peut toujours y avoir des erreurs au niveau des lignes, indiquées par une valeur non nulle dans la colonne "Lignes avec erreurs". Cliquez sur la valeur pour en savoir plus sur les enregistrements ayant échoué.
Modifier une connexion
Vous pouvez modifier les informations suivantes:
- Nom de la connexion
- Programmer
- Table de destination
- Mappage de champ
La modification de la source de données n'est pas prise en charge. Pour modifier une source de données, créez une nouvelle connexion et supprimez l'ancienne.
Pour modifier les détails d'une connexion:
- Cliquez sur Connexions.
- Cliquez sur le nom de la connexion que vous souhaitez modifier.
- Modifiez les informations que vous souhaitez modifier :
- Nom de la connexion: cliquez sur Modifier, saisissez le nouveau nom, puis appuyez sur Entrée.
- Calendrier: cliquez sur Modifier, définissez le nouveau calendrier, puis cliquez sur Enregistrer.
- Table de destination: cliquez sur Modifier, saisissez le nouveau nom de la destination, puis cliquez sur Enregistrer.
- Mappage des champs: cliquez sur , apportez des modifications aux champs, puis cliquez sur Enregistrer.
- Cliquez sur .
Interroger les données mises en correspondance
Interroger les tables des correspondances
Lorsque vos tables de correspondance contiennent suffisamment de données pour satisfaire aux contrôles de confidentialité, vous êtes prêt à exécuter des requêtes sur les tables.
La table d'origine des données first party (1PD) est représentée par my_data.
Cela inclut à la fois les informations permettant d'identifier personnellement l'utilisateur et les données non permettant d'identifier personnellement l'utilisateur.
L'utilisation du tableau d'origine peut améliorer vos rapports en fournissant plus d'insights, car il représente toutes les données de la table de données démographiques par adresse en comparaison avec une table de correspondance.
Chaque table du schéma Ads Data Hub contenant un champ user_id est accompagnée d'une table des correspondances. Par exemple, pour la table adh.google_ads_impressions, Ads Data Hub génère également une table des correspondances appelée adh.google_ads_impressions_updm qui contient vos ID utilisateur.
Des tables des correspondances distinctes sont créées pour les tables isolées conformément au règlement. Par exemple, pour la table adh.google_ads_impressions_policy_isolated_youtube, Ads Data Hub génère également une table des correspondances appelée adh.google_ads_impressions_policy_isolated_youtube_updm qui contient vos ID utilisateur.
Ces tables incluent un sous-ensemble des utilisateurs disponibles dans les tables d'origine, où il existe une correspondance avec le user_id. Par exemple, si la table d'origine contient des données pour les utilisateurs A et B, mais que seul l'utilisateur A correspond, l'utilisateur B ne figurera pas dans la table des correspondances.
Les tables des correspondances contiennent une colonne supplémentaire appelée customer_data_user_id, qui stocke l'identifiant utilisateur sous la forme d'OCTETS.
Il est important de prendre en compte le type de champ lorsque vous rédigez vos requêtes. Les opérateurs de comparaison SQL s'attendent à ce que les littéraux que vous comparez soient du même type. Selon la manière dont le user_id est stocké dans votre table de données first party, vous devrez peut-être encoder les valeurs dans la table avant de faire correspondre les données.
Vous devez caster votre clé de jointure en OCTETS pour que la mise en correspondance fonctionne :
JOIN ON
adh.google_ads_impressions_updm.customer_data_user_id = CAST(my_data.user_id AS BYTES)
De plus, les comparaisons de chaînes en SQL sont sensibles à la casse. Par conséquent, vous devrez peut-être encoder les chaînes des deux côtés pour pouvoir les comparer avec précision.
Exemples de requêtes
Compter les utilisateurs correspondants
Cette requête compte le nombre d'utilisateurs mis en correspondance dans votre table des impressions Google Ads.
/* Count matched users in Google Ads impressions table */
SELECT COUNT(DISTINCT user_id)
FROM adh.google_ads_impressions_updm
Cette requête montre comment joindre des données first party à des données 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
Questions fréquentes sur le taux de correspondance UPDM
Pour obtenir la liste des questions fréquentes sur le taux de correspondance UPDM, consultez les questions fréquentes sur le taux de correspondance UPDM.