Trabaja con uniones en LookML

Las uniones te permiten conectar diferentes vistas para que puedas explorar datos de más de una vista al mismo tiempo y ver cómo se relacionan entre sí las diferentes partes de tus datos.

Por ejemplo, tu base de datos podría incluir las tablas order_items, orders y users. Puedes usar las uniones para explorar los 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 combinaciones comienzan con una exploración

Los joins se definen en el archivo de modelo para establecer la relación entre un Explore 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.

Considera dos tablas de bases 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 el Explorador order_items, order_items aparece en la cláusula FROM del código SQL generado:

SELECT ...
FROM order_items

Puedes unir información adicional a la exploración order_items. Por ejemplo, puedes usar el siguiente LookML de muestra para unir la vista orders al Explorar order_items:

explore: order_items {
  join: orders {
    type: left_outer
    relationship: many_to_one
    sql_on: ${order_items.order_id} = ${orders.id} ;;
  }
}

El LookML que se mostró anteriormente logra dos objetivos. Primero, puedes ver los campos de orders y order_items en el selector de campos de Explorar:

En segundo lugar, LookML describe cómo unir orders y order_items. Ese código LookML se traduciría al siguiente código 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.

Parámetros de unión

Se utilizan cuatro parámetros principales para unir: join, type, relationship y sql_on.

Paso 1: Inicia la exploración

Primero, crea la Exploración order_items:

explore: order_items { ... }

Paso 2: join

Para unir una tabla, primero debes declararla en una vista. En este ejemplo, supón que orders es una vista existente en tu modelo.

Luego, usa el parámetro join para declarar que deseas unir la vista orders al Explorar order_items:

explore: order_items {
  join: orders { ... }
}

Paso 3: type

Considera qué tipo de combinación realizarás. Looker admite LEFT JOIN, INNER JOIN, FULL OUTER JOIN y CROSS JOIN. Estos corresponden a 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.

Paso 4: relationship

Define una relación de unión entre el Explore order_items y la vista orders. Declarar correctamente la relación de una unión es importante para que Looker calcule medidas precisas. La relación se define desde la Exploración 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 elementos de pedido para un solo pedido. La relación del Explorar order_items con la vista orders es many_to_one:

explore: order_items {
  join: orders {
    type: left_outer
    relationship: many_to_one
  }
}

Si no incluyes un parámetro relationship en tu unión, Looker usará many_to_one de forma predeterminada.

Si deseas obtener sugerencias adicionales para definir correctamente el parámetro relationship para una unión, consulta Cómo definir correctamente el parámetro relationship.

Paso 5: sql_on

Declara cómo unir la tabla order_items y la tabla orders con el parámetro sql_on o el parámetro foreign_key.

El parámetro sql_on equivale a la cláusula ON en el código SQL generado para una consulta. Con este parámetro, puedes 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 desees unir solo los pedidos con id superior a 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 la documentación sobre los operadores de sustitución para obtener más información sobre la sintaxis de ${ ... } en estos ejemplos.

Paso 6: Prueba

Para probar que esta unión funciona según lo esperado, ve al Explorar Order Items. Deberías ver campos de order_items y orders.

Consulta Cómo probar los campos en Explorar para obtener más información sobre cómo probar los cambios de LookML en Explorar.

Cómo unirse a través de otra vista

Puedes unir una vista a un Explorar a través de otra vista. En el ejemplo de parámetros de unión, uniste orders a order_items a través del campo order_id. También podríamos querer unir los datos de una vista llamada users al Explorar order_items, aunque no compartan un campo común. Esto se puede hacer uniendo a través de la vista orders.

Usa el parámetro sql_on o el parámetro foreign_key para unir la vista users a la vista orders, en lugar de a la función Explorar order_items. Para ello, define correctamente el alcance del campo de orders como orders.user_id.

A continuación, se muestra un ejemplo en el que se usa el parámetro 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 tanto para los compradores como para los vendedores. Para unir los datos de esta vista en order_items, pero hacerlo por separado para compradores y vendedores, puedes unir users dos veces, con nombres diferentes, usando el parámetro from.

El parámetro from te permite especificar qué vista usar en una unión, a la vez que le asigna un nombre único a la unión. 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 se unen los datos del comprador como buyers, mientras que solo se unen los datos del vendedor como sellers.

Nota: Ahora, se debe hacer referencia a la vista users por sus nombres con alias buyers y sellers en la unión.

Cómo limitar los campos de una unión

El parámetro fields te permite especificar qué campos se incorporan de una unión a una exploración. De forma predeterminada, cuando se unen, se incluyen todos los campos de una vista. Sin embargo, es posible que solo quieras importar un subconjunto de campos.

Por ejemplo, cuando orders se une a order_items, es posible que desees incluir 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 optar por incluir solo estos tres campos cuando combines orders con 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 las agregaciones (como sumas y promedios) de forma correcta, incluso cuando las uniones generan una expansión. Los agregados simétricos se describen con más detalle en Acerca de los agregados simétricos. El problema de expansión que resuelven los agregados simétricos se explica en la publicación de Comunidad El problema de la expansión de SQL.

Se requieren claves primarias

Para que las medidas (agregaciones) se incluyan en las combinaciones, debes definir claves primarias en todas las vistas que participan en la combinació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
}

Dialectos de SQL compatibles

Para que Looker admita agregaciones simétricas en tu proyecto de Looker, tu dialecto de base de datos también debe admitirlas. En la siguiente tabla, se muestran los dialectos que 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 las soluciones alternativas se describen con gran detalle en la publicación de Comunidad El problema de las fanouts 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.