Com as mesclagens, é possível conectar diferentes vistas da propriedade para que você possa explorar dados de mais de uma vista da propriedade ao mesmo tempo e ver como partes diferentes dos seus dados se relacionam entre si.
Por exemplo, seu banco de dados pode incluir as tabelas order_items, orders e users. Você pode usar junções para explorar dados de todas as tabelas ao mesmo tempo. Nesta página, explicamos as junções no LookML, incluindo parâmetros e padrões de mesclagem específicos.
As participações começam com o recurso Explorar
As junções são definidas no arquivo de modelo para estabelecer a relação entre uma exploração e uma visualização. As mesclagens conectam uma ou mais visualizações a uma única visualização, seja diretamente ou por outra visualização mesclada.
Vamos considerar duas tabelas de banco 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 arquivo de modelo:
explore: order_items { ... }
Quando você executa uma consulta na exploração order_items, order_items aparece na cláusula FROM do SQL gerado:
SELECT ...
FROM order_items
Você pode participar de mais informações com nossa exploração order_items. Por exemplo, para adicionar dados sobre o orders de que order_item faz parte, faça algo como:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
}
}
O LookML acima realiza duas ações. Primeiro, é possível ver os campos de orders e order_items na UI:
Em segundo lugar, o LookML descreve como mesclar 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
Esses parâmetros do LookML são descritos em mais detalhes nas seções a seguir. Consulte a página de referência do parâmetro join para saber mais sobre como esse LookML é convertido em SQL.
Dica da equipe do Chat: os usuários perguntam com mais frequência sobre o erro de validação "Campo desconhecido ou inacessível", que pode ser causado por uma mesclagem ausente. Consulte a página de práticas recomendadas sobre esse erro para mais informações.
Parâmetros de mesclagem
Quatro parâmetros principais são usados para mesclar: join, type, relationship e sql_on.
Etapa 1: como começar a explorar
Primeiro, crie a exploração order_items:
explore: order_items { ... }
Etapa 2: join
Para mesclar uma tabela, primeiro é necessário declará-la em uma visualização. Neste exemplo, orders é uma visualização existente no nosso modelo.
Em seguida, use o parâmetro join para declarar que você quer mesclar a visualização orders ao order_items:
explore: order_items {
join: orders { ... }
}
Etapa 3: type
Considere qual type de mesclagem deve ser executada. O Looker é compatível com LEFT JOIN, INNER JOIN, FULL OUTER JOIN e CROSS JOIN. Eles correspondem aos valores de parâmetro type de left_outer, inner, full_outer e cross.
explore: order_items {
join: orders {
type: left_outer
}
}
O valor padrão de type é left_outer, e geralmente é o tipo de mesclagem mais usado.
Etapa 4: relationship
Defina uma mesclagem relationship entre order_items e orders. Declarar corretamente o relationship de uma mesclagem é importante para que o Looker calcule medidas precisas. O relacionamento é definido de order_items Explorar para a visualização orders. 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 order_items para um único order. A relação de order_items para orders é many_to_one:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
}
}
Se você não incluir um relationship na mesclagem, o Looker usará como padrão many_to_one.
Para ver mais dicas sobre como definir o parâmetro relationship corretamente para uma mesclagem, consulte a página Práticas recomendadas para usar o parâmetro relationship corretamente.
Etapa 5: sql_on
Declare como mesclar essas duas tabelas com o parâmetro sql_on ou foreign_key. Geralmente sugerimos o sql_on, já que ele pode fazer tudo que o foreign_key faz, mas costuma ser mais fácil de entender.
sql_on é equivalente à cláusula ON no SQL gerado para uma consulta. Com este parâmetro, podemos declarar quais campos devem ser correspondidos para executar 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 é possível gravar junções mais complexas. Por exemplo, talvez você queira unir somente pedidos com id maior 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 ;;
}
}
Confira os operadores de substituição para saber mais sobre a sintaxe ${ ... } nesses exemplos.
Etapa 6: teste
Para testar se essa mesclagem está funcionando conforme o esperado, acesse a opção Explorar itens do pedido. Você verá campos de order_items e orders.
Consulte Desenvolvimento de modelos para saber mais sobre como testar alterações do LookML.
Como participar por meio de outra visualização
Você pode participar de uma visualização usando outra visualização. No exemplo acima, você associou orders a order_items pelo campo order_id. Também podemos mesclar os dados de uma visualização chamada users ao Explorar order_items, mesmo que eles não compartilhem um campo comum. Para fazer isso, participe com a visualização orders.
Use sql_on ou foreign_key para mesclar users com orders em vez de order_items. Para isso, faça o escopo correto do campo de orders como orders.user_id.
Veja um exemplo usando 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} ;;
}
}
Como participar de uma visualização mais de uma vez
Uma visualização users contém dados de compradores e de vendedores. Para agrupar dados dessa visualização no order_items, mas fazer isso separadamente para compradores e vendedores, é possível mesclar users duas vezes, com nomes diferentes, usando o parâmetro from.
O parâmetro from permite especificar qual visualização usar em uma mesclagem, além de dar um nome exclusivo à mesclagem. 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} ;;
}
}
Nesse caso, somente os dados de comprador são agregados como buyers, enquanto apenas os dados de vendedor são agregados como sellers.
Observação: a visualização users agora precisa ser chamada pelos nomes com alias buyers e sellers na mesclagem.
Como limitar campos de uma mesclagem
O parâmetro fields permite especificar quais campos são trazidos de uma mesclagem para uma exploração. Por padrão, todos os campos de uma visualização são trazidos quando são mesclados. No entanto, talvez você queira exibir apenas um subconjunto de campos.
Por exemplo, quando orders é associado a order_items, é possível trazer apenas os campos shipping e tax pela mesclagem:
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 é possível referenciar um conjunto de campos, como [set_a*]. Cada conjunto é definido em uma visualização usando o parâmetro set. Suponha que você tenha o seguinte conjunto definido na visualização orders:
set: orders_set {
fields: [created_date, shipping, tax]
}
Você pode optar por exibir apenas estes três campos quando mesclar orders com 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
O Looker usa um recurso chamado "agregações simétricas" para calcular as agregações (como somas e médias) corretamente, mesmo quando as mesclagens resultam em um fanout. Os agregados simétricos são descritos em mais detalhes na página Práticas recomendadas de agregados simétricos. O problema de fanout que eles resolvem é explicado na postagem O problema dos fanouts de SQL (em inglês).
Chaves primárias obrigatórias
Para que as medições (agregações) venham das junções, defina as chaves primárias em todas as visualizações envolvidas na junção.
Para isso, adicione o parâmetro primary_key à definição do campo da chave primária em cada visualização:
dimension: id {
type: number
primary_key: yes
}
Para processar corretamente as medidas unidas, o Looker depende de você especificar uma chave primária em que os valores são completamente exclusivos e não NULL. Se os dados não tiverem uma chave primária, considere se a concatenação de vários campos resultaria em uma chave primária de valores não NULL totalmente exclusivos. Se a chave primária não for exclusiva ou contiver valores NULL e a consulta incluir dados que revelam esses problemas, o Looker retornará um erro conforme descrito na página Erro: valor/chave primária não exclusiva (ou sql_distinct_key), estouro de valor ou colisão ao calcular a soma das práticas recomendadas.
Dialetos SQL compatíveis
Para que o Looker seja compatível com agregados simétricos no seu projeto, o dialeto do banco de dados também precisa ser compatível com eles. A tabela a seguir mostra quais dialetos são compatíveis com agregações simétricas na versão mais recente do Looker:
Se o dialeto não for compatível com agregações simétricas, tenha cuidado ao executar mesclagens no Looker, já que alguns tipos podem resultar em agregações imprecisas (como somas e médias). Este problema e as soluções alternativas para ele são descritos em detalhes na postagem da comunidade O problema de fanouts do SQL.
Saiba mais sobre mesclagens
Para saber mais sobre parâmetros de mesclagem no LookML, consulte a documentação de Referência de mesclagem.