Trabajar con combinaciones en LookML

Las combinaciones 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 puede incluir las tablas order_items, orders y users. Puedes usar las combinaciones para consultar 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 empiezan con Explorar

Las combinaciones se definen en el archivo de modelo para establecer la relación entre una Exploración y una vista. Las combinaciones conectan una o varias vistas a una sola exploración, ya sea directamente o a través de otra vista combinada.

Consideremos dos tablas de bases de datos: order_items y orders. Después de generar las vistas de ambas tablas, declare una o varias de ellas en el parámetro explore del archivo de modelo:

explore: order_items { ... }

Cuando ejecutas una consulta desde order_items Explorar, order_items aparece en la cláusula FROM del SQL generado:

SELECT ...
FROM order_items

Puedes añadir información adicional a la exploración order_items. Por ejemplo, puedes usar el siguiente LookML de muestra para unir la vista orders a la Exploración 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 ha mostrado anteriormente hace dos cosas. En primer lugar, puede 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 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.

Parámetros de unión

Para combinar, se usan cuatro parámetros principales: join, type, relationship y sql_on.

Paso 1: Iniciar la exploración

Primero, cree la exploración:order_items

explore: order_items { ... }

Paso 2: join

Para unirte a una tabla, primero debes declararla en una vista. En este ejemplo, supongamos que orders es una vista de tu modelo.

A continuación, utilice el parámetro join para declarar que quiere unir la vista orders a la exploración order_items:

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

Paso 3: type

Piensa qué tipo de combinación quieres realizar. Looker admite LEFT JOIN, INNER JOIN, FULL OUTER JOIN y CROSS JOIN. Estos valores 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 la exploración order_items y la vista orders. Declarar correctamente la relación de una combinación es importante para que Looker calcule medidas precisas. La relación se define desde la vista order_items Explorar 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 de la Exploración 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 la combinación, Looker usará many_to_one de forma predeterminada.

Para obtener más consejos sobre cómo definir correctamente el parámetro relationship en una unión, consulta el artículo Definir correctamente el parámetro relationship.

Paso 5: sql_on

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

El parámetro sql_on es equivalente a la cláusula ON en el código SQL generado para una consulta. Con este parámetro, puede declarar qué campos deben coincidir para realizar la combinació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 combinaciones más complejas. Por ejemplo, puede que solo quieras combinar pedidos con un id superior a 1000:

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 comprobar que esta combinación funciona correctamente, ve a la exploración Artículos de pedido. Deberías ver campos de order_items y orders.

Consulta Probar los campos de Exploración para obtener más información sobre cómo probar los cambios de LookML en una exploración.

Unirse a través de otra vista

Puedes unir una vista a una Exploración a través de otra vista. En el ejemplo de parámetros de unión, has unido orders a order_items mediante el campo order_id. También podríamos querer combinar los datos de una vista llamada users con los de la exploración order_items, aunque no compartan ningún campo. Para ello, únete a través de la vista orders.

Use 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 sección Explorar order_items. Para ello, asigna el valor orders.user_id al campo orders.

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 users contiene datos de compradores y vendedores. Para combinar los datos de esta vista en order_items, pero hacerlo por separado para compradores y vendedores, puede combinar users dos veces, con nombres diferentes, mediante el parámetro from.

El parámetro from te permite especificar qué vista quieres usar en una combinación y, al mismo tiempo, asignar un nombre único a la combinació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 combinan los datos del comprador como buyers, mientras que solo se combinan los datos del vendedor como sellers.

Nota: Ahora, la vista users debe referenciarse por sus nombres de alias buyers y sellers en la combinación.

Limitar los campos de una unión

El parámetro fields te permite especificar qué campos se incorporan a una Exploración a partir de una combinación. De forma predeterminada, se incluyen todos los campos de una vista cuando se combinan. Sin embargo, puede que solo quieras importar un subconjunto de campos.

Por ejemplo, cuando orders se une a order_items, puede que solo quiera incluir los campos shipping y tax en 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 en una vista mediante el parámetro set. Supongamos que tiene el siguiente conjunto definido en la vista orders:

set: orders_set {
  fields: [created_date, shipping, tax]
}

Puedes elegir incluir solo estos tres campos al combinar 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*]
  }
}

Agregados simétricos

Looker usa una función llamada "agregaciones simétricas" para calcular las agregaciones (como sumas y medias) correctamente, incluso cuando las combinaciones dan como resultado una ramificación. Los agregados simétricos se describen con más detalle en el artículo Información sobre los agregados simétricos. El problema de la dispersión que resuelven las agregaciones simétricas se explica en la publicación de la comunidad El problema de la dispersión de SQL.

Se requieren claves principales

Para que las medidas (agregaciones) se incluyan en las uniones, debe definir claves principales en todas las vistas que participen en la unión.

Para ello, añade el parámetro primary_key a la definición del campo de clave principal de cada vista:

dimension: id {
  type: number
  primary_key: yes
}

Dialectos de SQL admitidos

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 última versión de Looker:

Si tu dialecto no admite agregaciones simétricas, ten cuidado al ejecutar combinaciones en Looker, ya que algunos tipos de combinaciones pueden dar lugar a agregaciones imprecisas (como sumas y promedios). Este problema y las soluciones alternativas se describen con gran detalle en la publicación de la comunidad El problema de las réplicas de SQL.

Más información sobre las combinaciones

Para obtener más información sobre los parámetros de unión en LookML, consulta la documentación de referencia de unión.