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.
Visão geral
Para conseguir insights valiosos de publicidade, é preciso 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 engenharia. A página "Conexões" no Ads Data Hub simplifica esse processo fornecendo uma interface guiada e detalhada para importar, transformar e fazer a correspondência de dados com o 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.
Origens de dados próprios com suporte
É possível importar dados das seguintes fontes:
- BigQuery
- Cloud Storage
- FTP seguro (SFTP)
- Snowflake
- MySQL
- PostgreSQL
- Amazon Redshift
- Amazon S3
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 fazer correspondência com seus dados, programar importações de dados, transformar dados e fazer correspondência com 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
- 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.
- 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
- 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.
Quais permissões são concedidas para o BigQuery e o Cloud Storage?
Se você configurar o UPDM para uso com o BigQuery ou o Cloud Storage, use esta referência para entender as permissões concedidas às contas de serviço do Ads Data Hub.
BigQuery
| Conta de serviço do Data Fusion | |||||||||
| Finalidade | A conta de serviço do Data Fusion é usada para mostrar uma lista de campos de origem na interface do Ads Data Hub. | ||||||||
| Formato | service-some-number@gcp-sa-datafusion.iam.gserviceaccount.com |
||||||||
| Acesso necessário |
|
||||||||
| Conta de serviço do Dataproc | |||||||||
| Finalidade | A conta de serviço do Dataproc é responsável por executar os pipelines de dados em segundo plano. | ||||||||
| Formato | some-number-compute@developer.gserviceaccount.com |
||||||||
| Acesso necessário |
|
||||||||
| Conta de serviço do UPDM | |||||||||
| Finalidade | A conta de serviço do UPDM é usada para executar o job de correspondência. | ||||||||
| Formato | service-some-number@gcp-sa-adsdataconnector.iam.gserviceaccount.com |
||||||||
| Acesso necessário |
|
||||||||
Cloud Storage
| Conta de serviço do Data Fusion | |||||||
| Finalidade | A conta de serviço do Data Fusion é usada para mostrar uma lista de campos de origem na interface do Ads Data Hub. | ||||||
| Formato | service-some-number@gcp-sa-datafusion.iam.gserviceaccount.com |
||||||
| Acesso necessário |
|
||||||
| Conta de serviço do Dataproc | |||||||
| Finalidade | A conta de serviço do Dataproc é responsável por executar os pipelines de dados em segundo plano. | ||||||
| Formato | some-number-compute@developer.gserviceaccount.com |
||||||
| Acesso necessário |
|
||||||
| Conta de serviço do UPDM | |||||||
| Finalidade | A conta de serviço do UPDM é usada para executar o job de correspondência. | ||||||
| Formato | service-some-number@gcp-sa-adsdataconnector.iam.gserviceaccount.com |
||||||
| Acesso necessário |
|
||||||
Outras fontes de dados
Não é necessário para outras fontes de dados
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.
User-ID
- Texto simples
- Hash: nenhum
- Remover espaços em branco
- Insira todos os caracteres em letras minúsculas.
- Inclua o nome de domínio de todos os endereços de e-mail (por exemplo: gmail.com ou hotmail.com).
- Remova acentos. Por exemplo, mude è, é, ê ou ë para e.
- Hash: SHA256 codificado em base16
Válido: TO_HEX(SHA256("jeffersonloveshiking@gmail.com"))
Inválido: TO_HEX(SHA256("JéffersonLôvesHiking@gmail.com"))
Telefone
- Remover espaços em branco
- Use o formato E.164. Por exemplo, nos EUA: +14155552671, no Reino Unido: +442071838750
- Inclua o código do país (incluindo os EUA)
- Remova todos os caracteres especiais, exceto o "+" antes do código do país
- Hash: SHA256 codificado em base16
Válido: TO_HEX(SHA256("+18005550101"))
Inválido: TO_HEX(SHA256("(800) 555-0101"))
Nome
- Remover espaços em branco
- Insira todos os caracteres em letras minúsculas.
- Remova todos os prefixos, como "Sra.".
- Não remova acentos, por exemplo, è, é, ê ou ë.
- Hash: SHA256 codificado em base16
Válido: TO_HEX(SHA256("daní"))
Inválido: TO_HEX(SHA256("Daní"))
Sobrenome
- Remover espaços em branco
- Insira todos os caracteres em letras minúsculas.
- Remova todos os prefixos, como Jr.
- Não remova acentos, por exemplo, è, é, ê ou ë.
- Hash: SHA256 codificado em base16
Válido: TO_HEX(SHA256("delacruz"))
Inválido: TO_HEX(SHA256("de la Cruz, Jr."))
País
- Inclua o código do país mesmo que todos os dados dos seus clientes sejam do mesmo país.
- Não criptografe os dados do país com hash
- Use os códigos de país ISO 3166-1 alfa-2.
- Hash: nenhum
Válido: US
Inválido:United States of America ou USA
CEP
- Não criptografe os dados de CEP com hash.
- São permitidos CEPs e códigos postais dos EUA e internacionais.
- Para os EUA:
- São permitidos códigos de cinco dígitos, por exemplo, 94043
- Também são aceitos cinco dígitos seguidos por uma extensão de quatro dígitos, por exemplo, 94043-1351 ou 940431351.
- Para todos os outros países:
- Não é necessário formatar (não é necessário usar letras minúsculas ou remover espaços e caracteres especiais)
- Não inclua as extensões dos códigos postais.
- Hash: nenhum
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.
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`;
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.
- E-mail, telefone, endereço (mais forte)
- Telefone, endereço
- E-mail, endereço
- E-mail, telefone
- Endereço
- Telefone
- E-mail (mais fraco)
Criar uma tabela de correspondência
- Clique em Conexões > Criar conexão > Correspondência de dados fornecidos pelo usuário.
- Escolha uma fonte de dados e clique em Conectar.
- 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 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.
- 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 esta for a primeira vez que você 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.setIamPolicyao 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.csvSnowflake
Insira o banco de dados, o esquema e a tabela (ou visualização) do Snowflake que você quer usar.
- Selecione um conjunto de dados do BigQuery para usar como destino intermediário e clique em Próxima. Esta etapa garante que seus dados estejam corretamente formatados.
- 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.
- Clique em Ação > > Transformar.
- No painel que aparece, clique em Adicionar transformação ou Adicionar outra transformação.
- Escolha um tipo de transformação no menu suspenso e insira os requisitos.
- Clique em Salvar.
- 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 . Faça as edições necessárias e clique em Próxima.
- Defina uma programação:
- Atribuir um nome para sua conexão
- 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.
- 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.
- 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:
- Clique em Conexões.
- Clique no nome da conexão para conferir os detalhes.
- 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).
- 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.
- 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:
- Clique em Conexões.
- Clique no nome da conexão que você quer editar.
- 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 , faça alterações nos campos e clique em Salvar.
- Clique em .
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ência.
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 conta 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
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 taxa de correspondência de UPDM
Para uma lista de perguntas frequentes relacionadas à taxa de correspondência da UPDM, consulte Perguntas frequentes sobre a taxa de correspondência da UPDM.