LookML, abbreviazione 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 creare query SQL su un determinato database.
LookML è un linguaggio delle dipendenze come make, al contrario di un linguaggio imperativo come C o Ruby. LookML fornisce tipi di dati e sintassi predefiniti per la modellazione dei dati. Non è necessaria alcuna esperienza con i linguaggi di programmazione per comprendere LookML. LookML è indipendente da particolari dialetti SQL e incapsula espressioni SQL per supportare qualsiasi implementazione di SQL.
Per gli analisti di dati, LookML favorisce lo stile DRY ("non ripetere tutto"), vale a dire scrivere 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 nei progetti. Un progetto LookML è una raccolta di file che includono almeno file di modelli e di visualizzazioni e, facoltativamente, altri tipi di file, che in genere vengono controllati insieme tramite un repository Git. I file del modello contengono informazioni sulle tabelle che verranno utilizzate dal progetto e su come devono essere unite. I file della vista descrivono il modo in cui vengono calcolate le informazioni su ciascuna tabella (o in più tabelle se i join lo consentono).
LookML separa la struttura dai contenuti, di conseguenza 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. Gli analisti di dati 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 converte LookML in SQL, consentendo agli utenti aziendali di eseguire query senza scrivere LookML o SQL.
Gli utenti aziendali utilizzano il Query Builder di Looker, o l'interfaccia Esplora, 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 le proprie informazioni.
Quando un utente crea una query, questa viene inviata al generatore SQL di Looker, che la converte in SQL. La query SQL viene eseguita sul database e poi Looker restituisce all'utente i risultati formattati nell'interfaccia dell'esplorazione. L'utente può quindi visualizzare i risultati e generare informazioni.
Per ulteriori dettagli sugli elementi LookML fondamentali in un progetto e su come sono correlati tra loro, consulta Termini e concetti di LookML.
Che cosa vedono gli utenti
La configurazione del progetto e i contenuti specifici dei suoi file determinano ciò che gli utenti vedono e il modo in cui possono interagire con Looker.
- Il riquadro Esplora nel pannello di navigazione a sinistra è organizzato in base ai nomi dei model. Sotto il nome di ogni modello è presente un elenco delle esplorazioni disponibili che sono definite al suo interno.
- Gli utenti possono cercare un'esplorazione specifica.
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 campi è organizzato in base ai nomi delle viste. Sotto ogni nome di visualizzazione è presente un elenco dei campi disponibili delle tabelle incluse nella visualizzazione in questione. La maggior parte delle visualizzazioni mostra sia dimensioni sia misure. In questo esempio viene selezionata una dimensione Mese dall'interno di un gruppo di dimensioni Data di ritorno, che è stato definito nel file di visualizzazione.
Gli utenti possono selezionare più misure su cui basare la query.
Gli utenti possono applicare opzioni come filtri e pivot nel riquadro del selettore 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 scontato 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 dispone di un file modello - ecommercestore.model.lkml - e due file di visualizzazione - 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 mai utilizzato lo sviluppo di LookML, ti consigliamo di utilizzare le risorse descritte nelle sezioni seguenti per accelerare il tuo apprendimento:
- Accedere all'ambiente di apprendimento di Looker
- Scopri come utilizzare Looker per eseguire query ed esplorare i dati
- Rivedi le nozioni di base di SQL prima di approfondire LookML
- Impara le nozioni di base di LookML
Accedi 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 è molto utile per la modellazione dei dati in LookML. Se non hai dimestichezza con l'uso di Looker per eseguire query, filtrare ed esaminare i dati in dettaglio, ti consigliamo le seguenti risorse:
- Inizia con i tutorial per recuperare e creare grafici dei dati. I link nella parte inferiore di ogni pagina ti guideranno in una sequenza delle più importanti funzionalità di Looker.
- La Quest Exploring Data with Looker Skills Boost ti guiderà attraverso le basi dell'esplorazione.
Rivedi le nozioni di base di SQL prima di approfondire LookML
La scrittura di LookML richiede la comprensione delle query SQL. Non è necessario essere esperti di SQL e anche i principianti possono creare modelli Looker efficaci. Tuttavia, in generale, più approfondisci LookML, più puoi trarre 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 di Khan Academy's SQL Lessons
- Tutorial SQL interattivi di SQLZoo
- Libro Sams Teach Yourself SQL in 10 Minutes di Ben Forta
Scopri i concetti fondamentali di LookML
Queste risorse ti consentiranno di iniziare rapidamente le tue conoscenze su LookML. Utilizza il tuo account di apprendimento per sperimentare diversi modelli di progettazione.
- Inizia con termini e concetti di LookML.
- Vai a In che modo Looker genera SQL e Concetti avanzati di LookML.
- Una volta che avrai acquisito una buona conoscenza di LookML e SQL, scopri le nostre funzionalità più avanzate, come le tabelle derivate e i filtri basati su modelli.
Una volta apprese le nozioni di base di LookML, consulta le seguenti pagine per una panoramica dei diversi tipi di parametri LookML:
- Parametri del modello
- Esplora i parametri
- Unisci parametri
- Visualizza parametri
- Parametri dei campi
- Parametri della dashboard