Tipi di misurazione

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 parametro dimension_group.

Utilizzo

view: view_name {
measure: field_name {
type: measure_field_type
}
}

Gerarchia Visualizza file view Tipo di campo type

Tipi di campi possibili Misura Accetta 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 e average. Le misure aggregate possono fare riferimento solo alle dimensioni, non ad altre. Questo è l'unico tipo di misura che funziona con il parametro filters.
• Misure non aggregate: le misure non aggregate sono, come suggerisce il nome, i tipi di misurazione che non effettuano aggregazioni, come number e yesno. 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 parametro filters 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 utilizzare view_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:

view: view_name {
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 parametro filters in una misura type: 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 misura type: 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 misure type: number, ma la documentazione di filters 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 ;;
}