LookML, acronimo di Looker Modeling Language, è il linguaggio utilizzato in Looker per creare modelli di dati semantici. Puoi utilizzare LookML per descrivere dimensioni, aggregazioni, calcoli e relazioni tra i dati nel tuo database SQL. Looker utilizza un modello scritto in LookML per costruire le query SQL su un determinato database.
LookML è un linguaggio di dipendenza come make, al contrario di un linguaggio imperativo come C o Ruby. LookML fornisce tipi di dati e sintassi predefiniti per la definizione del modello di dati. Per comprendere LookML non è necessaria alcuna esperienza precedente con i linguaggi di programmazione. LookML è indipendente da determinati dialetti SQL e incapsula le espressioni SQL per supportare qualsiasi implementazione SQL.
Per gli analisti dei dati, LookML favorisce lo stile DRY ("don't repeat yourself"), il che significa che scrivi le espressioni SQL una volta, in un unico posto e Looker utilizza il codice ripetutamente per generare query SQL ad hoc. Gli utenti aziendali possono quindi utilizzare i risultati per creare query complesse in Looker, concentrandosi solo sui contenuti di cui hanno bisogno, non sulle complessità della struttura SQL.
Progetti LookML
LookML è definito in projects. Un progetto LookML è una raccolta di file che include almeno file di modelli e viste e, facoltativamente, altri tipi di file, che in genere sono sottoposti al controllo delle versioni insieme tramite un repository Git. I file modello contengono informazioni sulle tabelle che verranno utilizzate dal progetto e su come devono essere unite. I file delle viste descrivono come vengono calcolate le informazioni relative a ogni tabella (o a più tabelle, se i join lo 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).
Le query di Looker si basano sui file di progetto LookML. I data analyst utilizzano LookML per creare e gestire modelli di dati che definiscono la struttura dei dati e le regole aziendali per i dati analizzati. Il generatore SQL di Looker traduce il LookML in SQL, consentendo agli utenti aziendali di eseguire query senza scrivere LookML o SQL.
Gli utenti aziendali utilizzano Query Builder di Looker o l'interfaccia di esplorazione per creare query basate sul modello dei dati definito dagli analisti di Looker. Gli utenti possono selezionare dimensioni, misure e filtri per creare query personalizzate basate sulle proprie domande e generare i propri approfondimenti.
Quando un utente crea una query, questa viene inviata al generatore SQL di Looker, che la traduce in SQL. La query SQL viene eseguita sul database e poi Looker restituisce i risultati formattati all'utente nell'interfaccia di esplorazione. L'utente può quindi visualizzare i risultati e generare approfondimenti.
Per maggiori dettagli sugli elementi fondamentali di LookML in un progetto e sulla loro relazione tra loro, consulta Terminologia e concetti di LookML.
Che cosa vedono gli utenti
La configurazione del progetto e i contenuti specifici dei relativi file determinano cosa vedono gli utenti e in che modo possono interagire con Looker.
- Il riquadro Esplora nel pannello di navigazione a sinistra è organizzato in base ai nomi dei modelli. Sotto il nome di ogni modello è riportato un elenco delle esplorazioni disponibili definite in quel modello.
- Gli utenti possono cercare una determinata esplorazione.
Gli sviluppatori possono definire descrizioni per le esplorazioni, che gli utenti possono visualizzare passando il mouse sopra il nome dell'esplorazione nel menu Esplora.
Il riquadro del selettore di campi è organizzato in base ai nomi delle viste. Sotto ogni nome di visualizzazione è riportato un elenco dei campi disponibili delle tabelle incluse nella visualizzazione. La maggior parte delle visualizzazioni mostra sia le dimensioni sia le misure. Questo esempio seleziona una dimensione Mese all'interno di un gruppo di dimensioni Data di reso, definito nel file della visualizzazione.
Gli utenti possono selezionare più misure su cui basare la query.
Gli utenti possono applicare opzioni come filtri e pivot nel riquadro di selezione dei campi.
Gli utenti possono perfezionare i termini della query.
Gli utenti possono scegliere un tipo di visualizzazione da applicare ai risultati della query.
L'esecuzione di questa esplorazione genera una query SQL che restituisce sia una tabella di dati sia una visualizzazione del prezzo di vendita totale e del margine lordo totale degli ordini restituiti dell'anno precedente.
Esempio di codice
Il seguente esempio di codice mostra un progetto LookML minimo per un negozio di e-commerce, che ha un file modello (ecommercestore.model.lkml) e due file di vista (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'
}
}
Risorse aggiuntive
Se non hai esperienza con lo sviluppo di LookML, ti consigliamo di utilizzare le risorse descritte nelle sezioni seguenti per accelerare l'apprendimento:
- Accedere all'ambiente di apprendimento di Looker
- Scopri come utilizzare Looker per eseguire query ed esplorare i dati
- Esamina le nozioni di base di SQL prima di iniziare a utilizzare LookML
- Scopri le nozioni di base di LookML
Accedere all'ambiente di apprendimento di Looker
Dai un'occhiata ai corsi su Google Cloud Skills Boost.
Scopri come utilizzare Looker per eseguire query ed esplorare i dati
Sapere come esplorare i dati in Looker ti aiuterà molto quando modelli i dati in LookML. Se non hai dimestichezza con l'utilizzo di Looker per eseguire query, filtrare e visualizzare in dettaglio i dati, ti consigliamo le seguenti risorse:
- Inizia con i tutorial su come recuperare i dati e utilizzarli per creare grafici. I link in fondo a ogni pagina ti guideranno attraverso una sequenza delle funzionalità più importanti di Looker.
- La quest di potenziamento delle competenze Analisi e visualizzazione dei dati in Looker ti illustrerà le nozioni di base dell'esplorazione.
Esamina le nozioni di base di SQL prima di iniziare a utilizzare LookML
La scrittura di LookML richiede la conoscenza delle query SQL. Non è necessario essere esperti di SQL e anche i principianti possono creare potenti modelli Looker. Tuttavia, in generale, più approfondisci LookML, più trarrai vantaggio da una conoscenza più approfondita di SQL.
Se hai bisogno di un ripasso di SQL, ecco alcune delle nostre risorse preferite:
- Tutorial SQL interattivi delle lezioni di SQL di Khan Academy
- Tutorial SQL interattivi di SQLZoo
- Libro Sams Teach Yourself SQL in 10 Minutes di Ben Forta
Scopri i concetti di base di LookML
Queste risorse ti aiuteranno ad acquisire rapidamente le conoscenze di LookML. Utilizza il tuo account per l'apprendimento per sperimentare diversi pattern di progettazione.
- Inizia con i termini e i concetti di LookML.
- Vai a Come Looker genera SQL e Concetti avanzati di LookML.
- Una volta acquisita una buona conoscenza di LookML e SQL, scopri le nostre funzionalità più avanzate, come le tabelle derivate e i filtri basati su modelli.
Dopo aver appreso le nozioni di base di LookML, consulta le seguenti pagine per una panoramica dei diversi tipi di parametri LookML:
- Parametri del modello
- Esplorare i parametri
- Parametri join
- Visualizza i parametri
- Parametri di campo
- Parametri della dashboard