Una consulta de agregación procesa los datos de varias entidades indexadas para mostrar un solo valor de resumen. Firestore en modo Datastore admite las siguientes consultas de agregación:
count()sum()avg()
Las consultas de agregación simplifican el código de tu aplicación y cuestan menos que recuperar cada entidad para su procesamiento. Lee esta página para aprender a usar consultas de agregación.
Agregación de count()
Usa la agregación count() para mostrar la cantidad total de entidades indexadas que coinciden con una consulta determinada. Por ejemplo, esta agregación de count() muestra la
cantidad total de entidades de 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 admite una forma simplificada de consultas count():
SELECT COUNT(*) AS total FROM tasks
En este ejemplo, se usa un alias opcional de total.
El formulario simplificado solo admite cláusulas FROM y WHERE. Consulta la referencia de GQL para obtener más información.
La agregación count() toma en cuenta cualquier filtro en la consulta y cualquier
cláusula limit. Por ejemplo, la siguiente agregación muestra un recuento de la cantidad de entidades que coinciden con los filtros determinados.
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 admite una forma simplificada de consultas count():
SELECT COUNT(*) AS total FROM tasks WHERE is_done = false AND tag = 'house'
En este ejemplo, se usa un alias opcional de total.
El formato simplificado solo admite cláusulas FROM y WHERE. Consulta la referencia de GQL para obtener más información.
En este ejemplo, se muestra cómo contar hasta un valor determinado. Puedes usar esto para, por ejemplo, dejar de contar en un número determinado y, luego, informar a los usuarios que superaron ese número.
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 admite una forma simplificada de consultas count_up_to():
SELECT COUNT_UP_TO(1000) AS total FROM tasks WHERE is_done = false AND tag = 'house'
En este ejemplo, se usa un alias opcional de total.
El formato simplificado solo admite cláusulas FROM y WHERE. Consulta la referencia de GQL para obtener más información.
Agregación de sum()
Usa la agregación sum() para mostrar la suma total de los valores numéricos que coinciden con una consulta determinada. Por ejemplo, la siguiente agregación sum() muestra la suma total de los valores numéricos de la propiedad determinada de las entidades del tipo determinado:
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 admite una forma simplificada de consultas sum():
SELECT SUM(hours) AS total_hours FROM tasks
En este ejemplo, se usa un alias opcional de total_hours.
El formulario simplificado solo admite cláusulas FROM y WHERE. Consulta la referencia de GQL para obtener más información.
La agregación sum() toma en cuenta cualquier filtro en la consulta y cualquier
cláusula limit. Por ejemplo, la siguiente agregación muestra una suma de la
propiedad especificada con un valor numérico en las entidades que coinciden con los
filtros determinados.
Java
Python
Esta consulta requiere un índice como el siguiente:
- 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 admite una forma simplificada de consultas sum():
SELECT SUM(hours) AS total_hours FROM tasks WHERE is_done = false AND tag = 'house'
En este ejemplo, se usa un alias opcional de total_hours.
El formulario simplificado solo admite cláusulas FROM y WHERE. Consulta la referencia de GQL para obtener más información.
Agregación de avg()
Usa la agregación avg() para mostrar el promedio de valores numéricos que coinciden con una consulta determinada. Por ejemplo, la siguiente agregación avg() muestra el promedio aritmético de la propiedad especificada a partir de los valores numéricos de las entidades que coinciden con la consulta:
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 admite una forma simplificada de consultas avg():
SELECT AVG(hours) as avg_hours
En este ejemplo, se usa un alias opcional de avg_hours.
El formulario simplificado solo admite cláusulas FROM y WHERE. Consulta la referencia de GQL para obtener más información.
La agregación avg() toma en cuenta cualquier filtro en la consulta y cualquier
cláusula limit. Por ejemplo, la siguiente agregación muestra la media aritmética
de la propiedad especificada a partir de los valores numéricos de las propiedades de las entidades que coinciden con los
filtros de la consulta.
Java
Python
Esta consulta requiere un índice como el siguiente:
- 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 admite una forma simplificada de consultas avg():
SELECT AVG(hours) as avg_hours FROM tasks WHERE is_done = false AND tag = 'house'
En este ejemplo, se usa un alias opcional de avg_hours.
El formulario simplificado solo admite cláusulas FROM y WHERE. Consulta la referencia de GQL para obtener más información.
Calcula varias agregaciones en una consulta
Puedes combinar varias agregaciones en una sola canalización de agregación. Esto puede reducir la cantidad de lecturas de índice necesarias. Si la consulta incluye agregaciones en varios campos, requiere un índice compuesto, y cada cálculo de agregación solo incluye aquellas entidades que contienen todos los campos que usa cada agregación.
En el siguiente ejemplo, se realizan varias agregaciones en una sola consulta de agregación:
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 admite un formato simplificado para las consultas de agregación:
SELECT SUM(hours) AS total_hours, COUNT(*) AS total_tasks FROM tasks WHERE is_done = false AND tag = 'house'
En este ejemplo, se usan los alias opcionales de total_hours y total_tasks.
El formulario simplificado solo admite cláusulas FROM y WHERE. Consulta la referencia de GQL para obtener más información.
Las consultas con agregaciones múltiples incluyen solo las entidades que contienen todas las propiedades de cada agregación. Esto puede generar resultados diferentes a partir de la realización de cada agregación por separado.
Comportamiento y limitaciones
Cuando trabajes con consultas de agregación, ten en cuenta el comportamiento y las limitaciones siguientes:
- La consulta que proporciones a la agregación debe cumplir con las restricciones de las consultas.
Si una consulta de agregación no se puede resolver en 60 segundos, muestra un error
DEADLINE_EXCEEDED. El rendimiento depende de la configuración de tu índice y del tamaño del conjunto de datos.Si la operación no se puede completar dentro del plazo de 60 segundos, una posible solución alternativa es usar cursores para combinar varias agregaciones.
Las consultas de agregación leen de las entradas de índice y solo incluyen propiedades indexadas en el cálculo.
Agregar una cláusula
OrderBya la consulta limita la agregación a las entidades en las que existe la propiedad de ordenamiento.En GQL, el formato simplificado no admite cláusulas
ORDER BY,LIMITniOFFSET.En una consulta de proyección, puedes agregar datos solo de las propiedades de la proyección. Por ejemplo, en la consulta de GQL
SELECT a, b FROM k WHERE c = 1, puedes agregar datos solo deaob.Una agregación de
count()no quita los duplicados de las entidades con propiedades de array. Cada valor del array que coincida con la consulta agrega uno al recuento.Para las agregaciones
sum()yavg(), se ignoran los valores no numéricos. Las agregacionessum()yavg()solo tienen en cuenta los valores de número entero, los valores de número de punto flotante y las marcas de tiempo. Las marcas de tiempo se convierten en valores enteros de microsegundos parasum(),avg()y proyecciones.Cuando combines varias agregaciones en una sola consulta, ten en cuenta que
sum()yavg()ignoran los valores no numéricos, mientras quecount()incluye valores no numéricos.Si combinas agregaciones que se encuentran en propiedades diferentes, el cálculo solo incluye las entidades que contienen todas esas propiedades. Esto puede generar resultados diferentes a partir de la realización de cada agregación por separado.
Precios
El precio de las consultas de agregación count(), sum() y avg() depende de la
quantidad de entradas de índice analizadas durante la operación. Se te factura una
lectura de entidad por hasta 1,000 entradas de índice que coincidan. Las entradas de índice posteriores coincidieron con el costo de unidades de lectura adicionales. Existe un costo mínimo de una unidad de lectura por cada consulta. Para obtener información sobre los precios, consulta Precios de Firestore en el modo Datastore.
Si combinas varias agregaciones en una sola consulta, esta usa el mismo índice para cada agregación y realiza un solo análisis de los datos. Esto puede ayudar a reducir la cantidad de análisis y lecturas de índices facturados en comparación con la realización de cada agregación por separado. Sin embargo, las consultas con varias agregaciones solo incluyen las entidades que contienen todas esas propiedades. Esto puede generar resultados diferentes a partir de la realización de cada agregación por separado.
¿Qué sigue?
- Más información sobre consultas.
- Obtén información sobre las prácticas recomendadas para Firestore en modo Datastore.