Tipos de medida

Esta página se refere ao parâmetro type que faz parte de uma medida.

O type também pode ser usado como parte de uma dimensão ou filtro descrito na página de documentação de tipos de filtros, dimensões e parâmetros.

A type também pode ser usada como parte de um grupo de dimensões, descrito na página de documentação do parâmetro dimension_group.

Uso

view: view_name {
measure: field_name {
type: measure_field_type
}
}
Hierarquia
view
Tipo de campo
type
Tipos de campo possíveis
Medir

Aceita
Um tipo de medida

Esta página inclui detalhes sobre os vários tipos que podem ser atribuídos a uma medida. Uma medida só pode ter um tipo. Quando nenhum tipo é especificado, o padrão é string.

Alguns tipos de medida têm parâmetros de suporte, que são descritos na seção apropriada.

Medir as categorias de tipo

Cada tipo de medida se enquadra em uma das categorias a seguir. Essas categorias determinam se o tipo de medida executa agregações, o tipo de campos que o tipo de medida pode referenciar e se você pode filtrar o tipo de medida usando o parâmetro filters:

  • Medidas agregadas: os tipos de medidas agregadas realizam agregações, como sum e average. As medidas agregadas podem se referir apenas a dimensões, não a outras medidas. Esse é o único tipo de medida que funciona com o parâmetro filters.
  • Medidas não agregadas: medidas não agregadas são tipos de medidas que não realizam agregações, como number e yesno. Esses tipos de medição realizam transformações simples e, como não realizam agregações, só podem referenciar medidas agregadas ou dimensões agregadas anteriormente. Não é possível usar o parâmetro filters com esses tipos de medida.
  • Medidas pós-SQL: são medidas especiais que realizam cálculos específicos depois que o Looker gera o SQL de consulta. Eles podem referenciar apenas medidas numéricas ou dimensões numéricas. Não é possível usar o parâmetro filters com esses tipos de medida.

Lista de definições de tipo

Tipo Categoria Descrição
average Agregar Gera uma média (média) de valores em uma coluna
average_distinct Agregar Gera corretamente uma média (média) de valores ao usar dados desnormalizados. Veja a descrição completa na definição abaixo.
count Agregar Gera uma contagem de linhas
count_distinct Agregar Gera uma contagem de valores exclusivos em uma coluna
date Não agregado Para medidas que contêm datas
list Agregar Gera uma lista dos valores exclusivos em uma coluna
max Agregar Gera o valor máximo em uma coluna
median Agregar Gera a mediana (valor do ponto médio) de valores em uma coluna
median_distinct Agregar Gera corretamente uma mediana (valor do ponto médio) dos valores quando uma junção causa um fanout. Veja a descrição completa na definição abaixo.
min Agregar Gera o valor mínimo em uma coluna
number Não agregado Para medidas com números
percent_of_previous Pós-SQL Gera a diferença percentual entre as linhas exibidas
percent_of_total Pós-SQL Gera a porcentagem do total para cada linha exibida
percentile Agregar Gera o valor no percentil especificado em uma coluna
percentile_distinct Agregar Gera corretamente o valor no percentil especificado quando uma junção causa um fanout. Veja a descrição completa na definição abaixo.
running_total Pós-SQL Gera o total em execução para cada linha exibida
string Não agregado Para medidas que contêm letras ou caracteres especiais, como com a função GROUP_CONCAT do MySQL
sum Agregar Gera uma soma de valores dentro de uma coluna
sum_distinct Agregar Gera corretamente uma soma de valores ao usar dados desnormalizados.
Consulte a definição abaixo para ver uma descrição completa.
yesno Não agregado Para campos que mostrarão se algo é verdadeiro ou falso
int Não agregado REMOVED 5.4 Substituído por type: number

average

type: average calcula a média dos valores em um determinado campo. Ela é semelhante à função AVG do SQL. No entanto, ao contrário da gravação do SQL bruto, o Looker calculará as médias corretamente, mesmo que as junções da sua consulta contenham fanouts.

O parâmetro sql para medidas de type: average pode usar qualquer expressão SQL válida que resulte em uma coluna de tabela numérica, uma dimensão LookML ou uma combinação de dimensões LookML.

Os campos type: average podem ser formatados usando os parâmetros value_format ou value_format_name.

Por exemplo, o LookML a seguir cria um campo com o nome avg_order, em média, a dimensão sales_price e o exibe em um formato monetário (US$ 1.234,56):

measure: avg_order {
  type: average
  sql: ${sales_price} ;;
  value_format_name: usd
}

average_distinct

type: average_distinct é para uso com conjuntos de dados desnormalizados. Ele calcula a média dos valores não repetidos em um determinado campo com base nos valores exclusivos definidos pelo parâmetro sql_distinct_key.

Esse é um conceito avançado que pode ser explicado com mais clareza com um exemplo. Considere uma tabela desnormalizada como esta:

Código do item do pedido Código do pedido Frete do pedido
1 1 10.00
2 1 10.00
3 2 20,00
4 2 20,00
5 2 20,00

Nessa situação, é possível ver que há várias linhas para cada pedido. Consequentemente, se você adicionar uma medida type: average simples à coluna order_shipping, vai receber um valor de 16,00, mesmo que a média real seja 15,00.

 # Will NOT calculate the correct average
measure: avg_shipping {
  type: average
  sql: ${order_shipping} ;;
}

Para receber um resultado preciso, você pode explicar ao Looker como identificar cada entidade exclusiva (neste caso, cada pedido) usando o parâmetro sql_distinct_key. Isso calculará o valor correto de 15.00:

 # Will calculate the correct average
measure: avg_shipping {
  type: average_distinct
  sql_distinct_key: ${order_id} ;;
  sql: ${order_shipping} ;;
}

Cada valor exclusivo de sql_distinct_key precisa ter apenas um valor correspondente em sql. Em outras palavras, o exemplo acima funciona porque todas as linhas com order_id igual a 1 têm o mesmo order_shipping de 10, todas as linhas com order_id de 2 têm a mesma order_shipping de 20, e assim por diante.

Os campos type: average_distinct podem ser formatados usando os parâmetros value_format ou value_format_name.

count

type: count executa uma contagem de tabelas, semelhante à função COUNT do SQL. No entanto, ao contrário da gravação do SQL bruto, o Looker calculará corretamente as contagens, mesmo que as junções da consulta contenham fanouts.

As medidas de type: count não aceitam o parâmetro sql, já que uma medida de type: count realiza contagens de tabelas com base na chave primária da tabela. Se você quiser realizar uma contagem de tabela em um campo diferente da chave primária da tabela, use uma medida type: count_distinct.

Por exemplo, o seguinte LookML cria um campo number_of_products:

view: products {
  measure: number_of_products {
    type: count
    drill_fields: [product_details*]  # optional
  }
}

É muito comum fornecer um parâmetro drill_fields (para campos) ao definir uma medida type: count para que os usuários possam ver os registros individuais que compõem uma contagem ao clicar nela.

Quando você usa uma medida de type: count em um recurso "Explorar", a visualização rotula os valores resultantes com o nome da visualização em vez da palavra "Contagem". Para evitar confusão, recomendamos que você pluralize o nome da visualização, selecionando Mostrar nome de campo completo em Séries nas configurações de visualização ou usando um view_label com uma versão pluralizada do nome de visualização.

Se você quiser executar uma COUNT (não uma COUNT_DISTINCT) em um campo que não seja a chave primária, faça isso usando uma medida de type: number. Para mais informações, consulte o artigo da Central de Ajuda A diferença entre os tipos de medição count e count_distinct.

É possível adicionar um filtro a uma medida de type: count usando o parâmetro filters.

count_distinct

type: count_distinct calcula o número de valores distintos em um determinado campo. Ela usa a função COUNT DISTINCT do SQL.

O parâmetro sql para medidas de type: count_distinct pode usar qualquer expressão SQL válida que resulte em uma coluna de tabela, uma dimensão LookML ou uma combinação de dimensões LookML.

Por exemplo, o LookML a seguir cria um campo number_of_unique_customers, que conta o número de IDs de cliente exclusivos:

measure: number_of_unique_customers {
  type: count_distinct
  sql: ${customer_id} ;;
}

É possível adicionar um filtro a uma medida de type: count_distinct usando o parâmetro filters.

date

type: date é usado com campos que contêm datas.

O parâmetro sql para medidas type: date pode usar qualquer expressão SQL válida que resulte em uma data. Na prática, esse tipo raramente é usado, porque a maioria das funções de agregação SQL não retorna datas. Uma exceção comum é um MIN ou MAX de uma dimensão de data.

Como criar uma medida de data máxima ou mínima com type: date

Se você quiser criar uma medida de data máxima ou mínima, considere usar uma medida de type: max ou type: min. No entanto, esses tipos de medidas são compatíveis apenas com campos numéricos. Em vez disso, é possível capturar uma data máxima ou mínima definindo uma medida de type: date e encapsulando o campo de data referenciado no parâmetro sql em uma função MIN() ou MAX().

Suponha que você tenha um grupo de dimensões de type: time chamado updated:

dimension_group: updated {
  type: time
  timeframes: [time, date, week, month, raw]
  sql: ${TABLE}.updated_at ;;
}

Você pode criar uma medida de type: date para capturar a data máxima desse grupo de dimensões da seguinte maneira:

measure: last_updated_date {
  type: date
  sql: MAX(${updated_raw}) ;;
  convert_tz: no
}

Neste exemplo, em vez de usar uma medida de type: max para criar a medida last_updated_date, a função MAX() é aplicada no parâmetro sql. A medida last_updated_date também tem o parâmetro convert_tz definido como no para evitar a conversão dupla do fuso horário na medida, já que a conversão de fuso horário já ocorreu na definição do grupo de dimensões updated. Para mais informações, consulte a documentação sobre o parâmetro convert_tz.

No LookML de exemplo para a medida last_updated_date, type: date poderia ser omitido, e o valor seria tratado como uma string, porque string é o valor padrão para type. No entanto, você vai ter um recurso de filtragem melhor para os usuários se usar o type: date.

Também é possível observar que a definição de medida last_updated_date faz referência ao período ${updated_raw}, em vez de ${updated_date}. Como o valor retornado de ${updated_date} é uma string, é necessário usar ${updated_raw} para referenciar o valor real da data.

Também é possível usar o parâmetro datatype com type: date para melhorar o desempenho da consulta, especificando o tipo de dados de data que a tabela do banco de dados usa.

Como criar uma medida máxima ou mínima para uma coluna de data e hora

Cálculo do máximo para uma coluna type: datetime é um pouco diferente. Nesse caso, você quer criar uma medida sem declarar o tipo, desta forma:

measure: last_updated_datetime {
  sql: MAX(${TABLE}.datetime_string_field) ;;
}

list

type: list cria uma lista de valores distintos em um determinado campo. Ele é semelhante à função GROUP_CONCAT do MySQL.

Não é necessário incluir um parâmetro sql para type: list medidas. Em vez disso, use o parâmetro list_field para especificar a dimensão com que você quer criar listas.

O uso é o seguinte:

view: view_name {
measure: field_name {
type: list
list_field: my_field_name
}
}

Por exemplo, o LookML a seguir cria uma medida name_list com base na dimensão name:

measure: name_list {
  type: list
  list_field: name
}

Observe o seguinte para list:

  • O tipo de medida list não tem suporte à filtragem. Não é possível usar o parâmetro filters em uma medida type: list.
  • O tipo de medida list não pode ser referenciado usando o operador de substituição ($). Não é possível usar a sintaxe ${} para se referir a uma medida type: list.

Dialetos de banco de dados com suporte para list

Para que o Looker ofereça suporte a type: list no projeto do Looker, o dialeto do banco de dados também precisa ser compatível. A tabela a seguir mostra quais dialetos oferecem suporte a type: list na versão mais recente do Looker:

max

type: max encontra o maior valor em um determinado campo. Ela usa a função MAX do SQL.

O parâmetro sql para medidas de type: max pode usar qualquer expressão SQL válida que resulte em uma coluna de tabela numérica, uma dimensão LookML ou uma combinação de dimensões LookML.

Como as medidas de type: max são compatíveis apenas com campos numéricos, não é possível usar uma medida de type: max para encontrar uma data máxima. Em vez disso, é possível usar a função MAX() no parâmetro sql de uma medida de type: date para capturar uma data máxima, como mostrado anteriormente nos exemplos na seção date.

Os campos type: max podem ser formatados usando os parâmetros value_format ou value_format_name.

Por exemplo, o LookML a seguir cria um campo chamado largest_order analisando a dimensão sales_price e o exibe em um formato monetário (US$ 1.234,56):

measure: largest_order {
  type: max
  sql: ${sales_price} ;;
  value_format_name: usd
}

No momento, não é possível usar medidas type: max para strings ou datas, mas é possível adicionar manualmente a função MAX para criar esse campo, desta forma:

measure: latest_name_in_alphabet {
  type: string
  sql: MAX(${name}) ;;
}

median

type: median retorna o valor do ponto médio para os valores em um determinado campo. Isso é útil principalmente quando os dados têm alguns valores de outliers muito grandes ou pequenos que distorcem uma média simples (média) dos dados.

Considere uma tabela como esta:

Código do item do pedido | Custo | Ponto médio? -------------:|--------------: 2 | 10,00 | 4 | 10,00 | 3 | 20,00 | Valor médio 1 | 80,00 | 5 | 90,00 |

Para facilitar a visualização, a tabela é classificada por custo, mas isso não afeta o resultado. Enquanto o tipo average retornaria 42 (adicionando todos os valores e dividindo por 5), o tipo median retornaria o valor do ponto médio: 20,00.

Se houver um número par de valores, o valor mediano é calculado pela média dos dois valores mais próximos do ponto médio. Considere uma tabela como esta com um número par de linhas:

Código do item do pedido | Custo | Ponto médio? -------------:|--------------: 2 | 10 | 3 | 20 | Mais próximo antes do ponto médio 1 | 80 | Mais perto do ponto médio 4 | 90

A média, o valor do meio, é (20 + 80)/2 = 50.

A mediana também é igual ao valor no 50o percentil.

O parâmetro sql para medidas de type: median pode usar qualquer expressão SQL válida que resulte em uma coluna de tabela numérica, uma dimensão LookML ou uma combinação de dimensões LookML.

Os campos type: median podem ser formatados usando os parâmetros value_format ou value_format_name.

Exemplo

Por exemplo, o LookML a seguir cria um campo com o nome median_order, em média, a dimensão sales_price e o exibe em um formato monetário (US$ 1.234,56):

measure: median_order {
  type: median
  sql: ${sales_price} ;;
  value_format_name: usd
}

Considerações sobre median

Se você estiver usando median para um campo envolvido em um fanout, o Looker tentará usar o median_distinct. No entanto, medium_distinct só é compatível com determinados dialetos. Se median_distinct não estiver disponível para seu dialeto, o Looker retornará um erro. Como median pode ser considerado o 50o percentil, o erro declara que o dialeto não oferece suporte a percentis distintos.

Dialetos de banco de dados com suporte para median

Para que o Looker ofereça suporte ao tipo median no seu projeto do Looker, o dialeto do banco de dados também precisa ser compatível. A tabela a seguir mostra quais dialetos oferecem suporte ao tipo median na versão mais recente do Looker:

Quando há um fanout envolvido em uma consulta, o Looker tenta converter median em median_distinct. Isso só funciona em dialetos compatíveis com median_distinct.

median_distinct

Use type: median_distinct quando a mesclagem envolver um fanout. Ele calcula a média dos valores não repetidos em um determinado campo com base nos valores exclusivos definidos pelo parâmetro sql_distinct_key. Se a medida não tiver um parâmetro sql_distinct_key, o Looker tentará usar o campo primary_key.

Considere o resultado de uma consulta nas tabelas "Item de pedido" e "Pedido":

Código do item do pedido Código do pedido Frete do pedido
1 1 10
2 1 10
3 2 20
4 3 50
5 3 50
6 3 50

Nessa situação, é possível ver que há várias linhas para cada pedido. Essa consulta envolveu um fanout porque cada pedido é mapeado para vários itens. A median_distinct considera isso e encontra a mediana entre os valores 10, 20 e 50, portanto, o resultado seria 20.

Para receber um resultado preciso, você pode explicar ao Looker como identificar cada entidade exclusiva (neste caso, cada pedido) usando o parâmetro sql_distinct_key. O cálculo será o correto:

measure: median_shipping {
  type: median_distinct
  sql_distinct_key: ${order_id} ;;
  sql: ${order_shipping} ;;
}

Cada valor exclusivo de sql_distinct_key precisa ter apenas um valor correspondente no parâmetro sql da medida. Em outras palavras, o exemplo acima funciona porque todas as linhas com order_id de 1 têm a mesma order_shipping de 10, cada linha com a order_id de 2 tem a mesma order_shipping de 20 e assim por diante.

Os campos type: median_distinct podem ser formatados usando os parâmetros value_format ou value_format_name.

Considerações sobre median_distinct

O tipo de medida medium_distinct é compatível apenas com alguns dialetos. Se median_distinct não estiver disponível para o dialeto, o Looker retornará um erro. Como median pode ser considerado o 50o percentil, o erro declara que o dialeto não oferece suporte a percentis distintos.

Dialetos de banco de dados com suporte para median_distinct

Para que o Looker ofereça suporte ao tipo median_distinct no seu projeto do Looker, o dialeto do banco de dados também precisa ser compatível. A tabela a seguir mostra quais dialetos oferecem suporte ao tipo median_distinct na versão mais recente do Looker:

min

type: min encontra o menor valor em um determinado campo. Ela usa a função MIN do SQL.

O parâmetro sql para medidas de type: min pode usar qualquer expressão SQL válida que resulte em uma coluna de tabela numérica, uma dimensão LookML ou uma combinação de dimensões LookML.

Como as medidas de type: min são compatíveis apenas com campos numéricos, não é possível usar uma medida de type: min para encontrar uma data mínima. Em vez disso, é possível usar a função MIN() no parâmetro sql de uma medida de type: date para capturar um mínimo, assim como você pode usar a função MAX() com uma medida de type: date para capturar uma data máxima. Isso é mostrado anteriormente nesta página na seção date, que inclui exemplos de uso da função MAX() no parâmetro sql para encontrar uma data máxima.

Os campos type: min podem ser formatados usando os parâmetros value_format ou value_format_name.

Por exemplo, o LookML a seguir cria um campo chamado smallest_order analisando a dimensão sales_price e o exibe em um formato monetário (US$ 1.234,56):

measure: smallest_order {
  type: min
  sql: ${sales_price} ;;
  value_format_name: usd
}

No momento, não é possível usar medidas type: min para strings ou datas, mas é possível adicionar manualmente a função MIN para criar esse campo, desta forma:

measure: earliest_name_in_alphabet {
  type: string
  sql: MIN(${name}) ;;
}

number

type: number é usado com números ou números inteiros. Uma medida de type: number não realiza nenhuma agregação e serve para realizar transformações simples em outras medidas. Se estiver definindo uma medida com base em outra, a nova medida precisa ser type: number para evitar erros de agregação aninhados.

O parâmetro sql para medidas type: number pode usar qualquer expressão SQL válida que resulte em um número ou um número inteiro.

Os campos type: number podem ser formatados usando os parâmetros value_format ou value_format_name.

Por exemplo, o LookML a seguir cria uma medida chamada total_gross_margin_percentage com base nas medidas agregadas total_sale_price e total_gross_margin e a exibe em formato de porcentagem com duas casas decimais (12, 34%):

measure: total_sale_price {
  type: sum
  value_format_name: usd
  sql: ${sale_price} ;;
}

measure: total_gross_margin {
  type: sum
  value_format_name: usd
  sql: ${gross_margin} ;;
}

measure: total_gross_margin_percentage {
  type: number
  value_format_name: percent_2
  sql: ${total_gross_margin}/ NULLIF(${total_sale_price},0) ;;
}

O exemplo acima também usa a função SQL NULLIF() para remover a possibilidade de erros de divisão por zero.

Considerações sobre type: number

Ao usar as medidas de type: number, considere o seguinte:

  • Uma medida de type: number pode realizar aritmética apenas em outras medidas, não em outras dimensões.
  • Os agregados simétricos do Looker não protegem funções agregadas no SQL de uma medida type: number quando computados em uma mesclagem.
  • O parâmetro filters não pode ser usado com medidas type: number, mas a documentação filters explica uma solução alternativa.
  • type: number medidas não vão dar sugestões aos usuários.

percent_of_previous

type: percent_of_previous calcula a diferença percentual entre uma célula e a célula anterior na coluna.

O parâmetro sql para medidas type: percent_of_previous precisa fazer referência a outra medida numérica.

Os campos type: percent_of_previous podem ser formatados usando os parâmetros value_format ou value_format_name. No entanto, os formatos de porcentagem do parâmetro value_format_name não funcionam com medidas de type: percent_of_previous. Esses formatos percentuais multiplicam os valores por 100, o que distorce os resultados de um percentual do cálculo anterior.

No exemplo a seguir, este LookML cria uma medida count_growth com base na medida count:

measure: count_growth {
  type: percent_of_previous
  sql: ${count} ;;
}

Na IU do Looker, o código ficaria assim:

Os valores percent_of_previous dependem da ordem de classificação. Se você mudar a classificação, execute novamente a consulta para recalcular os valores percent_of_previous. Nos casos em que uma consulta é alterada, o percent_of_previous é executado na linha em vez de na coluna. No momento, não é possível mudar esse comportamento.

Além disso, as medidas de percent_of_previous são calculadas após o retorno dos dados do seu banco de dados. Isso significa que você não deve referenciar uma medida percent_of_previous em outra medida. Como elas podem ser calculadas em momentos diferentes, talvez você não receba resultados precisos. Isso também significa que as medidas de percent_of_previous não podem ser filtradas.

percent_of_total

type: percent_of_total calcula a parte total da coluna de uma célula. A porcentagem é calculada em relação ao total de linhas retornadas pela consulta, e não ao total de todas as linhas possíveis. No entanto, se os dados retornados pela sua consulta excederem um limite de linhas, os valores do campo aparecerão como nulos, já que serão necessários os resultados completos para calcular a porcentagem do total.

O parâmetro sql para medidas type: percent_of_total precisa fazer referência a outra medida numérica.

Os campos type: percent_of_total podem ser formatados usando os parâmetros value_format ou value_format_name. No entanto, os formatos de porcentagem do parâmetro value_format_name não funcionam com medidas de type: percent_of_total. Esses formatos percentuais multiplicam os valores por 100, o que distorce os resultados de um cálculo percent_of_total.

No exemplo a seguir, este LookML cria uma medida percent_of_total_gross_margin com base na medida total_gross_margin:

measure: percent_of_total_gross_margin {
  type: percent_of_total
  sql: ${total_gross_margin} ;;
}

Na IU do Looker, o código ficaria assim:

Nos casos em que uma consulta é alterada, o percent_of_total é executado na linha em vez de na coluna. Se não quiser isso, adicione direction: "column" à definição de medida.

Além disso, as medidas de percent_of_total são calculadas após o retorno dos dados do seu banco de dados. Isso significa que você não deve referenciar uma medida percent_of_total em outra medida. Como elas podem ser calculadas em momentos diferentes, talvez você não receba resultados precisos. Isso também significa que as medidas de percent_of_total não podem ser filtradas.

percentile

type: percentile retorna o valor no percentil especificado de valores em um determinado campo. Por exemplo, especificar o 75o percentil retornará o valor maior que 75% dos outros valores no conjunto de dados.

Para identificar o valor a ser retornado, o Looker calcula o número total de valores de dados e multiplica o percentil especificado pelo número total de valores de dados. Independentemente de como os dados são realmente classificados, o Looker identifica a ordem relativa dos valores de dados em valor crescente. O valor de dados retornado pelo Looker depende do cálculo resultar em um número inteiro ou não, conforme discutido abaixo.

Se o valor calculado não for um número inteiro

O Looker arredonda o valor calculado para cima e o usa para identificar o valor de dados que será retornado. Neste exemplo de conjunto de 19 pontuações de teste, o 75o percentil seria identificado por 19 * 0,75 = 14,25. Isso significa que 75% dos valores estão nos primeiros 14 valores de dados, abaixo da 15a posição. Assim, o Looker retorna o 15o valor de dados (87) como maior que 75% dos valores de dados.

Se o valor calculado for um número inteiro

Nesse caso um pouco mais complexo, o Looker retorna uma média do valor de dados naquela posição e o valor de dados a seguir. Para entender isso, considere um conjunto de 20 pontuações de teste: o 75o percentil seria identificado por 20 * 0,75 = 15. Isso significa que o valor dos dados na 15a posição faz parte do 75o percentil e precisamos retornar um valor que esteja acima de 75% dos valores de dados. Ao retornar a média dos valores na 15a posição (82) e na 16a posição (87), o Looker garante que 75%. Essa média (84,5) não existe no conjunto de valores de dados, mas seria maior que 75% deles.

Parâmetros obrigatórios e opcionais

Use a palavra-chave percentile: para especificar o valor fracionário, ou seja, a porcentagem de dados que precisa estar abaixo do valor retornado. Por exemplo, use percentile: 75 para especificar o valor no 75o percentil na ordem dos dados ou percentile: 10 para retornar o valor no 10o percentil. Se quiser encontrar o valor no 50o percentil, especifique percentile: 50 ou simplesmente use o tipo mediana.

O parâmetro sql para medidas de type: percentile pode usar qualquer expressão SQL válida que resulte em uma coluna de tabela numérica, uma dimensão LookML ou uma combinação de dimensões LookML.

Os campos type: percentile podem ser formatados usando os parâmetros value_format ou value_format_name.

Exemplo

Por exemplo, o LookML a seguir cria um campo chamado test_scores_75th_percentile, que retorna o valor no 75o percentil na dimensão test_scores:

measure: test_scores_75th_percentile {
  type: percentile
  percentile: 75
  sql: ${TABLE}.test_scores ;;
}

Considerações sobre percentile

Se você estiver usando percentile para um campo envolvido em um fanout, o Looker tentará usar percentile_distinct. Se percentile_distinct não estiver disponível para o dialeto, o Looker retornará um erro. Para mais informações, consulte os dialetos compatíveis com percentile_distinct.

Dialetos de banco de dados com suporte para percentile

Para que o Looker ofereça suporte ao tipo percentile no seu projeto do Looker, o dialeto do banco de dados também precisa ser compatível. A tabela a seguir mostra quais dialetos oferecem suporte ao tipo percentile na versão mais recente do Looker:

percentile_distinct

O type: percentile_distinct é uma forma especializada de percentil e precisa ser usado quando a mesclagem envolve um fanout. Ela usa os valores não repetidos em um determinado campo com base nos valores exclusivos definidos pelo parâmetro sql_distinct_key. Se a medida não tiver um parâmetro sql_distinct_key, o Looker tentará usar o campo primary_key.

Considere o resultado de uma consulta nas tabelas "Item de pedido" e "Pedido":

Código do item do pedido Código do pedido Frete do pedido
1 1 10
2 1 10
3 2 20
4 3 50
5 3 50
6 3 50
7 4 70
8 4 70
9 5 110
10 5 110

Nessa situação, é possível ver que há várias linhas para cada pedido. Essa consulta envolveu um fanout porque cada pedido é mapeado para vários itens. O percentile_distinct considera isso e encontra o valor do percentil usando os valores distintos 10, 20, 50, 70 e 110. O 25o percentil retornará o segundo valor distinto, ou 20, enquanto o 80o percentil retornará a média do quarto e quinto valores distintos, ou 90.

Parâmetros obrigatórios e opcionais

Use a palavra-chave percentile: para especificar o valor fracionário. Por exemplo, use percentile: 75 para especificar o valor no 75o percentil na ordem dos dados ou percentile: 10 para retornar o valor no 10o percentil. Se você estiver tentando encontrar o valor no 50o percentil, use o tipo median_distinct.

Para receber um resultado preciso, especifique como o Looker precisa identificar cada entidade exclusiva (neste caso, cada pedido) usando o parâmetro sql_distinct_key.

Veja um exemplo de como usar percentile_distinct para retornar o valor no 90o percentil:

measure: order_shipping_90th_percentile {
  type: percentile_distinct
  percentile: 90
  sql_distinct_key: ${order_id} ;;
  sql: ${order_shipping} ;;
}

Cada valor exclusivo de sql_distinct_key precisa ter apenas um valor correspondente no parâmetro sql da medida. Em outras palavras, o exemplo acima funciona porque todas as linhas com order_id de 1 têm o mesmo order_shipping de 10, cada linha com order_id de 2 tem o mesmo order_shipping de 20 e assim por diante.

Os campos type: percentile_distinct podem ser formatados usando os parâmetros value_format ou value_format_name.

Considerações sobre percentile_distinct

Se percentile_distinct não estiver disponível para o dialeto, o Looker retornará um erro. Para mais informações, consulte os dialetos compatíveis com percentile_distinct.

Dialetos de banco de dados com suporte para percentile_distinct

Para que o Looker ofereça suporte ao tipo percentile_distinct no seu projeto do Looker, o dialeto do banco de dados também precisa ser compatível. A tabela a seguir mostra quais dialetos oferecem suporte ao tipo percentile_distinct na versão mais recente do Looker:

running_total

type: running_total calcula uma soma cumulativa das células em uma coluna. Ela não pode ser usada para calcular somas em uma linha, a menos que a linha seja resultado de uma tabela dinâmica.

O parâmetro sql para medidas type: running_total precisa fazer referência a outra medida numérica.

Os campos type: running_total podem ser formatados usando os parâmetros value_format ou value_format_name.

Por exemplo, o LookML a seguir cria uma medida cumulative_total_revenue com base na medida total_sale_price:

measure: cumulative_total_revenue {
  type: running_total
  sql: ${total_sale_price} ;;
  value_format_name: usd
}

Na IU do Looker, o código ficaria assim:

Os valores running_total dependem da ordem de classificação. Se você mudar a classificação, execute novamente a consulta para recalcular os valores running_total. Nos casos em que uma consulta é alterada, o running_total é executado na linha em vez de na coluna. Se não quiser isso, adicione direction: "column" à definição de medida.

Além disso, as medidas de running_total são calculadas após o retorno dos dados do seu banco de dados. Isso significa que você não deve referenciar uma medida running_total em outra medida. Como elas podem ser calculadas em momentos diferentes, talvez você não receba resultados precisos. Isso também significa que as medidas de running_total não podem ser filtradas.

string

type: string é usado com campos que contêm letras ou caracteres especiais.

O parâmetro sql para medidas type: string pode usar qualquer expressão SQL válida que resulte em uma string. Na prática, esse tipo raramente é usado, porque a maioria das funções de agregação SQL não retornam strings. Uma exceção comum é a função GROUP_CONCAT do MySQL, embora o Looker forneça type: list para esse caso de uso.

Por exemplo, o LookML a seguir cria um campo category_list combinando os valores exclusivos de um campo chamado category:

measure: category_list {
  type: string
  sql: GROUP_CONCAT(${category}) ;;
}

Neste exemplo, type: string pode ser omitido, porque string é o valor padrão para type.

sum

type: sum soma os valores em um determinado campo. Ela é semelhante à função SUM do SQL. No entanto, ao contrário da gravação do SQL bruto, o Looker calculará corretamente as somas, mesmo se as junções da sua consulta contiverem fanouts.

O parâmetro sql para medidas de type: sum pode usar qualquer expressão SQL válida que resulte em uma coluna de tabela numérica, uma dimensão LookML ou uma combinação de dimensões LookML.

Os campos type: sum podem ser formatados usando os parâmetros value_format ou value_format_name.

Por exemplo, o LookML a seguir cria um campo chamado total_revenue adicionando a dimensão sales_price e o exibe em um formato de dinheiro (US$ 1.234,56):

measure: total_revenue {
  type: sum
  sql: ${sales_price} ;;
  value_format_name: usd
}

sum_distinct

type: sum_distinct é para uso com conjuntos de dados desnormalizados. Ele adiciona os valores não repetidos em um determinado campo com base nos valores exclusivos definidos pelo parâmetro sql_distinct_key.

Esse é um conceito avançado que pode ser explicado com mais clareza com um exemplo. Considere uma tabela desnormalizada como esta:

Código do item do pedido Código do pedido Frete do pedido
1 1 10.00
2 1 10.00
3 2 20,00
4 2 20,00
5 2 20,00

Nessa situação, é possível ver que há várias linhas para cada pedido. Consequentemente, se você adicionar uma medida type: sum simples à coluna order_shipping, vai receber um total de 80,00, mesmo que o frete total coletado seja de realmente 30,00.

 # Will NOT calculate the correct shipping amount
measure: total_shipping {
  type: sum
  sql: ${order_shipping} ;;
}

Para receber um resultado preciso, você pode explicar ao Looker como identificar cada entidade exclusiva (neste caso, cada pedido) usando o parâmetro sql_distinct_key. Isso calculará o valor correto de 30,00:

 # Will calculate the correct shipping amount
measure: total_shipping {
  type: sum_distinct
  sql_distinct_key: ${order_id} ;;
  sql: ${order_shipping} ;;
}

Cada valor exclusivo de sql_distinct_key precisa ter apenas um valor correspondente em sql. Em outras palavras, o exemplo acima funciona porque todas as linhas com order_id igual a 1 têm o mesmo order_shipping de 10, todas as linhas com order_id de 2 têm a mesma order_shipping de 20, e assim por diante.

Os campos type: sum_distinct podem ser formatados usando os parâmetros value_format ou value_format_name.

yesno

type: yesno cria um campo que indica se algo é verdadeiro ou falso. Os valores aparecem como Sim e Não na IU do Explore.

O parâmetro sql para uma medida type: yesno usa uma expressão SQL válida que é avaliada como TRUE ou FALSE. Se a condição for avaliada como TRUE, Yes será exibido ao usuário. Caso contrário, No será exibido.

A expressão SQL para medidas type: yesno precisa incluir apenas agregações, o que significa que agregações SQL ou referências a medidas LookML. Se você quiser criar um campo yesno que inclua uma referência a uma dimensão LookML ou uma expressão SQL que não seja uma agregação, use uma dimensão com type: yesno, não uma medida.

Assim como as medidas com type: number, uma medida com type: yesno não faz nenhuma agregação, apenas faz referência a outras agregações.

Por exemplo, a medida total_sale_price abaixo é a soma do preço total de venda dos itens de um pedido. Uma segunda medida chamada is_large_total é type: yesno. A medida is_large_total tem um parâmetro sql que avalia se o valor total_sale_price é maior que US $1.000.

measure: total_sale_price {
  type: sum
  value_format_name: usd
  sql: ${sale_price} ;;
  drill_fields: [detail*]
}
measure: is_large_total {
  description: "Is order total over $1000?"
  type: yesno
  sql: ${total_sale_price} > 1000 ;;
}

Se você quiser referenciar um campo type: yesno em outro campo, trate o campo type: yesno como um booleano (em outras palavras, como se ele já tivesse um valor verdadeiro ou falso). Exemplo:

measure: is_large_total {
  description: "Is order total over $1000?"
  type: yesno
  sql: ${total_sale_price} > 1000 ;;
}
}
# This is correct
measure: reward_points {
  type: number
  sql: CASE WHEN ${is_large_total} THEN 200 ELSE 100 END ;;
}
# This is NOT correct
measure: reward_points {
  type: number
  sql: CASE WHEN ${is_large_total} = 'Yes' THEN 200 ELSE 100 END ;;
}