Pattern LookML comuni

In questa pagina vengono descritti i seguenti pattern comuni in LookML:

Etichettatura dei campi (e nomi nell'interfaccia utente)

Looker converte i nomi dei campi LookML nelle stringhe visualizzate nella UI combinando il nome della visualizzazione in un carattere di peso normale con il nome breve del campo in grassetto. Ad esempio, un campo denominato Importo nella visualizzazione Ordini verrebbe visualizzato nell'interfaccia utente come Importo degli ordini. In questa pagina, entrambi i nomi dei campi sono in grassetto e il nome della visualizzazione è in maiuscolo (Importo ORDERS) per rendere la discussione più chiara.

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 genera 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 desideri un campo che conteggia gli utenti dell'UE, puoi utilizzare quanto segue:

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 filtrare un'espressione matematica, assicurati di racchiuderla tra virgolette:

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 ha portato a una vendita" o altre occorrenze 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 da zero in null, rendendo il risultato nullo 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 esaminare in dettaglio i dati per vedere le entità sottostanti che costituiscono un conteggio o un'altra misura.

Quando fai clic su una misura nell'interfaccia utente, Looker crea una nuova query per localizzare il set di dati che compongono la misura. Ogni valore per ogni dimensione nella riga della tabella viene aggiunto a

Per mostrare i dettagli, Looker ha bisogno di un elenco specificato di campi di analisi per 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 per lo Stato UTENTI nell'ultima settimana. In Looker, la query avrebbe il seguente aspetto:

Stato UTENTINumero ORDINI
California24
Texas5
Colorado4
Florida4
Illinois4

Se fai clic su 24 nella riga California, potresti aspettarti di visualizzare i 24 ordini provenienti dalla California. Anche se Looker aggiunge il filtro USERS State: California, Looker 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 da importare quando unisci una vista
  • I campi che vuoi indicizzare in un'esplorazione

Poiché lo stesso set può essere utilizzato in più punti in un modello, Looker offre diversi metodi per creare i set.

Insiemi letterali

Un set letterale è 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 i set 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 vista customers siano definiti due conteggi: count e in_california_count. Quando un utente visualizza in dettaglio il campo Conteggio o Conteggio in California in un'esplorazione, vuoi visualizzare i campi id, name e city.

Inizialmente, dichiarare letteralmente questi campi potrebbe sembrare sufficiente:

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 LookML sono efficaci per i seguenti modi:

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

Personalizzazione delle visualizzazioni in dettaglio

Se l'amministratore di Looker ha attivato la funzionalità di Labs Esaminare in dettaglio, le visualizzazioni di visualizzazione in dettaglio Esplora ed esplora non saranno sempre una tabella di dati per impostazione predefinita. In questo caso, puoi personalizzare la visualizzazione mostrata utilizzando le variabili liquide 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 la visualizzazione in dettaglio visiva utilizzando il parametro link senza dover attivare la funzionalità dei lab Esaminare in dettaglio visiva.

Applicazione di filtri agli 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, anche se gli utenti possono modificare il valore predefinito da te fornito, non possono rimuoverli. In genere, questi filtri vengono utilizzati per rimuovere 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 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]
}