Esta página aborda os padrões mais comuns no LookML.
Rotular campos (e nomes na UI)
O Looker converte nomes de campos do LookML nas strings mostradas na UI combinando o nome da visualização em fonte de peso normal com o nome curto do campo em negrito. Por exemplo, um campo chamado Amount na visualização Orders apareceria na UI como Pedidos. Nesta página, ambos estão em negrito e o nome da visualização está em maiúsculas (ORDERS Amount) para tornar a discussão mais clara.
Se você quiser que um campo tenha um nome diferente do nome da coluna da tabela, basta mudar o nome dele e declarar a vinculação sql:. No exemplo abaixo, há uma tabela airports com 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
}
}
Vamos renomear a dimensão cntrl_twr para ser 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
}
}
Filtrar contagens por uma dimensão
É muito fácil agrupar por uma dimensão e contar entidades. Com o agrupamento por País dos USUÁRIOs, a Contagem de PEDIDOS informa a origem dos seus pedidos por país. No entanto, muitas vezes é útil construir uma contagem filtrada por algum valor dimensional. Por exemplo, você pode criar uma nova medida 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ê quisesse um campo que contasse usuários da UE, poderia usar algo assim:
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 retornados", "a porcentagem de e-mails que resultaram em vendas" 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 calcule 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 formulário abaixo ao calcular porcentagens. No Postgres, as contagens são números inteiros, e a divisão entre números inteiros resulta em números inteiros. Multiplicar por 100,0 converte a primeira contagem em um número de ponto flutuante, convertendo o restante da expressão em um valor flutuante. Para evitar erros de divisão por zero, o NULLIF(value, 0) vai converter um valor zero em nulo, tornando o resultado nulo e evitando um erro.
100.0 * ${returned_count} / NULLIF(${count}, 0)
Como usar conjuntos para detalhes do detalhamento
Um dos recursos mais eficientes do Looker é a capacidade de analisar dados para ver as entidades subjacentes que compõem uma contagem ou outra medida.
Quando uma medida é clicada na interface do Looker, uma nova consulta é criada, localizando o conjunto de dados que a compõe. Os valores de cada dimensão na linha da tabela são adicionados aos filtros atuais.
Para mostrar os detalhes, o Looker precisa de uma lista especificada de campos de detalhamento para mostrar quando o valor da medida foi 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 estamos medindo a Contagem de PEDIDOS pelo Estado dos USUÁRIOS na última semana. No Looker, a consulta ficaria assim:
| Estado USERS | Contagem de PEDIDOS |
|---|---|
| Califórnia | 24 |
| Texas | 5 |
| Colorado | 4 |
| Flórida | 4 |
| Illinois | 4 |
Se clicarmos em 24 na linha Califórnia, o comportamento esperado é que os 24 pedidos vindos da Califórnia apareçam.
O Looker processa a adição do filtro USUÁRIOS Estado: Califórnia, mas não sabe quais campos você quer mostrar na ordem. Você precisa usar um conjunto para declarar esses campos no modelo.
No LookML, um conjunto é uma lista de nomes de campos (dimensão, medida e filtro). Os conjuntos são usados para informar ao Looker quais campos:
- Você quer exibir ao detalhar uma contagem ou outra medição
- Importar ao participar de uma visualização
- estão indexadas em um Explore;
O mesmo conjunto pode ser usado em muitos lugares em um modelo. Por isso, o Looker oferece várias maneiras de criar conjuntos.
Conjuntos literais
A forma mais simples de um conjunto é um conjunto literal. Um conjunto literal é criado simplesmente declarando-o como uma matriz. É possível declarar conjuntos literais usando "[]".
Dado este exemplo:
view: customers {
dimension: id {
primary_key: yes
}
measure: count {
type: count
}
dimension: city {}
dimension: state {}
dimension: name {}
}
Os campos que gostaríamos de mostrar são id, name e city.
Na medida, poderíamos simplesmente declarar uma matriz literal.
measure: count {
type: count
drill_fields: [id, name, city]
}
No caso de conjuntos usados apenas uma vez, declará-los literalmente é simples e fácil de entender.
Conjuntos nomeados
Suponha que temos duas contagens: CUSTOMERS Count e CUSTOMERS in California Count. Quando analisarmos qualquer uma dessas contagens, queremos mostrar os campos id, name e city. Se declararmos os campos de forma literal, podemos:
view: customers {
measure: count {
type: count
drill_fields: [id, name, city]
}
measure: in_california_count {
type: count
filters: [state: "California"]
}
}
Se quiséssemos adicionar um novo campo (por exemplo, customers.state), precisaríamos editar as duas listas. Em vez disso, o LookML oferece uma maneira de criar conjuntos nomeados que podemos manter em um local e usar em vários.
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"]
}
}
Os conjuntos do LookML são bastante poderosos:
- 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.
- Para incorporar conjuntos em outros, digite o nome do outro conjunto, seguido por um asterisco, como
setname*. - É possível até remover elementos dos conjuntos colocando um hífen antes do nome do campo, como
-fieldname.
Confira a referência completa de conjuntos
Como personalizar visualizações detalhadas
Se o administrador do Looker tiver ativado o recurso de Detalhamento visual do Labs, as visualizações de detalhamento do Look and Explore nem sempre terão como padrão uma tabela de dados. Nesse caso, é possível personalizar a visualização usando variáveis líquidas no parâmetro link, conforme mostrado na página de documentação do parâmetro link e na página de práticas recomendadas de Detalhamento de dados mais eficiente.
Os painéis são compatíveis com o detalhamento visual usando o parâmetro link sem a necessidade de ativar o recurso de Detalhamento visual do Labs.
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 que sejam retornados ao usuário.
always_filter na guia Explorar
Use always_filter para sempre aplicar um conjunto de filtros a qualquer consulta executada em um Explore. Os filtros vão aparecer na interface do Looker e, embora os usuários possam mudar o valor do filtro padrão fornecido, 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 de Pedidos, quiséssemos ver apenas os pedidos concluídos ou pendentes. Podemos adicionar:
explore: orders {
view_name: order
filters: [status: "complete,pending"]
}
}
Para ver pedidos com outros valores de status, o usuário pode definir ORDERS Status para % na UI.
sql_always_where na guia Explorar
Para aplicar uma restrição de consulta que os usuários não podem mudar, use sql_always_where. Além de consultas executadas por usuários humanos, a restrição será aplicada a dashboards, Looks programados e informações incorporadas que dependem dessa Análise. Uma condição sql_always_where não é exibida para o usuário, a menos que ele observe o SQL subjacente de todas as consultas criadas.
O exemplo a seguir impede que os usuários vejam 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 guia Explorar
Tabelas muito grandes exigem alguma reflexão durante as consultas, uma vez que consultas ilimitadas podem rapidamente se tornar muito sobrecarregadas no 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 alteração 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 1 dia em orders.created_time.
filters: [orders.created_time: "1 day"]
unless: [created_date, shipped_time, shipped_date, orders.id, customer.name]
}