Padrões comuns do LookML

Nesta página, descrevemos os seguintes padrões comuns em LookML:

• Campos de rotulagem (e nomes na UI)
• Filtrar contagens por uma dimensão
• Porcentagens
• Como usar conjuntos para detalhamento
• Filtrar conjuntos de resultados

Campos de rotulagem (e nomes na UI)

O Looker converte os nomes dos campos da 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 Valor na visualização Pedidos apareceria na UI como Pedidos Valor. Nesta página, os dois nomes de campo estão em negrito, e o nome da visualização está em maiúsculas (VALOR DOS PEDIDOS) 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 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
  }
}

Você pode renomear a dimensão cntrl_twr para que ela 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
  }
}

Filtrar contagens por uma dimensão

Você pode agrupar por uma dimensão e contar entidades. Por exemplo, ao agrupar por País dos USUÁRIOS e Contagem de PEDIDOS, você descobre 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 métrica e nomeá-la como 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-chave de performance são expressos na forma de porcentagens, como "a porcentagem de itens devolvidos", "a porcentagem de e-mails que resultaram em uma venda" ou outros casos de "a porcentagem de X que Y". Em LookML, o padrão de design é criar contagens para as duas condições e um terceiro campo que calcula a porcentagem entre elas.

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 seguinte formato 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. Multiplicar 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, a 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 exibir quando o valor da métrica for clicado. Quando você gera um modelo, o gerador normalmente cria alguns campos de detalhamento iniciais. Além disso, você pode adicionar campos de detalhamento. Por exemplo, suponha que você esteja medindo a contagem de PEDIDOS por estado dos USUÁRIOS na última semana. No Looker, a consulta seria parecida com esta:

Estado USERS	Contagem de PEDIDOS
Califórnia	24
Texas	5
Colorado	4
Flórida	4
Illinois	4

Se você clicar em 24 na linha Califórnia, vai ver os 24 pedidos feitos nesse estado. Embora o Looker adicione o filtro USERS State: California, ele não sabe quais campos você quer mostrar no pedido. Primeiro, você precisa usar um conjunto para declarar esses campos no modelo.

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

• Os campos que você quer mostrar ao detalhar uma contagem ou outra medida
• Os campos que você quer importar ao participar de 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 de literais

Um conjunto literal é uma maneira simples de definir um conjunto em 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, você pode 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 Contagem ou Contagem na Califórnia em uma análise detalhada, 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ê quisesse adicionar um novo campo (como customers.state), teria que editar as duas listas, a menos que usasse o parâmetro set 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 ambas as 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 redeclaraçã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 dentro de 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.

Personalizar visualizações de detalhamento

Se o administrador do Looker tiver ativado o recurso Detalhamento visual do Labs, as visualizações de detalhamento de análises e pesquisas nem sempre vão usar uma tabela de dados como padrão. Nesse caso, é possível personalizar a visualização mostrada usando variáveis 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 Detalhamento de dados mais eficiente.

Os painéis são compatíveis com o detalhamento visual usando o parâmetro link sem precisar ativar o recurso Detalhamento visual do Labs.

Filtrar conjuntos de resultados

A 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 eles sejam 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 detalhada. Os filtros vão aparecer na interface do Looker e, embora os usuários possam mudar o valor padrão fornecido, eles não podem remover os filtros. Em geral, esses filtros são usados para remover dados que você normalmente não quer incluir. Por exemplo, suponha que, na análise detalhada Pedidos, você só queira ver os 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 quisesse ver pedidos com outros valores de status, ele poderia definir Status dos PEDIDOS como % na UI.

sql_always_where na Análise

Se você quiser aplicar uma restrição de consulta que os usuários não possam mudar, use sql_always_where. Além das consultas executadas por usuários humanos, a restrição se aplica a dashboards, Looks programados e informações incorporadas que dependem dessa análise detalhada. Uma condição de 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 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 Análise

Tabelas muito grandes exigem cuidado 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]
}