La correlación de datos proporcionados por el usuario (UPDM) une los datos de origen que recopilaste sobre un usuario (como la información proveniente de tus sitios web, apps o tiendas físicas) con la actividad que se registra en los datos de anuncios de Google, incluidos los datos que Google posee y opera. Esto incluye los datos comprados a través de los productos de Google Marketing Platform (GMP), por ejemplo, YouTube comprado con Display & Video 360. No se admiten otros productos de GMP que no sean propiedad de Google ni estén operados por Google.
Para poder utilizar la correlación de datos proporcionados por el usuario, el evento de anuncio debe estar vinculado a un usuario que haya accedido a su cuenta y figure en los datos de anuncios de Google.
En este documento, se describe la función de coincidencia de datos proporcionados por el usuario y se proporciona orientación sobre su configuración y uso.
Descripción general
Para obtener estadísticas publicitarias valiosas, a menudo es necesario combinar datos de varias fuentes. Crear tu propia solución para este problema de canalización de datos requiere una inversión significativa de tiempo y de ingeniería. La página Conexiones en el Administrador de datos de anuncios optimiza este proceso, ya que proporciona una interfaz guiada paso a paso para importar, transformar y hacer coincidir datos con BigQuery, de modo que puedas usarlos en tus consultas del Administrador de datos de anuncios o en cualquier otro producto que lea desde BigQuery. Enriquecer tus consultas con datos de origen puede brindar experiencias del cliente más enriquecidas y es más resistente a los cambios en el seguimiento de anuncios en todo el sector.
La página Conexiones se creó con herramientas que te permiten encriptar y compartir información de identificación personal (PII) con socios de una manera centrada en la privacidad. Después de seleccionar qué columnas contienen PII, el Centro de Datos de Anuncios encripta los datos, lo que garantiza que solo las personas que tengan permiso para hacerlo puedan exportarlos o leerlos. Puede ser difícil saber qué datos de origen se necesitan para tu caso de uso de medición o activación, por lo que el Centro de Datos de Anuncios proporciona una lista completa de casos de uso predefinidos y, luego, te guía a través de toda la experiencia de extracción, transformación y carga de tus datos. Si bien puedes crear varios tipos de conexiones, en este documento se da por sentado que usas la página Conexiones para la coincidencia de datos proporcionados por el usuario.
Fuentes de datos de origen compatibles
Puedes importar datos de las siguientes fuentes de datos:
- BigQuery
- Cloud Storage
- FTP seguro (sFTP)
- Snowflake
- MySQL
- PostgreSQL
- Amazon Redshift
- Amazon S3
Debido a que la coincidencia de datos proporcionados por el usuario solo está disponible en el inventario administrado y propiedad de Google para los usuarios que accedieron a sus cuentas, no se verá afectada por la próxima baja de las cookies de terceros. Dado que es más resistente a los cambios en el sector que los datos de terceros, puede proporcionar estadísticas más detalladas, lo que puede generar una mayor participación de los clientes.
Conoce la terminología
- Conexión de datos proporcionados por el usuario: Configura una conexión de datos proporcionados por el usuario para importar y segmentar tus datos, programar importaciones de datos, transformar datos y segmentar tus datos de anuncios con un ID de usuario. El evento de anuncio debe estar vinculado a un usuario que haya accedido a su cuenta y figure en los datos de anuncios de Google. Se requieren varios proyectos de Google Cloud.
- Conexión de datos de origen: Configura una conexión de datos de origen como una herramienta de preparación de datos para programar importaciones de datos y transformarlos sin las funciones avanzadas de la UPDM. Este tipo de conexión solo requiere un proyecto de Google Cloud.
- Fuente de datos: Es un producto conectado, un archivo importado o una integración de terceros; por ejemplo, BigQuery.
- Destino: Es un caso de uso, que suele ser un producto o una función de producto de Google, en el que se activan los datos importados, por ejemplo, la coincidencia de datos proporcionados por el usuario de Ads Data Hub.
- Proyecto de administrador: Es el proyecto de Google Cloud que contiene tus datos de publicidad propios en su formato sin procesar.
- Conjunto de datos de salida: Es el conjunto de datos de BigQuery en el que escribe el Administrador de datos de anuncios. De forma predeterminada, este es un conjunto de datos en tu proyecto de administrador. Para cambiarla a otro proyecto de Google Cloud, consulta Configura cuentas de servicio.
Resumen del proceso
- Configuración de la transferencia y la coincidencia de datos
- Tú otorgas los permisos necesarios a las cuentas de servicio en tu proyecto de administrador. Consulta Cómo configurar la transferencia de datos.
- Transferencia y coincidencia de datos de origen
- Tú debes dar formato a tus datos de origen y subirlos a tu conjunto de datos de BigQuery. Para la configuración más sencilla, usa tu proyecto de administrador. Sin embargo, puedes usar cualquier conjunto de datos de BigQuery que tengas.
- Para iniciar una solicitud de coincidencia de datos, crea una conexión y configura un programa de importación.
- Google une los datos de tu proyecto con los datos que pertenecen a Google, que contienen el ID de usuario de Google y los datos proporcionados por el usuario con codificación hash, para crear y actualizar las tablas de coincidencias.
- Consulta Cómo transferir datos de origen
- Consultas en curso en el Centro de Datos de Anuncios, según los datos coincidentes
- Ejecutas consultas en las tablas de coincidencias de la misma manera que ejecutas consultas normales en el Centro de Datos de Anuncios. Consulta Cómo consultar datos coincidentes.
Más información sobre los requisitos de privacidad
Recopilación de datos de los clientes
Cuando utilizas la Segmentación por datos proporcionados por el usuario, debes subir datos de origen. Esta podría ser información que recopilaste de tus sitios web, aplicaciones, tiendas físicas o cualquier información que un cliente te haya compartido directamente.
Obligaciones:
- Asegúrate de que tu política de privacidad divulgue que compartes los datos de los clientes con terceros que prestan servicios en tu nombre, además de obtener el consentimiento para compartirlos cuando así lo exija la ley.
- Debe utilizar solo la interfaz o la API de Google aprobadas para subir los datos de clientes.
- Debe satisfacer todas las leyes y reglamentaciones aplicables, incluido cualquier código autorregulatorio o de la industria que se pudiera aplicar.
Confirmación del consentimiento propio
Para asegurarte de poder usar tus datos de origen en el Centro de Datos de Anuncios, debes confirmar que obtuviste el consentimiento adecuado para compartir los datos de los usuarios finales del EEE con Google de conformidad con la Política de Consentimiento de Usuarios de la UE y la política del Centro de Datos de Anuncios. Este requisito se aplica a cada cuenta de Ads Data Hub y se debe actualizar cada vez que subas datos de origen nuevos. Cualquier usuario puede realizar este reconocimiento en nombre de toda la cuenta.
Ten en cuenta que las mismas reglas de consulta de los servicios de Google que se aplican a las consultas de análisis también se aplican a las consultas de la UPDM. Por ejemplo, no puedes ejecutar consultas entre servicios en usuarios del EEE cuando creas una tabla de coincidencias.
Si deseas obtener información para confirmar el consentimiento en el Centro de datos de anuncios, consulta Requisitos de consentimiento para el Espacio Económico Europeo.
Tamaño de los datos
Para proteger la privacidad del usuario final, la coincidencia de datos proporcionados por el usuario aplica estos requisitos en relación con el tamaño de tus datos:
- Debes subir al menos 1,000 registros en tu lista de usuarios.
- Cada actualización correcta de tu tabla de coincidencias debe incluir una cantidad mínima de usuarios que se hayan agregado recientemente. Este comportamiento es similar a las comprobaciones de diferencias.
- La lista no debe superar la cantidad máxima de registros. Para obtener información sobre el límite máximo de datos, comunícate con tu representante de Google.
Configura la transferencia de datos
Antes de comenzar, debes configurar tu cuenta de Ads Data Hub para crear conexiones de datos, que es la forma en que establecerás tu canalización de coincidencia de datos. Solo debes realizar estos pasos una vez.
En la página Conexiones, haz clic en Iniciar configuración para abrir el asistente de configuración de la cuenta en la etapa de habilitación de la AUA.
¿Qué permisos se otorgan para BigQuery y Cloud Storage?
Si configuras la UPDM para usarla con BigQuery o Cloud Storage, usa esta referencia para comprender los permisos que se otorgan a las cuentas de servicio de Ads Data Hub.
| Cuenta de servicio de Data Fusion | |||||||||
| Objetivo | La cuenta de servicio de datafusion se usa para mostrar una lista de campos de origen en la IU del Centro de Datos de Anuncios. | ||||||||
| Formato | service-some-number@gcp-sa-datafusion.iam.gserviceaccount.com |
||||||||
| Acceso obligatorio |
|
||||||||
| Cuenta de servicio de Dataproc | |||||||||
| Objetivo | La cuenta de servicio de Dataproc es responsable de ejecutar las canalizaciones de datos en segundo plano. | ||||||||
| Formato | some-number-compute@developer.gserviceaccount.com |
||||||||
| Acceso obligatorio |
|
||||||||
| Cuenta de servicio de UPDM | |||||||||
| Objetivo | La cuenta de servicio de UPDM se usa para ejecutar el trabajo coincidente. | ||||||||
| Formato | service-some-number@gcp-sa-adsdataconnector.iam.gserviceaccount.com |
||||||||
| Acceso obligatorio | |||||||||
| Cuenta de servicio de Data Fusion | |||||||
| Objetivo | La cuenta de servicio de Data Fusion se usa para mostrar una lista de campos de origen en la IU del Centro de Datos de Anuncios. | ||||||
| Formato | service-some-number@gcp-sa-datafusion.iam.gserviceaccount.com |
||||||
| Acceso obligatorio |
|
||||||
| Cuenta de servicio de Dataproc | |||||||
| Objetivo | La cuenta de servicio de Dataproc es responsable de ejecutar las canalizaciones de datos en segundo plano. | ||||||
| Formato | some-number-compute@developer.gserviceaccount.com |
||||||
| Acceso obligatorio |
|
||||||
| Cuenta de servicio de UPDM | |||||||
| Objetivo | La cuenta de servicio de UPDM se usa para ejecutar el trabajo coincidente. | ||||||
| Formato | service-some-number@gcp-sa-adsdataconnector.iam.gserviceaccount.com |
||||||
| Acceso obligatorio | |||||||
No es necesario para otras fuentes de datos.
Cómo transferir y vincular datos de origen
Da formato a los datos de entrada
Para que tus datos coincidan correctamente, deben cumplir con estos requisitos de formato:
- Cuando se indique en las siguientes descripciones de campos de entrada, debes subir el archivo con el hash SHA256.
- Los campos de entrada deben tener el formato de cadena. Por ejemplo, si usas la función de hash SHA256 de BigQuery con la función de codificación Base16 (TO_HEX), usa la siguiente transformación:
TO_HEX(SHA256(user_data)). - UPDM admite la codificación Base16 y Base64. Debes alinear la codificación de tus datos de origen con la decodificación que se usa en tu consulta del Centro de Datos de Anuncios. Si cambias la codificación de tus datos de origen, debes actualizar la consulta del Centro de Datos de Anuncios para decodificar desde la misma base. En los siguientes ejemplos, se usa la codificación Base16.
ID de usuario
- Texto sin formato
- Hashing: Ninguno
Correo electrónico
- Quita los espacios en blanco
- Escribe todos los caracteres en minúscula.
- Incluye un nombre de dominio para todas las direcciones de correo electrónico, como gmail.com o hotmail.co.jp.
- Quita los acentos. Por ejemplo, cambia è, é, ê o ë a e.
- Hash: SHA256 con codificación base16
Válido: TO_HEX(SHA256("jeffersonloveshiking@gmail.com"))
No válida: TO_HEX(SHA256("JéffersonLôvesHiking@gmail.com"))
Teléfono
- Quita los espacios en blanco
- Debes usar el formato E.164. Por ejemplo, para EE.UU.: +14155552671, para el Reino Unido: +442071838750.
- Incluye el código de país (incluidos EE.UU.)
- Quita todos los caracteres especiales, excepto el signo “+” que antecede al código de país.
- Hash: SHA256 con codificación base16
Válido: TO_HEX(SHA256("+18005550101"))
No válida: TO_HEX(SHA256("(800) 555-0101"))
Nombre
- Quita los espacios en blanco
- Escribe todos los caracteres en minúscula.
- Quita todos los prefijos, como Sra.
- No quites los acentos, por ejemplo, è, é, ê o ë.
- Hash: SHA256 con codificación base16
Válido: TO_HEX(SHA256("daní"))
No válida: TO_HEX(SHA256("Daní"))
Apellido
- Quita los espacios en blanco
- Escribe todos los caracteres en minúscula.
- Quita todos los prefijos, como Jr.
- No quites los acentos, por ejemplo, è, é, ê o ë.
- Hash: SHA256 con codificación base16
Válido: TO_HEX(SHA256("delacruz"))
No válida: TO_HEX(SHA256("de la Cruz, Jr."))
País
- Incluya el código del país, aun cuando todos los datos de sus clientes correspondan al mismo país.
- No generes un hash en los datos de país
- Usa los códigos de país ISO 3166-1 alpha-2
- Hashing: Ninguno
Válido: US
No válido: United States of America o USA
Código postal
- No generes un hash en los datos de código postal
- Se permite el uso tanto de códigos postales estadounidenses como internacionales.
- Para EE.UU.:
- Se permiten códigos de 5 dígitos, por ejemplo, 94043.
- También se permite el uso de códigos de 5 dígitos seguidos de una extensión de 4 dígitos (por ejemplo, 94043-1351 o 940431351).
- Para todos los demás países:
- No se necesita formato (no es necesario escribir en minúsculas ni quitar espacios ni caracteres especiales)
- Omita las extensiones de código postal.
- Hashing: Ninguno
Validación de hash y codificación de datos
Puedes usar las siguientes secuencias de comandos de validación de hash para asegurarte de que tus datos tengan el formato correcto.
/**
* @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()
/**
* @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()
"""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()
"""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()
/*
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")
}
/*
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")
}
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");
}
}
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");
}
}
/*
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`;
/*
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`;
Claves de unión
Algunas combinaciones de datos proporcionados por el usuario son más sólidas que otras. A continuación, se muestra una lista de las diferentes combinaciones de datos proporcionados por el usuario, clasificadas según su fortaleza relativa. Si usas una dirección, debes incluir el nombre, el apellido, el país y el código postal.
- Correo electrónico, teléfono y dirección (más confiables)
- Teléfono y dirección
- Correo electrónico, dirección
- Correo electrónico, teléfono
- Dirección
- Teléfono
- Correo electrónico (menos seguro)
Crea una tabla de coincidencias
- Haz clic en Conexiones > Crear conexión > Correlación de datos proporcionados por el usuario.
- Elige una fuente de datos y, luego, haz clic en Conectar.
- Realiza la autenticación si se te solicita y, luego, haz clic en Siguiente:
Haz clic en Aplicar para otorgar acceso a BigQuery.
Haz clic en Aplicar para otorgar acceso a Cloud Storage.
Ingresa la ubicación, el puerto, el nombre de usuario y la contraseña de tu base de datos de MySQL.
Ingresa tu clave de acceso secreta de Amazon S3.
Ingresa la ubicación, el puerto, el nombre de usuario, la contraseña y la base de datos de PostgreSQL.
Ingresa la ubicación, el puerto, el nombre de usuario, la contraseña y la base de datos de Redshift.
Ingresa la ubicación, el nombre de usuario y la contraseña del servidor SFTP.
Ingresa el identificador, el nombre de usuario y la contraseña de tu cuenta de Snowflake.
- Configura tu fuente de datos y, luego, haz clic en Siguiente:
Selecciona la tabla de BigQuery que deseas importar.
Ingresa la ruta de acceso de gsutil, como
gs://my-bucket/folder/, y selecciona el formato de tu archivo.Si es la primera vez que conectas este recurso, aparecerá una alerta. Haz clic en Aplicar para otorgar acceso y, luego, en Siguiente. Nota: Debes tener un rol con permiso para delegar
storage.buckets.setIamPolicyal bucket pertinente.Selecciona la base de datos y la tabla de MySQL que quieres usar.
Ingresa el URI del archivo que deseas subir, en relación con la dirección del host.
Ingresa el esquema y el nombre de la tabla (o vista) de PostgreSQL.
Ingresa el esquema y el nombre de la tabla (o vista) de Redshift. De forma predeterminada, Redshift usa las URLs de ubicación de la base de datos que siguen esta plantilla:
cluster-identifier.account-number.aws-region.redshift.amazonaws.com.Ingresa la ruta de acceso y el nombre del archivo con el formato
/PATH/FILENAME.csv.Ingresa la base de datos, el esquema y la tabla (o vista) de Snowflake que deseas usar.
- Selecciona un conjunto de datos de BigQuery para usarlo como destino intermedio y, luego, haz clic en Siguiente. Este paso garantiza que tus datos tengan el formato correcto.
- Opcional: Modifica el formato de tus datos. Las transformaciones incluyen el hash de procesamiento, el formato de mayúsculas/minúsculas y la combinación o división de campos.
- Haz clic en Acción > > Transformar.
- En el panel que aparece, haz clic en Agregar transformación o Agregar otra transformación.
- Elige un tipo de transformación en el menú desplegable y, luego, ingresa los requisitos.
- Haz clic en Guardar.
- Elige al menos una clave de unión y asigna los campos que usarás. Ads Data Hub asignará automáticamente campos con nombres idénticos, indicados por una . Realiza las modificaciones necesarias y, luego, haz clic en Siguiente.
- Establece un programa:
- Asigna un nombre a la conexión.
- Establece una frecuencia que determine con qué frecuencia se importarán los datos al conjunto de datos que seleccionaste en el paso anterior. Cada ejecución reemplazará los datos de la tabla de destino.
- Especifica cómo deseas que se manejen las colisiones de ID de usuario. Puedes elegir entre mantener la coincidencia existente o reemplazarla con datos nuevos.
- Haz clic en Finalizar. Por lo general, las tablas de coincidencias están listas para consultarse 12 horas después de su creación.
Ver detalles de conexión
La página de detalles de la conexión te brinda información sobre las ejecuciones y los errores recientes de una conexión determinada. Para ver los detalles de una conexión específica, sigue estos pasos:
- Haz clic en Conexiones.
- Haz clic en el nombre de la conexión para ver sus detalles.
- Ahora puedes ver los detalles de la conexión y las ejecuciones recientes. Cada uno muestra dos tipos posibles de errores: a nivel de la conexión (la conexión no se ejecutó) y a nivel de la fila (no se importó una fila).
- Un estado Failed indica que no se pudo ejecutar toda la conexión (p.ej., un problema de permiso de la cuenta de servicio). Haz clic en el estado de error para ver qué errores afectaron la conexión.
- Un estado Completado indica que la conexión se ejecutó correctamente. Sin embargo, es posible que aún haya errores a nivel de la fila, que se indican con un valor distinto de cero en la columna "Rows with errors". Haz clic en el valor para obtener más información sobre los registros que fallaron.
Edita una conexión
Puedes editar los siguientes detalles:
- Nombre de la conexión
- Programar
- Tabla de destino
- Asignación de campos
No se admite la edición de la fuente de datos. Para cambiar una fuente de datos, crea una conexión nueva y borra la anterior.
Para editar los detalles de la conexión, sigue estos pasos:
- Haz clic en Conexiones.
- Haz clic en el nombre de la conexión que deseas editar.
- Edita los detalles que quieras cambiar:
- Nombre de la conexión: Haz clic en Editar, ingresa el nombre nuevo y, luego, presiona Intro.
- Programación: Haz clic en Editar, establece la nueva programación y, luego, haz clic en Guardar.
- Tabla de destino: Haz clic en Editar, ingresa el nuevo nombre de destino y, luego, haz clic en Guardar.
- Asignación de campos: Haz clic en , realiza cambios en los campos y, luego, haz clic en Guardar.
- Haz clic en .
Cómo consultar datos coincidentes
Consulta las tablas de coincidencias
Cuando tus tablas de coincidencias contengan suficientes datos para satisfacer las verificaciones de privacidad, podrás ejecutar consultas en ellas.
La tabla original de los datos de origen (1PD) se representa con my_data.
Esto incluye la información de identificación personal (PII) y los datos que no son PII.
El uso de la tabla original puede mejorar tus informes con más estadísticas, ya que representa todos los datos de 1PD en el alcance, en comparación con una tabla de coincidencias.
Cada tabla del esquema del Centro de Datos de Anuncios que contiene un campo user_id se acompaña de una tabla de concordancia. Por ejemplo, para la tabla adh.google_ads_impressions, el Centro de Datos de Anuncios también genera una tabla de coincidencias llamada adh.google_ads_impressions_updm que contiene tus IDs de usuario.
Se crean tablas de coincidencias independientes para las tablas aisladas por políticas. Por ejemplo, para la tabla adh.google_ads_impressions_policy_isolated_youtube, el Centro de Datos de Anuncios también genera una tabla de coincidencias llamada adh.google_ads_impressions_policy_isolated_youtube_updm que contiene tus IDs de usuario.
Estas tablas contienen un subconjunto de los usuarios disponibles en las tablas originales,
en las que hay una coincidencia en user_id. Por ejemplo, si la tabla original contiene datos del Usuario A y del Usuario B, pero solo se encuentra una coincidencia para el Usuario A, el Usuario B no estará en la tabla de coincidencias.
Las tablas de coincidencias contienen una columna adicional llamada customer_data_user_id, que almacena el identificador de usuario como BYTES.
Es importante considerar el tipo de campo cuando escribas tus consultas. Los operadores de comparación de SQL esperan que los literales que comparas sean del mismo tipo. Según cómo se almacene el user_id en tu tabla de datos propios, es posible que debas codificar los valores de la tabla antes de hacer coincidir los datos.
Debes transmitir tu clave de unión a BYTES para que las coincidencias se realicen correctamente:
JOIN ON
adh.google_ads_impressions_updm.customer_data_user_id = CAST(my_data.user_id AS BYTES)
Además, las comparaciones de cadenas en SQL distinguen mayúsculas de minúsculas, por lo que es posible que debas codificar cadenas en ambos lados de la comparación para asegurarte de que se puedan comparar con precisión.
Consultas de muestra
Cuenta los usuarios coincidentes
Esta consulta cuenta la cantidad de usuarios coincidentes en tu tabla de impresiones de Google Ads.
/* Count matched users in Google Ads impressions table */
SELECT COUNT(DISTINCT user_id)
FROM adh.google_ads_impressions_updm
En esta consulta, se muestra cómo unir datos de origen con datos de 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
Preguntas frecuentes sobre el porcentaje de coincidencias de la UPDM
Para obtener una lista de preguntas frecuentes relacionadas con el porcentaje de coincidencias de la UPDM, consulta las Preguntas frecuentes sobre el porcentaje de coincidencias de la UPDM.