Las uniones le permiten conectar diferentes vistas para que pueda explorar datos de más de una vista al mismo tiempo y ver cómo se relacionan las diferentes partes de sus datos entre sí.
Por ejemplo, tu base de datos podría incluir las tablas order_items, orders y users. Puede usar uniones para explorar datos de todas las tablas al mismo tiempo. En esta página, se explican las uniones en LookML, incluidos los parámetros de unión específicos y los patrones de unión.
Las uniones comienzan con la función Explorar
Las uniones se definen en el archivo de modelo para establecer la relación entre una exploración y una vista. Las uniones conectan una o más vistas a una sola exploración, ya sea directamente o a través de otra vista unida.
Consideremos dos tablas de base de datos: order_items y orders. Después de generar vistas para ambas tablas, declara una o más de ellas en el parámetro explore del archivo del modelo:
explore: order_items { ... }
Cuando ejecutas una consulta desde order_items Explore, order_items aparece en la cláusula FROM del SQL generado:
SELECT ...
FROM order_items
Puedes unirte a la información adicional en order_items Explorar. Por ejemplo, para agregar datos sobre el orders del que forma parte order_item, puedes hacer lo siguiente:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
}
}
El LookML anterior logra dos cosas. Primero, puedes ver los campos de orders y order_items en la IU:
En segundo lugar, el LookML describe cómo unir orders y order_items. Ese LookML se traduciría al siguiente SQL:
SELECT ...
FROM order_items
LEFT JOIN orders
ON order_items.order_id = orders.id
Estos parámetros de LookML se describen con más detalle en las siguientes secciones. Consulta la página de referencia del parámetro join para obtener más información sobre cómo se traduce este LookML a SQL.
Sugerencia para el equipo de Chat: Los usuarios suelen preguntar sobre el error de validación "Campo desconocido o inaccesible", que puede deberse a una unión faltante. Consulta la página de prácticas recomendadas sobre este error para obtener más información.
Parámetros de unión
Se usan cuatro parámetros principales para unir: join, type, relationship y sql_on.
Paso 1: Inicia la exploración
Primero, crea el archivo Explorar de order_items:
explore: order_items { ... }
Paso 2: join
Para unirte a una tabla, primero debes declararla en una vista. En este ejemplo, orders es una vista existente en nuestro modelo.
Luego, usa el parámetro join para declarar que quieres unir la vista orders a order_items:
explore: order_items {
join: orders { ... }
}
Paso 3: type
Considera qué type realizar. Looker admite LEFT JOIN, INNER JOIN, FULL OUTER JOIN y CROSS JOIN. Estas se corresponden con los valores del parámetro type de left_outer, inner, full_outer y cross.
explore: order_items {
join: orders {
type: left_outer
}
}
El valor predeterminado de type es left_outer y, por lo general, es el tipo de unión popular.
Paso 4: relationship
Define una unión relationship entre order_items y orders. Es importante declarar correctamente el relationship de una unión para que Looker calcule mediciones precisas. La relación se define desde la vista order_items hasta la vista orders. Las opciones posibles son one_to_one, many_to_one, one_to_many y many_to_many.
En este ejemplo, puede haber muchos order_items para una sola order. La relación de order_items con orders es many_to_one:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
}
}
Si no incluyes un relationship en la unión, el valor predeterminado de Looker es many_to_one.
Si quieres obtener sugerencias adicionales a fin de definir correctamente el parámetro relationship para una unión, consulta la página Cómo obtener el parámetro relationship correcto.
Paso 5: sql_on
Declara cómo unir estas dos tablas con el parámetro sql_on o foreign_key. Por lo general, sugerimos sql_on, ya que puede hacer todo lo que hace foreign_key, pero suele ser más fácil de entender.
sql_on es equivalente a la cláusula ON en el SQL generado para una consulta. Con este parámetro, podemos declarar qué campos deben coincidir para realizar la unión:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
}
}
También puede escribir uniones más complejas. Por ejemplo, es posible que quieras unir solo pedidos con un valor de id mayor que 1,000:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} AND ${orders.id} > 1000 ;;
}
}
Consulta los operadores de sustitución para obtener más información sobre la sintaxis de ${ ... } en estos ejemplos.
Paso 6: Prueba
Pruebe que la unión funcione según lo previsto. Para ello, vaya a Explorar artículos del pedido. Deberías ver campos de order_items y orders.
Consulta Desarrollo de modelos para obtener más información sobre cómo probar los cambios de LookML.
Unirse mediante otra vista
Puedes unirte a una vista a Explorar a través de otra vista. En el ejemplo anterior, uniste orders a order_items mediante el campo order_id. También es posible que deseemos unir los datos de una vista llamada users a la exploración de order_items, aunque no compartan un campo común. Para ello, puedes unirte a través de la vista orders.
Usa sql_on o foreign_key para unir a users a orders, en lugar de order_items. Para hacerlo, define correctamente el alcance del campo de orders como orders.user_id.
En este ejemplo, se usa sql_on:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
}
join: users {
type: left_outer
relationship: many_to_one
sql_on: ${orders.user_id} = ${users.id} ;;
}
}
Cómo unirse a una vista más de una vez
Una vista de users contiene datos de los compradores y los vendedores. Para unir los datos de esta vista a order_items, pero lo haces de forma separada para los compradores y vendedores, puedes unir users dos veces, con nombres diferentes, mediante el parámetro from.
El parámetro from te permite especificar qué vista usar en una unión y darle un nombre único a esta. Por ejemplo:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
}
join: buyers {
from: users
type: left_outer
relationship: many_to_one
sql_on: ${orders.buyer_id} = ${buyers.id} ;;
}
join: sellers {
from: users
type: left_outer
relationship: many_to_one
sql_on: ${orders.seller_id} = ${sellers.id} ;;
}
}
En este caso, solo los datos del comprador se unen como buyers, mientras que solo los datos del vendedor se unen como sellers.
Nota: La vista users ahora debe referirse a sus nombres con alias buyers y sellers en la unión.
Limita los campos de una unión
El parámetro fields te permite especificar qué campos se trasladan de una unión a Explorar. De forma predeterminada, todos los campos de una vista se incorporan cuando se unen. Sin embargo, es posible que quieras usar solo un subconjunto de campos.
Por ejemplo, cuando orders se une a order_items, es posible que quieras usar solo los campos shipping y tax a través de la unión:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
fields: [shipping, tax]
}
}
También puedes hacer referencia a un conjunto de campos, como [set_a*]. Cada conjunto se define dentro de una vista con el parámetro set. Supongamos que tienes el siguiente conjunto definido en la vista orders:
set: orders_set {
fields: [created_date, shipping, tax]
}
Puedes elegir solo estos tres campos cuando unas orders a order_items:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
fields: [orders_set*]
}
}
Agregaciones simétricas
Looker usa una función llamada “agregaciones simétricas” para calcular correctamente las agregaciones (como sumas y promedios), incluso cuando las uniones generan una distribución. Los grupos simétricos se describen con más detalle en la página de prácticas recomendadas Información sobre los agregados simétricos, y el problema de distribución que se explica se explica en la publicación de Comunidad El problema de las distribuciones de SQL.
Claves primarias obligatorias
Para que las mediciones (agregaciones) se realicen mediante uniones, debe definir claves primarias en todas las vistas que participan en la unión.
Para ello, agrega el parámetro primary_key a la definición del campo de clave primaria en cada vista:
dimension: id {
type: number
primary_key: yes
}
Para controlar de forma correcta las medidas que se unen, Looker se basa en que especificas una clave primaria en la que los valores son completamente únicos y no nulos. Si tus datos no contienen una clave primaria, considera si la concatenación de varios campos daría como resultado una clave primaria de valores completamente únicos y no NULOS. Si tu clave primaria no es única o contiene valores NULL y tu consulta incluye datos que revelan esos problemas, Looker muestra un error como se describe en la página de prácticas recomendadas Error: Valor no único/clave primaria (o clave sql_distinct_key), desbordamiento de valor o colisión.
Dialectos de SQL compatibles
Para que Looker admita agregaciones simétricas en tu proyecto de Looker, el dialecto de tu base de datos también debe admitirlas. En la siguiente tabla, se muestra qué dialectos admiten agregaciones simétricas en la versión más reciente de Looker:
Si tu dialecto no admite agregaciones simétricas, ten cuidado cuando ejecutes uniones en Looker, ya que algunos tipos de uniones pueden generar agregaciones inexactas (como sumas y promedios). Este problema y sus soluciones alternativas se describen en detalle en la publicación de Comunidad El problema de las distribuciones de SQL.
Más información sobre las uniones
Para obtener más información sobre los parámetros de unión en LookML, consulta la documentación de referencia de unión.