LookML, abreviação de Looker Modeling Language, é a linguagem usada no Looker para criar modelos de dados semânticos. É possível usar a LookML para descrever dimensões, agregações, cálculos e relações de dados no 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, e não uma linguagem imperativa, como C ou Ruby. A LookML oferece tipos de dados e sintaxe predefinidos para a modelagem de dados. Não é necessário ter experiência com linguagens de programação para entender o LookML. A LookML é independente de dialetos SQL específicos e encapsula expressões SQL para oferecer suporte a qualquer implementação de SQL.
Para analistas de dados, a LookML promove o estilo DRY ("não se repita"), ou seja, 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. Em seguida, os usuários de negócios podem usar os resultados para criar consultas complexas no Looker, concentrando-se apenas no conteúdo necessário, não nas complexidades da estrutura SQL.
Projetos do LookML
O LookML é definido em projetos. Um projeto do LookML é uma coleção de arquivos, incluindo pelo menos arquivos de modelo e de visualização, e, opcionalmente, outros tipos de arquivos, que geralmente são controlados por versão juntos em um repositório Git. Os arquivos de modelo contêm informações sobre quais tabelas o projeto vai usar e como elas devem ser unidas. Os arquivos de visualização descrevem como as informações são calculadas sobre cada tabela (ou em várias tabelas, se as junções permitirem isso).
O LookML separa a estrutura do conteúdo. Assim, a estrutura da consulta (como as tabelas são unidas) é independente do conteúdo da consulta (as colunas a serem acessadas, os campos derivados, as funções de agregação a serem calculadas e as 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 a LookML para criar e manter modelos de dados que definem a estrutura de dados e as regras de negócios para os dados que estão sendo analisados. O gerador de SQL do Looker traduz a LookML para SQL, permitindo que os usuários empresariais façam consultas sem escrever LookML ou SQL.
Os usuários comerciais usam o criador de consultas do Looker ou a interface de análise detalhada para criar consultas com base no modelo de dados definido pelos analistas do Looker. Os usuários podem selecionar dimensões, métricas e filtros para criar consultas personalizadas com base nas próprias perguntas e gerar insights.
Quando um usuário cria uma consulta, ela é enviada ao gerador de SQL do Looker, que a traduz para SQL. A consulta SQL é executada no banco de dados, e o Looker retorna os resultados formatados para o usuário na interface do recurso "Explorar". Em seguida, 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 determinam o que os usuários veem e como podem interagir com o Looker.
- O painel "Analisar" no painel de navegação à esquerda é organizado por nomes de modelos. Abaixo de cada nome de modelo, há uma lista das Análises disponíveis definidas nesse modelo.
- Os usuários podem pesquisar um detalhamento específico.
Os desenvolvedores podem definir descrições para as Análises, que os usuários podem conferir passando o cursor sobre o nome da Análise no menu Análise.
O painel do seletor de campos é organizado por nomes de visualização. Abaixo de cada nome de visualização, há uma lista dos campos disponíveis das tabelas incluídas nessa visualização. A maioria das visualizações mostra dimensões e medidas. Este exemplo seleciona uma dimensão Mês em um grupo de dimensões Data de devolução, que foi definido no arquivo de visualização.
Os usuários podem selecionar várias medidas para basear a consulta.
Os usuários podem aplicar opções como filtros e tabelas dinâmicas no painel do seletor de campos.
Os usuários podem refinar os termos da consulta.
Os usuários podem escolher um tipo de visualização para aplicar aos resultados da consulta.
Executar essa análise detalhada 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 do ano anterior.
Exemplo de código
O exemplo de código a seguir mostra um projeto mínimo do LookML 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 em desenvolvimento com LookML, use os recursos descritos nas seções a seguir para acelerar seu aprendizado:
- Acessar o ambiente de aprendizado do Looker
- Saiba como usar o Looker para consultar e analisar dados
- Revise os princípios básicos do SQL antes de começar a usar o LookML
- Aprenda os fundamentos do LookML
Acessar o ambiente de aprendizado do Looker
Confira os cursos no Google Cloud Ensina.
Aprenda a usar o Looker para consultar e analisar dados
Saber como analisar dados no Looker ajuda muito ao modelar dados em LookML. Se você não sabe como usar o Looker para consultar, filtrar e detalhar dados, sugerimos os seguintes recursos:
- Comece com os tutoriais Recuperar e criar gráficos com os dados. Os links na parte de baixo de cada página vão guiar você por uma sequência dos recursos mais importantes do Looker.
- A missão de aprendizado rápido "Analisar e visualizar dados no Looker" ensina os conceitos básicos da análise detalhada.
Revisar os princípios básicos do SQL antes de começar a usar a LookML
Para escrever LookML, é preciso entender consultas SQL. Não é preciso 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 relembrar o SQL, confira alguns dos nossos recursos favoritos:
- Tutoriais interativos de SQL das lições de SQL da Khan Academy.
- Tutoriais interativos de SQL da SQLZoo (em inglês)
- Livro Sams Teach Yourself SQL in 10 Minutes de Ben Forta (link em inglês)
Aprenda os fundamentos do LookML
Esses recursos vão ajudar você a começar a aprender sobre a LookML. Use sua conta de aprendizado para testar diferentes padrões de design.
- Comece com os termos e conceitos do LookML.
- Continue lendo Como o Looker gera SQL e Conceitos avançados do LookML.
- Depois de entender bem o LookML e o SQL, leia sobre nossos recursos mais avançados, como tabelas derivadas e filtros com modelo.
Depois de aprender o básico da LookML, confira as páginas a seguir para ver visões gerais dos diferentes tipos de parâmetros da LookML:
- Parâmetros do modelo
- Explorar parâmetros
- Parâmetros de junção
- Parâmetros de visualização
- Parâmetros de campo
- Parâmetros do painel