Mise en correspondance des données fournies par l'utilisateur

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

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 de l'onglet "Connexions"

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 mettre en correspondance vos données publicitaires dans 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.

É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

1. 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 d'administrateur. Consultez Configurer l'ingestion de données.
2. 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.
3. 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 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.

Accéder à Connexions

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 l'encodage 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 base16.

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.

/**
 * @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 [email protected]:
  // 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674
  hash('[email protected]').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()

/**
 * @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 [email protected]:
  // h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
  hash('[email protected]').then(result => console.log(result));

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

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

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

main()

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

Supports: Python 2, Python 3

Sample hashes:

  - Email '[email protected]': 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('[email protected]')
  print_updm_hash('+18005551212')
  print_updm_hash('John')
  print_updm_hash('Doe')

if __name__ == '__main__':
  main()

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

Supports: Python 2, Python 3

Sample hashes:

  - Email '[email protected]': 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(
      '[email protected]', expected='h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=')
  print_hash(
      '+18005551212', expected='YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=')
  print_hash('John', expected='ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=')
  print_hash('Doe', expected='eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=')

if __name__ == '__main__':
  main()

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

Sample hashes:

  - Email '[email protected]': 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("[email protected]")
  PrintHash("+18005551212")
  PrintHash("John")
  PrintHash("Doe")
}

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

Sample hashes:

  - Email '[email protected]': 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("[email protected]")
  PrintHash("+18005551212")
  PrintHash("John")
  PrintHash("Doe")
}

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 "[email protected]": "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("[email protected]");
    printHash("+18005551212");
    printHash("John");
    printHash("Doe");
  }
}

package updm.hashing;

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

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

/**
* Example of the hashing algorithm.
*
* <p>Sample hashes:
*
* <ul>
*   <li>Email '[email protected]': 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("[email protected]");
  printHash("+18005551212");
  printHash("John");
  printHash("Doe");
}
}

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

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

Sample hashes:

  - Email '[email protected]': 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`;

/*
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 '[email protected]': 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`;

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.

1. E-mail, téléphone, adresse (plus efficace)
2. Téléphone, adresse
3. Adresse e-mail, adresse
4. E-mail, téléphone
5. Adresse
6. Téléphone
7. E-mail (le moins sécurisé)

Créer un tableau de correspondance

1. Cliquez sur Connexions > Créer une connexion > Mise en correspondance des données fournies par l'utilisateur.
2. Choisissez une source de données, puis cliquez sur Connecter.
3. 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.

4. 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 format 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.setIamPolicy pour 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.csv

   Snowflake

   Indiquez la base de données, le schéma et la table (ou la vue) Snowflake à utiliser.

5. 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.
6. 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.
   1. Cliquez sur Action > more_vert > Transformer.
   2. Dans le panneau qui s'affiche, cliquez sur Ajouter une transformation ou Ajouter une autre transformation.
   3. Choisissez un type de transformation dans le menu déroulant, puis saisissez les exigences.
   4. Cliquez sur Enregistrer.
7. 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 auto_fix_high. Apportez les modifications nécessaires, puis cliquez sur Suivant.
8. Définissez un planning :
   1. Nommez votre connexion
   2. 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.
   3. Indiquez comment les conflits d'ID utilisateur doivent être gérés. Vous pouvez choisir de conserver la correspondance existante ou de l'écraser avec de nouvelles données.
9. 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:

1. Cliquez sur Connexions.
2. Cliquez sur le nom de la connexion pour en afficher les détails.
3. 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).
   1. 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.
   2. 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:

1. Cliquez sur Connexions.
2. Cliquez sur le nom de la connexion que vous souhaitez modifier.
3. 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 navigate_next, apportez des modifications aux champs, puis cliquez sur Enregistrer.
4. Cliquez sur close.

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 de première partie en comparaison avec une table des correspondances.

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

Calculer le taux de correspondance

Tous les utilisateurs ne peuvent pas être mis en correspondance. Par exemple, les utilisateurs déconnectés, les enfants et les utilisateurs qui n'ont pas donné leur consentement ne sont pas mis en correspondance via l'UPDM. Vous pouvez utiliser le champ is_updm_eligible pour calculer des taux de correspondance UPDM plus précis. Notez que le champ is_updm_eligible est disponible depuis le 1er octobre 2024. Vous ne pouvez pas utiliser ce champ pour calculer les taux de correspondance avant cette date.

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

Associer des données first party et Google Ads

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 MCDFU

Pour obtenir la liste des questions fréquentes sur l'UPDM, consultez les questions fréquentes sur l'UPDM.