Dê um Upgrade no seu LookML: Modularidade e Reutilização para Turbinar suas Análises

No universo do Looker, o LookML é a linguagem que manda e desmanda na forma como seus dados são organizados, conectados e acessados. Conforme seus projetos de análise crescem, o código pode virar uma bagunça. Mas calma, o Looker tem dois truques na manga para te ajudar a manter tudo sob controle e super eficiente: o comando include e o extends. Pense neles como os superpoderes para deixar seu LookML mais organizado, fácil de manter e pronto para qualquer desafio, similar aos imports e heranças que você já conhece da programação.

include: Juntando os Pedaços do seu Código

O include é o seu amigo para trazer pedaços de código LookML de outros arquivos para dentro do seu modelo ou view. Sabe quando você quer separar suas dimensões, medidas ou tabelas derivadas em arquivos diferentes? O include faz essa mágica acontecer, organizando a casa.

Como Funciona o include?

A sintaxe é simples:

include: "nome_do_arquivo.view"

Ou pode ser mais geral:

include: "*.view"

Se precisar trazer vários arquivos de uma vez:

include: ["pedidos.view", "usuarios.view"]

E sim, você pode usar o coringa (*) para incluir todos os arquivos de um certo tipo, como todos os arquivos .view. Isso é uma mão na roda para quem tem muitos arquivos.

Onde Usar o include?

• Em arquivos de modelo (.model): Para incluir arquivos de view, dashboards e explores que se relacionam.
• Em arquivos manifest.lkml: Se você precisar puxar LookML de outros projetos. Isso ajuda muito na modularização entre projetos.
• Em outros arquivos LookML: Para incluir arquivos de apoio, como constantes ou templates.

Exemplo Prático com include

No seu arquivo de modelo (ex: ecommerce.model.lkml):

include: "*.view"

explore: order {
  join: user {
    sql_on: ${order.user_id} = ${user.id} ;;
  }
}

Com essa linha, o Looker vai incluir todas as views que estão no diretório do seu projeto. A vantagem? Se você criar uma nova view (tipo produtos.view.lkml), ela já estará disponível automaticamente para o seu modelo. Genial, né?

Boas Práticas com include

• Use nomes de arquivo que façam sentido (ex: pedidos.view.lkml, metricas_vendas.view.lkml).
• Agrupe lógicas parecidas em arquivos dedicados (ex: dimensoes.view.lkml).
• Use o coringa (*) só quando realmente precisar; em projetos grandes, incluir explicitamente deixa tudo mais claro.
• Mantenha os include no topo do seu arquivo de modelo.

extends: Herança e Reutilização Inteligente

O extends é o seu atalho para herdar ou reutilizar campos, joins ou lógicas de outro objeto LookML. Pense nele como um “copia tudo daqui e me deixa adicionar ou mudar algumas coisas”. Ele é super útil para:

• Criar views base com lógicas reutilizáveis.
• Construir variações personalizadas de explores ou views já existentes.
• Simplificar a manutenção dos seus modelos.

Como Funciona o extends?

Imagine que você tem uma view orders e quer criar uma versão que calcula o preço total:

view: extended_orders {
  extends: [orders]

  dimension: total_price {
    sql: ${order_amount} * ${unit_price} ;;
  }
}

Isso significa que a view extended_orders herda TUDO da view orders. E o melhor: você pode adicionar novas dimensões, medidas, ou até mesmo mexer nas que já existem.

Usando extends em Explores

Você também pode estender explores! Imagine um explore base e uma versão que sempre filtra os últimos 30 dias:

explore: orders_base {
  join: users {
    sql_on: ${orders.user_id} = ${users.id} ;;
  }
}

explore: orders_extended {
  extends: [orders_base]
  always_filter: {
    filters: [created_date: "30 days"]
  }
}

O orders_extended herda todos os joins do orders_base e ainda adiciona um filtro padrão. Muito prático!

Herança Múltipla com extends

Se a necessidade for grande, você pode estender vários arquivos ao mesmo tempo:

view: combined_metrics {
  extends: [sales_base, profit_base]
}

O Looker vai juntar todos os campos. Se houver algum conflito de nomes, ele usa a última definição que apareceu. Fique atento a isso!

Regras de Sobrescrita (Override)

• Você pode sobrescrever uma dimensão, medida ou join existente só de redefini-la no seu arquivo estendido.
• O Looker junta tudo o que for compatível automaticamente.
• Lembre-se: o arquivo que você está estendendo precisa estar incluído (usando include) antes.

Combinando include e extends: A Dupla Dinâmica

Esses dois comandos costumam trabalhar juntos para deixar seu código ainda mais organizado. Veja um exemplo:

# Arquivo de modelo
include: ["base_views/*.view", "custom_views/*.view"]

explore: ecommerce_orders {
  extends: [base_orders]
}

Primeiro, o modelo inclui todas as views base e customizadas. Depois, o explore usa o extends na view base para adicionar ou modificar conteúdo. Essa combinação é a chave para um LookML limpo, modular e escalável.

Exemplo Real: View Base e Sua Versão Turbinada

Vamos criar uma view base e depois uma versão customizada:

base_orders.view.lkml:

view: base_orders {
  dimension: id {
    primary_key: yes
  }
  dimension: order_date {
    type: date
  }
  measure: total_orders {
    type: count
  }
}

extended_orders.view.lkml:

view: extended_orders {
  extends: [base_orders]

  dimension: month {
    type: date
    sql: DATE_TRUNC('month', ${order_date}) ;;
  }

  measure: total_revenue {
    type: sum
    sql: ${TABLE}.revenue ;;
  }
}

Agora, extended_orders tem tudo da base_orders, mais os novos campos de mês e receita total. Simples assim!

Limitações Importantes do extends

Apesar de poderoso, o extends tem suas regrinhas:

• Ele não estende modelos diretamente, apenas views ou explores.
• Todos os arquivos LookML referenciados precisam estar incluídos antes.
• Não é possível estender conexões de banco de dados diferentes.
• Cadeias muito longas de extensões podem complicar o debug.

Dicas para Solucionar Problemas

Se o Looker der erro como “Nome de view não reconhecido” ou “Não é possível estender view indefinida”, verifique:

• Se o arquivo estendido está incluído corretamente antes de ser usado.
• Se não há erros de digitação no valor do extends.
• Evite extensões circulares (A estende B, e B estende A).

Conclusão: Mantenha seu LookML Afiado!

Dominar include e extends é essencial para quem quer um LookML bem estruturado. O include te ajuda a organizar e reutilizar arquivos, enquanto o extends permite herdar lógicas e criar variações personalizadas. O resultado? Um código mais limpo, modular, fácil de manter e seguindo o princípio DRY (Don’t Repeat Yourself – Não Se Repita).

Lembre-se sempre de testar suas mudanças no modo de desenvolvimento do Looker. Isso garante que tudo está funcionando como esperado antes de ir para produção.

Estruturar seu projeto com pastas bem definidas, como base_views/ e custom_views/, e usar o manifest.lkml ou o arquivo principal do modelo para incluir essas pastas, facilita muito a herança de campos, filtros e lógicas de forma organizada.