Visão geral
Com os refinamentos do LookML, é possível adaptar uma visualização ou Análise atual sem editar o arquivo do LookML que a contém. Isso é ideal para:
- Projetos com Blocos do Looker, que usam partes pré-criadas do LookML.
- Projetos que importam arquivos de outros projetos
- Projetos em que você frequentemente precisa gerar seus arquivos a partir de tabelas do banco de dados
- Situações em que você quer compartilhar LookML entre modelos ou projetos e, ao mesmo tempo, fazer personalizações em cada lugar (configurações hub e spoke)
Por exemplo, se você tiver o seguinte arquivo de visualização no projeto:
view: flights {
sql_table_name: flightstats.accidents ;;
dimension: id {
label: "id"
primary_key: yes
type: number
sql: ${TABLE}.id ;;
}
}
É possível refinar a visualização flights
, conforme mostrado no exemplo a seguir: use o parâmetro view
com o mesmo nome de visualização, mas adicione um sinal de adição (+
) na frente do nome para indicar que é um refinamento de uma visualização existente.
Esse refinamento adiciona uma dimensão air_carrier
à visualização flights
atual:
view: +flights {
dimension: air_carrier {
type: string
sql: ${TABLE}.air_carrier ;;
}
}
Esse refinamento pode entrar em qualquer arquivo LookML do projeto, como um arquivo de modelo, um arquivo de visualização ou em um arquivo LookML próprio dedicado. Consulte a seção Como usar refinamentos no seu projeto do LookML para saber como ele funciona.
O refinamento combinado com o LookML original tem o resultado final como se este fosse o LookML original da visualização:
view: flights {
sql_table_name: flightstats.accidents ;;
dimension: id {
label: "id"
primary_key: yes
type: number
sql: ${TABLE}.id ;;
}
dimension: air_carrier {
type: string
sql: ${TABLE}.air_carrier ;;
}
}
Na interface do Looker, os usuários vão encontrar a dimensão Transportadora aérea, como se você tivesse adicionado a dimensão ao próprio arquivo de visualização original.
Confira o exemplo abaixo para informações de implementação mais detalhadas.
Refinamentos comparados a extensões
O Looker também é compatível com a extending de objetos LookML. A extensão é útil quando você quer criar uma nova cópia de uma visualização ou Análise para adicionar novos objetos a ela. Por exemplo, você pode criar uma visualização base que defina todos os seus campos e, em seguida, criar várias novas visualizações que estendam a visualização base. Essas novas visualizações podem ser modificadas para ocultar determinados campos na visualização básica ou para alterar definições ou rótulos dos campos na visualização básica.
Os refinamentos são úteis quando você quer modificar uma visualização ou Análise com alguns ajustes ou ajustes em determinados objetos, mas sem criar cópias dela. Os refinamentos são ideais para situações em que não é possível ou não quer modificar a visualização base ou o Explore e para situações em que a criação de uma nova visualização ou Análise exigiria extensas alterações em outras referências do LookML. Consulte a seção Exemplo nesta página para conferir um exemplo desse caso de uso.
Na maioria dos casos de uso, os refinamentos são uma alternativa mais simples e limpa a extends
.
Os desenvolvedores avançados do LookML podem querer usar o parâmetro extends
dentro de um refinamento do LookML. Consulte a seção Refinamentos podem conter extensões nesta página para mais informações.
Os refinamentos modificam a maioria dos parâmetros
É importante observar que, na maioria dos casos, um refinamento substitui as configurações originais de um objeto. No exemplo a seguir, a visualização original tem uma dimensão oculta (hidden: yes
):
view: faa_flights {
dimension: carrier {
hidden: yes
}
}
E em outro arquivo há um refinamento dessa dimensão com hidden: no
:
include: "/views/faa_flights.view.lkml"
view: +faa_flights {
dimension: carrier {
hidden: no
}
}
O último refinamento tem precedência. Portanto, a hidden: no
é aplicada e a dimensão aparece na visualização final.
Em alguns casos, os refinamentos são aditivos em vez de substituição. Consulte a seção Alguns parâmetros são aditivos desta página para mais informações.
Alguns parâmetros são aditivos
Em muitos casos, se o refinamento contiver o mesmo parâmetro que o objeto que está sendo refinado, o refinamento vai substituir os valores de parâmetro do objeto refinado.
Mas os refinamentos podem ser aditivos para alguns parâmetros, o que significa que os valores do objeto base são usados em conjunto com os valores do objeto refinado.
Os seguintes parâmetros são aditivos:
Para dimensões e medidas:
Para parâmetros:
Para tabelas derivadas:
Para visualizações:
extends
Consulte a seção Refinamentoextends
são aditivos nesta página para mais informações.
Para Explores:
access_filter
aggregate_table
extends
Consulte a seção Refinamentoextends
são aditivos nesta página para mais informações.join
query
Por exemplo, esta é uma visualização que tem uma dimensão name
com um parâmetro link
:
view: carriers {
sql_table_name: flightstats.carriers ;;
dimension: name {
sql: ${TABLE}.name ;;
type: string
link: {
label: "Google {{ value }}"
url: "http://www.google.com/search?q={{ value }}"
icon_url: "http://google.com/favicon.ico"
}
}
}
Aqui está um refinamento da visualização carriers
, com uma dimensão name
que tem valores diferentes para o parâmetro link
:
include: "/views/carriers.view.lkml"
view: +carriers {
label: "Refined carriers"
dimension: name {
sql: ${TABLE}.name ;;
type: string
link: {
label: "Dashboard for {{ value }}"
url: "https://docsexamples.dev.looker.com/dashboards/307?Carrier={{ value }}"
icon_url: "https://www.looker.com/favicon.ico"
}
}
}
Na visualização carriers
refinada, os dois parâmetros link
são cumulativos. Portanto, a dimensão name
mostra os dois links.
Os refinamentos são aplicados em ordem
Um objeto pode ser refinado várias vezes e em vários lugares, o que permite que os desenvolvedores do Looker usem refinamentos de muitas maneiras criativas. Mas isso também significa que os desenvolvedores precisam estar muito atentos à ordem em que os refinamentos são aplicados:
- Dentro de um projeto, os refinamentos são aplicados na ordem em que os arquivos são incluídos. Os refinamentos dos arquivos incluídos por último substituem os refinamentos dos arquivos incluídos anteriormente.
- Em um único arquivo, os refinamentos são aplicados linha por linha de baixo. Os refinamentos com o maior número de linhas são aplicados por último e substituem os anteriores, se houver conflitos.
Por exemplo, no arquivo de visualização a seguir, há dois refinamentos da visualização faa_flights
. O primeiro refinamento oculta uma dimensão (hidden: yes
), e o segundo mostra a dimensão (hidden: no
). Quando há conflitos como esse, o refinamento mais abaixo no arquivo tem precedência:
include: "//e_faa_original/views/faa_flights.view.lkml"
view: +faa_flights {
dimension: carrier {
hidden: yes
}
}
view: +faa_flights {
dimension: carrier {
hidden: no
}
}
A lógica é semelhante para incluir vários arquivos em um projeto: os refinamentos no último arquivo listado nas inclusões terão precedência. Por exemplo, se um arquivo de modelo incluir estes arquivos:
include: "/refinements/distance_analysis.lkml"
include: "/refinements/finishing_touches.lkml"
Todos os refinamentos no distance_analysis.lkml
serão aplicados primeiro, e depois aqueles no finishing_touches.lkml
serão aplicados. Se houver conflitos, os refinamentos no último arquivo, finishing_touches.lkml
, terão precedência.
Uso de final: yes
para evitar mais refinamentos.
Conforme descrito anteriormente, o mesmo objeto pode ser refinado várias vezes em vários lugares, e o último refinamento substituirá todos os anteriores.
Se você tiver um refinamento e quiser que ele seja considerado o refinamento final da visualização ou da Análise, adicione a sinalização final: yes
a ele. O ambiente de desenvolvimento integrado do Looker vai retornar um erro do LookML se houver refinamentos que serão aplicados após o refinamento final ou se um desenvolvedor tentar adicionar um novo para ser aplicado após esse refinamento. Por exemplo, o segundo refinamento nesse arquivo de visualização criaria um erro do LookML porque o refinamento anterior tem a flag final: yes
:
include: "//e_faa_original/views/faa_flights.view.lkml"
view: +faa_flights {
final: yes
dimension: carrier {
hidden: yes
}
}
view: +faa_flights {
dimension: carrier {
hidden: no
}
}
Adicionar a sinalização final: yes
a um refinamento é uma boa maneira de verificar se eles estão sendo aplicados na ordem pretendida.
Os refinamentos podem conter extensões
Os desenvolvedores avançados do LookML podem querer usar um parâmetro extends
dentro de um refinamento do LookML, que adiciona o objeto estendido ao objeto que está sendo refinado.
Para resumir o comportamento de extends
e os refinamentos, faça o seguinte:
- A extensão de um objeto cria uma nova cópia dele e depois se baseia nela. Por exemplo, você pode criar uma visualização base que defina todos os seus campos e, em seguida, criar várias novas visualizações que estendam a visualização base. Cada uma dessas novas vistas incorpora uma cópia da vista básica. A partir daí, o desenvolvedor pode adicionar campos, filtros ou outras propriedades diferentes para modificar o que está nela. A ideia é que você comece com um objeto base e o use de diferentes maneiras em vários outros objetos. Consulte a página de documentação Reutilizar código com estende para uma discussão completa sobre o trabalho com extensões.
- Refinar um objeto adiciona uma camada de modificações a ele. No entanto, ao contrário da extensão, o refinamento não cria várias cópias do objeto. A ideia é criar com base em um objeto base sem modificar o LookML original.
Como exemplo do uso padrão de refinamentos, confira uma Análise chamada orders
e a Análise +orders
que a refina:
explore: orders {
view_name: orders
# other Explore parameters
}
explore: +orders {
label: "Orders Information"
# other Explore parameters to build on the original Explore
}
Além disso, você pode adicionar um refinamento que inclui um extends
. Com base no exemplo, apresentamos o mesmo Explore orders
. Além disso, há uma Análise básica chamada users_base
, e agora o refinamento +orders
tem um parâmetro extends
que traz o users_base
:
explore: users_base {
view_name: users
extension: required
# other Explore parameters
}
explore: orders {
view_name: orders
# other Explore parameters
}
explore: +orders {
label: "Orders Information"
extends: [users_base]
# other Explore parameters to build on the original Explore
}
O que é especial nesse caso é que o refinamento +orders
tem um extends
. O resultado é que a visualização +orders
agora vai estender a Explore users_base
.
Como o Looker implementa o extends
nos refinamentos
Estender um objeto dentro de um refinamento é um conceito avançado do LookML. Antes de usar extends
em um refinamento, é preciso ter um bom conhecimento dos seguintes itens:
- Como o Looker implementa
extends
: se um elemento LookML for definido tanto no objeto estendido quanto no objeto extensão estendido, a versão no objeto estendido será usada, a menos que o parâmetro seja aditivo. Para mais detalhes, consulte a página da documentação Reutilizar código com extensões. - Como o Looker implementa refinamentos: se um elemento LookML for definido em vários refinamentos, o último deles vai substituir os anteriores. Consulte a seção Refinamentos são aplicados em ordem nesta página para mais detalhes.
Por fim, você precisa entender como o Looker combina esses princípios para implementar o extends
usado nos refinamentos. Esta é a ordem que o Looker implementa, com cada etapa substituindo a anterior em caso de conflitos:
- Valores do
extends
especificados no objeto - Valores de
extends
especificados nos refinamentos do objeto - Valores do objeto
- Valores dos refinamentos do objeto
Para ilustrar, aqui está um exemplo que segue o valor do parâmetro label
em cada etapa da implementação:
explore: orders_base {
label: "Orders Base"
view_name: orders
extension: required
}
explore: users_base {
label: "Users Base"
view_name: users
extension: required
}
explore: orders {
label: "Orders"
extends: [orders_base]
}
explore: +orders {
label: "Orders Refined"
extends: [users_base]
}
Confira como o Looker implementa o valor de label
para a Análise de orders
neste exemplo:
- Valores do
extends
especificados no objeto. Como a Análiseorders
tem um parâmetroextends
, o Looker começa com os elementos LookML do objeto que está sendo estendido, que nesse caso é a Análiseorders_base
. Neste ponto, o valor delabel
é "Orders Base". - Valores do
extends
especificados nos refinamentos do objeto. Comoorders
tem um refinamento e ele tem um parâmetroextends
, o Looker aplica elementos LookML da extensão do refinamento, que, nesse caso, é a Análiseusers_base
. Neste ponto, o valor delabel
é "Base de usuários". - Valores do objeto. Agora que todas as extensões foram abordadas, o Looker aplica elementos do objeto de extensão, que, neste caso, é a Análise
orders
. Se houver conflitos, o objeto estendido vencerá. Agora, o valor delabel
é "Orders". - Valores dos refinamentos do objeto. Por fim, o Looker aplica elementos de todos os refinamentos da Análise
orders
. Se houver conflitos, o objeto de refinamento vencerá. Agora, o valor delabel
é "Pedidos refinados".
O refinamento extends
é adicionado.
Conforme descrito na seção Parâmetros de substituição de refinamentos desta página, os refinamentos geralmente substituem as configurações originais de um objeto. Esse não é o caso do parâmetro extends
. Quando extends
é usado em um refinamento, o valor no parâmetro extends
é anexado à lista de itens estendidas no objeto original ou em refinamentos anteriores, se houver. Em seguida, se houver conflitos, a prioridade é dada ao último item na cadeia de extensões.
Por exemplo, esta é uma Análise básica chamada orders_base
e uma Análise orders
que estende a base. Além disso, há um Explore users_base
e o refinamento +orders
que estende o users_base
:
explore: orders_base {
view_name: orders
extension: required
# other Explore parameters
}
explore: users_base {
view_name: users
extension: required
# other Explore parameters
}
explore: orders {
extends: [orders_base]
# other Explore parameters to build on the base Explore
}
explore: +orders {
extends: [users_base]
# other Explore parameters to build on the base Explores
}
O Explore orders
estende o orders_base
, e os refinamentos +orders
adicionam o users_base
à lista extends
. O resultado é que a Análise +orders
agora vai estender orders_base
e users_base
, como se esse fosse o LookML original para a Análise:
explore: orders {
extends: [orders_base, users_base]
}
Em seguida, se houver conflitos, a prioridade é dada ao último item na cadeia de extensões. Neste exemplo, os elementos em users_base
modificariam todos os elementos conflitantes em orders_base
.
O conceito de estender mais de um objeto por vez é discutido na página de documentação Reutilizar código com extensões.
Uma última coisa a observar: neste exemplo, a ordem dos parâmetros explore
não importa. Mas, nos casos com vários refinamentos para o mesmo objeto, a ordem deles é importante. Conforme descrito na seção Refinamentos são aplicados em ordem nesta página, o último refinamento em um arquivo substitui os anteriores.
Como usar refinamentos no seu projeto do LookML
Confira as etapas gerais para refinar visualizações e Análises no projeto:
- Identifique a visualização ou a Análise que você quer refinar.
- Decida onde você quer armazenar seus refinamentos. É possível adicionar refinamentos a qualquer arquivo do LookML atual ou criar arquivos separados do LookML. Consulte o procedimento para criar um arquivo de teste de dados na página de documentação Noções básicas sobre outros arquivos de projeto para conferir um exemplo de como criar arquivos LookML genéricos.
- Use o parâmetro
include
para incorporar os refinamentos ao modelo:- No arquivo em que você grava seus refinamentos, é necessário incluir os arquivos do LookML que você está refinando. O ambiente de desenvolvimento integrado do Looker vai mostrar avisos se você tentar refinar um objeto que não está incluído.
- Em seu arquivo de modelo, inclua os arquivos em que os refinamentos estão definidos. É possível combinar arquivos e usar inclusões de maneiras muito criativas. Consulte a seção Como usar refinamentos para adicionar camadas ao seu modelo nesta página para detalhes.
Exemplo
Refinar objetos do LookML é uma maneira fácil de adaptar visualizações e Análises sem precisar editar o LookML original. Isso é especialmente útil quando as visualizações e Análises são somente leitura no projeto, como acontece com arquivos importados de outros projetos. Confira um exemplo de como refinar uma Análise.
Este é o LookML do Explore aircraft
:
explore: aircraft {
join: aircraft_types {
type: left_outer
sql_on: ${aircraft.id} = ${aircraft_types.id} ;;
relationship: many_to_one
}
join: aircraft_engine_types {
type: left_outer
sql_on: ${aircraft.id} = ${aircraft_engine_types.id} ;;
relationship: many_to_one
}
}
Essa Análise contém várias visualizações, cada uma com muitas dimensões.
Agora, outro projeto do LookML chamado e_faa_refined
importa o arquivo Explore aircraft
. No projeto e_faa_refined
, é possível usar um refinamento para simplificar significativamente o Explore aircraft
.
Como o Explore aircraft
é um arquivo importado, não é possível editá-lo diretamente. Em vez disso, é possível adicionar um refinamento. Aqui está um exemplo de um arquivo separado chamado refinements.lkml
que contém este LookML:
include: "//e_faa_original/Explores/aircraft.explore.lkml"
explore: +aircraft {
label: "Aircraft Simplified"
fields: [aircraft.aircraft_serial, aircraft.name, aircraft.count]
}
O arquivo refinements.lkml
contém o seguinte:
- O parâmetro
include
para trazer o arquivoaircraft.explore.lkml
original do projeto importado. Consulte a página de documentação Como importar arquivos de outros projetos para mais detalhes sobre como consultar arquivos de projetos importados. - Melhorias na Análise de
aircraft
:
O resultado final é como se fosse a visualização original aircraft
e aircraft
:
explore: aircraft {
label: "Aircraft Simplified"
}
view: aircraft {
sql_table_name: flightstats.aircraft ;;
dimension: aircraft_serial {
type: string
sql: ${TABLE}.aircraft_serial ;;
}
dimension: name {
type: string
sql: ${TABLE}.name ;;
}
measure: count {
type: count
}
}
Para conferir um exemplo de como usar refinamentos para personalizar uma única visualização para vários casos de uso, consulte o roteiro Maximizar a reutilização de código com o LookML DRY: como personalizar uma única visualização base para vários casos de uso.
Outros casos de uso para refinamentos
Como mencionado anteriormente, os refinamentos são ideais para adaptar objetos do LookML que são somente leitura, como blocos do Looker ou arquivos importados.
Mas, quando você sentir como adicionar refinamentos e incluí-los nos seus modelos, vai poder fazer coisas muito legais com seus projetos, conforme descrito nos exemplos a seguir.
Como usar refinamentos para adicionar análises
É possível usar refinamentos para adicionar análises ao modelo sem tocar nos arquivos originais do LookML. Por exemplo, se houver um projeto em que as visualizações e Análises são geradas a partir de tabelas no banco de dados e armazenadas em um arquivo LookML chamado faa_basic.lkml
, crie um arquivo faa_analysis.lkml
em que você use refinamentos para adicionar análises. Este é um exemplo de uma nova tabela derivada chamada distance_stats
que tem uma análise de distância. Este exemplo mostra refinamentos do Explore flights
já existente no arquivo faa_basic.lkml
que mescla a tabela derivada distance_stats
à Explore flights
. Além disso, na parte de baixo do exemplo, a visualização flights
atual é refinada para adicionar novos campos da análise:
include: "faa_basic.lkml"
explore: +flights {
join: distance_stats {
relationship: one_to_one
type: cross
}
}
view: distance_stats {
derived_table: {
explore_source: flights {
bind_all_filters: yes
column: distance_avg {field:flights.distance_avg}
column: distance_stddev {field:flights.distance_stddev}
}
}
dimension: avg {
type:number
sql: CAST(${TABLE}.distance_avg as INT64) ;;
}
dimension: stddev {
type:number
sql: CAST(${TABLE}.distance_stddev as INT64) ;;
}
}
view: +flights {
measure: distance_avg {
type: average
sql: ${distance} ;;
}
measure: distance_stddev {
type: number
sql: STDDEV(${distance}) ;;
}
dimension: distance_tiered2 {
type: tier
sql: ${distance} ;;
tiers: [500,1300]
}
}
Como usar refinamentos para adicionar camadas ao modelo.
Outro caso de uso interessante para refinamentos é adicionar camadas ao seu projeto. É possível criar vários arquivos de refinamento e incluí-los estrategicamente para adicionar camadas.
Por exemplo, no projeto da FAA, há um arquivo faa_raw.lkml
que contém todas as visualizações e Análises geradas a partir de tabelas no seu banco de dados. Esse arquivo tem uma visualização de todas as tabelas no banco de dados, cada uma com uma dimensão para cada coluna do banco de dados.
Além do arquivo bruto, você pode criar um arquivo faa_basic.lkml
para adicionar uma nova camada com refinamentos básicos, como adicionar mesclagens às suas Análises ou adicionar medidas às suas visualizações da seguinte forma:
include: "faa_raw.lkml"
explore: +flights {
join: carriers {
sql_on: ${flights.carrier} = ${carriers.name} ;;
}
}
view: +flights {
measure: total_seats {
type: sum
sql: ${aircraft_models.seats} ;;
}
}
Você pode então adicionar um arquivo faa_analysis.layer.lkml
para acrescentar uma nova camada com análises. Consulte a subseção Como usar refinamentos para adicionar análises para ver um exemplo de arquivo de análise.
Depois, basta incluir todos os arquivos de refinamento no arquivo de modelo. Também é possível usar o arquivo de modelo para adicionar refinamentos para apontar as visualizações nas tabelas de banco de dados que você quer referenciar:
connection: "publicdata_standard_sql"
include: "faa_raw.lkml"
include: "faa_basic.lkml"
include: "faa_analysis.lkml"
view: +flights {
sql_table_name: lookerdata.faa.flights;;
}
view: +airports {
sql_table_name: lookerdata.faa.airports;;
}
view: +aircraft {
sql_table_name: lookerdata.faa.aircraft;;
}
view: +aircraft_models{
sql_table_name: lookerdata.faa.aircraft_models;;
}
view: +carriers {
sql_table_name: lookerdata.faa.carriers;;
}
É possível duplicar esse arquivo de modelo e apontar para diferentes tabelas de banco de dados ou incluir diferentes arquivos de refinamento criados para definir outras camadas que você quer em seu modelo.
Como usar refinamentos para TDPs
Conforme descrito na seção Refinamentos comparados a extensões nesta página, uma extensão cria uma nova cópia do objeto que está sendo estendido. No caso de tabelas derivadas persistentes (TDPs), não use extensões, porque cada extensão de uma TDP cria uma nova cópia da tabela no seu banco de dados.
No entanto, é possível adicionar refinamentos à visualização da TDP, já que os refinamentos não criam uma nova cópia do objeto que está sendo refinado.
Como usar metadados para exibir refinamentos para um objeto
É possível clicar em um parâmetro explore
ou view
no ambiente de desenvolvimento integrado do Looker e usar o painel de metadados para ver os refinamentos do objeto. Para mais informações, consulte a página de documentação Metadados para objetos do LookML.
Informações importantes
Projetos com localização
Ao refinar um objeto, saiba que as regras de localização também se aplicam aos seus refinamentos. Se você estiver refinando um objeto e definindo novos rótulos ou descrições, forneça definições de localização nos arquivos de strings de localidade do seu projeto. Para mais informações, consulte a página de documentação Como localizar seu modelo LookML.