LookML è un linguaggio per la descrizione di dimensioni, aggregazioni, calcoli e relazioni tra i dati in un database SQL. Looker utilizza un modello scritto in LookML per costruire le query SQL su un particolare database.
Progetti LookML
Un progetto LookML è una raccolta di file di modelli, viste e dashboard che in genere sono sottoposti al controllo delle versioni insieme tramite un repository Git. I file modello contengono informazioni sulle tabelle da utilizzare e su come devono essere unite tra loro. I file delle viste contengono informazioni su come calcolare informazioni relative alle singole tabelle (o su tabelle multiple, se i join le consentono).
LookML separa la struttura dal contenuto, per cui la struttura della query (modalità di unione delle tabelle) è indipendente dal contenuto della query (colonne a cui accedere, campi derivati, funzioni di aggregazione da calcolare ed espressioni di filtro da applicare).
Query SQL generate da Looker
Per gli analisti di dati, LookML promuove lo stile DRY ('non ripetere' te stesso), ovvero scrivi espressioni SQL una volta, in un unico posto e Looker utilizza il codice ripetutamente per generare query SQL ad hoc. Per gli utenti aziendali, il risultato finale è la possibilità di creare query complesse in Looker, concentrandosi solo sui contenuti di cui hanno bisogno, non sulle complessità della struttura SQL.
La figura seguente mostra una query, creata in Looker, che unisce i valori di più tabelle: Orders items, Products e Users:
Nella figura sopra, l'utente finale non deve comprendere le espressioni SQL per i join o i filtri.
Un linguaggio delle dipendenze per la descrizione delle strutture di dati
LookML è un linguaggio delle dipendenze come make, a differenza di un linguaggio imperativo come C o Ruby. LookML offre tipi di dati e sintassi predefiniti per la modellazione dei dati. La sintassi di LookML ha una struttura chiara e facile da imparare. Non hai bisogno di esperienza con i linguaggi di programmazione, tutto ciò che devi sapere è documentato qui. LookML è indipendente da specifici dialetti SQL e incapsula espressioni SQL per supportare qualsiasi implementazione SQL.
Esempio di codice
L'esempio seguente mostra un progetto LookML minimo per un negozio di e-commerce, che ha un file modello e due file di visualizzazione:
######################################
# 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 è sensibile alle maiuscole
LookML fa distinzione tra maiuscole e minuscole, quindi assicurati di fare distinzione tra maiuscole e minuscole quando fai riferimento a elementi LookML. Looker ti avvisa se fai riferimento a un elemento che non esiste. Nell'esempio seguente, lo sviluppatore ha utilizzato le maiuscole in modo errato "Voli". L'IDE di Looker mostra che il e_FLIGHTS_pdt non esiste. Inoltre, l'IDE suggerisce il nome di un Explore esistente, che è e_flights_pdt:
Tuttavia, se il progetto contiene sia e_FLIGHTS_pdt che e_flights_pdt, l'IDE di Looker non può correggerti, quindi dovresti essere sicuro di quale versione intendevi. In genere, è consigliabile utilizzare lettere minuscole per assegnare un nome agli oggetti LookML.
I nomi delle cartelle dell'IDE sono sensibili alle maiuscole. Devi utilizzare le maiuscole e i nomi delle cartelle ogni volta che specifichi percorsi di file. Ad esempio, se hai una cartella denominata Views, devi utilizzare la stessa combinazione di maiuscole e minuscole nel parametro include. Anche in questo caso, l'IDE di Looker indicherà un errore se l'uso delle lettere maiuscole non corrisponde a una cartella esistente nel progetto:
Panoramica degli elementi fondamentali di LookML
Il seguente diagramma mostra gli elementi fondamentali di LookML e le loro relazioni. Per maggiori dettagli, vedi Termini e concetti di LookML.
