agrupamento

Uso

explore: explore_name {
join: view_name { ... }
}

Hierarquia Arquivo de modelo explore join

Valor padrão Nenhuma Aceita O nome de uma visualização existente Regras especiais Esse parâmetro aceita um nome de visualização, e não o nome da tabela subjacente da visualização, embora sejam geralmente idênticos. Se o seu dialeto não for compatível com o symmetric_aggregates, a maioria dos tipos de medição será excluída das visualizações mescladas. É possível participar da mesma visualização mais de uma vez usando from.

Definição

O join permite definir a relação de mesclagem entre uma exploração e uma visualização para que você possa combinar dados de várias visualizações. Você pode participar de quantas vistas quiser para um determinado recurso "Explorar".

Lembre-se de que cada visualização é associada a uma tabela no banco de dados ou a uma tabela derivada que você definiu no Looker. Da mesma forma, como uma exploração é associada a uma visualização, ela também é conectada a algum tipo de tabela.

A tabela associada a "Explorar" é colocada na cláusula FROM do SQL gerado pelo Looker. As tabelas associadas às visualizações mescladas são colocadas na cláusula JOIN do SQL gerado pelo Looker.

Principais parâmetros de mesclagem

Para definir a relação de mesclagem (a cláusula ON do SQL) entre uma visualização e uma visualização, será necessário usar join em combinação com outros parâmetros.

É necessário usar o sql_on ou o parâmetro foreign_key para estabelecer a cláusula SQL ON.

Você também precisa garantir que está usando os tipos e relações de mesclagem adequados, embora os parâmetros type e relationship nem sempre sejam explicitamente necessários. Se os valores padrão de type: left_outer e relationship: many_to_one forem adequados para seu caso de uso, esses parâmetros poderão ser excluídos.

Estes parâmetros importantes e sua relação com o SQL gerado pelo Looker são mostrados aqui:

sql_on

sql_on permite estabelecer uma relação de mesclagem gravando a cláusula SQL ON diretamente. Ele pode realizar as mesmas mesclagens que o foreign_key, mas é mais fácil de ler e entender.

Consulte a página de documentação do parâmetro sql_on para mais informações.

foreign_key

O foreign_key permite estabelecer uma relação de junção usando a chave primária da visualização mesclada e a conectar a uma dimensão em "Explorar". Esse padrão é muito comum no design de bancos de dados, e o foreign_key é uma maneira elegante de expressar a mesclagem nesses casos.

Para entender melhor, consulte a página de documentação do parâmetro foreign_key.

type

A maioria das mesclagens no Looker é LEFT JOIN pelos motivos discutidos na seção Não aplicar lógica de negócios em mesclagens se possível nesta página. Portanto, se você não adicionar explicitamente um type, o Looker entenderá que você quer um LEFT JOIN. No entanto, se você precisar de outro tipo de mesclagem por algum motivo, poderá fazer isso com type.

Para ver uma explicação completa, consulte a página de documentação do parâmetro type.

relationship

No diagrama acima, relationship não tem um impacto direto no SQL gerado pelo Looker, mas é essencial para o funcionamento adequado do Looker. Se você não adicionar explicitamente um relationship, o Looker vai presumir que é many-to-one, ou seja, muitas linhas em "Explorar" podem ter uma linha na visualização mesclada. Nem todas as mesclagens têm esse tipo de relação, e as junções com outras relações precisam ser declaradas corretamente.

Para entender melhor, consulte a página de documentação do parâmetro relationship.

Examples

Mescle a visualização chamada customer ao Explorar chamado order, em que a relação de mesclagem é

FROM order LEFT JOIN customer ON order.customer_id = customer.id:

explore: order {
  join: customer {
    foreign_key: customer_id
    relationship: many_to_one # Could be excluded since many_to_one is the default
    type: left_outer          # Could be excluded since left_outer is the default
  }
}

-

Mescle a visualização chamada address ao Explorar chamado person, em que a relação de mesclagem é

FROM person LEFT JOIN address ON person.id = address.person_id AND address.type = 'permanent'.

explore: person {
  join: address {
    sql_on: ${person.id} = ${address.person_id} AND ${address.type} = 'permanent' ;;
    relationship: one_to_many
    type: left_outer # Could be excluded since left_outer is the default
  }
}

-

Mescle a visualização chamada member ao Explorar chamado event, em que a relação de mesclagem é

FROM event INNER JOIN member ON member.id = event.member_id:

explore: event {
  join: member {
    sql_on: ${event.member_id} = ${member.id} ;;
    relationship: many_to_one # Could be excluded since many_to_one is the default
    type: inner
  }
}

-

Desafios comuns

join precisa usar nomes de visualização, não nomes de tabela subjacentes

O parâmetro join recebe apenas um nome de visualização, não o nome da tabela associado a ela. Muitas vezes, os nomes da visualização e da tabela são idênticos, o que pode levar à falsa conclusão de que podem ser usados.

Alguns tipos de medidas exigem agregações simétricas

Se você não usa agregações simétricas, a maioria dos tipos de medição é excluída das visualizações mescladas. Para que o Looker ofereça suporte a agregados simétricos no projeto Looker, seu dialeto de 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:

Sem agregações simétricas, mesclando relações que não são de um para um pode gerar resultados imprecisos em funções de agregação. Como as medidas do Looker são funções agregadas, somente medidas de type: count (como COUNT DISTINCT) são trazidas das visualizações mescladas para o recurso Explorar. Se você tiver uma relação de mesclagem um para um, use o parâmetro relationship para forçar a inclusão dos outros tipos de medida, desta forma:

explore: person {
  join: dna {
    sql_on: ${person.dna_id} = ${dna.id} ;;
    relationship: one_to_one
  }
}

Os motivos para o Looker funcionar dessa forma (para dialetos não compatíveis com agregações simétricas) são abordados com mais detalhes no artigo O problema dos fanouts do SQL na Central de Ajuda.

Informações úteis

É possível mesclar a mesma tabela mais de uma vez usando from.

Em casos em que uma única tabela contém diferentes tipos de entidades, é possível mesclar uma visualização a um recurso Explorar mais de uma vez. Para isso, você precisa usar o parâmetro from. Imagine que você tenha uma exploração order e precise participar de uma visualização person duas vezes: uma para o cliente e outra para o representante de atendimento ao cliente. Você pode fazer algo parecido com isto:

explore: order {
  join: customer {
    from: person
    sql_on: ${order.customer_id} = ${customer.id} ;;
  }
  join: representative {
    from: person
    sql_on: ${order.representative_id} = ${representative.id} ;;
  }
}

Não aplique lógica de negócios em mesclagens, se possível

A abordagem padrão do Looker para participar é usar um LEFT JOIN sempre que possível. Considere uma abordagem diferente se você perceber algo assim:

explore: member_event {
  from: event
  always_join: [member]
  join: member {
    sql_on: ${member_event.member_id} = ${member.id} ;;
    type: inner
  }
}

-

Neste exemplo, criamos um recurso Explorar que apenas analisa eventos associados a membros conhecidos. No entanto, a maneira mais comum de executar isso no Looker é usar um LEFT JOIN para agrupar os dados de eventos e os de membros da seguinte maneira:

explore: event {
  join: member {
    sql_on: ${event.member_id} = ${member.id} ;;
  }
}

-

Em seguida, você cria uma dimensão que pode ser definida como yes ou no, caso queira apenas analisar eventos de membros, desta forma:

dimension: is_member_event {
  type: yesno
  sql: ${member.id} IS NOT NULL ;;
}

-

É preferível usar essa abordagem porque ela oferece aos usuários a flexibilidade de ver em todos os eventos ou apenas em eventos de membros, como quiserem. Não é necessário forçar a exibição apenas dos eventos de membros na mesclagem.

Se não estiver usando agregações simétricas, evite mesclagens que causem fanouts

Esta seção se aplica somente aos dialetos de banco de dados que não são compatíveis com agregações simétricas. Consulte a discussão sobre agregações simétricas na seção Desafios comuns nesta página para saber se o dialeto é compatível com agregações simétricas.

Se o dialeto do banco de dados não for compatível com agregações simétricas, evite mesclagens que resultem em um fanout. Em outras palavras, as mesclagens que têm uma relação de um para muitos entre a guia "Explorar" e a visualização geralmente precisam ser evitadas. Em vez disso, agregue os dados da visualização em uma tabela derivada para estabelecer uma relação de um para um com o recurso Explorar e mescle essa tabela derivada ao Explorar.

Esse conceito importante é explicado em mais detalhes no artigo O problema de fanouts do SQL na Central de Ajuda.