feat: Sum/Avg aggregation queries

google/cloud/firestore_v1/async_query.py

@@ -231,6 +231,40 @@ def count(
         """
         return AsyncAggregationQuery(self).count(alias=alias)
 
+    def sum(
+        self, field_ref: str, alias: str | None = None
+    ) -> Type["firestore_v1.async_aggregation.AsyncAggregationQuery"]:
+        """Adds a sum over the nested query.
+
+        Args:
+            field(str): The field for the sum
+
+            alias
+                (Optional[str]): The alias for the sum
+
+        Returns:
+            :class:`~google.cloud.firestore_v1.async_aggregation.AsyncAggregationQuery`:
+            An instance of an AsyncAggregationQuery object
+        """
+        return AsyncAggregationQuery(self).sum(field_ref, alias=alias)
+
+    def avg(
+        self, field_ref: str, alias: str | None = None
+    ) -> Type["firestore_v1.async_aggregation.AsyncAggregationQuery"]:
+        """Adds an avg over the nested query.
+
+        Args:
+            field_ref(str): The field_ref for the avg
+
+            alias
+                (Optional[str]): The alias for the avg
+
+        Returns:
+            :class:`~google.cloud.firestore_v1.async_aggregation.AsyncAggregationQuery`:
+            An instance of an AsyncAggregationQuery object
+        """
+        return AsyncAggregationQuery(self).avg(field_ref, alias=alias)
+
     async def stream(
         self,
         transaction=None,

google/cloud/firestore_v1/base_aggregation.py

@@ -60,14 +60,17 @@ def __repr__(self):
 
 
 class BaseAggregation(ABC):
+    def __init__(self, alias: str | None = None):
+        self.alias = alias
+
     @abc.abstractmethod
     def _to_protobuf(self):
         """Convert this instance to the protobuf representation"""
 
 
 class CountAggregation(BaseAggregation):
     def __init__(self, alias: str | None = None):
-        self.alias = alias
+        super(CountAggregation, self).__init__(alias=alias)
 
     def _to_protobuf(self):
         """Convert this instance to the protobuf representation"""
@@ -77,13 +80,42 @@ def _to_protobuf(self):
         return aggregation_pb
 
 
+class SumAggregation(BaseAggregation):
+    def __init__(self, field_ref: str, alias: str | None = None):
+        self.field_ref = field_ref
+        super(SumAggregation, self).__init__(alias=alias)
+
+    def _to_protobuf(self):
+        """Convert this instance to the protobuf representation"""
+        aggregation_pb = StructuredAggregationQuery.Aggregation()
+        aggregation_pb.alias = self.alias
+        aggregation_pb.sum = StructuredAggregationQuery.Aggregation.Sum()
+        aggregation_pb.sum.field.field_path = self.field_ref
+        return aggregation_pb
+
+
+class AvgAggregation(BaseAggregation):
+    def __init__(self, field_ref: str, alias: str | None = None):
+        self.field_ref = field_ref
+        super(AvgAggregation, self).__init__(alias=alias)
+
+    def _to_protobuf(self):
+        """Convert this instance to the protobuf representation"""
+        aggregation_pb = StructuredAggregationQuery.Aggregation()
+        aggregation_pb.alias = self.alias
+        aggregation_pb.avg = StructuredAggregationQuery.Aggregation.Avg()
+        aggregation_pb.avg.field.field_path = self.field_ref
+        return aggregation_pb
+
+
 def _query_response_to_result(
     response_pb: RunAggregationQueryResponse,
 ) -> List[AggregationResult]:
     results = [
         AggregationResult(
             alias=key,
-            value=response_pb.result.aggregate_fields[key].integer_value,
+            value=response_pb.result.aggregate_fields[key].integer_value
+            or response_pb.result.aggregate_fields[key].double_value,
             read_time=response_pb.read_time,
         )
         for key in response_pb.result.aggregate_fields.pb.keys()
@@ -95,11 +127,9 @@ def _query_response_to_result(
 class BaseAggregationQuery(ABC):
     """Represents an aggregation query to the Firestore API."""
 
-    def __init__(
-        self,
-        nested_query,
-    ) -> None:
+    def __init__(self, nested_query, alias: str | None = None) -> None:
         self._nested_query = nested_query
+        self._alias = alias
         self._collection_ref = nested_query._parent
         self._aggregations: List[BaseAggregation] = []
 
@@ -115,6 +145,22 @@ def count(self, alias: str | None = None):
         self._aggregations.append(count_aggregation)
         return self
 
+    def sum(self, field_ref, alias=None):
+        """
+        Adds a sum over the nested query
+        """
+        sum_aggregation = SumAggregation(field_ref, alias=alias)
+        self._aggregations.append(sum_aggregation)
+        return self
+
+    def avg(self, field_ref, alias=None):
+        """
+        Adds an avg over the nested query
+        """
+        avg_aggregation = AvgAggregation(field_ref, alias=alias)
+        self._aggregations.append(avg_aggregation)
+        return self
+
     def add_aggregation(self, aggregation: BaseAggregation) -> None:
         """
         Adds an aggregation operation to the nested query

google/cloud/firestore_v1/base_collection.py

@@ -507,6 +507,30 @@ def count(self, alias=None):
         """
         return self._aggregation_query().count(alias=alias)
 
+    def sum(self, field_ref: str, alias=None):
+        """
+        Adds a sum over the nested query.
+
+        :type field_ref: str
+        :param field_ref: The field_ref for the aggregation
+
+        :type alias: str
+        :param alias: (Optional) The alias for the aggregation
+        """
+        return self._aggregation_query().sum(field_ref, alias=alias)
+
+    def avg(self, field_ref: str, alias=None):
+        """
+        Adds an avg over the nested query.
+
+        :type field_ref: str
+        :param field_ref: The field_ref for the aggregation
+
+        :type alias: str
+        :param alias: (Optional) The alias for the aggregation
+        """
+        return self._aggregation_query().avg(field_ref, alias=alias)
+
 
 def _auto_id() -> str:
     """Generate a "random" automatically generated ID.

google/cloud/firestore_v1/base_query.py

@@ -963,6 +963,16 @@ def count(
     ) -> Type["firestore_v1.base_aggregation.BaseAggregationQuery"]:
         raise NotImplementedError
 
+    def sum(
+        self, property_ref: str, alias: str | None = None
+    ) -> Type["firestore_v1.base_aggregation.BaseAggregationQuery"]:
+        raise NotImplementedError
+
+    def avg(
+        self, property_ref: str, alias: str | None = None
+    ) -> Type["firestore_v1.base_aggregation.BaseAggregationQuery"]:
+        raise NotImplementedError
+
     def get(
         self,
         transaction=None,

google/cloud/firestore_v1/query.py

@@ -248,6 +248,34 @@ def count(
         """
         return aggregation.AggregationQuery(self).count(alias=alias)
 
+    def sum(
+        self, field_ref: str, alias: str | None = None
+    ) -> Type["firestore_v1.aggregation.AggregationQuery"]:
+        """
+        Adds a sum over the query.
+
+        :type field_ref: str
+        :param field_ref: The field_ref for the sum
+
+        :type alias: str
+        :param alias: (Optional) The alias for the sum
+        """
+        return aggregation.AggregationQuery(self).sum(field_ref, alias=alias)
+
+    def avg(
+        self, field_ref: str, alias: str | None = None
+    ) -> Type["firestore_v1.aggregation.AggregationQuery"]:
+        """
+        Adds an avg over the query.
+
+        :type field_ref: str
+        :param field_ref: The field_ref for the avg
+
+        :type alias: str
+        :param alias: (Optional) The alias for the avg
+        """
+        return aggregation.AggregationQuery(self).avg(field_ref, alias=alias)
+
     def stream(
         self,
         transaction=None,