LookML é uma linguagem para descrever dimensões, agregações, cálculos e relações de dados em um banco de dados SQL. O Looker usa um modelo escrito no LookML para construir consultas SQL em um banco de dados específico.
Projetos do LookML
Um projeto LookML é uma coleção de modelos, visualizações e arquivos de painel que normalmente são controlados por uma versão em um repositório Git. Os arquivos de modelo contêm informações sobre quais tabelas usar e como elas precisam ser unidas. Os arquivos de visualização contêm informações sobre como calcular informações sobre cada tabela (ou em várias tabelas, se as mesclagens permitirem).
O LookML separa a estrutura do conteúdo. Portanto, a estrutura da consulta (como as tabelas são mescladas) é independente do conteúdo da consulta (as colunas a serem acessadas, campos derivados, funções de agregação para computação e expressões de filtragem a serem aplicadas).
Consultas SQL geradas pelo Looker
Para analistas de dados, o LookML promove o estilo DRY ("don't repetida por conta própria"), o que significa que você escreve expressões SQL uma só vez em um só lugar, e o Looker usa o código repetidamente para gerar consultas SQL ad hoc. Para os usuários comerciais, o resultado final é a capacidade de criar consultas complexas no Looker, com foco apenas no conteúdo de que precisam, não nas complexidades da estrutura SQL.
A figura a seguir mostra uma consulta, criada no Looker, que une valores de várias tabelas: itens de pedidos, produtos e usuários:
Na figura acima, o usuário final não precisa entender expressões SQL para mesclas ou filtragem.
Uma linguagem de dependência para descrever estruturas de dados
LookML é uma linguagem de dependência, como make, em vez de uma linguagem imperativa, como C ou Ruby. O LookML oferece sintaxe e tipos de dados predefinidos para modelagem de dados. A sintaxe do LookML tem uma estrutura clara e fácil de aprender. Não é preciso ter experiência com linguagens de programação. Tudo o que você precisa saber está documentado aqui. O LookML é independente de dialetos SQL específicos e encapsula expressões SQL para dar suporte a qualquer implementação SQL.
Exemplo de código
O exemplo abaixo mostra um projeto LookML mínimo para uma loja de e-commerce que tem um arquivo de modelo e dois arquivos de visualização:
######################################
# 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'
}
}
LookML diferencia maiúsculas de minúsculas
LookML diferencia maiúsculas de minúsculas. Portanto, verifique se ele corresponde ao caso ao se referir a elementos LookML. O Looker alertará você se você tiver mencionado um elemento que não existe. No exemplo abaixo, o desenvolvedor capitalizou incorretamente "quot;FlightS"." O ambiente de desenvolvimento integrado do Looker mostra um aviso de que e_FLIGHTS_pdt não existe. Além disso, o ambiente de desenvolvimento integrado sugere o nome de uma exploração atual, que é e_flights_pdt:
No entanto, se o projeto contivesse e_FLIGHTS_pdt e e_flights_pdt, o ambiente de desenvolvimento integrado do Looker não poderia corrigi-lo, então você teria que confirmar a versão pretendida. Geralmente, é uma boa ideia usar letras minúsculas ao nomear objetos LookML.
Os nomes das pastas do ambiente de desenvolvimento integrado também diferenciam maiúsculas de minúsculas. É necessário corresponder o uso de maiúsculas e minúsculas nos nomes de pastas sempre que você especificar caminhos de arquivo. Por exemplo, se você tiver uma pasta chamada Views, use letras maiúsculas no parâmetro include. Novamente, o ambiente de desenvolvimento integrado do Looker indicará um erro se as letras maiúsculas e minúsculas não corresponderem a uma pasta existente no seu projeto:
Visão geral dos elementos LookML fundamentais
O diagrama a seguir mostra os elementos LookML fundamentais e suas relações. Para mais detalhes, consulte os termos e conceitos do LookML.
