Trabaja con uniones en LookML

Los joins 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 joins para explorar datos de todas las tablas al mismo tiempo. En esta página, se explican los joins en LookML, incluidos los parámetros de join específicos y los patrones de unión.

Los joins comienzan con una exploración

Los joins se definen en el archivo de modelo para establecer la relación entre una exploración y una vista. Los joins 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 de modelo:

explore: order_items { ... }

Cuando ejecutas una consulta desde la exploración order_items, order_items aparece en la cláusula FROM del 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 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 mostró anteriormente logra dos cosas. Primero, puedes ver los campos de orders y order_items en el selector de campos de la exploración:

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.

Sugerencia del equipo de chat: Los usuarios preguntan más sobre el error de validación "Unknown or inaccessible field", que puede deberse a un join faltante. Consulta Error: Unknown or inaccessible field para obtener más información.

Parámetros de join

Se usan 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, supongamos que orders es una vista existente en tu modelo.

Luego, usa el parámetro join para declarar que deseas unir la vista orders a la exploración order_items:

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

Paso 3: type

Considera qué tipo de join realizar. 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 join entre la exploración order_items y la vista orders. Declarar correctamente la relación de un join 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 de la exploración order_items a 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 join, Looker usará many_to_one de forma predeterminada.

Para obtener sugerencias adicionales sobre cómo definir correctamente el parámetro relationship para un join, consulta Cómo obtener el parámetro relationship correcto.

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.

**Sugerencia:** Por lo general, sugerimos usar el parámetro sql_on, ya que puede hacer todo lo que puede hacer el parámetro foreign_key, pero el parámetro sql_on suele ser más fácil de entender.

El parámetro sql_on equivale a la cláusula ON en el SQL generado para una consulta. Con este parámetro, puedes declarar qué campos se deben hacer coincidir para realizar el join:

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

También puedes escribir joins más complejos. Por ejemplo, es posible que desees unir solo los pedidos con un id mayor que 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 de los operadores de sustitución para obtener más información sobre la sintaxis ${ ... } en estos ejemplos.

Paso 6: Prueba

Para probar que este join funcione según lo previsto, ve a la exploración Order Items. Deberías ver campos de order_items y orders.

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

Cómo 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 join, uniste orders a order_items con el campo order_id. También es posible que queramos unir los datos de una vista llamada users a la exploración order_items, aunque no compartan un campo común. Esto se puede hacer uniendo a través de la vista orders.

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

Este es 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} ;;
  }
}

Cómo unir una vista más de una vez

Una vista users contiene datos de compradores y vendedores. Para unir datos de esta vista a order_items, pero hacerlo por separado para compradores y vendedores, puedes unir users dos veces, con nombres diferentes, usando el from parámetro.

El parámetro from te permite especificar qué vista usar en un join y, al mismo tiempo, asignarle un nombre único al join. 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 el join.

Cómo limitar campos de un join

El parámetro fields te permite especificar qué campos se traen de un join a una exploración. De forma predeterminada, se incluyen todos los campos de una vista cuando se unen. Sin embargo, es posible que desees incluir solo 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 del join:

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 set parámetro. 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 unes 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 las agregaciones (como sumas y promedios) correctamente, incluso cuando los joins generan una expansión. Las agregaciones simétricas se describen con más detalle en Comprende las agregaciones simétricas. El problema de expansión que resuelven las agregaciones simétricas se explica en la publicación de Comunidad El problema de las expansiones de SQL.

Se requieren claves primarias

Para que las medidas (agregaciones) se realicen a través de joins, debes definir claves primarias en todas las vistas que participan en el join.

Para ello, agrega el primary_key parámetro a la definición del campo de clave primaria en cada vista:

dimension: id {
  type: number
  primary_key: yes
}

Nota: Para controlar correctamente las medidas unidas, Looker depende de que especifiques una clave primaria en la que los valores sean completamente únicos y no sean NULL. Si tus datos no contienen una clave primaria, considera si la concatenación de varios campos generaría una clave primaria de valores completamente únicos y no NULL. 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 Prácticas recomendadas para el error: valor o clave primaria no únicos (o sql_distinct_key), desbordamiento o colisión de valores cuando se calcula la suma.

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 muestran los dialectos que admiten agregaciones simétricas en la versión más reciente de Looker:

Dialecto	¿Es compatible?
Actian Avalanche
Amazon Athena
Amazon Aurora MySQL
Amazon Redshift
Amazon Redshift 2.1+
Amazon Redshift Serverless 2.1+
Apache Druid
Apache Druid 0.13+
Apache Druid 0.18+
Apache Hive 2.3+
Apache Hive 3.1.2+
Apache Spark 3+
ClickHouse
Cloudera Impala 3.1+
Cloudera Impala 3.1+ with Native Driver
Cloudera Impala with Native Driver
DataVirtuality
Databricks
Denodo 7
Denodo 8 & 9
Dremio
Dremio 11+
Exasol
Google BigQuery Legacy SQL
Google BigQuery Standard SQL
Google Cloud PostgreSQL
Google Cloud SQL
Google Spanner
Greenplum
HyperSQL
IBM Netezza
MariaDB
Microsoft Azure PostgreSQL
Microsoft Azure SQL Database
Microsoft Azure Synapse Analytics
Microsoft SQL Server 2008+
Microsoft SQL Server 2012+
Microsoft SQL Server 2016
Microsoft SQL Server 2017+
MongoBI
MySQL
MySQL 8.0.12+
Oracle
Oracle ADWC
PostgreSQL 9.5+
PostgreSQL pre-9.5
PrestoDB
PrestoSQL
SAP HANA
SAP HANA 2+
SingleStore
SingleStore 7+
Snowflake
Teradata
Trino
Vector
Vertica

Si tu dialecto no admite agregaciones simétricas, ten cuidado cuando ejecutes joins en Looker, ya que algunos tipos de joins pueden generar agregaciones inexactas (como sumas y promedios). Este problema y las soluciones alternativas se describen en detalle en la publicación de Comunidad El problema de las expansiones de SQL.

Más información sobre los joins

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