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 detalhar
• Como filtrar conjuntos de resultados

Como rotular campos (e nomes na interface)

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 Amount na visualização Orders vai aparecer na interface como Amount. 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 do campo e use o parâmetro sql para vincular o campo à coluna adequada na tabela. No exemplo abaixo, 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 País de USUÁRIOS e Contagem de PEDIDOS 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 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-chave 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 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 foi clicado. Quando você gera um modelo, o gerador normalmente cria alguns campos de detalhamento iniciais. Além disso, você mesmo pode adicionar campos de detalhamento. Por exemplo, suponha que você esteja medindo a contagem de PEDIDOS por estado de USUÁRIOS na última semana. No Looker, a consulta seria semelhante a esta:

Estado de USERS	Número de PEDIDOS
Califórnia	24
Texas	5
Colorado	4
Flórida	4
Illinois	4

Se você clicar em 24 na linha Califórnia, vai encontrar os 24 pedidos que vieram da Califórnia. Embora o Looker adicione o filtro USERS State: California, ele 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, métrica e filtro). Use conjuntos para dar ao Looker as seguintes informações:

• 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 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 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, 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.

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 Laboratórios de detalhamento visual, as visualizações de detalhamento do Look e da Análise nem sempre usarão uma tabela de dados por 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 são compatíveis com o detalhamento visual usando o parâmetro link sem a necessidade de ativar o recurso de laboratórios de detalhamento visual.

Como filtrar conjuntos de resultados

O LookML fornece 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 em "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 quisesse ver pedidos com outros valores de status, ele poderia definir STATUS DOS PEDIDOS como % na interface.

sql_always_where na guia "Explorar"

Para aplicar uma restrição de consulta que os usuários não podem alterar, 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 acessem 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 em "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 fará nenhuma alteração na consulta do usuário se ele tiver aplicado um filtro a 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]
}