Questa pagina si riferisce al parametro
type
che fa parte di una misura.
type
può essere utilizzato anche come parte di una dimensione o di un filtro, descritto nella pagina della documentazione Tipi di dimensioni, filtri e parametri.
type
può essere utilizzato anche come parte di un gruppo di dimensioni, descritto nella pagina della documentazione del parametrodimension_group
.
Utilizzo
measure: field_name {
type: measure_field_type
}
}
Gerarchia
type |
Tipi di campi possibili
MisuraAccetta
Un tipo di misura |
Questa pagina include i dettagli sui vari tipi che possono essere assegnati a una misura. Una misura può avere un solo tipo e per impostazione predefinita viene usato il valore string
se non ne viene specificato alcun tipo.
Alcuni tipi di misurazioni hanno parametri di supporto, descritti nella sezione appropriata.
Categoria di misurazione
Ogni tipo di misura rientra in una delle seguenti categorie. Queste categorie determinano se il tipo di misurazione esegue aggregazioni, il tipo di campi a cui il tipo di misurazione può fare riferimento e se è possibile filtrare il tipo di misurazione utilizzando il parametro filters
:
- Misure aggregate: i tipi di misurazione aggregati eseguono aggregazioni, come
sum
eaverage
. Le misure aggregate possono fare riferimento solo alle dimensioni, non ad altre. Questo è l'unico tipo di misura che funziona con il parametrofilters
. - Misure non aggregate: le misure non aggregate sono, come suggerisce il nome, i tipi di misurazione che non effettuano aggregazioni, come
number
eyesno
. Questi tipi di misurazione eseguono semplici trasformazioni e, poiché non eseguono aggregazioni, possono fare riferimento solo a misure aggregate o a dimensioni aggregate in precedenza. Non puoi utilizzare il parametrofilters
con questi tipi di misurazione. - Misure post-SQL: le misure Post-SQL sono tipi speciali di misurazione che eseguono calcoli specifici dopo che Looker ha generato SQL di query. Possono fare riferimento solo a misure numeriche o dimensioni numeriche. Non puoi utilizzare il parametro
filters
con questi tipi di misurazione.
Elenco di definizioni dei tipi
Tipo | Categoria | Descrizione |
---|---|---|
average |
Aggregazione | Genera una media (media) di valori all'interno di una colonna |
average_distinct |
Aggregazione | Genera correttamente una media (media) di valori quando utilizzi dati denormalizzati. Consulta la definizione di seguito per una descrizione completa. |
count |
Aggregazione | Genera un conteggio di righe |
count_distinct |
Aggregazione | Genera un conteggio dei valori unici all'interno di una colonna |
date |
Non aggregato | Per le misure che contengono date |
list |
Aggregazione | Genera un elenco dei valori unici all'interno di una colonna |
max |
Aggregazione | Genera il valore massimo all'interno di una colonna |
median |
Aggregazione | Genera la mediana (valore in punti medi) dei valori all'interno di una colonna |
median_distinct |
Aggregazione | Genera correttamente una mediana (valore in punto centrale) dei valori quando un join causa un fanout. Consulta la definizione di seguito per una descrizione completa. |
min |
Aggregazione | Genera il valore minimo all'interno di una colonna |
number |
Non aggregato | Per le misure che contengono numeri |
percent_of_previous |
Post-SQL | Genera la differenza percentuale tra le righe visualizzate |
percent_of_total |
Post-SQL | Genera la percentuale del totale per ogni riga visualizzata |
percentile |
Aggregazione | Genera il valore al percentile specificato all'interno di una colonna |
percentile_distinct |
Aggregazione | Genera correttamente il valore al percentile specificato quando un join causa una fanout. Consulta la definizione di seguito per una descrizione completa. |
running_total |
Post-SQL | Genera il totale corrente per ogni riga visualizzata. |
string |
Non aggregato | Per le misure che contengono lettere o caratteri speciali (come con la funzione GROUP_CONCAT di MySQL). |
sum |
Aggregazione | Genera una somma di valori all'interno di una colonna |
sum_distinct |
Aggregazione | Genera correttamente una somma di valori quando utilizzi dati denormalizzati. Consulta la definizione di seguito per una descrizione completa. |
yesno |
Non aggregato | Per i campi che mostrano se qualcosa è vero o falso |
int |
Non aggregato |
RIMOSSO 5.4
Sostituito da type: number |
average
type: average
calcola la media dei valori in un determinato campo. È simile alla funzione AVG
di SQL. Tuttavia, a differenza di come SQL non elaborato, Looker calcolerà correttamente le medie anche se i join della tua query contengono fanout.
Il parametro sql
per type: average
misure può assumere qualsiasi espressione SQL valida che generi una colonna di tabella numerica, una dimensione LookML o una combinazione di dimensioni LookML.
I campi type: average
possono essere formattati utilizzando i parametri value_format
o value_format_name
.
Ad esempio, il seguente codice LookML crea un campo denominato avg_order
calcolando la media di sales_price
, quindi lo visualizza in un formato monetario ($1,234,56):
measure: avg_order {
type: average
sql: ${sales_price} ;;
value_format_name: usd
}
average_distinct
type: average_distinct
deve essere utilizzato con set di dati denormalizzati. Rappresenta la media dei valori non ripetuti in un determinato campo, in base ai valori unici definiti dal parametro sql_distinct_key
.
Si tratta di un concetto avanzato che può essere spiegato più chiaramente con un esempio. Prendi in considerazione una tabella denormalizzata come la seguente:
ID articolo dell'ordine | ID ordine | Spedizione ordine |
---|---|---|
1 | 1 | 10,00 |
2 | 1 | 10,00 |
3 | 2 | 20,00 |
4 | 2 | 20,00 |
5 | 2 | 20,00 |
In questo caso puoi vedere che ci sono più righe per ogni ordine. Di conseguenza, se aggiungi una misura type: average
semplice per la colonna order_shipping
, otterrai un valore pari a 16,00, anche se la media effettiva è 15,00.
# Will NOT calculate the correct average
measure: avg_shipping {
type: average
sql: ${order_shipping} ;;
}
Per ottenere un risultato preciso, puoi spiegare a Looker come deve identificare ogni entità unica (in questo caso, ogni ordine univoco) utilizzando il parametro sql_distinct_key
. Questo valore calcolerà l'importo corretto di 15,00:
# Will calculate the correct average
measure: avg_shipping {
type: average_distinct
sql_distinct_key: ${order_id} ;;
sql: ${order_shipping} ;;
}
Tieni presente che ogni valore univoco di sql_distinct_key
deve avere un solo valore corrispondente in sql
. In altre parole, l'esempio precedente funziona perché ogni riga con un order_id
di 1 ha la stessa order_shipping
di 10,00, ogni riga con order_id
di 2 ha la stessa order_shipping
di 20,00 e così via.
I campi type: average_distinct
possono essere formattati utilizzando i parametri value_format
o value_format_name
.
count
type: count
esegue un conteggio della tabella, in modo simile alla funzione COUNT
di SQL. Tuttavia, a differenza di SQL non elaborato, Looker calcolerà correttamente i conteggi anche se i join della tua query contengono fanout.
Le misure type: count
non supportano il parametro sql
, poiché una misura type: count
esegue i conteggi delle tabelle in base alla chiave principale della tabella. Se vuoi eseguire un conteggio tabella in un campo diverso dalla chiave primaria della tabella, utilizza una misura type: count_distinct
.
Ad esempio, il seguente LookML crea un campo number_of_products
:
view: products {
measure: number_of_products {
type: count
drill_fields: [product_details*] # optional
}
}
È molto comune fornire un parametro drill_fields
(per i campi) durante la definizione di una misura type: count
, in modo che gli utenti possano vedere i singoli record che costituiscono il conteggio quando fanno clic su questa.
Quando utilizzi una misura di
type: count
in un'esplorazione, la visualizzazione etichetta i valori risultanti con il nome della visualizzazione anziché la parola "Conteggio". Per evitare confusione, ti consigliamo di pluralizzare il nome della vista, selezionando Mostra campo completo in Serie nelle impostazioni di visualizzazione, oppure di utilizzareview_label
con una versione plurale del nome vista.
Se vuoi eseguire una COUNT
(non un COUNT_DISTINCT
) su un campo che non è la chiave principale, puoi farlo utilizzando una misura di type: number
. Per saperne di più, consulta l'articolo del Centro assistenza La differenza tra count
e count_distinct
tipi di misurazione.
Puoi aggiungere un filtro a una misura di type: count
utilizzando il parametro filters
.
count_distinct
type: count_distinct
calcola il numero di valori distinti in un determinato campo. Utilizza la funzione COUNT DISTINCT
di SQL.
Il parametro sql
per type: count_distinct
misure può assumere qualsiasi espressione SQL valida che restituisca una colonna di tabella, una dimensione LookML o una combinazione di dimensioni LookML.
Ad esempio, il seguente codice LookML crea un campo number_of_unique_customers
, che conteggia il numero di ID cliente univoci:
measure: number_of_unique_customers {
type: count_distinct
sql: ${customer_id} ;;
}
Puoi aggiungere un filtro a una misura di type: count_distinct
utilizzando il parametro filters
.
date
type: date
viene utilizzato con i campi che contengono date.
Il parametro sql
per le misure type: date
può assumere qualsiasi espressione SQL valida che restituisca una data. In pratica, questo tipo viene utilizzato raramente, perché la maggior parte delle funzioni aggregate di SQL non restituisce date. Un'eccezione comune è un MIN
o una MAX
della dimensione data.
Creazione di una misurazione della data massima o minima con type: date
Se vuoi creare una misura di una data massima o minima, potresti inizialmente pensare che funzionerà per una misura di type: max
o di type: min
. Tuttavia, questi tipi di misurazione sono compatibili solo con i campi numerici. Puoi invece acquisire una data massima o minima definendo una misura di type: date
e includendo il campo data a cui si fa riferimento nel parametro sql
di una funzione MIN()
o MAX()
.
Supponiamo che tu abbia un gruppo di dimensioni pari a type: time
, chiamato updated
:
dimension_group: updated {
type: time
timeframes: [time, date, week, month, raw]
sql: ${TABLE}.updated_at ;;
}
Puoi creare una misura di type: date
per acquisire la data massima di questo gruppo di dimensioni come segue:
measure: last_updated_date {
type: date
sql: MAX(${updated_raw}) ;;
convert_tz: no
}
In questo esempio, anziché utilizzare una misura di type: max
per creare la misura di last_updated_date
, la funzione MAX()
viene applicata nel parametro sql
. La misura last_updated_date
ha anche il parametro convert_tz
impostato su no
per impedire la doppia conversione del fuso orario nella misura, poiché la conversione del fuso orario è già stata eseguita nella definizione del gruppo di dimensioni updated
. Per ulteriori informazioni, consulta la documentazione sul parametro convert_tz
.
Nel LookML di esempio per la misura last_updated_date
, type: date
potrebbe essere omesso e il valore verrebbe considerato come una stringa, perché string
è il valore predefinito per type
. Tuttavia, avrai a disposizione una migliore capacità di filtro per gli utenti se utilizzi type: date
.
Potresti anche notare che la definizione della misura last_updated_date
fa riferimento al periodo di tempo di ${updated_raw}
anziché a quello di ${updated_date}
. Poiché il valore restituito da ${updated_date}
è una stringa, devi utilizzare ${updated_raw}
per fare riferimento al valore effettivo della data.
Puoi anche utilizzare il parametro datatype
con type: date
per migliorare le prestazioni delle query specificando il tipo di dati di data utilizzati nella tabella del database.
Creare una misurazione massima o minima per una colonna di data/ora
Il calcolo del valore massimo per una colonna type: datetime
è leggermente diverso. In questo caso, vuoi creare una misura senza dichiarare il tipo, in questo modo:
measure: last_updated_datetime {
sql: MAX(${TABLE}.datetime_string_field) ;;
}
list
type: list
crea un elenco dei valori distinti in un determinato campo. È simile alla funzione GROUP_CONCAT
di MySQL.
Non è necessario includere un parametro sql
per le misure type: list
. Dovrai invece utilizzare il parametro list_field
per specificare la dimensione da cui creare gli elenchi.
Utilizzo:
measure: field_name {
type: list
list_field: my_field_name
}
}
Ad esempio, il seguente codice LookML crea una misura name_list
in base alla dimensione name
:
measure: name_list {
type: list
list_field: name
}
Nota per list
:
- Il tipo di misurazione
list
non supporta il filtro. Non puoi utilizzare il parametrofilters
in una misuratype: list
. - Non è possibile fare riferimento al tipo di misurazione
list
utilizzando l'operatore di sostituzione ($). Non puoi utilizzare la sintassi${}
per fare riferimento a una misuratype: list
.
Dialetti di database supportati per list
Affinché Looker supporti type: list
nel tuo progetto Looker, deve essere supportato anche il dialetto del tuo database. La tabella seguente mostra quali dialetti supportano type: list
nell'ultima release di Looker:
max
type: max
trova il valore più alto in un determinato campo. Utilizza la funzione MAX
di SQL.
Il parametro sql
per le misure di type: max
può assumere qualsiasi espressione SQL valida che restituisca una colonna di tabella numerica, una dimensione LookML o una combinazione di dimensioni LookML.
Poiché le misure di type: max
sono compatibili solo con i campi numerici, non puoi utilizzare una misura di type: max
per trovare una data massima. Puoi invece utilizzare la funzione MAX()
nel parametro sql
di una misura di type: date
per acquisire una data massima, come mostrato in precedenza negli esempi nella sezione date
.
I campi type: max
possono essere formattati utilizzando i parametri value_format
o value_format_name
.
Ad esempio, il seguente LookML crea un campo denominato largest_order
esaminando la dimensione sales_price
, quindi visualizzala in un formato monetario ($1234,56):
measure: largest_order {
type: max
sql: ${sales_price} ;;
value_format_name: usd
}
Al momento non puoi utilizzare le misure type: max
per stringhe o date, ma puoi aggiungere manualmente la funzione MAX
per creare un campo di questo tipo, in questo modo:
measure: latest_name_in_alphabet {
type: string
sql: MAX(${name}) ;;
}
median
type: median
restituisce il valore del punto centrale per i valori in un determinato campo. Ciò è particolarmente utile quando i dati hanno alcuni valori anomali molto grandi o piccoli che potrebbero alterare una media semplice (media) dei dati.
Prendiamo in considerazione una tabella come la seguente:
ID articolo dell'ordine | Costo | Punto centrale? -------------:|--------------: 2 | 10.00 | 4 | 10.00 | 3 | 20.00 | Valore punto medio 1 | 80.00 | 5 | 90.00 |
Per facilitare la visualizzazione, la tabella viene ordinata in base al costo, ma non influisce sul risultato. Mentre il tipo average
restituisce 42 (aggiungendo tutti i valori e dividendo per 5), il tipo median
restituisce il valore del punto centrale: 20,00.
Se c'è un numero pari di valori, il valore mediano viene calcolato prendendo la media dei due valori più vicini al punto medio. Prendi in considerazione una tabella come questa con un numero pari di righe:
ID articolo dell'ordine | Costo | Punto centrale? -------------:|--------------: 2 | 10 | 3 | 20 | Più vicino prima del punto centrale 1 | 80 | Il più vicino dopo il punto centrale 4 | 90
La mediana, il valore medio, è (20 + 80)/2 = 50
.
La mediana è uguale al valore del 50° percentile.
Il parametro sql
per type: median
misure può assumere qualsiasi espressione SQL valida che generi una colonna di tabella numerica, una dimensione LookML o una combinazione di dimensioni LookML.
I campi type: median
possono essere formattati utilizzando i parametri value_format
o value_format_name
.
Esempio
Ad esempio, il seguente codice LookML crea un campo denominato median_order
calcolando la media di sales_price
, quindi lo visualizza in un formato monetario ($1,234,56):
measure: median_order {
type: median
sql: ${sales_price} ;;
value_format_name: usd
}
Aspetti da considerare per median
Se usi median
per un campo coinvolto in un fanout, Looker tenterà di utilizzare median_distinct
. Tuttavia, il servizio medium_distinct
è supportato solo per determinati dialetti. Se median_distinct
non è disponibile per il tuo dialetto, Looker restituisce un errore. Poiché median
può essere considerato il 50° percentile, l'errore afferma che il dialetto non supporta i percentili distinti.
Dialetti di database supportati per median
Affinché il supporto del tipo median
nel tuo progetto Looker sia supportato dal tuo dialetto del database. La tabella seguente mostra quali dialetti supportano il tipo median
nell'ultima release di Looker:
Quando è presente un fan-out in una query, Looker cerca di convertire median
in median_distinct
. Questa operazione è riuscita solo nei dialetti che supportano median_distinct
.
median_distinct
Usa type: median_distinct
quando la tua partecipazione coinvolge un fan-out. Rappresenta la media dei valori non ripetuti in un determinato campo, in base ai valori unici definiti dal parametro sql_distinct_key
. Se la misura non dispone di un parametro sql_distinct_key
, Looker tenta di utilizzare il campo primary_key
.
Considera il risultato di una query che unisce le tabelle degli articoli e degli ordini dell'ordine:
ID articolo dell'ordine | ID ordine | Spedizione ordine |
---|---|---|
1 | 1 | 10 |
2 | 1 | 10 |
3 | 2 | 20 |
4 | 3 | 50 |
5 | 3 | 50 |
6 | 3 | 50 |
In questo caso puoi vedere che ci sono più righe per ogni ordine. Questa query ha coinvolto un fanout perché ogni ordine è associato a diversi articoli dell'ordine. median_distinct
prende in considerazione questo valore e trova la media tra i valori 10, 20 e 50, quindi otterrai un valore 20.
Per ottenere un risultato preciso, puoi spiegare a Looker come deve identificare ogni entità unica (in questo caso, ogni ordine univoco) utilizzando il parametro sql_distinct_key
. Verrà calcolato l'importo corretto:
measure: median_shipping {
type: median_distinct
sql_distinct_key: ${order_id} ;;
sql: ${order_shipping} ;;
}
Tieni presente che ogni valore univoco di sql_distinct_key
deve avere un solo valore corrispondente nel parametro sql
della misura. In altre parole, l'esempio precedente funziona perché ogni riga con order_id
di 1 ha la stessa order_shipping
di 10, ogni riga con order_id
di 2 ha la stessa order_shipping
di 20 e così via.
I campi type: median_distinct
possono essere formattati utilizzando i parametri value_format
o value_format_name
.
Aspetti da considerare per median_distinct
Il tipo di misurazione medium_distinct
è supportato solo per determinati dialetti. Se median_distinct
non è disponibile per il dialetto, Looker restituisce un errore. Poiché median
può essere considerato il 50° percentile, l'errore afferma che il dialetto non supporta i percentili distinti.
Dialetti di database supportati per median_distinct
Affinché il supporto del tipo median_distinct
nel tuo progetto Looker sia supportato dal tuo dialetto del database. La tabella seguente mostra quali dialetti supportano il tipo median_distinct
nell'ultima release di Looker:
min
type: min
trova il valore più basso in un determinato campo. Utilizza la funzione MIN
di SQL.
Il parametro sql
per le misure di type: min
può assumere qualsiasi espressione SQL valida che restituisca una colonna di tabella numerica, una dimensione LookML o una combinazione di dimensioni LookML.
Poiché le misure di type: min
sono compatibili solo con i campi numerici, non puoi utilizzare una misura di type: min
per trovare una data minima. Puoi utilizzare la funzione MIN()
nel parametro sql
di una misura di type: date
per acquisire un valore minimo, così come puoi utilizzare la funzione MAX()
con una misura di type: date
per acquisire una data massima. In precedenza, viene mostrata in questa pagina nella sezione date
, che include esempi dell'utilizzo della funzione MAX()
nel parametro sql
per trovare una data massima.
I campi type: min
possono essere formattati utilizzando i parametri value_format
o value_format_name
.
Ad esempio, il seguente LookML crea un campo denominato smallest_order
esaminando la dimensione sales_price
, quindi visualizzala in un formato monetario ($1234,56):
measure: smallest_order {
type: min
sql: ${sales_price} ;;
value_format_name: usd
}
Al momento non puoi utilizzare le misure type: min
per stringhe o date, ma puoi aggiungere manualmente la funzione MIN
per creare un campo di questo tipo, in questo modo:
measure: earliest_name_in_alphabet {
type: string
sql: MIN(${name}) ;;
}
number
type: number
viene utilizzato con numeri o numeri interi. Una misura di type: number
non esegue alcuna aggregazione e ha lo scopo di eseguire semplici trasformazioni su altre misure. Se definisci una misura in base a un'altra, la nuova misura deve essere type: number
per evitare errori di aggregazione nidificata.
Il parametro sql
per le misure type: number
può assumere qualsiasi espressione SQL valida che restituisca un numero o un numero intero.
I campi type: number
possono essere formattati utilizzando i parametri value_format
o value_format_name
.
Ad esempio, il seguente codice LookML crea una misura denominata total_gross_margin_percentage
in base alle misure aggregate total_sale_price
e total_gross_margin
, quindi la visualizza in un formato percentuale con due decimali (12,34%):
measure: total_sale_price {
type: sum
value_format_name: usd
sql: ${sale_price} ;;
}
measure: total_gross_margin {
type: sum
value_format_name: usd
sql: ${gross_margin} ;;
}
measure: total_gross_margin_percentage {
type: number
value_format_name: percent_2
sql: ${total_gross_margin}/ NULLIF(${total_sale_price},0) ;;
}
L'esempio precedente utilizza anche la funzione SQL NULLIF()
per eliminare la possibilità di errori di divisione per zero.
Aspetti da considerare per type: number
Quando utilizzi type: number
, tieni presente alcuni aspetti importanti:
- Una misura dell'
type: number
può generare dati aritmetici solo su altre misure, non su altre dimensioni. - Gli aggregati simmetrici di Looker non proteggono le funzioni aggregate nell'SQL di una misura
type: number
quando vengono calcolate in un join. - Il parametro
filters
non può essere utilizzato con le misuretype: number
, ma la documentazione difilters
spiega una soluzione alternativa. type: number
misure non daranno suggerimenti agli utenti.
percent_of_previous
type: percent_of_previous
calcola la differenza percentuale tra una cella e la cella precedente nella sua colonna.
Il parametro sql
per le misure type: percent_of_previous
deve fare riferimento a un'altra misura numerica.
I campi type: percent_of_previous
possono essere formattati utilizzando i parametri value_format
o value_format_name
. Tuttavia, i formati percentuali del parametro value_format_name
non funzionano con le misure type: percent_of_previous
. Questi formati percentuali moltiplicano i valori per 100, il che compensa i risultati di una percentuale del calcolo precedente.
Nell'esempio seguente, questo LookML crea una misura count_growth
in base alla misura count
:
measure: count_growth {
type: percent_of_previous
sql: ${count} ;;
}
Nell'interfaccia utente di Looker, il codice dovrebbe avere il seguente aspetto:
Tieni presente che i valori percent_of_previous
dipendono dall'ordinamento. Se modifichi l'ordinamento, devi eseguire nuovamente la query per ricalcolare i valori di percent_of_previous
. Nei casi in cui una query viene pivot, percent_of_previous
viene eseguita sulla riga invece che lungo la colonna. Al momento non puoi modificare questo comportamento.
Inoltre, le misure di percent_of_previous
vengono calcolate dopo che i dati vengono restituiti dal database. Ciò significa che non devi fare riferimento a una misura percent_of_previous
all'interno di un'altra misura; poiché potrebbe essere calcolata in momenti diversi, potresti non ottenere risultati precisi. Ciò significa, inoltre, che non è possibile filtrare le misure di percent_of_previous
.
percent_of_total
type: percent_of_total
calcola la porzione di una cella del totale di colonna. La percentuale viene calcolata sul totale delle righe restituite dalla query e non sul totale di tutte le righe possibili. Tuttavia, se i dati restituiti dalla query superano il limite di righe, i valori del campo verranno visualizzati come nulli, poiché sono necessari i risultati completi per calcolare la percentuale del totale.
Il parametro sql
per le misure type: percent_of_total
deve fare riferimento a un'altra misura numerica.
I campi type: percent_of_total
possono essere formattati utilizzando i parametri value_format
o value_format_name
. Tuttavia, i formati percentuali del parametro value_format_name
non funzionano con le misure type: percent_of_total
. Questi formati percentuali moltiplicano i valori per 100, il che compensa i risultati di un calcolo di percent_of_total
.
Nell'esempio seguente, questo LookML crea una misura percent_of_total_gross_margin
in base alla misura total_gross_margin
:
measure: percent_of_total_gross_margin {
type: percent_of_total
sql: ${total_gross_margin} ;;
}
Nell'interfaccia utente di Looker, il codice dovrebbe avere il seguente aspetto:
Nei casi in cui una query viene pivot, percent_of_total
viene eseguita sulla riga invece che lungo la colonna. Se non vuoi che lo faccia, aggiungi direction: "column"
alla definizione della misura.
Inoltre, le misure di percent_of_total
vengono calcolate dopo che i dati vengono restituiti dal database. Ciò significa che non devi fare riferimento a una misura percent_of_total
all'interno di un'altra misura; poiché potrebbe essere calcolata in momenti diversi, potresti non ottenere risultati precisi. Ciò significa, inoltre, che non è possibile filtrare le misure di percent_of_total
.
percentile
type: percentile
restituisce il valore al percentile specificato dei valori in un determinato campo. Ad esempio, se specifichi il 75° percentile, verrà restituito il valore superiore al 75% degli altri valori nel set di dati.
Per identificare il valore da restituire, Looker calcola il numero totale di valori dei dati e moltiplica il percentile specificato per il numero totale di valori dei dati. Indipendentemente da come sono effettivamente ordinati i dati, Looker identifica l'ordine relativo dei valori dei dati in aumento. Il valore dei dati restituito da Looker varia a seconda che il calcolo fornisca o meno un numero intero, come illustrato di seguito.
Se il valore calcolato non è un numero intero
Looker arrotonda il valore calcolato e lo utilizza per identificare il valore dei dati da restituire. In questo esempio di set di 19 punteggi di test, il 75° percentile verrebbe identificato da 19 * 0,75 = 14,25, il che significa che il 75% dei valori si trova nei primi 14 valori dei dati, al di sotto della 15a posizione. Pertanto, Looker restituisce il 15° valore dei dati (87) come maggiore del 75% dei valori dei dati.
Se il valore calcolato è un numero intero
In questo caso leggermente più complesso, Looker restituisce una media del valore dei dati in quella posizione e quello successivo. Per capire questo, considera un insieme di 20 punteggi di test, il 75° percentile verrebbe identificato da 20 * 0,75 = 15, il che significa che il valore dei dati nella 15a posizione fa parte del 75° percentile e dobbiamo restituire un valore che sia superiore al 75% dei valori dei dati. Restituire la media dei valori nella 15a posizione (82) e nella 16a posizione (87), Looker assicura che il 75%. La media (84,5) non esiste nel set di valori dei dati, ma sarebbe superiore al 75% di questi.
Parametri obbligatori e facoltativi
Utilizza la parola chiave percentile:
per specificare il valore frazionario, ovvero la percentuale dei dati che deve essere inferiore al valore restituito. Ad esempio, utilizza percentile: 75
per specificare il valore al 75° percentile nell'ordine dei dati oppure percentile: 10
per restituire il valore al 10° percentile. Se vuoi trovare il valore al 50° percentile, puoi specificare percentile: 50
o utilizzare semplicemente il tipo mediana.
Il parametro sql
per type: percentile
misure può assumere qualsiasi espressione SQL valida che generi una colonna di tabella numerica, una dimensione LookML o una combinazione di dimensioni LookML.
I campi type: percentile
possono essere formattati utilizzando i parametri value_format
o value_format_name
.
Esempio
Ad esempio, il seguente codice LookML crea un campo denominato test_scores_75th_percentile
che restituisce il valore al 75° percentile della dimensione test_scores
:
measure: test_scores_75th_percentile {
type: percentile
percentile: 75
sql: ${TABLE}.test_scores ;;
}
Aspetti da considerare per percentile
Se usi percentile
per un campo coinvolto in un fan-out, Looker tenterà di utilizzare percentile_distinct
. Se percentile_distinct
non è disponibile per il dialetto, Looker restituisce un errore. Per ulteriori informazioni, vedi i dialetti supportati per percentile_distinct
.
Dialetti di database supportati per percentile
Affinché il supporto del tipo percentile
nel tuo progetto Looker sia supportato dal tuo dialetto del database. La tabella seguente mostra quali dialetti supportano il tipo percentile
nell'ultima release di Looker:
percentile_distinct
type: percentile_distinct
è una forma specializzata di percentile e deve essere utilizzata quando il tuo abbonamento coinvolge un fanout. Utilizza i valori non ripetuti in un determinato campo, in base ai valori univoci definiti dal parametro sql_distinct_key
. Se la misura non dispone di un parametro sql_distinct_key
, Looker tenta di utilizzare il campo primary_key
.
Considera il risultato di una query che unisce le tabelle degli articoli e degli ordini dell'ordine:
ID articolo dell'ordine | ID ordine | Spedizione ordine |
---|---|---|
1 | 1 | 10 |
2 | 1 | 10 |
3 | 2 | 20 |
4 | 3 | 50 |
5 | 3 | 50 |
6 | 3 | 50 |
7 | 4 | 70 |
8 | 4 | 70 |
9 | 5 | 110 |
10 | 5 | 110 |
In questo caso puoi vedere che ci sono più righe per ogni ordine. Questa query ha coinvolto un fanout perché ogni ordine è associato a diversi articoli dell'ordine. percentile_distinct
prende in considerazione questo valore e trova il valore del percentile utilizzando i valori distinti 10, 20, 50, 70 e 110. Il 25° percentile restituirà il secondo valore diverso, o 20, mentre l'80° percentile restituirà la media del quarto e del quinto valore distinto, ovvero 90.
Parametri obbligatori e facoltativi
Utilizza la parola chiave percentile:
per specificare il valore frazionario. Ad esempio, utilizza percentile: 75
per specificare il valore al 75° percentile nell'ordine dei dati oppure percentile: 10
per restituire il valore al 10° percentile. Se stai cercando di trovare il valore al 50° percentile, puoi utilizzare il tipo median_distinct
.
Per ottenere un risultato preciso, utilizza il parametro sql_distinct_key
per specificare in che modo Looker deve identificare ogni entità univoca (in questo caso, ogni ordine univoco).
Ecco un esempio di utilizzo di percentile_distinct
per restituire il valore al 90° percentile:
measure: order_shipping_90th_percentile {
type: percentile_distinct
percentile: 90
sql_distinct_key: ${order_id} ;;
sql: ${order_shipping} ;;
}
Tieni presente che ogni valore univoco di sql_distinct_key
deve avere un solo valore corrispondente nel parametro sql
della misura. In altre parole, l'esempio precedente funziona perché ogni riga con order_id
di 1 ha la stessa order_shipping
di 10, ogni riga con order_id
di 2 ha la stessa order_shipping
di 20 e così via.
I campi type: percentile_distinct
possono essere formattati utilizzando i parametri value_format
o value_format_name
.
Aspetti da considerare per percentile_distinct
Se percentile_distinct
non è disponibile per il dialetto, Looker restituisce un errore. Per ulteriori informazioni, vedi i dialetti supportati per percentile_distinct
.
Dialetti di database supportati per percentile_distinct
Affinché il supporto del tipo percentile_distinct
nel tuo progetto Looker sia supportato dal tuo dialetto del database. La tabella seguente mostra quali dialetti supportano il tipo percentile_distinct
nell'ultima release di Looker:
running_total
type: running_total
calcola una somma cumulativa delle celle lungo una colonna. Non può essere utilizzata per calcolare le somme lungo una riga, a meno che la riga non sia il risultato di un pivot.
Il parametro sql
per le misure type: running_total
deve fare riferimento a un'altra misura numerica.
I campi type: running_total
possono essere formattati utilizzando i parametri value_format
o value_format_name
.
Ad esempio, il seguente LookML crea una misura cumulative_total_revenue
in base alla misura total_sale_price
:
measure: cumulative_total_revenue {
type: running_total
sql: ${total_sale_price} ;;
value_format_name: usd
}
Nell'interfaccia utente di Looker, il codice dovrebbe avere il seguente aspetto:
Tieni presente che i valori running_total
dipendono dall'ordinamento. Se modifichi l'ordinamento, devi eseguire di nuovo la query per ricalcolare i valori di running_total
. Nei casi in cui una query viene pivot, running_total
viene eseguita sulla riga invece che lungo la colonna. Se non vuoi che lo faccia, aggiungi direction: "column"
alla definizione della misura.
Inoltre, le misure di running_total
vengono calcolate dopo che i dati vengono restituiti dal database. Ciò significa che non devi fare riferimento a una misura running_total
all'interno di un'altra misura; poiché potrebbe essere calcolata in momenti diversi, potresti non ottenere risultati precisi. Ciò significa, inoltre, che non è possibile filtrare le misure di running_total
.
string
type: string
viene utilizzato con campi che contengono lettere o caratteri speciali.
Il parametro sql
per le misure type: string
può utilizzare qualsiasi espressione SQL valida che generi una stringa. In pratica, questo tipo viene utilizzato raramente perché la maggior parte delle funzioni aggregate di SQL non restituisce stringhe. Un'eccezione comune è la funzione GROUP_CONCAT
di MySQL, anche se Looker fornisce type: list
per il caso d'uso.
Ad esempio, il seguente LookML crea un campo category_list
combinando i valori univoci di un campo denominato category
:
measure: category_list {
type: string
sql: GROUP_CONCAT(${category}) ;;
}
In questo esempio, type: string
potrebbe essere omesso perché string
è il valore predefinito di type
.
sum
type: sum
somma i valori di un determinato campo. È simile alla funzione SUM
di SQL. Tuttavia, a differenza di SQL non elaborato, Looker calcolerà correttamente le somme anche se i join della tua query contengono fanout.
Il parametro sql
per type: sum
misure può assumere qualsiasi espressione SQL valida che generi una colonna di tabella numerica, una dimensione LookML o una combinazione di dimensioni LookML.
I campi type: sum
possono essere formattati utilizzando i parametri value_format
o value_format_name
.
Ad esempio, il seguente LookML crea un campo denominato total_revenue
sommando la dimensione sales_price
, per poi visualizzarla in un formato monetario ($1234,56):
measure: total_revenue {
type: sum
sql: ${sales_price} ;;
value_format_name: usd
}
sum_distinct
type: sum_distinct
deve essere utilizzato con set di dati denormalizzati. Somma i valori non ripetuti in un determinato campo in base ai valori unici definiti dal parametro sql_distinct_key
.
Si tratta di un concetto avanzato che può essere spiegato più chiaramente con un esempio. Prendi in considerazione una tabella denormalizzata come la seguente:
ID articolo dell'ordine | ID ordine | Spedizione ordine |
---|---|---|
1 | 1 | 10,00 |
2 | 1 | 10,00 |
3 | 2 | 20,00 |
4 | 2 | 20,00 |
5 | 2 | 20,00 |
In questo caso puoi vedere che ci sono più righe per ogni ordine. Di conseguenza, se aggiungi una semplice misura di type: sum
per la colonna order_shipping
, riceverai un totale di 80,00, anche se la spedizione totale riscossa è effettivamente pari a 30,00.
# Will NOT calculate the correct shipping amount
measure: total_shipping {
type: sum
sql: ${order_shipping} ;;
}
Per ottenere un risultato preciso, puoi spiegare a Looker come deve identificare ogni entità unica (in questo caso, ogni ordine univoco) utilizzando il parametro sql_distinct_key
. Questo valore calcolerà l'importo corretto di 30,00:
# Will calculate the correct shipping amount
measure: total_shipping {
type: sum_distinct
sql_distinct_key: ${order_id} ;;
sql: ${order_shipping} ;;
}
Tieni presente che ogni valore univoco di sql_distinct_key
deve avere un solo valore corrispondente in sql
. In altre parole, l'esempio precedente funziona perché ogni riga con un order_id
di 1 ha la stessa order_shipping
di 10,00, ogni riga con order_id
di 2 ha la stessa order_shipping
di 20,00 e così via.
I campi type: sum_distinct
possono essere formattati utilizzando i parametri value_format
o value_format_name
.
yesno
type: yesno
crea un campo che indica se qualcosa è vero o falso. Nell'interfaccia utente di Esplora, i valori sono indicati come Sì e No.
Il parametro sql
per una misura type: yesno
utilizza un'espressione SQL valida che restituisce TRUE
o FALSE
. Se la condizione restituisce un valore TRUE
, all'utente viene mostrato il valore Sì; in caso contrario, viene visualizzato il messaggio No.
L'espressione SQL per le misurazioni type: yesno
deve includere solo le aggregazioni, ovvero le aggregazioni SQL o i riferimenti alle misure LookML. Se vuoi creare un campo yesno
che include un riferimento a una dimensione LookML o un'espressione SQL non un'aggregazione, utilizza una dimensione con type: yesno
, non una misura.
Analogamente alle misure con type: number
, una misura con type: yesno
non esegue aggregazioni, ma fa riferimento solo ad altre aggregazioni.
Ad esempio, la misura total_sale_price
riportata di seguito corrisponde alla somma del prezzo scontato totale degli articoli di un ordine. La seconda misura chiamata is_large_total
è type: yesno
. La misura is_large_total
ha un parametro sql
che valuta se il valore total_sale_price
è maggiore di 1000 $.
measure: total_sale_price {
type: sum
value_format_name: usd
sql: ${sale_price} ;;
drill_fields: [detail*]
}
measure: is_large_total {
description: "Is order total over $1000?"
type: yesno
sql: ${total_sale_price} > 1000 ;;
}
Se vuoi fare riferimento a un campo type: yesno
in un altro campo, devi considerare il campo type: yesno
come un valore booleano (in altre parole, se contiene già un valore vero o falso). Ad esempio:
measure: is_large_total {
description: "Is order total over $1000?"
type: yesno
sql: ${total_sale_price} > 1000 ;;
}
}
# This is correct
measure: reward_points {
type: number
sql: CASE WHEN ${is_large_total} THEN 200 ELSE 100 END ;;
}
# This is NOT correct
measure: reward_points {
type: number
sql: CASE WHEN ${is_large_total} = 'Yes' THEN 200 ELSE 100 END ;;
}