Una query di aggregazione elabora i dati di più entità indicizzate per restituire un singolo valore di riepilogo. Firestore in modalità Datastore supporta le seguenti query di aggregazione:
count()
sum()
avg()
Le query di aggregazione semplificano il codice dell'applicazione e hanno un costo inferiore rispetto al recupero di ogni entità per l'elaborazione. Leggi questa pagina per scoprire come utilizzare le query di aggregazione.
Aggregazione count()
Utilizza l'aggregazione count()
per restituire il numero totale di entità indicizzate
corrispondenti a una determinata query. Ad esempio, questa aggregazione count()
restituisce il
numero totale di entità in un tipo.
Java
Python
Go
aggregationCountQuery := datastore.NewQuery("Task"). NewAggregationQuery(). WithCount("total_tasks") countResults, err := client.RunAggregationQuery(ctx, aggregationCountQuery) count := countResults["total_tasks"] countValue := count.(*datastorepb.Value) fmt.Printf("Number of results from query: %d\n", countValue.GetIntegerValue())
GQL
AGGREGATE COUNT(*) AS total OVER ( SELECT * AS total FROM tasks )
GQL supporta una forma semplificata di query count()
:
SELECT COUNT(*) AS total FROM tasks
In questo esempio viene utilizzato un alias facoltativo di total
.
Il modulo semplificato supporta solo le clausole FROM
e WHERE
. Per ulteriori informazioni, consulta la documentazione di riferimento GQL.
L'aggregazione count()
tiene conto di eventuali filtri nella query ed
eventuali clausole limit
. Ad esempio, la seguente aggregazione restituisce un conteggio del
numero di entità che corrispondono ai filtri specificati.
Java
Python
Go
aggregationCountQuery := datastore.NewQuery("Task"). FilterField("done", "=", true). NewAggregationQuery(). WithCount("total_tasks_done") countResults, err := client.RunAggregationQuery(ctx, aggregationCountQuery) count := countResults["total_tasks_done"] countValue := count.(*datastorepb.Value) fmt.Printf("Number of results from query: %d\n", countValue.GetIntegerValue())
GQL
AGGREGATE COUNT(*) OVER ( SELECT * FROM tasks WHERE is_done = false AND tag = 'house')
GQL supporta una forma semplificata di query count()
:
SELECT COUNT(*) AS total FROM tasks WHERE is_done = false AND tag = 'house'
In questo esempio viene utilizzato un alias facoltativo di total
.
Il modulo semplificato supporta solo le clausole FROM
e WHERE
. Per ulteriori informazioni, consulta la documentazione di riferimento GQL.
Questo esempio mostra come conteggiare fino a un determinato valore. Puoi utilizzarlo, ad esempio, per interrompere il conteggio a un determinato numero e informare gli utenti che hanno superato quel numero.
Java
Python
Go
aggregationCountQuery := datastore.NewQuery("Task"). Limit(2). NewAggregationQuery(). WithCount("at_least") countResults, err := client.RunAggregationQuery(ctx, aggregationCountQuery) count := countResults["at_least"] countValue := count.(*datastorepb.Value) fmt.Printf("We have at least %d tasks\n", countValue.GetIntegerValue())
GQL
AGGREGATE COUNT_UP_TO(1000) OVER ( SELECT * FROM tasks WHERE is_done = false)
GQL supporta una forma semplificata di query count_up_to()
:
SELECT COUNT_UP_TO(1000) AS total FROM tasks WHERE is_done = false AND tag = 'house'
In questo esempio viene utilizzato un alias facoltativo di total
.
Il modulo semplificato supporta solo le clausole FROM
e WHERE
. Per ulteriori informazioni, consulta la documentazione di riferimento GQL.
Aggregazione sum()
Utilizza l'aggregazione sum()
per restituire la somma totale dei valori numerici che corrispondono
a una determinata query. Ad esempio, la seguente aggregazione sum()
restituisce la somma totale dei valori numerici della proprietà specificata da
entità del tipo specificato:
Java
Python
Go
aggregationSumQuery := datastore.NewQuery("Task"). NewAggregationQuery(). WithSum("hours", "total_hours") sumResults, err := client.RunAggregationQuery(ctx, aggregationSumQuery) sum := sumResults["total_hours"] sumValue := sum.(*datastorepb.Value) fmt.Printf("Sum of results from query: %d\n", sumValue.GetIntegerValue())
GQL
AGGREGATE SUM(hours) AS total_hours OVER ( SELECT * FROM tasks )
GQL supporta una forma semplificata di query sum()
:
SELECT SUM(hours) AS total_hours FROM tasks
In questo esempio viene utilizzato un alias facoltativo di total_hours
.
Il modulo semplificato supporta solo le clausole FROM
e WHERE
. Per ulteriori informazioni, consulta la documentazione di riferimento GQL.
L'aggregazione sum()
tiene conto di eventuali filtri nella query ed
eventuali clausole limit
. Ad esempio, la seguente aggregazione restituisce una somma della
proprietà specificata con un valore numerico nelle entità che corrispondono ai
filtri specificati.
Java
Python
Questa query richiede un indice come:
- kind: Task properties: - name: done - name: hours
Go
aggregationSumQuery := datastore.NewQuery("Task"). FilterField("done", "=", false). FilterField("tag", "=", "house"). NewAggregationQuery(). WithSum("hours", "total_hours") sumResults, err := client.RunAggregationQuery(ctx, aggregationSumQuery) sum := sumResults["total_hours"] sumValue := sum.(*datastorepb.Value) fmt.Printf("Sum of results from query: %d\n", sumValue.GetIntegerValue())
GQL
AGGREGATE SUM(hours) AS total_hours OVER ( SELECT * FROM tasks WHERE is_done = false AND tag = 'house' )
GQL supporta una forma semplificata di query sum()
:
SELECT SUM(hours) AS total_hours FROM tasks WHERE is_done = false AND tag = 'house'
In questo esempio viene utilizzato un alias facoltativo di total_hours
.
Il modulo semplificato supporta solo le clausole FROM
e WHERE
. Per ulteriori informazioni, consulta la documentazione di riferimento GQL.
Aggregazione avg()
Utilizza l'aggregazione avg()
per restituire la media dei valori numerici che
corrispondono a una determinata query. Ad esempio, la seguente aggregazione di avg()
restituisce la media aritmetica della proprietà specificata dai valori delle proprietà numeriche delle entità che corrispondono alla query:
Java
Python
Go
aggregationAvgQuery := datastore.NewQuery("Task"). NewAggregationQuery(). WithAvg("hours", "avg_hours") avgResults, err := client.RunAggregationQuery(ctx, aggregationAvgQuery) avg := avgResults["avg_hours"] avgValue := avg.(*datastorepb.Value) fmt.Printf("average hours: %f\n", avgValue.GetDoubleValue())
GQL
AGGREGATE AVG(hours) as avg_hours OVER ( SELECT * FROM tasks )
GQL supporta una forma semplificata di query avg()
:
SELECT AVG(hours) as avg_hours
In questo esempio viene utilizzato un alias facoltativo di avg_hours
.
Il modulo semplificato supporta solo le clausole FROM
e WHERE
. Per ulteriori informazioni, consulta la documentazione di riferimento GQL.
L'aggregazione avg()
tiene conto di eventuali filtri nella query ed
eventuali clausole limit
. Ad esempio, la seguente aggregazione restituisce la media aritmetica
della proprietà specificata dai valori della proprietà numerica delle entità che
corrispondono ai filtri della query.
Java
Python
Questa query richiede un indice come:
- kind: Task properties: - name: done - name: hours
Go
aggregationAvgQuery := datastore.NewQuery("Task"). FilterField("done", "=", false). FilterField("tag", "=", "house"). NewAggregationQuery(). WithAvg("hours", "avg_hours") avgResults, err := client.RunAggregationQuery(ctx, aggregationAvgQuery) avg := avgResults["avg_hours"] avgValue := avg.(*datastorepb.Value) fmt.Printf("average hours: %f\n", avgValue.GetDoubleValue())
GQL
AGGREGATE AVG(hours) as avg_hours OVER ( SELECT * FROM tasks WHERE is_done = false AND tag = 'house' )
GQL supporta una forma semplificata di query avg()
:
SELECT AVG(hours) as avg_hours FROM tasks WHERE is_done = false AND tag = 'house'
In questo esempio viene utilizzato un alias facoltativo di avg_hours
.
Il modulo semplificato supporta solo le clausole FROM
e WHERE
. Per ulteriori informazioni, consulta la documentazione di riferimento GQL.
Calcolare più aggregazioni in una query
Puoi combinare più aggregazioni in un'unica pipeline di aggregazione. Ciò può ridurre il numero di letture dell'indice richieste. Se la query include aggregazioni su più campi, richiede un indice composto e ogni calcolo di aggregazione include solo le entità che contengono tutti i campi utilizzati da ogni aggregazione.
L'esempio seguente esegue più aggregazioni in una singola query di aggregazione:
Java
Python
Go
aggregationQuery := datastore.NewQuery("Task"). NewAggregationQuery(). WithCount("total_tasks"). WithSum("hours", "total_hours"). WithAvg("hours", "avg_hours") Results, err := client.RunAggregationQuery(ctx, aggregationQuery) fmt.Printf("Number of results from query: %d\n", Results["total_tasks"].(*datastorepb.Value).GetIntegerValue()) fmt.Printf("Sum of results from query: %d\n", Results["total_hours"].(*datastorepb.Value).GetIntegerValue()) fmt.Printf("Avg of results from query: %f\n", Results["avg_hours"].(*datastorepb.Value).GetDoubleValue())
GQL
AGGREGATE SUM(hours) AS total_hours, COUNT(*) AS total_tasks OVER ( SELECT * FROM tasks WHERE is_done = false AND tag = 'house' )
GQL supporta una forma semplificata per le query di aggregazione:
SELECT SUM(hours) AS total_hours, COUNT(*) AS total_tasks FROM tasks WHERE is_done = false AND tag = 'house'
In questo esempio vengono utilizzati gli alias facoltativi di total_hours
e total_tasks
.
Il modulo semplificato supporta solo le clausole FROM
e WHERE
. Per ulteriori informazioni, consulta la documentazione di riferimento GQL.
Le query con più aggregazioni includono solo le entità che contengono tutte le proprietà di ogni aggregazione. Ciò potrebbe portare a risultati diversi dall'esecuzione separata di ogni aggregazione.
Comportamento e limitazioni
Quando lavori con le query di aggregazione, tieni presente i seguenti comportamenti e limitazioni:
- La query fornita all'aggregazione deve rispettare le restrizioni sulle query.
Se una query di aggregazione non può essere risolta entro 60 secondi, restituisce un errore
DEADLINE_EXCEEDED
. Le prestazioni dipendono dalla configurazione dell'indice e dalle dimensioni del set di dati.Se l'operazione non può essere completata entro la scadenza dei 60 secondi, una possibile soluzione alternativa è utilizzare i cursors per unire più aggregazioni.
Le query di aggregazione lette dalle voci di indice e includono nel calcolo solo le proprietà indicizzate.
L'aggiunta di una clausola
OrderBy
alla query limita l'aggregazione alle entità in cui esiste la proprietà di ordinamento.In GQL, il modulo semplificato non supporta le clausole
ORDER BY
,LIMIT
oOFFSET
.In una query di proiezione, puoi aggregare i dati solo dalle proprietà nella proiezione. Ad esempio, nella query GQL
SELECT a, b FROM k WHERE c = 1
puoi aggregare i dati solo traa
ob
.Un'aggregazione
count()
non deduplica le entità con proprietà array. Ogni valore dell'array corrispondente alla query ne aggiunge uno al conteggio.Per le aggregazioni
sum()
eavg()
, i valori non numerici vengono ignorati. L'aggregazionesum()
eavg()
prende in considerazione solo valori interi, valori numerici in virgola mobile e timestamp. I timestamp vengono convertiti in valori interi in microsecondi persum()
,avg()
e proiezioni.Quando combini più aggregazioni in una singola query, tieni presente che
sum()
eavg()
ignorano i valori non numerici, mentrecount()
include valori non numerici.Se combini aggregazioni che si trovano su proprietà diverse, il calcolo include solo le entità che contengono tutte quelle proprietà. Ciò potrebbe portare a risultati diversi rispetto all'esecuzione di ogni aggregazione separatamente.
Prezzi
I prezzi delle query di aggregazione count()
, sum()
e avg()
dipendono dal numero di voci di indice analizzate durante l'operazione. Ti viene addebitata un'entità letta per un massimo di 1000 voci di indice corrispondenti. Le voci di indice successive corrispondono a unità di lettura aggiuntive al costo. Esiste un costo minimo di un'unità
di lettura per ogni query. Per informazioni sui prezzi, consulta Prezzi di Firestore in modalità Datastore.
Se combini più aggregazioni in una singola query, la query utilizza lo stesso indice per ogni aggregazione ed esegue una singola scansione sui dati. Ciò può aiutare a ridurre il numero di scansioni e letture fatturate dell'indice rispetto all'esecuzione di ogni aggregazione separatamente. Tuttavia, le query con più aggregazioni includono solo le entità che contengono tutte quelle proprietà. Ciò potrebbe portare a risultati diversi dall'esecuzione di ogni aggregazione separatamente.
Passaggi successivi
- Scopri di più sulle query.
- Scopri le best practice per Firestore in modalità Datastore.