Introduzione a LookML

LookML, abbreviazione di Looker Modeling Language, è il linguaggio utilizzato in Looker per creare modelli semantici dei dati. 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, anziché un linguaggio imperativo come C o Ruby. LookML fornisce tipi di dati e sintassi predefiniti per la modellazione dei dati. Per comprendere LookML non è necessaria alcuna esperienza pregressa con i linguaggi di programmazione. LookML è indipendente da dialetti SQL particolari e incapsula le espressioni SQL per supportare qualsiasi implementazione SQL.

Per gli analisti dei dati, LookML promuove lo stile DRY ("non ripeterti"), il che significa che scrivi le espressioni SQL una sola 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 codice LookML o SQL.

Gli utenti aziendali utilizzano 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, metriche e filtri per creare query personalizzate basate sulle proprie domande e generare approfondimenti personalizzati.

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, quindi Looker restituisce i risultati formattati all'utente nell'interfaccia Esplora. L'utente può quindi visualizzare i risultati e generare approfondimenti.

Per maggiori dettagli sugli elementi fondamentali di LookML in un progetto e sul loro rapporto reciproco, vedi Terminologia 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.

  1. Il pannello 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 nel modello.
  2. Gli utenti possono cercare un'esplorazione specifica.

  3. Gli sviluppatori possono definire descrizioni per le esplorazioni, che gli utenti possono visualizzare passando il mouse sopra il nome dell'esplorazione nel menu Esplora.

  4. Il riquadro Selettore campi è organizzato in base ai nomi delle viste. Sotto il nome di ogni visualizzazione è riportato un elenco dei campi disponibili delle tabelle incluse nella visualizzazione. La maggior parte delle visualizzazioni mostra sia le dimensioni che le misure. Questo esempio seleziona una dimensione Mese all'interno di un gruppo di dimensioni Data restituzione, definito nel file della visualizzazione.

  5. Gli utenti possono selezionare più misure su cui basare la query.

  6. Gli utenti possono applicare opzioni come filtri e tabelle pivot nel riquadro del selettore di campi.

  7. Gli utenti possono perfezionare i termini della query.

  8. Gli utenti possono scegliere un tipo di visualizzazione da applicare ai risultati della query.

  9. 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 nell'ultimo anno.

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 mai sviluppato in LookML, ti consigliamo di utilizzare le risorse descritte nelle sezioni seguenti per accelerare l'apprendimento:

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 familiarità con l'utilizzo di Looker per eseguire query, filtrare ed esaminare in dettaglio i dati, ti consigliamo le seguenti risorse:

Rivedi le nozioni di base di 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 Looker efficaci. Tuttavia, in generale, più approfondisci LookML, più ti avvantaggi di una conoscenza approfondita di SQL.

Se hai bisogno di ripassare SQL, ecco alcune delle nostre risorse preferite:

Scopri le nozioni di base di LookML

Queste risorse ti aiuteranno ad acquisire rapidamente le conoscenze di base di LookML. Utilizza il tuo account di apprendimento per sperimentare diversi pattern di progettazione.

Dopo aver appreso le nozioni di base di LookML, consulta le seguenti pagine per una panoramica dei diversi tipi di parametri LookML: