Introdução ao LookML

LookML, abreviação de Looker Modeling Language, é a linguagem usada no Looker para criar modelos de dados semânticos. É possível usar o LookML para descrever dimensões, agregados, cálculos e relações de dados em seu banco de dados SQL. O Looker usa um modelo escrito em LookML para criar consultas SQL em um banco de dados específico.

O LookML é uma linguagem de dependência como make, diferente de uma linguagem imperativa, como C ou Ruby. O LookML oferece tipos de dados predefinidos e sintaxe para modelagem de dados. Não é necessário ter experiência com linguagens de programação para entender o LookML. O LookML é independente de dialetos SQL específicos e encapsula expressões SQL para dar suporte a qualquer implementação SQL.

Para analistas de dados, o LookML promove o estilo DRY ("não se repita"), o que significa que você escreve expressões SQL uma vez em um só lugar, e o Looker usa o código repetidamente para gerar consultas SQL ad hoc. Os usuários comerciais podem usar os resultados para criar consultas complexas no Looker, concentrando-se apenas no conteúdo de que precisam, não nas complexidades da estrutura SQL.

Projetos do LookML

O LookML é definido em projects. Um projeto do LookML é uma coleção de arquivos que inclui pelo menos arquivos de modelo e visualização e, opcionalmente, outros tipos de arquivos, que normalmente têm controle de versões em conjunto por um repositório Git. Os arquivos modelo contêm informações sobre quais tabelas o projeto usará e como elas serão mescladas. Os arquivos de visualização descrevem como as informações são calculadas sobre cada tabela (ou em várias tabelas, se as mesclagens permitirem isso).

O LookML separa estrutura do conteúdo. Portanto, a estrutura da consulta (como as tabelas são unidas) é independente do conteúdo da consulta (colunas para acessar, campos derivados, funções de agregação a serem computadas e expressões de filtragem a serem aplicadas).

As consultas do Looker são baseadas em arquivos de projeto do LookML. Os analistas de dados usam o LookML para criar e manter modelos de dados que definem a estrutura dos dados e as regras de negócios dos dados analisados. O gerador de SQL do Looker converte o LookML em SQL. Assim, os usuários comerciais podem fazer consultas sem programar LookML ou SQL.

Os usuários comerciais usam o criador de consultas do Looker ou a interface "Explorar" para criar consultas baseadas no modelo de dados definido pelos analistas do Looker. Os usuários podem selecionar dimensões, medidas e filtros para criar consultas personalizadas com base nas próprias perguntas e gerar insights próprios.

Quando um usuário cria uma consulta, ela é enviada ao gerador SQL do Looker, que a converte em SQL. A consulta SQL é executada no banco de dados, e o Looker retorna os resultados formatados ao usuário na interface "Explore". Assim, o usuário pode visualizar os resultados e gerar insights.

Para mais detalhes sobre os elementos fundamentais do LookML em um projeto e como eles se relacionam, consulte Termos e conceitos do LookML.

O que os usuários veem

A forma como o projeto é configurado e o conteúdo específico dos arquivos determina o que os usuários veem e como podem interagir com o Looker.

  1. O painel "Explorar" no painel de navegação à esquerda está organizado pelos nomes dos model. Abaixo de cada nome de modelo, há uma lista de Análises disponíveis que são definidas nele.
  2. Os usuários podem pesquisar uma Análise específica.

  3. Os desenvolvedores podem definir descrições para as Análises, que os usuários podem conferir ao passar o cursor sobre o nome da Análise no menu Explorar.

  4. O painel do seletor de campo é organizado por nomes de visualização. Abaixo de cada nome de visualização, há uma lista dos campos disponíveis das tabelas incluídas na visualização. A maioria das visualizações mostra as dimensões e as medidas. Neste exemplo, selecionamos uma dimensão Mês no grupo de dimensões Data de retorno, que foi definido no arquivo de visualização.

  5. Os usuários podem selecionar várias medidas nas quais basear a consulta.

  6. Os usuários podem aplicar opções como filtros e tabelas dinâmicas no painel do seletor de campo.

  7. Os usuários podem refinar os termos da consulta.

  8. Os usuários podem escolher um tipo de visualização para aplicar aos resultados da consulta.

  9. A execução desse Explore gera uma consulta SQL que retorna uma tabela de dados e uma visualização do preço total de venda e da margem bruta total dos pedidos retornados no ano anterior.

Exemplo de código

O exemplo de código a seguir mostra um projeto LookML mínimo para uma loja de e-commerce, que tem um arquivo de modelo (ecommercestore.model.lkml) e dois arquivos de visualização (orders.view.lkml e customers.view.lkml):

######################################
# FILE: ecommercestore.model.lkml    #
# Define the explores and join logic #
######################################
connection: order_database
include: "*.view.lkml"
explore: orders {
  join: customers {
    sql_on: ${orders.customer_id} = ${customers.id} ;;
  }
}

##########################################################
# FILE: orders.view.lkml                                 #
# Define the dimensions and measures for the ORDERS view #
##########################################################
view: orders {
  dimension: id {
    primary_key: yes
    type: number
    sql: ${TABLE}.id ;;
  }
  dimension: customer_id {      # field: orders.customer_id
    sql: ${TABLE}.customer_id ;;
  }
  dimension: amount {           # field: orders.amount
    type: number
    value_format: "0.00"
    sql: ${TABLE}.amount ;;
  }
  dimension_group: created {                # generates fields:
    type: time                              # orders.created_time, orders.created_date
    timeframes: [time, date, week, month]   # orders.created_week, orders.created_month
    sql: ${TABLE}.created_at ;;
  }
  measure: count {             # field: orders.count
    type: count                # creates a sql COUNT(*)
    drill_fields: [drill_set*] # list of fields to show when someone clicks 'ORDERS Count'
  }
  measure: total_amount {
    type: sum
    sql: ${amount} ;;
  }
  set: drill_set {
    fields: [id, created_time, customers.name, amount]
  }
}

#############################################################
# FILE: customers.view.lkml                                 #
# Define the dimensions and measures for the CUSTOMERS view #
#############################################################
view: customers {
  dimension: id {
    primary_key: yes
    type: number
    sql: ${TABLE}.id ;;
  }
  dimension: city {                    # field: customers.city
    sql: ${TABLE}.city ;;
  }
  dimension: state {                   # field: customers.state
    sql: ${TABLE}.state ;;
  }
  dimension: name {
    sql: CONCAT(${TABLE}.firstname, " ", ${TABLE}.lastname) ;;
  }
  measure: count {             # field: customers.count
    type: count                # creates a sql COUNT(*)
    drill_fields: [drill_set*] # fields to show when someone clicks 'CUSTOMERS Count'
  }
  set: drill_set {                     # set: customers.drill_set
    fields: [id, state, orders.count]  # list of fields to show when someone clicks 'CUSTOMERS Count'
  }
}

Outros recursos

Se você não tem experiência com o desenvolvimento em LookML, considere usar os recursos descritos nas seções a seguir para acelerar seu aprendizado:

Tenha acesso ao ambiente de aprendizado do Looker

Confira os cursos no Google Cloud Ensina.

Saiba como usar o Looker para consultar e analisar dados

Saber explorar dados no Looker é muito útil para modelar seus dados no LookML. Se você não sabe usar o Looker para consultar, filtrar e detalhar dados, sugerimos os seguintes recursos:

Revise os conceitos básicos de SQL antes de se aprofundar no LookML

Escrever no LookML exige uma compreensão das consultas SQL. Você não precisa ser especialista em SQL, e até mesmo iniciantes podem criar modelos avançados do Looker. Mas, em geral, quanto mais você se aprofunda no LookML, mais se beneficia de um conhecimento mais profundo de SQL.

Se você precisar de uma atualização do SQL, aqui estão alguns de nossos recursos favoritos:

Aprenda os conceitos básicos do LookML

Estes recursos impulsionarão seu conhecimento sobre o LookML. Use sua conta de aprendizado para testar diferentes padrões de design.

Depois de aprender os conceitos básicos do LookML, consulte as páginas a seguir para acessar visões gerais dos diferentes tipos de parâmetros do LookML: