Una consulta de agregación procesa los datos de múltiples entidades indexadas para muestran 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 utilizar 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 count()
muestra la
la cantidad total de entidades en una categoría.
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 diferentes cláusulas. Para obtener más información, consulta la referencia de GQL.
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 indicados.
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 diferentes cláusulas. Para obtener más información, consulta la referencia de GQL.
En este ejemplo, se muestra cómo realizar el recuento hasta cierto valor. Puedes usarlo para, 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 FROM
y WHERE
.
a sus diferentes cláusulas. 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 valores numéricos que coinciden
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 diferentes cláusulas. Para obtener más información, consulta la referencia de GQL.
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 FROM
y WHERE
.
a sus cláusulas. 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, el siguiente avg()
la agregación devuelve la fórmula
media de la propiedad especificada a partir de los valores numéricos de propiedad de las entidades
que coincidan 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 diferentes 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 aritmética
media de la propiedad especificada a partir de los valores numéricos de propiedad de las entidades que
coincidan 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 formulario 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 FROM
y WHERE
.
a sus cláusulas. Para obtener más información, consulta la referencia de GQL.
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 sobre las consultas.
Si una consulta de agregación no se puede resolver en 60 segundos, muestra un
DEADLINE_EXCEEDED
error. 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 entradas de índice y solo incluyen las indexadas propiedades 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 formulario simplificado no es compatible. Cláusulas
ORDER BY
,LIMIT
oOFFSET
.En una consulta de proyección, solo puedes agregar datos 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 deduplica entidades con propiedades de array. Cada valor de array que coincida con la consulta agrega uno al recuento.Para las agregaciones
sum()
yavg()
, se ignoran los valores no numéricos.sum()
y la agregaciónavg()
solo tiene en cuenta los valores de números enteros, valores numéricos de punto flotante y marcas de tiempo. Las marcas de tiempo son convertidos 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 están en diferentes propiedades, el cálculo incluye solo las entidades que contienen todas esas propiedades. Esto podría provocar a resultados diferentes si realiza 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 facturará uno
lectura de entidad para un máximo de 1,000 entradas de índice coincidentes. Entradas de índice posteriores
unidades de lectura adicionales de costo coincidente. Existe un costo mínimo de una unidad de lectura
para cada consulta. Para conocer los precios
consulta Precios de Firestore en 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.