Padrões comuns do LookML

Esta página descreve os seguintes padrões comuns no LookML:

• Como rotular campos (e nomes na interface)
• Como filtrar contagens por uma dimensão
• Porcentagens
• Como usar conjuntos para o detalhamento
• Como filtrar conjuntos de resultados

Como rotular campos (e nomes na UI)

O Looker converte nomes de campos do LookML nas strings que a UI exibe combinando o nome da visualização em uma fonte de peso normal com o nome curto do campo em negrito. Por exemplo, um campo chamado Valor na visualização Pedidos apareceria na UI como Valor dos pedidos. Nesta página, os nomes dos campos estão em negrito e o nome da visualização está em maiúsculas (ORDERS Amount) para facilitar a discussão.

Se você quiser que um campo tenha um nome diferente do nome da coluna em uma tabela, mude o nome dele e use o parâmetro sql para vincular o campo à coluna apropriada na tabela. No exemplo a seguir, a tabela airports tem uma coluna cntrl_twr. O Looker geraria a seguinte declaração:

view: airports {
  dimension: cntrl_twr {        # full name: airports.cntrl_twr
    type: yesno                 # default name: AIRPORT Cntrl Twr (Yes/No)
    sql: ${TABLE}.cntrl_twr ;;  # the sql expression for this field
  }
}

Você pode renomear a dimensão cntrl_twr para que seja legível:

view: airports {
  dimension: has_control_tower {  # full name: airports.has_control_tower
    type: yesno                   # aliased name: AIRPORTS Has Control Tower (Yes/No)
    sql: ${TABLE}.cntrl_twr ;;    # the sql expression for this field
  }
}

Como filtrar contagens por uma dimensão

Você pode agrupar por uma dimensão e contar entidades. Agrupar por USUÁRIOS País e Contagem de pedidos informará a origem dos seus pedidos por país. No entanto, muitas vezes é útil criar uma contagem filtrada por algum valor dimensional. Por exemplo, você pode criar uma nova medida com o nome ORDERS France Count:

view: users {
  dimension: country {}
}
view: orders {
  dimension: id {
    primary_key: yes
    sql: ${TABLE}.id ;;
  }
  measure: count {
    type: count
    drill_fields: [detail]
  }
  measure: france_count {
    type: count   # COUNT(CASE WHEN users.country = 'France' THEN 1 ELSE NULL END)
    filters: [users.country: "France"]
  }
}

Os filtros podem usar qualquer expressão. Se você quiser um campo que conte os usuários da UE, use algo como:

measure: eu_count {
  type: count   # COUNT(CASE WHEN users.countrycode IN 'UK','FR','ES' THEN 1 ELSE NULL END)
  drill_fields: [detail]
  filters: [users.countrycode: "UK,FR,ES"]
}

Se quiser filtrar com uma expressão matemática, coloque-a entre aspas duplas:

measure: total_orders_above_100_dollars {
  type: sum   # SUM(CASE WHEN order.value > 100 THEN order.value ELSE NULL END)
  sql: ${order.value} ;;
  drill_fields: [detail]
  filters: [order.value: ">100"]
}

Porcentagens

Muitos indicadores principais de desempenho são expressos na forma de porcentagens, como "a porcentagem de itens devolvidos", “a porcentagem de e-mails que resultaram em vendas”, ou outras instâncias de "a porcentagem de X de Y". No LookML, o padrão de design é criar contagens para as duas condições e um terceiro campo que calcula a porcentagem entre as duas.

dimension: returned {
  type: yesno
}
measure: count {   # total count of items
  type: count_distinct
  sql: ${TABLE}.id ;;
  drill_fields: [detail]
}
measure: returned_count {   # count of returned items
  type: count_distinct
  sql: ${TABLE}.id ;;
  drill_fields: [detail]
  filters: [returned: "Yes"]
}
measure: percent_returned {
  type: number
  sql: 100.0 * ${returned_count} / NULLIF(${count}, 0) ;;
  value_format: "0.00"
}

Use o formato a seguir para calcular porcentagens. No Postgres, as contagens são números inteiros, e a divisão entre números inteiros resulta em números inteiros. A multiplicação por 100,0 converte a primeira contagem em um número de ponto flutuante, convertendo o restante da expressão em um número de ponto flutuante. Para evitar erros de divisão por zero, o NULLIF(value, 0) converte um valor zero em nulo, o que torna o resultado nulo e evita um erro.

100.0 * ${returned_count} / NULLIF(${count}, 0)

Usar conjuntos para detalhes de detalhamento

Um dos recursos mais eficientes do Looker é a capacidade de analisar os dados para conferir as entidades subjacentes que compõem uma contagem ou outra medida.

Quando você clica em uma medida na interface, o Looker cria uma nova consulta para localizar o conjunto de dados que compõe a medida. Cada valor para cada dimensão na linha da tabela é adicionada

Para mostrar os detalhes, o Looker precisa de uma lista especificada de campos de detalhamento para mostrar quando o valor da medida é clicado. Quando você gera um modelo, o gerador normalmente cria alguns campos de detalhamento iniciais para você. Além disso, você mesmo pode adicionar campos de detalhamento. Por exemplo, suponha que você esteja medindo Contagem de pedidos por Estado dos usuários na última semana. No Looker, a consulta teria a seguinte aparência:

Ao clicar em 24 na linha Califórnia, você verá os 24 pedidos originários da Califórnia. Embora o Looker adicione o filtro USUÁRIOS Estado: Califórnia, o Looker não sabe quais campos você quer mostrar na ordem. Primeiro, você precisa usar um conjunto para declarar esses campos no modelo.

No LookML, um conjunto é uma lista de nomes de campos (dimensão, medição e filtro). Você usa conjuntos para fornecer as seguintes informações ao Looker:

• Os campos que você quer mostrar ao detalhar uma contagem ou outra medição
• Os campos que você quer importar ao mesclar uma visualização
• Os campos que você quer indexar em uma Análise detalhada

Como o mesmo conjunto pode ser usado em vários lugares em um modelo, o Looker oferece vários métodos para criar conjuntos.

Conjuntos literais

Um conjunto literal é uma maneira simples de definir um conjunto no LookML, principalmente quando ele é usado apenas uma vez. Um conjunto literal é criado declarando o conjunto como uma matriz. É possível declarar conjuntos literais usando [].

Veja o exemplo a seguir.

view: customers {
  dimension: id {
    primary_key: yes
  }
  measure: count {
    type: count
  }
  dimension: city {}
  dimension: state {}
  dimension: name {}
}

Neste exemplo, os campos que você quer mostrar são id, name e city.

Na medida, é possível declarar uma matriz literal da seguinte maneira:

measure: count {
  type: count
  drill_fields: [id, name, city]
}

Conjuntos nomeados

Suponha que duas contagens sejam definidas na visualização customers: count e in_california_count. Quando um usuário detalha o campo Count ou In California Count em uma Análise, você quer mostrar os campos id, name e city.

No início, a declaração desses campos pode parecer suficiente:

view: customers {
  measure: count {
    type: count
    drill_fields: [id, name, city]
  }
  measure: in_california_count {
    type: count
    filters: [state: "California"]
    drill_fields: [id, name, city]
  }
}

No entanto, se você quiser adicionar um novo campo (como customers.state), será necessário editar as duas listas, a menos que você tenha usado o parâmetro set para criar conjuntos nomeados que podem ser mantidos em um lugar e usados em vários lugares.

O código a seguir cria um conjunto customers.detail e aponta as duas contagens para o mesmo conjunto de campos.

view: customers {
  set: detail {
    fields: [id, name, city]      # creates named set customers.detail
  }

  measure: count {
    type: count
    drill_fields: [detail*]       # show fields in the set "customers.detail"
  }
  measure: in_california_count {
    type: count
    filters: [state: "California"]
    drill_fields: [detail*]      # show fields in the set "customers.detail"
  }
}

Os conjuntos do LookML são poderosos das seguintes maneiras:

• A nova declaração de conjuntos é aditiva. Se você declarar um conjunto em vários lugares, o Looker vai incluir todos os campos declarados para o conjunto em todos os locais.
• É possível incorporar conjuntos em outros conjuntos digitando o nome do outro conjunto seguido de um asterisco, por exemplo, setname*.
• Para remover elementos de conjuntos, coloque um hífen antes do nome do campo, por exemplo, -fieldname.

Como personalizar visualizações de detalhamento

Se o administrador do Looker tiver ativado o recurso de laboratórios Visual Drilling, as visualizações de detalhamento do Looker e do Analisar não vão sempre usar uma tabela de dados como padrão. Nesse caso, é possível personalizar a visualização exibida usando variáveis do Liquid no parâmetro link, conforme mostrado na página de documentação do parâmetro link e na página de práticas recomendadas Mais detalhamento de dados.

Os painéis oferecem suporte ao detalhamento visual usando o parâmetro link sem a necessidade de ativar o recurso de laboratórios Detalhes visuais.

Filtrar conjuntos de resultados

O LookML oferece um conjunto de operações de filtro que podem ser aplicadas a campos e Análises para filtrar conjuntos de resultados antes de serem retornados ao usuário.

always_filter na guia "Explorar"

Use always_filter para aplicar sempre um conjunto de filtros a qualquer consulta executada em uma Análise detalhada. Os filtros aparecem na interface do Looker e, embora os usuários possam mudar o valor de filtro padrão que você fornece, eles não podem removê-los. Geralmente, esses filtros são usados para remover dados que você normalmente não deseja incluir. Por exemplo, suponha que, na Análise de Pedidos, você queira ver apenas os pedidos que estavam concluídos ou pendentes. Você pode adicionar o seguinte código do LookML:

explore: orders {
  view_name: order
    filters: [status: "complete,pending"]
  }
}

Se o usuário quiser ver pedidos com outros valores de status, ele poderá definir ORDERS Status como % na UI.

sql_always_where em "Explorar"

Se você quiser aplicar uma restrição de consulta que os usuários não podem mudar, use sql_always_where. Além das consultas executadas por usuários humanos, a restrição vai ser aplicada a dashboards, Looks programados e informações incorporadas que dependam dessa Análise. Uma condição sql_always_where não é exibida ao usuário, a menos que ele analise o SQL de qualquer consulta criada.

O exemplo a seguir impede que os usuários consultem pedidos antes de 01/01/2012:

# Using Looker references
explore: order {
  sql_always_where: ${created_date} >= '2012-01-01' ;;
}

# Using raw SQL
explore: order {
  sql_always_where: DATE(created_time) >= '2012-01-01' ;;
}

conditionally_filter na guia "Explorar"

Tabelas muito grandes exigem um pouco de reflexão ao fazer consultas, já que consultas ilimitadas podem se tornar muito pesadas para o banco de dados. O LookML oferece uma maneira de resolver isso na forma de conditionally_filter.

Use o parâmetro conditionally_filter para aplicar um filtro à consulta, a menos que o usuário já tenha adicionado um filtro para um dos campos listados na seção unless.

O exemplo a seguir não vai fazer nenhuma mudança na consulta do usuário se ele tiver aplicado um filtro em um ou mais desses campos: created_date, shipped_time, shipped_date, orders.id ou customer.name. Se o usuário não filtrar nenhum desses campos, o Looker vai adicionar automaticamente um filtro de um dia em orders.created_time.

  filters: [orders.created_time: "1 day"]
  unless: [created_date, shipped_time, shipped_date, orders.id, customer.name]
}