Introdução ao LookML

O LookML, abreviatura de Looker Modeling Language, é a linguagem usada no Looker para criar modelos de dados semânticos. Pode usar o LookML para descrever dimensões, agregados, cálculos e relações de dados na sua base de dados SQL. O Looker usa um modelo escrito em LookML para criar consultas SQL numa base de dados específica.

O LookML é uma linguagem de dependência como o make, em oposição a uma linguagem imperativa como C ou Ruby. O LookML oferece tipos de dados e sintaxe predefinidos para a modelagem de dados. Não precisa de experiência prévia com linguagens de programação para compreender o LookML. O LookML é independente de dialetos de SQL específicos e encapsula expressões SQL para suportar qualquer implementação de SQL.

Para os analistas de dados, o LookML promove o estilo DRY ("don't repeat yourself"), o que significa que escreve expressões SQL uma vez, num único local, e o Looker usa o código repetidamente para gerar consultas SQL ad hoc. Em seguida, os utilizadores empresariais podem usar os resultados para criar consultas complexas no Looker, focando-se apenas no conteúdo de que precisam e não nas complexidades da estrutura SQL.

Projetos do LookML

O LookML é definido em projetos. Um projeto do LookML é uma coleção de ficheiros que inclui, pelo menos, ficheiros de modelo e de visualização e, opcionalmente, outros tipos de ficheiros, que são normalmente controlados em conjunto através de um repositório Git. Os ficheiros de modelo contêm informações sobre as tabelas que o projeto vai usar e como as tabelas devem ser associadas. Os ficheiros de visualização descrevem como as informações são calculadas sobre cada tabela (ou em várias tabelas, se as junções o permitirem).

O LookML separa a estrutura do conteúdo, pelo que a estrutura da consulta (como as tabelas são unidas) é independente do conteúdo da consulta (as colunas a aceder, os campos derivados, as funções de agregação a calcular e as expressões de filtragem a aplicar).

As consultas do Looker baseiam-se em ficheiros de projetos do LookML. Os analistas de dados usam o LookML para criar e manter modelos de dados que definem a estrutura de dados e as regras empresariais para os dados que estão a ser analisados. O gerador de SQL do Looker traduz o LookML em SQL, o que permite aos utilizadores empresariais fazer consultas sem escrever código LookML nem SQL.

Os utilizadores empresariais usam o criador de consultas do Looker ou a interface Explore para criar consultas baseadas no modelo de dados que os analistas do Looker definem. Os utilizadores podem selecionar dimensões, medidas e filtros para criar consultas personalizadas com base nas suas próprias perguntas e gerar as suas próprias estatísticas.

Quando um utilizador cria uma consulta, esta é enviada para o gerador de SQL do Looker, que traduz a consulta em SQL. A consulta SQL é executada na base de dados e, em seguida, o Looker devolve os resultados formatados ao utilizador na interface Explorar. Em seguida, o utilizador pode visualizar os resultados e gerar estatísticas.

Para ver mais detalhes sobre os elementos fundamentais do LookML num projeto e como se relacionam entre si, consulte Termos e conceitos do LookML.

O que os utilizadores veem

A forma como o projeto está configurado e os conteúdos específicos dos respetivos ficheiros determinam o que os utilizadores veem e como podem interagir com o Looker.

  1. O painel Explorar no painel de navegação do lado esquerdo está organizado por nomes de modelos. Abaixo do nome de cada modelo, encontra uma lista de explorações disponíveis definidas nesse modelo.
  2. Os utilizadores podem pesquisar um Explore específico.

  3. Os programadores podem definir descrições para as Explorações, que os utilizadores podem ver ao passar o cursor do rato sobre o nome da Exploração no menu Explorar.

  4. O painel do selecionador de campos está organizado por nomes de visualização de propriedade. Abaixo do nome de cada vista, encontra uma lista dos campos disponíveis das tabelas incluídas nessa vista. A maioria das vistas mostra dimensões e medidas. Este exemplo seleciona uma dimensão Mês num grupo de dimensões Data de devolução, que foi definido no ficheiro de visualização.

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

  6. Os utilizadores podem aplicar opções como filtros e tabelas dinâmicas no painel de seleção de campos.

  7. Os utilizadores podem refinar os termos da consulta.

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

  9. A execução desta análise detalhada gera uma consulta SQL que devolve uma tabela de dados e uma visualização do preço de venda total e da margem bruta total das encomendas devolvidas do ano anterior.

Exemplo de código

O exemplo de código seguinte mostra um projeto do LookML mínimo para uma loja de comércio eletrónico, que tem um ficheiro de modelo, ecommercestore.model.lkml, e dois ficheiros 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'
  }
}

Recursos adicionais

Se está a começar a desenvolver em LookML, considere usar os recursos descritos nas secções seguintes para acelerar a sua aprendizagem:

Aceda ao ambiente de aprendizagem do Looker

Consulte os cursos no Google Cloud Skills Boost.

Saiba como usar o Looker para consultar e explorar dados

Saber como explorar dados no Looker vai ajudar muito quando estiver a modelar os seus dados no LookML. Se não estiver familiarizado com a utilização do Looker para consultar, filtrar e detalhar dados, sugerimos os seguintes recursos:

Reveja os conceitos básicos de SQL antes de explorar o LookML

A escrita de LookML requer um conhecimento das consultas SQL. Não tem de ser um especialista em SQL e, mesmo os principiantes, podem criar modelos do Looker eficazes. No entanto, em geral, quanto mais aprofundar o LookML, mais beneficia de um conhecimento mais profundo do SQL.

Se precisar de relembrar o SQL, seguem-se alguns dos nossos recursos favoritos:

Aprenda os princípios básicos do LookML

Estes recursos vão ajudar a começar a usar o LookML. Use a sua conta de aprendizagem para fazer experiências com diferentes padrões de design.

Depois de aprender os conceitos básicos do LookML, consulte as páginas seguintes para ver descrições gerais dos diferentes tipos de parâmetros do LookML: