Una consulta de agregación procesa los datos de varias entidades indexadas para mostrar un solo valor de resumen. Firestore en modo Datastore admite lo siguiente: 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 FROM
y WHERE
.
a sus cláusulas. 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 formulario simplificado solo admite FROM
y WHERE
.
a sus cláusulas. 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 Por ejemplo, deja de contar en un número determinado e informa a los usuarios que superó 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 formulario simplificado solo admite cláusulas FROM
y WHERE
. Para obtener más información, consulta la referencia de GQL.
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, el siguiente sum()
la agregación devuelve la suma total de los valores numéricos de la propiedad determinada de
Entidades de un 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 FROM
y WHERE
.
a sus cláusulas. 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 el valor especificado
filtros.
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
. Para obtener más información, consulta la referencia de GQL.
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 FROM
y WHERE
.
a sus cláusulas. Para obtener más información, consulta la referencia de GQL.
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 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 FROM
y WHERE
.
a sus cláusulas. Para obtener más información, consulta la referencia de GQL.
Calcula varias agregaciones en una consulta
Puedes combinar varias agregaciones en una sola canalización de agregación. Esta puede reducir la cantidad de lecturas de índice necesarias. Si la consulta incluye agregaciones en varios campos, la consulta requiere un índice compuesto, y cada agregación incluye solo aquellas entidades que contienen todos los campos utilizados por 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 agregación múltiple incluyen solo las entidades que contienen todas las propiedades en cada agregación. Esto puede dar lugar a diferentes resultados de realizar 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 le proporciones a la agregación debe cumplir con los restricciones para 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, se aplicará 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
OrderBy
a la consulta limita la agregación a la entidades en las que existe la propiedad de ordenamiento.En GQL, el formato simplificado no admite cláusulas
ORDER BY
,LIMIT
niOFFSET
.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 dea
ob
.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 para las consultas de agregación count()
, sum()
y avg()
depende 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 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 para cada agregación y realiza un análisis único de los datos. Esto puede ayudar a reducir la cantidad de conversiones análisis y lecturas que se facturan cuando se compara con la ejecución de cada agregación por separado. Sin embargo, las consultas con varias agregaciones incluyen solo las entidades que que contiene 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 más información sobre las prácticas recomendadas para Firestore en modo Datastore.