Introduzione a LookML

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, anziché un linguaggio imperativo come C o Ruby. LookML fornisce tipi di dati e sintassi predefiniti per la definizione del modello di dati. Non è necessaria esperienza con i linguaggi di programmazione per comprendere LookML. LookML è indipendente da particolari dialetti SQL e incapsula 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 includono almeno file di modelli e visualizzazioni e, facoltativamente, altri tipi di file, che in genere vengono controllati insieme alle versioni tramite un repository Git. I file modello contengono informazioni sulle tabelle che verranno utilizzate dal progetto e su come devono essere unite. I file di visualizzazione descrivono la modalità di calcolo delle informazioni su ciascuna tabella (o in più tabelle, se i join lo consentono).

LookML separa la struttura dal contenuto, quindi la struttura della query (il modo in cui vengono unite le tabelle) è indipendente dal contenuto della query (le colonne a cui accedere, i campi derivati, le funzioni di aggregazione da calcolare ed le 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 converte il LookML in SQL, che consente agli utenti aziendali di eseguire query senza scrivere alcun codice 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 LookML fondamentali in un progetto e sulla loro correlazione tra loro, consulta Termini 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.

  1. Il riquadro Esplora nel pannello di navigazione a sinistra è organizzato in base ai nomi dei modelli. Sotto il nome di ogni modello è presente un elenco di Esplorazioni disponibili definite in quel modello.
  2. Gli utenti possono cercare un'esplorazione specifica.

  3. 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.

  4. Il riquadro del selettore dei 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.

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

  6. Gli utenti possono applicare opzioni come filtri e pivot nel riquadro del selettore 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 scontato totale e del margine lordo totale degli ordini restituiti nell'ultimo anno.

Esempio di codice

L'esempio di codice seguente mostra un progetto LookML minimo per un negozio di e-commerce, che include un file del 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 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

Dai un'occhiata ai corsi su Google Cloud Skills Boost.

Scopri come utilizzare Looker per eseguire query sui dati ed esplorarli

Sapere come esplorare i dati in Looker ti aiuterà molto quando modelli i dati in LookML. Se non sai come utilizzare Looker per eseguire query, filtrare ed esaminare i dati, ti suggeriamo le seguenti risorse:

Rivedi le nozioni di base su SQL prima di immergerti in LookML

La scrittura in 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 su SQL, ecco alcune delle nostre risorse preferite:

Impara i concetti fondamentali di LookML

Queste risorse ti aiuteranno a migliorare le tue conoscenze su 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: