Os padrões de design do LookML permitem personalizar o modelo de dados para apresentar métricas comerciais claras e orientar a forma como os usuários consultam os dados. É possível aplicar essas técnicas para rotular UI interface, filtrar contagens por uma dimensão, calcular porcentagens, definir conjuntos de detalhamento e restringir os resultados da Análise.
Como rotular campos (e nomes na UI)
O Looker converte os nomes dos campos do LookML nas strings que a UI mostra combinando o nome da visualização em fonte normal com o nome abreviado do campo em negrito. Por exemplo, um campo chamado Amount na visualização Orders apareceria na UI como Orders Amount. Nesta página, os dois nomes de campo estão em negrito e o nome da visualização está em maiúsculas (ORDERS Amount) para deixar a discussão mais clara.
Se você quiser que um campo tenha um nome diferente do nome da coluna em uma tabela, mude o nome do campo 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
}
}
É possível renomear a dimensão cntrl_twr para que ela seja legível por humanos:
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
É possível agrupar por uma dimensão e contar entidades. O agrupamento por USERS Country, ORDERS Count informa de onde vêm 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 métrica e chamá-la de 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 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 você 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 uma venda" ou outras instâncias de "a porcentagem de X que Y". No LookML, o padrão de design é criar contagens para as duas condições e criar 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 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)
Como usar conjuntos para detalhes de detalhamento
Um dos recursos mais eficientes do Looker é a capacidade de detalhar os dados para conferir as entidades subjacentes que compõem uma contagem ou outra métrica.
Quando você clica em uma métrica na UI, o Looker cria uma nova consulta para localizar o conjunto de dados que compõe a métrica. Cada valor de cada dimensão na linha da tabela é adicionado a
Para mostrar o detalhe, o Looker precisa de uma lista especificada de campos de detalhamento para mostrar quando o valor da métrica for clicado. Ao gerar um modelo, o gerador normalmente cria alguns campos de detalhamento iniciais para você. Além disso, é possível adicionar campos de detalhamento. Por exemplo, suponha que você esteja medindo a ORDERS Count por USERS State na última semana. No Looker, a consulta seria semelhante a esta:
| USERS State | ORDERS Count |
|---|---|
| Califórnia | 24 |
| Texas | 5 |
| Colorado | 4 |
| Flórida | 4 |
| Illinois | 4 |
Se você clicar em 24 na linha California, verá os 24 pedidos da Califórnia. Embora o Looker adicione o filtro USERS State: California, ele não sabe quais campos você quer mostrar no pedido. Primeiro, é necessário usar um conjunto para declarar esses campos no modelo.
No LookML, um conjunto é uma lista de nomes de campos (dimensão, métrica e filtro). Use conjuntos para fornecer ao Looker as seguintes informações:
- Os campos que você quer mostrar ao detalhar uma contagem ou outra métrica
- Os campos que você quer importar ao unir uma visualização
- Os campos que você quer indexar em uma Análise
Como o mesmo conjunto pode ser usado em muitos 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 métrica, é 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 o campo In California Count em uma Análise, você quer mostrar os campos id, name e city.
Inicialmente, declarar esses campos literalmente 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ê use o set parâmetro para criar conjuntos nomeados que podem ser mantidos em um só 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 eficientes das seguintes maneiras:
- A 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*. - É possível remover elementos de conjuntos colocando 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 detalhamento visual, as visualizações de detalhamento do Look e da Análise nem sempre serão padrão para uma tabela de dados. Nesse caso, é possível personalizar a visualização mostrada usando variáveis líquidas do Liquid no parâmetro link, conforme mostrado na página de documentação do parâmetro link e na página Práticas recomendadas de detalhamento de dados mais eficientes.
Os painéis aceitam o detalhamento visual usando o parâmetro link sem a necessidade de ativar o recurso Visual Drilling.
Como 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 Análise
Use always_filter para sempre aplicar um conjunto de filtros a qualquer consulta executada em uma Análise. Os filtros vão aparecer na interface do Looker e, embora os usuários possam mudar o valor do filtro padrão fornecido, eles não podem remover os filtros. Geralmente, esses filtros são usados para remover dados que você normalmente não quer incluir. Por exemplo, suponha que, na Análise Orders , você só queira ver pedidos concluídos ou pendentes. Você pode adicionar o seguinte código 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 na Análise
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 será aplicada a painéis, Looks programados e informações incorporadas que dependem dessa Análise. Uma condição sql_always_where não é mostrada ao usuário, a menos que ele analise o SQL das consultas criadas.
O exemplo a seguir impede que os usuários consultem pedidos anteriores a 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 Análise
Tabelas muito grandes exigem um pouco de reflexão ao serem consultadas, já que consultas ilimitadas podem rapidamente 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 fará nenhuma mudança na consulta do usuário se ele tiver aplicado um filtro em um ou mais destes 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]
}