Padrões comuns do LookML

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

Como rotular campos (e nomes na UI)

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 Valor na visualização Pedidos apareceria na UI como Valor dos pedidos. Nessa página, os dois nomes de campo estão em negrito e o nome da visualização está em maiúsculas (ORDERS Amount) para esclarecer a discussão.

Se você quiser que um campo tenha um nome diferente do nome da coluna em uma tabela, mude o nome dele 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 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 NOME DO USUÁRIO e Contagem de pedidos vai mostrar a origem dos 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 contabilize usuários da UE, use 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 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 sobre Y". No LookML, o padrão de design é criar contagens para as duas condições e 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 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 valor 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 detalhamento

Um dos recursos mais eficientes do Looker é a capacidade de detalhar os dados para ver as entidades subjacentes que compõem uma contagem ou outra medida.

Quando você clica em uma medição na UI, o Looker cria uma nova consulta para localizar o conjunto de dados que compõe a medida. Os valores de cada dimensão na linha na tabela são adicionados

Para mostrar os detalhes, o Looker precisa de uma lista especificada de campos de detalhamento para mostrar quando o valor da medição receber um clique. 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 você esteja medindo Contagem de pedidos por Estado dos usuários na última semana. No Looker, a consulta teria esta aparência:

Estado de USERSContagem de PEDIDOS
Califórnia24
Texas5
Colorado4
Flórida4
Illinois4

Ao clicar em 24 na linha Califórnia, você verá os 24 pedidos originários da Califórnia. Embora o Looker adicione o filtro USUÁRIOS Estado: Califórnia, o Looker 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, medição 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 que sejam indexados em uma Análise

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 literais

Um conjunto literal é uma maneira direta de definir um conjunto no LookML, especialmente 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 Count ou 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), terá que editar as duas listas, a menos que tenha usado o parâmetro set para criar conjuntos nomeados que podem ser mantidos em um local 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 nova declaração de conjuntos é cumulativa. Se você declarar um conjunto em vários locais, o Looker vai incluir todos os campos declarados para ele em todos os locais.
  • Para incorporar conjuntos a outros conjuntos, digite o nome do outro conjunto seguido por um asterisco, por exemplo, setname*.
  • É possível remover elementos dos 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 Laboratórios de detalhamento visual, as visualizações de detalhamento do Look e Explore nem sempre usarão uma tabela de dados por padrão. Nesse caso, é possível personalizar a visualização mostrada 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 da Análise 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 laboratórios de detalhamento visual.

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 em "Explorar"

Use always_filter para sempre aplicar um conjunto de filtros a qualquer consulta executada em uma Análise. 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 quiser ver pedidos com outros valores de status, ele poderá definir ORDERS Status como % na UI.

sql_always_where em "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 consultem 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, uma vez que consultas ilimitadas podem rapidamente se tornar muito pesadas para o banco de dados. O LookML oferece uma maneira de abordar isso no formato 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]
}