Correspondência de dados fornecidos pelo usuário

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

A correspondência de dados fornecidos pelo usuário (UPDM) reúne dados próprios que você coletou sobre um usuário, como informações dos seus sites, apps ou lojas físicas, com a atividade de login do mesmo usuário em todos os dados de anúncios do Google, incluindo dados operados e de propriedade do Google. Isso inclui dados comprados com produtos do Google Marketing Platform (GMP), por exemplo, o YouTube comprado usando o Display & Video 360. Outros produtos do GMP que não são de propriedade e operados pelo Google não são compatíveis.

Para se qualificar para a correspondência de dados fornecidos pelo usuário, o evento de anúncio precisa estar vinculado a um usuário conectado nos dados de anúncios do Google.

Este documento descreve o recurso de correspondência de dados fornecido pelo usuário e oferece orientações sobre configuração e uso.

Informações gerais sobre a guia "Conexões"

Para conseguir insights valiosos de publicidade, é necessário combinar dados de várias fontes. Criar sua própria solução para esse problema de pipeline de dados exige um investimento significativo de tempo e de engenharia. A página "Conexões" no Ads Data Hub simplifica esse processo com uma interface guiada e detalhada para importar, transformar e fazer a correspondência dos seus dados de anúncios no BigQuery. Assim, você pode usar essas informações nas consultas do Ads Data Hub ou em qualquer outro produto que leia as informações enviadas pelo BigQuery. Ao usar dados próprios nas consultas, você oferece uma experiência mais avançada aos clientes e consegue lidar melhor com as mudanças no acompanhamento de anúncios que atingem todo o setor.

A página "Conexões" foi criada com ferramentas que permitem criptografar e compartilhar informações de identificação pessoal (PII) com parceiros de uma forma focada na privacidade. Depois de selecionar quais colunas contêm PII, o Ads Data Hub os criptografa, garantindo que seus dados próprios só possam ser exportados ou lidos por pessoas que têm permissão para isso. Saber quais dados próprios são necessários para seu caso de uso de medição ou ativação pode ser difícil. Por isso, o Ads Data Hub oferece uma lista abrangente de casos de uso predefinidos e, em seguida, orienta você durante toda a experiência de extração, transformação e carregamento dos dados. Embora seja possível criar vários tipos de conexões, este documento pressupõe que você está usando a página "Conexões" para a correspondência de dados fornecidos pelo usuário.

Como a correspondência de dados fornecidos pelo usuário só está disponível no inventário pertencente e operado pelo Google para usuários conectados, ela não é afetada pela descontinuação dos cookies de terceiros. Como eles são mais resistentes a mudanças do setor do que os dados de terceiros, eles podem fornecer insights mais ricos, o que pode aumentar o engajamento do cliente.

Conhecer a terminologia

• Conexão de dados fornecida pelo usuário:configure uma conexão de dados fornecida pelo usuário para importar e combinar seus dados, programar importações de dados, transformar dados e combinar seus dados de anúncios usando um ID do usuário. O evento de anúncio precisa estar vinculado a um usuário conectado nos dados de anúncios do Google. Requer vários projetos do Google Cloud.
• Conexão de dados próprios:configure uma conexão de dados próprios como uma ferramenta de preparação de dados para programar importações e transformar dados sem os recursos avançados da UPDM. Esse tipo de conexão requer apenas um projeto do Google Cloud.
• Origem de dados:um produto conectado, um arquivo importado ou uma integração de terceiros, por exemplo, o BigQuery.
• Destino:um caso de uso, normalmente um produto ou recurso do Google em que os dados importados são ativados, por exemplo, a correspondência de dados fornecidos pelo usuário do Ads Data Hub.
• Projeto administrativo:o projeto do Google Cloud que contém seus dados de publicidade proprietários no formato bruto.
• Conjunto de dados de saída:o conjunto de dados do BigQuery em que o Ads Data Hub grava. Por padrão, esse é um conjunto de dados no projeto de administrador. Para mudar para outro projeto do Google Cloud, consulte Configurar contas de serviço.

Resumo do processo

1. Configuração da transferência e correspondência de dados
   • Você concede as permissões necessárias às contas de serviço no seu projeto de administrador. Consulte Configurar a transferência de dados.
2. Transferência e correspondência de dados próprios
   • Você formata e faz o upload dos seus dados próprios para o conjunto de dados do BigQuery. Para a configuração mais simples, use seu projeto de administrador. No entanto, você pode usar qualquer conjunto de dados do BigQuery que seja seu.
   • Você inicia uma solicitação de correspondência de dados criando uma conexão e definindo uma programação de importação.
   • O Google mescla dados entre seu projeto e dados pertencentes ao Google que contêm o ID do usuário do Google e dados fornecidos pelo usuário com hash para criar e atualizar tabelas de correspondência.
   • Consulte Ingerir dados próprios
3. Consultas em andamento no Ads Data Hub com base nos dados correspondentes
   • Você executa consultas nas tabelas de correspondência da mesma forma que executa consultas regulares no Ads Data Hub. Consulte Consultar dados correspondentes.

Saiba mais sobre os requisitos de privacidade

Como coletar dados do cliente

Ao usar a correspondência de dados fornecidos pelo usuário, é necessário fazer o upload de dados próprios. Essas informações podem ser coletadas em sites, apps, lojas físicas ou qualquer informação que um cliente compartilhou diretamente com você.

Você precisa:

• divulgar na sua Política de Privacidade que você compartilha dados dos clientes com terceiros para realizar serviços em seu nome e que obtém consentimento para esse compartilhamento quando exigido por lei;
• usar somente a API ou a interface aprovada do Google para fazer o upload de dados dos clientes;
• Obedecer a todas as leis e regulamentações aplicáveis, incluindo códigos de autorregulação ou do setor.

Confirmação do consentimento para uso de dados próprios

Para conseguir usar seus dados próprios no Ads Data Hub, você precisa confirmar que obteve o consentimento necessário para compartilhar dados dos usuários finais do EEE com o Google conforme a Política de consentimento de usuários da União Europeia e a política do Ads Data Hub. Essa exigência vale para cada conta do Ads Data Hub e precisa ser atualizada toda vez que você faz upload de novos dados próprios. Qualquer usuário pode fazer essa confirmação em nome da conta como um todo.

As mesmas regras para consultas dos Serviços do Google aplicáveis às consultas de análises também valem para as consultas de UPDM. Por exemplo, não é possível realizar consultas entre serviços envolvendo usuários que estejam no EEE na hora de criar uma tabela de correspondência.

Para saber como confirmar o consentimento no Ads Data Hub, consulte Requisitos de conhecimento no Espaço Econômico Europeu.

Tamanho dos dados

Para proteger a privacidade do usuário final, a correspondência de dados fornecidos pelo usuário impõe estes requisitos em relação ao tamanho dos dados:

• É necessário fazer upload de pelo menos 1.000 registros na lista de usuários.
• Cada atualização bem-sucedida da tabela de correspondências precisa incluir um número mínimo de usuários recém-correspondidos. Esse comportamento é semelhante às verificações de diferenças.
• Sua lista não pode exceder o número máximo de registros. Para saber mais sobre o limite máximo de dados, entre em contato com seu representante do Google.

Configurar a ingestão de dados

Antes de começar, configure sua conta do Ads Data Hub para criar conexões de dados, que é como você vai estabelecer seu pipeline de correspondência de dados. Você só precisa realizar essas etapas uma vez.

Na página Conexões, clique em Iniciar configuração para abrir o assistente de configuração da conta na fase de ativação do UPDM.

Acessar Conexões

Transferir e combinar dados próprios

Formatar dados para entrada

Seus dados precisam obedecer a estes requisitos de formatação para serem correspondidos corretamente:

• Onde indicado nas descrições dos campos de entrada a seguir, faça upload usando hash SHA256.
• Os campos de entrada precisam ser formatados como strings. Por exemplo, se você estiver usando a função de hash SHA256 do BigQuery com a função de codificação Base16 (TO_HEX), use a seguinte transformação: TO_HEX(SHA256(user_data)).
• O UPDM oferece suporte à codificação Base16 e Base64. É necessário alinhar a codificação dos seus dados próprios à decodificação usada na consulta do Ads Data Hub. Se você mudar a codificação dos dados próprios, atualize a consulta do Ads Data Hub para decodificar com a mesma base. Os exemplos a seguir usam a codificação Base16.

Validação de hash e codificação de dados

Você pode usar os scripts de validação de hash abaixo para garantir que seus dados estejam formatados corretamente.

/**
 * @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`;

Combinar chaves

Algumas combinações de dados fornecidos pelo usuário são mais fortes do que outras. Confira a seguir uma lista de diferentes combinações de dados fornecidos pelo usuário, classificadas por força relativa. Se você usar um endereço, inclua: nome, sobrenome, país e CEP.

1. E-mail, telefone, endereço (mais forte)
2. Telefone, endereço
3. E-mail, endereço
4. E-mail, telefone
5. Endereço
6. Telefone
7. E-mail (mais fraco)

Criar uma tabela de correspondência

1. Clique em Conexões > Criar conexão > Correspondência de dados fornecidos pelo usuário.
2. Escolha uma fonte de dados e clique em Conectar.
3. Faça a autenticação, se solicitado, e clique em Próxima:

   BigQuery

   Clique em "Aplicar" para conceder acesso ao BigQuery.

   Cloud Storage

   Clique em "Aplicar" para conceder acesso ao Cloud Storage.

   MySQL

   Digite o local, a porta, o nome de usuário e a senha do banco de dados MySQL.

   S3

   Insira sua chave de acesso secreta do Amazon S3.

   PostgreSQL

   Digite o local, a porta, o nome de usuário, a senha e o banco de dados do banco de dados PostgreSQL.

   Redshift

   Digite o local, a porta, o nome de usuário, a senha e o banco de dados do Redshift.

   SFTP

   Insira o local do servidor sFTP, o nome de usuário e a senha.

   Snowflake

   Insira o identificador da conta, o nome de usuário e a senha do Snowflake.

4. Configure a fonte de dados e clique em Próxima:

   BigQuery

   Selecione a tabela do BigQuery a ser importada.

   Cloud Storage

   Insira o caminho do gsutil, como gs://my-bucket/folder/, e selecione a formatação do arquivo.

   Se você nunca conectou esse recurso, um alerta vai aparecer. Clique em "Aplicar" para conceder acesso e, em seguida, em "Próxima". Observação: você precisa ter um papel com permissão para delegar storage.buckets.setIamPolicy ao bucket relevante.

   MySQL

   Selecione o banco de dados e a tabela do MySQL que você quer usar.

   S3

   Insira o URI do arquivo que você quer enviar (em relação ao endereço do host).

   PostgreSQL

   Insira o esquema e o nome da tabela (ou visualização) do PostgreSQL.

   Redshift

   Insira o esquema e o nome da tabela (ou visualização) do Redshift. Por padrão, o Redshift usa URLs de local do banco de dados que seguem este modelo: cluster-identifier.account-number.aws-region.redshift.amazonaws.com .

   SFTP

   Insira o caminho e o nome do arquivo, formatados como /PATH/FILENAME.csv

   Snowflake

   Insira o banco de dados, o esquema e a tabela (ou visualização) do Snowflake que você quer usar.

5. Selecione um conjunto de dados do BigQuery para usar como um destino intermediário e clique em Próxima. Esta etapa garante que seus dados estejam corretamente formatados.
6. Opcional: modifique o formato dos dados. As transformações incluem hash de computação, formatação de maiúsculas/minúsculas e campos de mesclagem/divisão.
   1. Clique em Ação > more_vert > Transformar.
   2. No painel que aparece, clique em Adicionar transformação ou Adicionar outra transformação.
   3. Escolha um tipo de transformação no menu suspenso e insira os requisitos.
   4. Clique em Salvar.
7. Escolha pelo menos uma chave de mesclagem e mapeie os campos que você vai usar. O Ads Data Hub mapeia automaticamente campos com nomes idênticos, indicados por um auto_fix_high. Faça as edições necessárias e clique em Próxima.
8. Defina uma programação:
   1. Atribuir um nome para sua conexão
   2. Defina uma frequência, determinando com que frequência os dados serão importados para o conjunto de dados selecionado na etapa anterior. Cada execução vai substituir os dados na tabela destino.
   3. Especifique como você quer que as colisões de ID do usuário sejam tratadas. Você pode escolher entre manter a correspondência atual ou substituir por novos dados.
9. Clique em Concluir. Geralmente, as tabelas de correspondências ficam prontas para consulta 12 horas após a criação.

Ver detalhes da conexão

A página de detalhes da conexão fornece informações sobre as execuções e os erros recentes de uma determinada conexão. Para conferir os detalhes de uma conexão específica:

1. Clique em Conexões.
2. Clique no nome da conexão para conferir os detalhes.
3. Agora você pode conferir os detalhes da conexão e as execuções recentes. Cada um mostra dois tipos possíveis de erros: no nível da conexão (a conexão não foi executada) e no nível da linha (uma linha não foi importada).
   1. Um status Falha indica que toda a conexão falhou na execução (por exemplo, problema de permissão da conta de serviço). Clique no status do erro para conferir quais erros afetaram a conexão.
   2. Um status Concluído indica que a conexão foi realizada. No entanto, ainda pode haver erros no nível da linha, indicados por um valor diferente de zero na coluna "Linhas com erros". Clique no valor para saber mais sobre quais registros falharam.

Editar uma conexão

É possível editar os seguintes detalhes:

• Nome da conexão
• Programação
• Tabela de destino
• Mapeamento de campo

Não é possível editar a fonte de dados. Para mudar uma fonte de dados, crie uma nova conexão e exclua a antiga.

Para editar os detalhes da conexão:

1. Clique em Conexões.
2. Clique no nome da conexão que você quer editar.
3. Edite os detalhes que você quer mudar:
   • Nome da conexão: clique em Editar, digite o novo nome e pressione Enter.
   • Programação: clique em Editar, defina a nova programação e clique em Salvar.
   • Tabela de destino: clique em Editar, insira o novo nome de destino e clique em Salvar.
   • Mapeamento de campo: clique em navigate_next, faça alterações nos campos e clique em Salvar.
4. Clique em close.

Consultar dados correspondentes

Consultar as tabelas de correspondências

Quando as tabelas de correspondências tiverem dados suficientes para atender às verificações de privacidade, você poderá fazer consultas nelas.

A tabela original de dados próprios (1PD, na sigla em inglês) é representada por my_data. Isso inclui informações de identificação pessoal (PII) e dados não relacionados a PII. O uso da tabela original pode melhorar seus relatórios com mais insights, já que ela representa todos os dados de 1PD no escopo, quando comparada a uma tabela de correspondências.

Cada tabela no esquema do Ads Data Hub que contém um campo user_id é acompanhada por uma tabela de correspondência. Por exemplo, na tabela adh.google_ads_impressions, o Ads Data Hub gera uma tabela de correspondências chamada adh.google_ads_impressions_updm, que inclui os IDs dos usuários. Tabelas de correspondências separadas são criadas para tabelas isoladas por política. Por exemplo, na tabela adh.google_ads_impressions_policy_isolated_youtube, o Ads Data Hub também gera uma tabela de correspondências chamada adh.google_ads_impressions_policy_isolated_youtube_updm, que contém seus IDs de usuários.

Elas têm um subconjunto dos usuários disponíveis nas tabelas originais, com uma correspondência em user_id. Por exemplo, se a tabela original tiver dados do Usuário A e do Usuário B, mas só o Usuário A for correspondido, o Usuário B não vai estar na tabela de correspondências.

As tabelas de correspondências contêm uma coluna extra chamada customer_data_user_id, que armazena o identificador do usuário como BYTES.

É importante considerar o tipo do campo na hora de criar suas consultas. Os operadores de comparação do SQL esperam que os literais comparados sejam do mesmo tipo. Dependendo de como o user_id é armazenado na sua tabela de dados próprios, é necessário codificar os valores nela antes de fazer a correspondência dos dados. É necessário transmitir a chave de mesclagem em BYTES para encontrar correspondências:

JOIN ON
  adh.google_ads_impressions_updm.customer_data_user_id = CAST(my_data.user_id AS BYTES)

Além disso, as comparações de strings no SQL consideram maiúsculas e minúsculas. Então, pode ser necessário codificar as strings em ambos os lados da comparação.

Amostras de consultas

Contagem de usuários correspondentes

Essa consulta contabiliza o número de usuários correspondentes na tabela de impressões do Google Ads.

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

SELECT COUNT(DISTINCT user_id)
FROM adh.google_ads_impressions_updm

Calcular a taxa de correspondência

Nem todos os usuários estão qualificados para correspondência. Por exemplo, usuários desconectados, crianças e usuários sem consentimento não são associados pelo UPDM. É possível usar o campo is_updm_eligible para calcular taxas de correspondência de UPDM mais precisas. O campo is_updm_eligible ficou disponível a partir de 1º de outubro de 2024. Não é possível usar esse campo para calcular as taxas de correspondência antes dessa data.

/* Calculate the UPDM match rate */

CREATE TEMP TABLE total_events OPTIONS(privacy_checked_export=TRUE) AS
SELECT
  customer_id,
  COUNT(*) AS n
FROM adh.google_ads_impressions
WHERE is_updm_eligible
GROUP BY 1;

CREATE TEMP TABLE matched_events OPTIONS(privacy_checked_export=TRUE) AS
SELECT
  customer_id,
  COUNT(*) AS n
FROM adh.google_ads_impressions_updm
GROUP BY 1;

SELECT
  customer_id,
  SAFE_DIVIDE(matched_events.n, total_events.n) AS match_rate
FROM total_events
LEFT JOIN matched_events
  USING (customer_id)

Combinar dados próprios e do Google Ads

Esta consulta mostra como agrupar dados próprios com dados do 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

Perguntas frequentes sobre a UPDM

Para uma lista de perguntas frequentes relacionadas à UPDM, consulte Perguntas frequentes sobre a UPDM.