Add result type to SUM

hasura · Sep 11, 2024 · b86d8cb · b86d8cb
1 parent f53a991
commit b86d8cb
Show file tree

Hide file tree

Showing 5 changed files with 29 additions and 25 deletions.
diff --git a/ndc-models/src/lib.rs b/ndc-models/src/lib.rs
@@ -337,10 +337,15 @@ pub enum ComparisonOperatorDefinition {
 #[serde(tag = "type", rename_all = "snake_case")]
 #[schemars(title = "Aggregate Function Definition")]
 pub enum AggregateFunctionDefinition {
-    Sum,
     Min,
     Max,
-    Average,
+    Sum {
+        /// The scalar type of the result of this function, which should have
+        /// one of the type representations Int64 or Float64, depending on
+        /// whether this function is defined on a scalar type with an integer or
+        /// floating-point representation, respectively.
+        result_type: ScalarTypeName,
+    },
     Custom {
         /// The scalar or object type of the result of this function
         result_type: Type,

diff --git a/ndc-models/tests/json_schema/schema_response.jsonschema b/ndc-models/tests/json_schema/schema_response.jsonschema
@@ -428,20 +428,6 @@
       "title": "Aggregate Function Definition",
       "description": "The definition of an aggregation function on a scalar type",
       "oneOf": [
-        {
-          "type": "object",
-          "required": [
-            "type"
-          ],
-          "properties": {
-            "type": {
-              "type": "string",
-              "enum": [
-                "sum"
-              ]
-            }
-          }
-        },
         {
           "type": "object",
           "required": [
@@ -473,14 +459,19 @@
         {
           "type": "object",
           "required": [
+            "result_type",
             "type"
           ],
           "properties": {
             "type": {
               "type": "string",
               "enum": [
-                "average"
+                "sum"
               ]
+            },
+            "result_type": {
+              "description": "The scalar type of the result of this function, which should have one of the type representations Int64 or Float64, depending on whether this function is defined on a scalar type with an integer or floating-point representation, respectively.",
+              "type": "string"
             }
           }
         },

diff --git a/ndc-test/src/error.rs b/ndc-test/src/error.rs
@@ -52,6 +52,8 @@ pub enum Error {
     UnexpectedField(ndc_models::FieldName),
     #[error("scalar type {0} has multiple equality operators")]
     MultipleEqualityOperators(ndc_models::ScalarTypeName),
+    #[error("scalar type {0} has an invalid type representation")]
+    InvalidTypeRepresentation(ndc_models::ScalarTypeName),
     #[error("error response from connector: {0:?}")]
     ConnectorError(ndc_models::ErrorResponse),
     #[error("cannot open snapshot file: {0:?}")]

diff --git a/ndc-test/src/test_cases/schema.rs b/ndc-test/src/test_cases/schema.rs
@@ -26,6 +26,18 @@ pub async fn validate_schema<R: Reporter>(
         for (type_name, scalar_type) in &schema.scalar_types {
             for aggregate_function in scalar_type.aggregate_functions.values() {
                 match aggregate_function {
+                    models::AggregateFunctionDefinition::Sum { result_type } => {
+                        let Some(scalar_type) = schema.scalar_types.get(result_type) else {
+                            return Err(Error::NamedTypeIsNotDefined(result_type.inner().clone()));
+                        };
+                        let Some(
+                            models::TypeRepresentation::Int64 | models::TypeRepresentation::Float64,
+                        ) = scalar_type.representation
+                        else {
+                            return Err(Error::InvalidTypeRepresentation(result_type.clone()));
+                        };
+                        Ok(())
+                    }
                     models::AggregateFunctionDefinition::Custom { result_type } => {
                         validate_type(schema, result_type)
                     }

diff --git a/specification/src/specification/schema/scalar-types.md b/specification/src/specification/schema/scalar-types.md
@@ -164,15 +164,9 @@ For example:
 
 An aggregation function defined using type `sum` should return the numerical sum of its provided values.
 
-A `sum` function should ignore the order of its input values, and should be invariant of partitioning, that is: `sum(x, sum(y, z))` = `sum(x, y, z)` for any partitioning `x, y, z` of the input values.
-
-#### `average`
-
-An aggregation function defined using type `average` should return the numerical average of its provided values.
+The result type should be provided explicitly, in the `result_type` field, and should be a scalar type with a type representation of either `Int64` or `Float64`, depending on whether the scalar type defining this function has an integer representation or floating point representation,
 
-Its implicit result type, i.e. the type of the aggregated values, is the same as the scalar type on which the function is defined, but with nulls allowed if not allowed already.
-
-An `average` function should return null for an empty set of input values.
+A `sum` function should ignore the order of its input values, and should be invariant of partitioning, that is: `sum(x, sum(y, z))` = `sum(x, y, z)` for any partitioning `x, y, z` of the input values.
 
 #### `min`, `max`