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 las distintas partes de sus datos se relacionan entre sí.
Por ejemplo, tu base de datos puede incluir las tablas order_items, orders y users. Puedes 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 y patrones de unión específicos.
Las uniones comienzan con una exploración
Las uniones se definen en el archivo de modelo para establecer la relación entre Explorar 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 Explorar de order_items, order_items aparece en la cláusula FROM del SQL generado:
SELECT ...
FROM order_items
Puedes unirte a la exploración adicional de order_items. Por ejemplo, para agregar datos sobre el order 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, LookML describe cómo unir orders y order_items juntos. 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 equipos de chat: Los usuarios preguntan más acerca del error de validación, que puede deberse a una unión faltante. Consulta el artículo del Centro de ayuda sobre este error para obtener más información.
Parámetros de unión
Se usan cuatro parámetros principales: joins, join, type, relationship y sql_on.
Paso 1: Inicia la exploración
Primero, crea la exploración de order_items:
explore: order_items { ... }
Paso 2: join
Para unir 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 deseas unir la vista orders a order_items:
explore: order_items {
join: orders { ... }
}
Paso 3: type
Considera qué type de unión realizar. Looker admite LEFT JOIN, INNER JOIN, FULL OUTER JOIN y CROSS JOIN. Estos corresponden a los valores de 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 las medidas precisas. La relación se define desde la exploración de order_items hasta la vista de orders. Las opciones posibles son one_to_one, many_to_one, one_to_many y many_to_many.
En este ejemplo, puede haber muchas order_items para una sola order. La relación de order_items a orders es many_to_one:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
}
}
Si no incluyes un relationship en tu unión, Looker usa many_to_one de forma predeterminada.
Si quieres obtener sugerencias adicionales sobre cómo definir correctamente el parámetro relationship para una unión, consulta el artículo del Centro de ayuda Cómo obtener el parámetro relationship adecuado.
Paso 5: sql_on
Declara cómo unir estas dos tablas con los parámetros sql_on o foreign_key. Por lo general, sugerimos sql_on, ya que puede hacer todo lo que foreign_key puede hacer, 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 puedes escribir uniones más complejas. Por ejemplo, es posible que solo desees unir pedidos con id mayores 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 ${ ... } en estos ejemplos.
Paso 6: Prueba
Pruebe que esta combinación funcione según lo esperado en la sección 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 a través del campo order_id. Es posible que también desees unir los datos de una vista llamada users a la exploración 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 users a orders en lugar de order_items. Para ello, establece el alcance correctamente del campo de orders como orders.user_id.
A continuación, se muestra un ejemplo con 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} ;;
}
}
Unirse a una vista más de una vez
Una vista de users contiene datos de compradores y vendedores. Para unir los datos de esta vista en order_items, pero lo haces por separado para 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 combinación y darle un nombre único. 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: Ahora se debe hacer referencia a la vista users por sus nombres de alias buyers y sellers en la unión.
Limita los campos de una combinación
El parámetro fields te permite especificar qué campos se trasladan de una combinación en Explorar. De forma predeterminada, todos los campos de una vista se incorporan cuando se unen. Sin embargo, te recomendamos que uses solo un subconjunto de campos.
Por ejemplo, cuando orders se une a order_items, es posible que quieras mostrar 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 incluir 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*]
}
}
Totales simétricos
Looker usa una función llamada agregados simétricos para calcular correctamente las agregaciones (como sumas y promedios), incluso cuando las uniones generan un fanout. Los agregados simétricos se describen con más detalle en el artículo Explicación sencilla de los agregados simétricos del Centro de ayuda. El problema de distribución que se resuelve se explica en el artículo Problemas de las distribuciones de SQL.
Se requieren claves primarias
Para que las mediciones (agregaciones) provengan de uniones, debes 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 manejar correctamente las medidas unidas, Looker se basa en que especifique una clave primaria en la que los valores sean valores únicos, 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 no nulos por completo. Si su clave primaria no es única o contiene valores NULL y su consulta incluye datos que revelan esos problemas, Looker muestra un error como se describe en este artículo del Centro de ayuda.
Dialectos de SQL compatibles
Para que Looker admita los agregados simétricos en su proyecto de Looker, su dialecto de base de datos también debe admitirlos. 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 combinaciones en Looker, ya que algunos tipos de uniones pueden dar como resultado agregaciones imprecisas (como sumas y promedios). Este problema y las soluciones alternativas que se brindan se describen en detalle en el artículo El problema de las distribuciones manuales 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 Referencia de uniones.