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 su costo es menor que recuperar cada entidad para su procesamiento. Lee esta página para aprender a usar las consultas de agregación.
Agregación 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 count()
muestra la cantidad total de entidades en 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 especificados.
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 esta opción, por ejemplo, para dejar de contar un número determinado y también 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 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 provenientes de entidades del tipo dado:
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 dados.
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 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 la media aritmética de la propiedad especificada a partir de los valores de propiedad 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 de propiedad numérica de las entidades que coinciden con los filtros de 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 requerida de lecturas de índice. Si la consulta incluye agregaciones en varios campos, requiere un índice compuesto. Cada cálculo de agregación incluye solo 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 formulario simplificado para 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 varias agregaciones incluyen solo las entidades que contienen todas las propiedades de cada agregación. Esto puede generar resultados diferentes si se realiza 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 para 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 solución alternativa es usar cursors para combinar varias agregaciones.
Las consultas de agregación leen desde las entradas de índice y, además, incluyen solo propiedades indexadas en el cálculo.
Agregar una cláusula
OrderBy
a la consulta limita la agregación a las entidades en las que existe la propiedad de ordenamiento.En GQL, el formulario simplificado no admite las cláusulas
ORDER BY
,LIMIT
niOFFSET
.En una consulta de proyección, puedes agregar datos solo de las propiedades en la proyección. Por ejemplo, en la consulta
SELECT a, b FROM k WHERE c = 1
de GQL, solo puedes agregar datos dea
ob
.Una agregación
count()
no anula la duplicación de entidades con propiedades de array. Cada valor de array que coincide con la consulta agrega uno al recuento.Para las agregaciones
sum()
yavg()
, se ignoran los valores no numéricos. La agregación desum()
yavg()
solo tiene en cuenta valores de números enteros, valores numéricos de punto flotante y marcas de tiempo. Las marcas de tiempo se convierten en valores de números enteros de microsegundo 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 incluye solo las entidades que contienen todas esas propiedades. Esto puede generar resultados diferentes a partir de realizar cada agregación por separado.
Precios
Los precios de las consultas de agregación count()
, sum()
y avg()
dependen de
la cantidad de entradas de índice analizadas durante la operación. Se te factura una lectura de entidad por hasta 1,000 entradas de índice coincidentes. Las entradas de índice posteriores coinciden con las unidades de lectura adicionales de costo. 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 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 de índice y lecturas facturadas en comparación con realizar cada agregación por separado. Sin embargo, las consultas con múltiples agregaciones incluyen solo 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.