Properly cast column types for spec

crates/configuration/src/introspection.rs

@@ -77,17 +77,17 @@ pub fn map_type_representation(sql_type: &str) -> Option<TypeRepresentation> {
         "float" => Some(TypeRepresentation::Float64),
         "real" => Some(TypeRepresentation::Float32),
         "date" => Some(TypeRepresentation::Date),
-        "datetime" | "datetime2" | "smalldatetime" | "timestamp" => Some(TypeRepresentation::Timestamp),
+        "datetime" | "datetime2" | "smalldatetime" => Some(TypeRepresentation::Timestamp),
         "datetimeoffset" => Some(TypeRepresentation::TimestampTZ),
-        "time" => Some(TypeRepresentation::String),
+        "time" | "timestamp" => Some(TypeRepresentation::String),
         "char" | "varchar" | "text" | "nchar" | "nvarchar" | "ntext" => Some(TypeRepresentation::String),
         "binary" | "varbinary" | "image" => Some(TypeRepresentation::String),
         "uniqueidentifier" => Some(TypeRepresentation::UUID),
         "xml" => Some(TypeRepresentation::String),
-        "geometry" => Some(TypeRepresentation::Geometry),
-        "geography" => Some(TypeRepresentation::Geography),
         "json" => Some(TypeRepresentation::JSON),
         // TODO: Add support for hierarchyid and sql_variant
+        // "geometry" => Some(TypeRepresentation::Geometry),
+        // "geography" => Some(TypeRepresentation::Geography),
         // "hierarchyid" | "sql_variant" => XXX,
         _ => None,
     }

crates/query-engine/sql/src/sql/helpers.rs

@@ -50,12 +50,26 @@ pub fn make_column(
     table: TableReference,
     name: ColumnName,
     alias: ColumnAlias,
+    column_type: ScalarType,
 ) -> (ColumnAlias, Expression) {
     (
         alias,
-        Expression::ColumnReference(ColumnReference::TableColumn { table, name }),
+        cast_column(column_type, Expression::ColumnReference(ColumnReference::TableColumn { table, name })),
     )
 }
+
+/// Should we cast the column to a specific type?
+pub fn cast_column(column_type: ScalarType, expression: Expression) -> Expression {
+    match column_type.0.as_str() {
+        "bigint" | "decimal" | "numeric" | "money" | "smallmoney" =>
+            Expression::Cast {
+                expression: Box::new(expression),
+                r#type: ScalarType("varchar".to_string()),
+            },
+        _ => expression,
+    }
+}
+
 /// Create column aliases using this function so we build everything in one place.
 pub fn make_column_alias(name: String) -> ColumnAlias {
     ColumnAlias { name }

crates/query-engine/translation/src/translation/helpers.rs

@@ -12,7 +12,7 @@ use query_engine_sql::sql;
 #[derive(Debug)]
 /// Static information from the query and metadata.
 pub struct Env<'a> {
-    metadata: &'a metadata::Metadata,
+    pub metadata: &'a metadata::Metadata,
     relationships: BTreeMap<ndc_models::RelationshipName, ndc_models::Relationship>,
 }
 

crates/query-engine/translation/src/translation/query/aggregates.rs

@@ -2,13 +2,15 @@
 
 use indexmap::IndexMap;
 
-use crate::translation::error::Error;
-use query_engine_sql::sql;
+use crate::translation::{error::Error, helpers::{Env, CollectionOrProcedureInfo}};
+use query_engine_sql::sql::{self, helpers::cast_column, ast::ScalarType};
 
 /// Translate any aggregates we should include in the query into our SQL AST.
 pub fn translate(
     table: &sql::ast::TableReference,
     aggregates: &IndexMap<ndc_models::FieldName, ndc_models::Aggregate>,
+    collection_info: &CollectionOrProcedureInfo,
+    env: &Env,
 ) -> Result<Vec<(sql::ast::ColumnAlias, sql::ast::Expression)>, Error> {
     aggregates
         .into_iter()
@@ -45,18 +47,46 @@ pub fn translate(
                             column: sql::helpers::make_column_alias(column.to_string()),
                         },
                     );
+                    let column_type = match collection_info {
+                        CollectionOrProcedureInfo::Collection(ci) => {
+                            match ci {
+                                crate::translation::helpers::CollectionInfo::Table { info, .. } => {
+                                    info.columns.get(column.as_str()).map(|c| c.r#type.clone())
+                                },
+                                crate::translation::helpers::CollectionInfo::NativeQuery { info, .. } => {
+                                    info.columns.get(column.as_str()).map(|c| c.r#type.clone())
+                                },
+                                _ => None,
+                            }
+                        }
+                        CollectionOrProcedureInfo::Procedure(_) => None
+                    };
+                    let function_type = column_type.and_then(|column_type| env.metadata.aggregate_functions.0
+                        .get(&column_type)
+                        .and_then(|functions| functions.get(function.as_str())));
                     match function.as_str() {
-                        "SUM" | "AVG" => sql::ast::Expression::FunctionCall {
-                            function: sql::ast::Function::Unknown(function.to_string()),
-                            args: vec![sql::ast::Expression::Cast {
-                                expression: Box::new(column_ref_expression),
-                                r#type: sql::ast::ScalarType("BIGINT".to_string()),
-                            }],
-                        },
-                        _ => sql::ast::Expression::FunctionCall {
-                            function: sql::ast::Function::Unknown(function.to_string()),
-                            args: vec![column_ref_expression],
+                        "SUM" | "AVG" => sql::ast::Expression::Cast {
+                            expression: Box::new(sql::ast::Expression::FunctionCall {
+                                function: sql::ast::Function::Unknown(function.to_string()),
+                                args: vec![sql::ast::Expression::Cast {
+                                    expression: Box::new(column_ref_expression),
+                                    r#type: sql::ast::ScalarType("BIGINT".to_string()),
+                                }],
+                            }),
+                            r#type: sql::ast::ScalarType("varchar".to_string()),
                         },
+                        _ => {
+                            let expression = sql::ast::Expression::FunctionCall {
+                                function: sql::ast::Function::Unknown(function.to_string()),
+                                args: vec![column_ref_expression],
+                            };
+                            match function_type.map(|f| f.return_type.clone()) {
+                                Some(scalar_type) => cast_column(ScalarType(scalar_type.0), expression),
+                                None => expression
+                            }
+                        }
+
+
                     }
                 }
                 ndc_models::Aggregate::StarCount {} => {

crates/query-engine/translation/src/translation/query/mod.rs

@@ -90,7 +90,7 @@ pub fn translate_query(
 
     // translate aggregate select. if there are no fields, make this a None
     let aggregate_select =
-        root::translate_aggregate_query(env, state, current_table, from_clause, query)?;
+        root::translate_aggregate_query(env, state, collection_info, current_table, from_clause, query)?;
 
     match (row_select, aggregate_select) {
         (Some(rows), None) => Ok(sql::helpers::SelectSet::Rows(rows)),

crates/query-engine/translation/src/translation/query/root.rs

@@ -11,6 +11,7 @@ use crate::translation::helpers::CollectionOrProcedureInfo;
 use crate::translation::helpers::{
     CollectionInfo, Env, RootAndCurrentTables, State, TableNameAndReference,
 };
+use query_engine_sql::sql::ast::ScalarType;
 
 use super::relationships;
 use super::sorting;
@@ -20,6 +21,7 @@ use query_engine_sql::sql;
 pub fn translate_aggregate_query(
     env: &Env,
     state: &mut State,
+    collection_info: &CollectionOrProcedureInfo,
     current_table: &TableNameAndReference,
     from_clause: &sql::ast::From,
     query: &ndc_models::Query,
@@ -29,7 +31,7 @@ pub fn translate_aggregate_query(
         Some(aggregate_fields) => {
             // create all aggregate columns
             let aggregate_columns =
-                aggregates::translate(&current_table.reference, aggregate_fields)?;
+                aggregates::translate(&current_table.reference, aggregate_fields, collection_info, env)?;
 
             // create the select clause and the joins, order by, where clauses.
             // We don't add the limit afterwards.
@@ -189,6 +191,7 @@ pub fn translate_rows_query(
                             current_table.reference.clone(),
                             column_info.name,
                             sql::helpers::make_column_alias(alias.to_string()),
+                            ScalarType(column_info.r#type.0),
                         ))
                     }
                     ndc_models::Field::Relationship {