Trabalhar com junções no LookML

As junções permitem-lhe associar diferentes vistas para poder explorar dados de mais de uma vista em simultâneo e ver como as diferentes partes dos seus dados se relacionam entre si.

Por exemplo, a sua base de dados pode incluir as tabelas order_items, orders e users. Pode usar junções para explorar dados de todas as tabelas ao mesmo tempo. Esta página explica as junções no LookML, incluindo parâmetros de junção específicos e padrões de junção.

As junções começam com uma exploração

As junções são definidas no ficheiro de modelo para estabelecer a relação entre uma exploração e uma vista. As junções associam uma ou mais visualizações a uma única exploração, diretamente ou através de outra visualização unida.

Considere duas tabelas da base de dados: order_items e orders. Depois de gerar visualizações para ambas as tabelas, declare uma ou mais delas no parâmetro explore no ficheiro do modelo:

explore: order_items { ... }

Quando executa uma consulta a partir da funcionalidade order_items Explorarorder_items, order_items aparece na cláusula FROM do SQL gerado:

SELECT ...
FROM order_items

Pode juntar informações adicionais à análise detalhada order_items. Por exemplo, pode usar o seguinte LookML de exemplo para associar a vista orders à exploração order_items:

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

O LookML apresentado anteriormente realiza duas ações. Primeiro, pode ver campos de orders e order_items no selecionador de campos do Explorar:

Em segundo lugar, o LookML descreve como juntar orders e order_items. Esse LookML seria convertido no seguinte SQL:

SELECT ...
FROM order_items
LEFT JOIN orders
ON order_items.order_id = orders.id

Estes parâmetros do LookML são descritos mais detalhadamente nas secções seguintes.

Sugestão da equipa do Chat: os utilizadores perguntam mais sobre o erro de validação "Campo desconhecido ou inacessível", que pode ser causado por uma junção em falta. Consulte Erro: campo desconhecido ou inacessível para mais informações.

Parâmetros de junção

São usados quatro parâmetros principais para a associação: join, type, relationship e sql_on.

Passo 1: iniciar o Explorar

Primeiro, crie a order_itemsexploração:

explore: order_items { ... }

Passo 2: join

Para juntar uma tabela, primeiro tem de declarar a tabela numa vista. Neste exemplo, vamos assumir que orders é uma visualização existente no seu modelo.

Em seguida, use o parâmetro join para declarar que quer juntar a vista orders à exploração order_items:

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

Passo 3: type

Considere o tipo de junção a realizar. O Looker suporta LEFT JOIN, INNER JOIN, FULL OUTER JOIN e CROSS JOIN. Estes correspondem aos valores do parâmetro type de left_outer, inner, full_outer e cross.

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

O valor predefinido de type é left_outer.

Passo 4: relationship

Defina uma relação de junção entre a exploração order_items e a vista orders. Declarar corretamente a relação de uma junção é importante para o Looker calcular medidas precisas. A relação é definida de Explorar para a vista orders.order_items As opções possíveis são one_to_one, many_to_one, one_to_many e many_to_many.

Neste exemplo, pode haver muitos artigos de encomenda para uma única encomenda. A relação da opção Explorar order_items com a vista orders é many_to_one:

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

Se não incluir um parâmetro relationship na junção, o Looker usa a predefinição many_to_one.

Para ver sugestões adicionais sobre como definir corretamente o parâmetro relationship para uma associação, consulte o artigo Como definir corretamente o parâmetro relationship.

Passo 5: sql_on

Declare como juntar a tabela order_items e a tabela orders com o parâmetro sql_on ou o parâmetro foreign_key.

Sugestão: normalmente, sugerimos a utilização do parâmetro sql_on, uma vez que pode fazer tudo o que o parâmetro foreign_key faz, mas o parâmetro sql_on é normalmente mais fácil de compreender.

O parâmetro sql_on é equivalente à cláusula ON no SQL gerado para uma consulta. Com este parâmetro, pode declarar que campos devem ser associados para realizar a junção:

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

Também pode escrever uniões mais complexas. Por exemplo, pode querer juntar apenas encomendas com 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 ;;
  }
}

Consulte a documentação sobre operadores de substituição para saber mais sobre a sintaxe ${ ... } nestes exemplos.

Passo 6: testes

Teste se esta junção está a funcionar como esperado acedendo ao Explorar Order Items. Deve ver campos de order_items e orders.

Consulte o artigo Testar os campos na exploração para saber como testar alterações do LookML numa exploração.

Participar através de outra vista

Pode juntar uma visualização a uma exploração através de outra visualização. No exemplo de parâmetros de junção, juntou orders a order_items através do campo order_id. Também podemos querer juntar os dados de uma vista denominada users à vista order_items Explore, mesmo que não partilhem um campo comum. Pode fazê-lo através da vista orders.

Use o parâmetro sql_on ou o parâmetro foreign_key para associar a vista users à vista orders, em vez de ao Explorar order_items. Para o fazer, defina corretamente o âmbito do campo de orders como orders.user_id.

Segue-se um exemplo que usa o 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} ;;
  }
}

Participar numa visualização mais do que uma vez

Uma vista users contém dados para compradores e vendedores. Para juntar dados desta vista ao order_items, mas fazê-lo separadamente para compradores e vendedores, pode juntar users duas vezes, com nomes diferentes, usando o parâmetro from.

O parâmetro from permite-lhe especificar que visualização usar numa junção, ao mesmo tempo que atribui um nome exclusivo à junção. Por exemplo:

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

Neste caso, apenas os dados do comprador são associados como buyers, enquanto apenas os dados do vendedor são associados como sellers.

Nota: agora, a vista users tem de ser referida pelos respetivos nomes com alias buyers e sellers na junção.

Limitar campos de uma junção

O parâmetro fields permite-lhe especificar que campos são transferidos de uma junção para uma exploração. Por predefinição, todos os campos de uma vista são importados quando associados. No entanto, pode querer transferir apenas um subconjunto de campos.

Por exemplo, quando junta orders a order_items, pode querer transferir apenas os campos shipping e tax através da junção:

explore: order_items {
  join: orders {
    type: left_outer
    relationship: many_to_one
    sql_on: ${order_items.order_id} = ${orders.id} ;;
    fields: [shipping, tax]
  }
}

Também pode fazer referência a um conjunto de campos, como [set_a*]. Cada conjunto é definido numa visualização de propriedade através do parâmetro set. Suponhamos que tem o seguinte conjunto definido na vista orders:

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

Pode optar por transferir apenas estes três campos quando associar o orders ao 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*]
  }
}

Dados agregados simétricos

O Looker usa uma funcionalidade denominada "agregados simétricos" para calcular agregações (como somas e médias) corretamente, mesmo quando as junções resultam numa expansão. As agregações simétricas são descritas mais detalhadamente no artigo Compreender as agregações simétricas. O problema de fanout que os agregados simétricos resolvem é explicado na publicação da comunidade O problema dos fanouts de SQL.

Chaves principais obrigatórias

Para que as medidas (agregações) sejam apresentadas através de uniões, tem de definir chaves principais em todas as vistas envolvidas na união.

Para tal, adicione o parâmetro primary_key à definição do campo de chave principal em cada vista:

dimension: id {
  type: number
  primary_key: yes
}

Nota: para processar corretamente as medidas unidas, o Looker depende de si para especificar uma chave primária em que os valores são completamente únicos e não são valores NULL. Se os seus dados não contiverem uma chave primária, pondere se a concatenação de vários campos resultaria numa chave primária de valores não NULL completamente únicos. Se a sua chave primária não for exclusiva ou contiver valores NULL e a sua consulta incluir dados que revelem esses problemas, o Looker devolve um erro, conforme descrito na página de práticas recomendadas Erro: valor/chave primária (ou sql_distinct_key) não exclusivo, excesso de valor ou colisão ao calcular a soma.

Dialetos de SQL suportados

Para que o Looker suporte agregações simétricas no seu projeto do Looker, o dialeto da base de dados também tem de as suportar. A tabela seguinte mostra os dialetos que suportam agregações simétricas na versão mais recente do Looker:

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

Se o seu dialeto não suportar agregações simétricas, tenha cuidado ao executar junções no Looker, uma vez que alguns tipos de junções podem resultar em agregações imprecisas (como somas e médias). Este problema e as soluções alternativas para o mesmo são descritos detalhadamente na publicação da comunidade O problema das ramificações SQL.

Saiba mais sobre as junções

Para saber mais sobre os parâmetros de junção no LookML, consulte a documentação de referência de junção.