Padrões comuns do LookML

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

• Etiquetar campos (e nomes na IU)
• Filtrar contagens por uma dimensão
• Percentagens
• Usar conjuntos para detalhes de detalhe
• Filtrar conjuntos de resultados

Etiquetar campos (e nomes na IU)

O Looker converte os nomes dos campos LookML nas strings que a IU apresenta combinando o nome da vista com uma fonte normal com o nome abreviado do campo em negrito. Por exemplo, um campo denominado Amount na vista Orders seria apresentado na IU como Orders Amount. Nesta página, os nomes dos campos estão em negrito e o nome da vista está em maiúsculas (VALOR DE ENCOMENDAS) para tornar a discussão mais clara.

Se quiser que um campo tenha um nome diferente do nome da respetiva coluna numa tabela, altere o nome do campo e use o parâmetro sql para associar o campo à coluna adequada na tabela. No exemplo seguinte, 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
  }
}

Pode mudar o nome da dimensão cntrl_twr para ser 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
  }
}

Filtrar contagens por uma dimensão

Pode agrupar por uma dimensão e contar entidades. Se agrupar por País dos UTILIZADORES, Número de ENCOMENDAS, fica a saber de que país são as suas encomendas. No entanto, muitas vezes, é útil criar uma contagem filtrada por algum valor dimensional. Por exemplo, pode criar uma nova medida e dar-lhe 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 quiser um campo que contabilize os utilizadores da UE, pode usar 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, certifique-se de que a inclui entre aspas:

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"]
}

Percentagens

Muitos indicadores de desempenho chave são expressos sob a forma de percentagens, como "a percentagem de artigos devolvidos", "a percentagem de emails que resultaram numa venda" ou outros exemplos de "a percentagem de X que Y". No LookML, o padrão de design consiste em criar contagens para as duas condições e criar um terceiro campo que calcule a percentagem 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 seguinte formato para calcular percentagens. 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 num número de vírgula flutuante, convertendo assim o resto da expressão num número de vírgula flutuante. Para evitar erros de divisão por zero, a funçã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 ver detalhes detalhados

Uma das funcionalidades mais poderosas do Looker é a capacidade de analisar detalhadamente os dados para ver as entidades subjacentes que compõem uma contagem ou outra medida.

Quando clica numa medida na IU, o Looker cria uma nova consulta para localizar o conjunto de dados que compõem a medida. Cada valor para cada dimensão na linha da tabela é adicionado a

Para mostrar os detalhes, o Looker precisa de uma lista especificada de campos de detalhe para mostrar quando o valor da medida é clicado. Quando gera um modelo, o gerador cria normalmente alguns campos de detalhe iniciais. Além disso, pode adicionar campos de detalhe manualmente. Por exemplo, suponha que está a medir a quantidade de ENCOMENDAS por estado dos UTILIZADORES na última semana. No Looker, a consulta teria um aspeto semelhante ao seguinte:

Se clicar em 24 na linha Califórnia, pode esperar ver as 24 encomendas provenientes da Califórnia. Embora o Looker adicione o filtro USERS State: California, o Looker não sabe que campos quer apresentar na ordem. Primeiro, tem de usar um conjunto para declarar esses campos no seu modelo.

No LookML, um conjunto é uma lista de nomes de campos (dimensão, medida e filtro). Usa conjuntos para dar ao Looker as seguintes informações:

• Os campos que quer mostrar quando detalha uma contagem ou outra medida
• Os campos que quer importar quando associa uma vista
• Os campos que quer indexar numa exploração

Uma vez que o mesmo conjunto pode ser usado em muitos locais num modelo, o Looker oferece vários métodos para criar conjuntos.

Conjuntos literais

Um conjunto literal é uma forma simples de definir um conjunto em LookML, especialmente quando o conjunto é usado apenas uma vez. Um conjunto literal é criado declarando o conjunto como uma matriz. Pode declarar conjuntos literais através de [].

Considere o seguinte exemplo:

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

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

Na medida, pode declarar uma matriz literal da seguinte forma:

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

Conjuntos com nome

Suponhamos que duas contagens estão definidas na vista customers: count e in_california_count. Quando um utilizador detalha o campo Contagem ou o campo Na Califórnia, contagem numa análise detalhada, quer apresentar os campos id, name e city.

Inicialmente, declarar estes 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 quisesse adicionar um novo campo (como customers.state), teria de editar ambas as listas, a menos que usasse o parâmetro set para criar conjuntos com nomes que pode manter num único local e usar em vários locais.

O código seguinte 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 eficazes das seguintes formas:

• A nova declaração de conjuntos é cumulativa. Se declarar um conjunto em vários locais, o Looker inclui todos os campos que foram declarados para o conjunto em todas as localizações.
• Pode incorporar conjuntos noutros conjuntos escrevendo o nome do outro conjunto seguido de um asterisco, por exemplo, setname*.
• Pode remover elementos de conjuntos colocando um hífen antes do nome do campo, por exemplo, -fieldname.

Personalizar visualizações de detalhe

Se o administrador do Looker tiver ativado a funcionalidade de laboratório Visualização detalhada, as visualizações detalhadas de Looks e Explorar nem sempre são predefinidas para uma tabela de dados. Neste caso, pode personalizar a visualização apresentada através de 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 Análise detalhada de dados mais eficaz.

Os painéis de controlo suportam a análise detalhada visual através do parâmetro link sem necessidade de ativar a funcionalidade Labs Análise detalhada visual.

Filtrar conjuntos de resultados

O LookML fornece um conjunto de operações de filtro que podem ser aplicadas a campos e Explores para filtrar conjuntos de resultados antes de serem devolvidos ao utilizador.

always_filter na página Explorar

Use always_filter para aplicar sempre um conjunto de filtros a qualquer consulta executada numa análise detalhada. Os filtros aparecem na IU do Looker e, embora os utilizadores possam alterar o valor predefinido do filtro que fornece, não podem remover os filtros. Geralmente, estes filtros são usados para remover dados que normalmente não quer incluir. Por exemplo, suponhamos que, na análise detalhada Encomendas, só queria ver encomendas concluídas ou pendentes. Pode adicionar o seguinte código LookML:

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

Se o utilizador quisesse ver encomendas com outros valores de estado, podia definir Estado das ENCOMENDAS como % na IU.

sql_always_where na página Explorar

Se quiser aplicar uma restrição de consulta que os utilizadores não possam alterar, pode usar sql_always_where. Além das consultas executadas por utilizadores humanos, a restrição aplica-se a painéis de controlo, Looks agendados e informações incorporadas que dependem desse Explore. Uma condição sql_always_where não é apresentada ao utilizador, a menos que este consulte o SQL subjacente de quaisquer consultas que criar.

O exemplo seguinte impede que os utilizadores consultem encomendas 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 página Explorar

As tabelas muito grandes requerem alguma reflexão ao consultar, uma vez que as consultas ilimitadas podem rapidamente tornar-se demasiado pesadas para a base de dados. O LookML oferece uma forma de resolver este problema através de conditionally_filter.

Usa o parâmetro conditionally_filter para aplicar um filtro à consulta, a menos que o utilizador já tenha adicionado um filtro para um dos campos indicados na secção unless.

O exemplo seguinte não altera a consulta do utilizador se este tiver aplicado um filtro a um ou mais destes campos: created_date, shipped_time, shipped_date, orders.id ou customer.name. Se o utilizador não filtrar nenhum desses campos, o Looker adiciona 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]
}