Preserve explicit derived inline aggregates

Author: nicosuave

sidemantic-rs/src/config/schema.rs

@@ -606,20 +606,18 @@ impl DimensionConfig {
 
 impl MetricConfig {
     fn into_metric(self) -> Metric {
-        let inline_aggregation = if self.agg.is_none() {
+        let explicit_metric_type = self.metric_type.as_deref().map(str::to_ascii_lowercase);
+        let can_normalize_inline_aggregation =
+            matches!(explicit_metric_type.as_deref(), None | Some("simple"));
+        let inline_aggregation = if self.agg.is_none() && can_normalize_inline_aggregation {
             self.sql
                 .as_deref()
                 .and_then(parse_inline_metric_aggregation)
         } else {
             None
         };
 
-        let metric_type = match self
-            .metric_type
-            .as_deref()
-            .map(str::to_ascii_lowercase)
-            .as_deref()
-        {
+        let metric_type = match explicit_metric_type.as_deref() {
             Some("simple") => MetricType::Simple,
             Some("derived") => MetricType::Derived,
             Some("ratio") => MetricType::Ratio,
@@ -1795,6 +1793,9 @@ models:
         sql: VARIANCE_POP(amount)
       - name: revenue_per_order
         sql: SUM(amount) / COUNT(*)
+      - name: explicit_derived_revenue
+        type: derived
+        sql: SUM(orders.amount)
 "#;
 
         let config: SidemanticConfig = serde_yaml::from_str(yaml).unwrap();
@@ -1844,6 +1845,18 @@ models:
             revenue_per_order.sql.as_deref(),
             Some("SUM(amount) / COUNT(*)")
         );
+
+        let explicit_derived_revenue = orders
+            .metrics
+            .iter()
+            .find(|m| m.name == "explicit_derived_revenue")
+            .unwrap();
+        assert_eq!(explicit_derived_revenue.r#type, MetricType::Derived);
+        assert_eq!(explicit_derived_revenue.agg, None);
+        assert_eq!(
+            explicit_derived_revenue.sql.as_deref(),
+            Some("SUM(orders.amount)")
+        );
     }
 
     #[test]

sidemantic-rs/src/config/sql_parser.rs

@@ -1938,12 +1938,8 @@ fn build_metric(props: &HashMap<String, String>) -> Option<Metric> {
 
     metric.agg = parse_metric_aggregation(props.get("agg"));
 
-    if metric.agg.is_none()
-        && matches!(
-            metric.r#type,
-            MetricType::Simple | MetricType::Cumulative | MetricType::Derived
-        )
-    {
+    let explicit_metric_type = props.get("type").map(|value| value.to_ascii_lowercase());
+    if metric.agg.is_none() && matches!(explicit_metric_type.as_deref(), None | Some("simple")) {
         if let Some(sql) = metric.sql.as_deref() {
             if let Some((agg, inner_expr)) = extract_aggregation_with_polyglot(sql) {
                 metric.agg = parse_metric_aggregation(Some(&agg));
@@ -2228,6 +2224,20 @@ mod tests {
         assert_eq!(revenue.sql, Some("amount".to_string()));
     }
 
+    #[test]
+    fn test_parse_explicit_derived_metric_preserves_inline_aggregate_expression() {
+        let sql = r#"
+            MODEL (name orders, table orders);
+            METRIC (name revenue, type derived, sql SUM(orders.amount));
+        "#;
+
+        let model = parse_sql_model(sql).unwrap();
+        let revenue = model.get_metric("revenue").unwrap();
+        assert_eq!(revenue.r#type, MetricType::Derived);
+        assert_eq!(revenue.agg, None);
+        assert_eq!(revenue.sql, Some("SUM(orders.amount)".to_string()));
+    }
+
     #[test]
     fn test_parse_cohort_metric_preserves_outer_aggregation() {
         let sql = r#"

sidemantic-rs/src/sql/generator.rs

@@ -4804,6 +4804,34 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_explicit_derived_inline_aggregate_from_yaml_generates_aggregate() {
+        let graph = crate::config::load_from_string(
+            r#"
+models:
+  - name: orders
+    table: orders
+    primary_key: order_id
+    metrics:
+      - name: derived_revenue
+        type: derived
+        sql: SUM(orders.amount)
+"#,
+        )
+        .unwrap();
+        let generator = SqlGenerator::new(&graph);
+
+        let query = SemanticQuery::new().with_metrics(vec!["orders.derived_revenue".into()]);
+
+        let sql = generator.generate(&query).unwrap();
+
+        assert!(sql.contains("amount AS amount"), "{sql}");
+        assert!(
+            sql.contains("SUM(orders_cte.amount) AS derived_revenue"),
+            "{sql}"
+        );
+    }
+
     #[test]
     fn test_ordered_set_aggregate_metric_is_not_treated_as_metric_reference() {
         let mut graph = SemanticGraph::new();