Pattern LookML comuni

Questa pagina descrive i seguenti pattern comuni in LookML:

Etichettatura dei campi (e nomi nell'interfaccia utente)

Looker converte i nomi dei campi LookML nelle stringhe visualizzate dall'interfaccia utente combinando il nome della visualizzazione in carattere normale con il nome breve del campo in grassetto. Ad esempio, un campo denominato Importo nella visualizzazione Ordini viene visualizzato nell'interfaccia utente come Importo ordini. In questa pagina, entrambi i nomi dei campi sono in grassetto e il nome della visualizzazione è scritto in maiuscolo (Importo ordini) per chiarire la discussione.

Se vuoi che un campo abbia un nome diverso dal nome della colonna in una tabella, modifica il nome del campo e utilizza il parametro sql per collegare il campo alla colonna appropriata della tabella. Nell'esempio seguente, la tabella airports ha una colonna cntrl_twr. Looker genererà la seguente dichiarazione:

view: airports {
  dimension: cntrl_twr {        # full name: airports.cntrl_twr
    type: yesno                 # default name: AIRPORT Cntrl Twr (Yes/No)
    sql: ${TABLE}.cntrl_twr ;;  # the sql expression for this field
  }
}

Puoi rinominare la dimensione cntrl_twr in modo che sia leggibile:

view: airports {
  dimension: has_control_tower {  # full name: airports.has_control_tower
    type: yesno                   # aliased name: AIRPORTS Has Control Tower (Yes/No)
    sql: ${TABLE}.cntrl_twr ;;    # the sql expression for this field
  }
}

Filtrare i conteggi in base a una dimensione

Puoi raggruppare in base a una dimensione e contare le entità: se raggruppi i dati per Paese UTENTI, Conteggio ORDINI ti indicherà la provenienza degli ordini in base al paese. Tuttavia, spesso è utile creare un conteggio filtrato in base a un valore dimensionale. Ad esempio, potresti creare una nuova misura e denominarla ORDERS France Count:

view: users {
  dimension: country {}
}
view: orders {
  dimension: id {
    primary_key: yes
    sql: ${TABLE}.id ;;
  }
  measure: count {
    type: count
    drill_fields: [detail]
  }
  measure: france_count {
    type: count   # COUNT(CASE WHEN users.country = 'France' THEN 1 ELSE NULL END)
    filters: [users.country: "France"]
  }
}

I filtri possono utilizzare qualsiasi espressione. Se vuoi un campo che conteggia gli utenti dell'UE, puoi utilizzare qualcosa di simile al seguente:

measure: eu_count {
  type: count   # COUNT(CASE WHEN users.countrycode IN 'UK','FR','ES' THEN 1 ELSE NULL END)
  drill_fields: [detail]
  filters: [users.countrycode: "UK,FR,ES"]
}

Se vuoi applicare un filtro con un'espressione matematica, assicurati di racchiuderla tra virgolette doppie:

measure: total_orders_above_100_dollars {
  type: sum   # SUM(CASE WHEN order.value > 100 THEN order.value ELSE NULL END)
  sql: ${order.value} ;;
  drill_fields: [detail]
  filters: [order.value: ">100"]
}

Percentuali

Molti indicatori chiave di prestazione sono espressi sotto forma di percentuali, ad esempio "la percentuale di articoli restituiti", "la percentuale di email che hanno portato a una vendita", o altre istanze della "percentuale di X di Y". In LookML, il pattern di progettazione consiste nel creare i conteggi per le due condizioni e creare un terzo campo che calcola la percentuale tra le due condizioni.

dimension: returned {
  type: yesno
}
measure: count {   # total count of items
  type: count_distinct
  sql: ${TABLE}.id ;;
  drill_fields: [detail]
}
measure: returned_count {   # count of returned items
  type: count_distinct
  sql: ${TABLE}.id ;;
  drill_fields: [detail]
  filters: [returned: "Yes"]
}
measure: percent_returned {
  type: number
  sql: 100.0 * ${returned_count} / NULLIF(${count}, 0) ;;
  value_format: "0.00"
}

Utilizza il seguente formato per calcolare le percentuali. In Postgres, i conteggi sono numeri interi e la divisione tra numeri interi genera numeri interi. Moltiplicando per 100,0, il primo conteggio viene convertito in un numero in virgola mobile, quindi il resto dell'espressione viene convertito in un numero in virgola mobile. Per evitare errori di divisione per zero, NULLIF(value, 0) converte un valore pari a zero in null, rendendo il risultato null e evitando un errore.

100.0 * ${returned_count} / NULLIF(${count}, 0)

Utilizzare gli insiemi per visualizzare in dettaglio i dettagli

Una delle funzionalità più potenti di Looker è la possibilità di visualizzare in dettaglio i dati per vedere le entità sottostanti che compongono un conteggio o un'altra misura.

Quando fai clic su una misura nell'interfaccia utente, Looker crea una nuova query per localizzare l'insieme di dati che compone la misura. Ogni valore per ogni dimensione nella riga della tabella viene aggiunta

Per mostrare i dettagli, Looker ha bisogno di un elenco specificato di campi di visualizzazione da mostrare quando viene fatto clic sul valore della misura. Quando generi un modello, in genere il generatore crea automaticamente alcuni campi di analisi iniziali. Inoltre, puoi aggiungere manualmente i campi di visualizzazione in dettaglio. Ad esempio, supponiamo che tu stia misurando il Conteggio ordini in base allo stato Utenti nell'ultima settimana. In Looker, la query avrà il seguente aspetto:

Stato USERSConteggio ordini
California24
Texas5
Colorado4
Florida4
Illinois4

Se fai clic su 24 nella riga California, potresti aspettarti di vedere i 24 ordini provenienti dalla California. Sebbene Looker aggiunga il filtro USERS Stato: California, non sa quali campi vuoi mostrare nell'ordine. Devi prima utilizzare un set per dichiarare questi campi nel modello.

In LookML, un set è un elenco di nomi di campi (dimensioni, misure e filtro). Puoi utilizzare gli insiemi per fornire a Looker le seguenti informazioni:

  • I campi da visualizzare quando visualizzi in dettaglio un conteggio o un'altra misura
  • I campi che vuoi importare quando unisci una visualizzazione
  • I campi che vuoi indicizzare in un'esplorazione

Poiché lo stesso insieme può essere utilizzato in molti punti di un modello, Looker fornisce diversi metodi per creare insiemi.

Insiemi letterali

Un set di valori letterali è un modo semplice per definire un set in LookML, in particolare quando il set viene utilizzato una sola volta. Un set letterale viene creato dichiarando il set come array. Puoi dichiarare insiemi di valori letterali utilizzando [].

Considera il seguente esempio:

view: customers {
  dimension: id {
    primary_key: yes
  }
  measure: count {
    type: count
  }
  dimension: city {}
  dimension: state {}
  dimension: name {}
}

In questo esempio, i campi da visualizzare sono id, name e city.

Nella misura, puoi dichiarare un array letterale come segue:

measure: count {
  type: count
  drill_fields: [id, name, city]
}

Insiemi denominati

Supponiamo che nella visualizzazione customers siano definiti due conteggi: count e in_california_count. Quando un utente visualizza in dettaglio il campo Conteggio o il campo Conteggio in California in un'esplorazione, vuoi visualizzare i campi id, name e city.

All'inizio, potrebbe sembrare sufficiente dichiarare questi campi in modo letterale:

view: customers {
  measure: count {
    type: count
    drill_fields: [id, name, city]
  }
  measure: in_california_count {
    type: count
    filters: [state: "California"]
    drill_fields: [id, name, city]
  }
}

Tuttavia, per aggiungere un nuovo campo (ad esempio customers.state), devi modificare entrambi gli elenchi, a meno che tu non abbia utilizzato il parametro set per creare insiemi denominati che puoi conservare in un unico posto e utilizzare in più posizioni.

Il seguente codice crea un set customers.detail e punta entrambi allo stesso insieme di campi.

view: customers {
  set: detail {
    fields: [id, name, city]      # creates named set customers.detail
  }

  measure: count {
    type: count
    drill_fields: [detail*]       # show fields in the set "customers.detail"
  }
  measure: in_california_count {
    type: count
    filters: [state: "California"]
    drill_fields: [detail*]      # show fields in the set "customers.detail"
  }
}

I set di LookML sono efficaci nei seguenti modi:

  • La rideclarazione degli insiemi è additiva. Se dichiari un set in più posizioni, Looker include tutti i campi dichiarati per l'insieme in tutte le posizioni.
  • Puoi incorporare insiemi in altri insiemi digitando il nome dell'altro insieme seguito da un asterisco, ad esempio setname*.
  • Puoi rimuovere elementi dagli insiemi inserendo un trattino prima del nome del campo, ad esempio -fieldname.

Personalizzare le visualizzazioni dettagliate

Se l'amministratore di Looker ha attivato la funzionalità di Labs Visual Drilling, le visualizzazioni di visualizzazione di Look ed Esplora non utilizzeranno sempre per impostazione predefinita una tabella di dati. In questo caso, puoi personalizzare la visualizzazione mostrata utilizzando le variabili Liquid nel parametro link, come mostrato nella pagina della documentazione relativa al parametro link e nella pagina delle best practice per Esaminare i dati in dettaglio più efficace.

Le dashboard supportano il drill-down visivo utilizzando il parametro link senza dover attivare la funzionalità di Labs Visual Drilling.

Filtrare gli insiemi di risultati

LookML fornisce un insieme di operazioni di filtro che possono essere applicate ai campi e alle esplorazioni per filtrare i set di risultati prima che vengano restituiti all'utente.

always_filter in Esplora

Utilizza always_filter per applicare sempre un insieme di filtri a qualsiasi query eseguita all'interno di un'esplorazione. I filtri vengono visualizzati nell'interfaccia utente di Looker e, sebbene gli utenti possano modificare il valore predefinito da te fornito, non possono rimuoverli. In genere, questi filtri vengono utilizzati per rimuovere i dati che normalmente non vuoi includere. Ad esempio, supponiamo che nell'esplorazione Ordini tu voglia visualizzare solo gli ordini completati o in attesa. Potresti aggiungere il seguente codice LookML:

explore: orders {
  view_name: order
    filters: [status: "complete,pending"]
  }
}

Se l'utente volesse visualizzare gli ordini con altri valori di stato, può impostare Stato ORDINI su % nell'interfaccia utente.

sql_always_where in Esplora

Se vuoi applicare una limitazione alle query che gli utenti non possono modificare, puoi utilizzare sql_always_where. Oltre alle query eseguite da utenti umani, la limitazione verrà applicata a dashboard, Look pianificati e informazioni incorporate che si basano su quell'esplorazione. Una condizione sql_always_where non viene mostrata all'utente, a meno che non esamini l'SQL sottostante delle query che crea.

L'esempio seguente impedisce agli utenti di visualizzare gli ordini precedenti al 1° gennaio 2012:

# Using Looker references
explore: order {
  sql_always_where: ${created_date} >= '2012-01-01' ;;
}

# Using raw SQL
explore: order {
  sql_always_where: DATE(created_time) >= '2012-01-01' ;;
}

conditionally_filter in Esplora

Le tabelle molto grandi richiedono una certa attenzione durante l'esecuzione delle query, dato che le query illimitate possono diventare rapidamente troppo onerose per il database. LookML fornisce un modo per risolvere questo problema sotto forma di conditionally_filter.

Puoi utilizzare il parametro conditionally_filter per applicare un filtro alla query, a meno che l'utente non abbia già aggiunto un filtro per uno dei campi elencati nella sezione unless.

L'esempio seguente non modificherà la query dell'utente se quest'ultimo ha applicato un filtro a uno o più di questi campi: created_date, shipped_time, shipped_date, orders.id o customer.name. Se l'utente non ha applicato un filtro in base a nessuno di questi campi, Looker aggiungerà automaticamente un filtro di 1 giorno il giorno orders.created_time.

  filters: [orders.created_time: "1 day"]
  unless: [created_date, shipped_time, shipped_date, orders.id, customer.name]
}