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 database SQL. Looker utilizza un modello scritto in LookML per costruire le query SQL su un particolare database.
LookML è un linguaggio di dipendenza come make, a differenza 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 precedente con i linguaggi di programmazione per comprendere LookML. LookML è indipendente da dialetti SQL specifici e incapsula le espressioni SQL per supportare qualsiasi implementazione SQL.
Per i data analyst, LookML promuove 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 nei progetti. Un progetto LookML è una raccolta di file, inclusi almeno i file modello e vista 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 il progetto utilizzerà e su come devono essere unite. I file delle viste descrivono come vengono calcolate le informazioni su ogni tabella (o su 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 LookML in SQL, consentendo agli utenti aziendali di eseguire query senza scrivere LookML o SQL.
Gli utenti aziendali utilizzano il generatore di query 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 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 Esplora. L'utente può quindi visualizzare i risultati e generare approfondimenti.
Per ulteriori dettagli sugli elementi LookML fondamentali di un progetto e su come sono correlati tra loro, consulta Terminologia e concetti di LookML.
Cosa vedono gli utenti
La configurazione del progetto e i contenuti specifici dei relativi file determinano ciò che gli utenti vedono e come possono interagire con Looker.
- Il riquadro Esplora nel pannello di navigazione a sinistra è organizzato in base ai nomi dei modelli. Sotto ogni nome del modello è riportato un elenco delle esplorazioni disponibili Explores definite in quel modello.
- Gli utenti possono cercare un'esplorazione specifica.
Gli sviluppatori possono definire le 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 della vista è riportato un elenco dei campi disponibili delle tabelle incluse in quella vista. La maggior parte delle viste mostra sia le dimensioni sia le misure. Questo esempio seleziona una dimensione Mese all'interno di un gruppo di dimensioni Data di restituzione, definito nel file di vista.
Gli utenti possono selezionare più misure su cui basare la query.
Gli utenti possono applicare opzioni come filtri e tabelle pivot nel 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 ha 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 familiarità con lo sviluppo di LookML, ti consigliamo di utilizzare le risorse descritte nelle sezioni seguenti per accelerare l'apprendimento:
- Accedi all'ambiente di apprendimento di Looker
- Scopri come utilizzare Looker per eseguire query ed esplorare i dati
- Rivedi le nozioni di base su SQL prima di approfondire LookML
- Scopri le nozioni di base su 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 ti sarà di grande aiuto quando modellerai i dati in LookML. Se non hai familiarità con l'utilizzo di Looker per eseguire query, filtrare ed esaminare in dettaglio i dati, ti consigliamo le seguenti risorse:
- Inizia con i tutorial Recupera e crea grafici dei dati. I link in fondo a ogni pagina ti guideranno attraverso una sequenza delle funzionalità più importanti di Looker.
- La missione di potenziamento delle competenze Analisi e visualizzazione dei dati in Looker ti guiderà attraverso le nozioni di base dell'esplorazione.
Rivedi le nozioni di base su SQL prima di approfondire LookML
La scrittura di LookML richiede la comprensione delle query SQL. Non devi essere un esperto di SQL e anche i principianti possono creare modelli di Looker efficaci. 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 di Khan Academy's SQL Lessons
- SQLZoo tutorial SQL interattivi
- Libro Sams Teach Yourself SQL in 10 Minutes di Ben Forta
Scopri le nozioni di base su LookML
Queste risorse ti aiuteranno a iniziare a conoscere LookML. Utilizza il tuo account di apprendimento per sperimentare diversi pattern di progettazione.
- Inizia con Terminologia e concetti di LookML.
- Continua con Come Looker genera SQL e Concetti avanzati di LookML.
- Una volta acquisita una buona conoscenza di LookML e SQL, leggi le nostre funzionalità più avanzate, come le tabelle derivate e i filtri con modelli.
Dopo aver appreso le nozioni di base su LookML, consulta le seguenti pagine per le panoramiche dei diversi tipi di parametri LookML:
- Parametri del modello
- Parametri di esplorazione
- Parametri di join
- Parametri di visualizzazione
- Parametri dei campi
- Parametri della dashboard