polyglot-sql 0.9.0__tar.gz → 0.9.2__tar.gz

{polyglot_sql-0.9.0 → polyglot_sql-0.9.2}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.9.0"
+version = "0.9.2"
 dependencies = [
  "criterion",
  "once_cell",
@@ -623,7 +623,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ast-derive"
-version = "0.9.0"
+version = "0.9.2"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -632,7 +632,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.9.0"
+version = "0.9.2"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -642,11 +642,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.9.0"
+version = "0.9.2"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.9.0"
+version = "0.9.2"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -657,7 +657,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.9.0"
+version = "0.9.2"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.9.0 → polyglot_sql-0.9.2}/Cargo.toml

@@ -6,7 +6,7 @@ exclude = [
 ]
 
 [workspace.package]
-version = "0.9.0"
+version = "0.9.2"
 edition = "2021"
 license = "MIT"
 authors = ["polyglot contributors"]

{polyglot_sql-0.9.0 → polyglot_sql-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.9.0
+Version: 0.9.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyglot_sql-0.9.0 → polyglot_sql-0.9.2}/crates/polyglot-sql/Cargo.toml

@@ -100,14 +100,14 @@ function-catalog-all-dialects = [
 ]
 
 [dependencies]
-polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.9.0" }
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.9.2" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 unicode-segmentation = { workspace = true }
 stacker = { version = "0.1", optional = true }
 ts-rs = { version = "12.0", features = ["serde-compat"], optional = true }
-polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.9.0", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.9.2", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.9.0 → polyglot_sql-0.9.2}/crates/polyglot-sql/README.md

@@ -25,7 +25,7 @@ By default, `polyglot-sql` enables the full public API. Parser-only consumers ca
 disable default features and opt into only the dialect parsers they need:
 
 ```toml
-polyglot-sql = { version = "0.9.0", default-features = false }
+polyglot-sql = { version = "0.9.2", default-features = false }
 ```
 
 ```toml

{polyglot_sql-0.9.0 → polyglot_sql-0.9.2}/crates/polyglot-sql/src/ast_transforms.rs

@@ -11,7 +11,7 @@ use std::collections::{HashMap, HashSet};
 
 use crate::builder::engine;
 use crate::expressions::*;
-use crate::traversal::ExpressionWalk;
+use crate::traversal::{is_aggregate, ExpressionWalk};
 
 /// Apply a bottom-up transformation to every node in the tree.
 /// Wraps `crate::traversal::transform` with a simpler signature for this module.
@@ -336,6 +336,26 @@ pub fn get_output_column_names(expr: &Expression) -> Vec<String> {
     output_column_names_from_query(expr)
 }
 
+/// Collect projected output column names using dialect-specific set-operation
+/// alignment rules.
+///
+/// This differs from [`get_output_column_names`] only for name-aligned set
+/// operations. When an output shape is not statically knowable (for example an
+/// unresolved wildcard), it preserves the existing leftmost-branch behavior.
+pub fn get_output_column_names_for_dialect(
+    expr: &Expression,
+    dialect: Option<crate::dialects::DialectType>,
+) -> Vec<String> {
+    crate::set_operation::query_output_identifiers(expr, dialect)
+        .map(|identifiers| {
+            identifiers
+                .into_iter()
+                .map(|identifier| identifier.name)
+                .collect()
+        })
+        .unwrap_or_else(|_| output_column_names_from_query(expr))
+}
+
 fn output_column_names_from_query(expr: &Expression) -> Vec<String> {
     match expr {
         Expression::Select(select) => select_output_column_names(select),
@@ -540,22 +560,7 @@ pub fn get_subqueries(expr: &Expression) -> Vec<&Expression> {
 /// Includes typed aggregates (`Count`, `Sum`, `Avg`, `Min`, `Max`, etc.)
 /// and generic `AggregateFunction` nodes.
 pub fn get_aggregate_functions(expr: &Expression) -> Vec<&Expression> {
-    expr.find_all(|e| {
-        matches!(
-            e,
-            Expression::AggregateFunction(_)
-                | Expression::Count(_)
-                | Expression::Sum(_)
-                | Expression::Avg(_)
-                | Expression::Min(_)
-                | Expression::Max(_)
-                | Expression::ApproxDistinct(_)
-                | Expression::ArrayAgg(_)
-                | Expression::GroupConcat(_)
-                | Expression::StringAgg(_)
-                | Expression::ListAgg(_)
-        )
-    })
+    expr.find_all(is_aggregate)
 }
 
 /// Collect all window function nodes in the expression tree.
@@ -695,6 +700,37 @@ mod tests {
         assert_eq!(names, vec!["c1".to_string(), "c2".to_string()]);
     }
 
+    #[test]
+    fn test_get_output_column_names_uses_dialect_by_name_layout() {
+        for dialect in [
+            crate::dialects::DialectType::DuckDB,
+            crate::dialects::DialectType::Snowflake,
+        ] {
+            let expr = crate::parse_one(
+                "SELECT 1 AS left_value UNION ALL BY NAME SELECT 2 AS right_value",
+                dialect,
+            )
+            .expect("parse");
+            assert_eq!(
+                get_output_column_names_for_dialect(&expr, Some(dialect)),
+                vec!["left_value", "right_value"]
+            );
+        }
+
+        let expr = crate::parse_one(
+            "SELECT 1 AS a, 2 AS b UNION ALL BY NAME SELECT 3 AS b, 4 AS a",
+            crate::dialects::DialectType::BigQuery,
+        )
+        .expect("parse");
+        assert_eq!(
+            get_output_column_names_for_dialect(
+                &expr,
+                Some(crate::dialects::DialectType::BigQuery),
+            ),
+            vec!["a", "b"]
+        );
+    }
+
     #[test]
     fn test_get_column_names_union_still_returns_all_references() {
         let expr =
@@ -851,12 +887,35 @@ mod tests {
 
     #[test]
     fn test_get_aggregate_functions() {
-        let expr = parse_one("SELECT COUNT(*), SUM(x) FROM t");
+        let expr = crate::parse_one(
+            "SELECT COUNT_IF(numeric_value > 0), MEDIAN(numeric_value), FIRST(numeric_value) FROM source_table",
+            crate::dialects::DialectType::DuckDB,
+        )
+        .unwrap();
         let aggs = get_aggregate_functions(&expr);
-        assert!(
-            aggs.len() >= 2,
-            "Expected at least 2 aggregates, got {}",
-            aggs.len()
-        );
+        let aggregate_types: Vec<_> = aggs.iter().map(|agg| agg.variant_name()).collect();
+
+        assert_eq!(aggregate_types, vec!["count_if", "median", "first"]);
+    }
+
+    #[test]
+    fn test_get_duckdb_null_preserving_arg_extrema() {
+        let expr = crate::parse_one(
+            "SELECT ARG_MAX_NULL(label, score), ARG_MIN_NULL(label, score) FROM source_table",
+            crate::dialects::DialectType::DuckDB,
+        )
+        .unwrap();
+        let aggregates = get_aggregate_functions(&expr);
+
+        assert_eq!(aggregates.len(), 2);
+        for (aggregate, expected_name) in
+            aggregates.into_iter().zip(["ARG_MAX_NULL", "ARG_MIN_NULL"])
+        {
+            let Expression::AggregateFunction(function) = aggregate else {
+                panic!("expected a generic aggregate node, got {aggregate:?}");
+            };
+            assert_eq!(function.name, expected_name);
+            assert_eq!(function.args.len(), 2);
+        }
     }
 }

{polyglot_sql-0.9.0 → polyglot_sql-0.9.2}/crates/polyglot-sql/src/builder/mod.rs

@@ -186,6 +186,7 @@ pub fn col(name: &str) -> Expr {
             expr = Expression::Dot(Box::new(DotAccess {
                 this: expr,
                 field: builder_identifier(field),
+                inferred_type: None,
             }));
         }
 
@@ -2783,6 +2784,27 @@ mod tests {
         assert_eq!(sql, "SELECT price * quantity AS total FROM items");
     }
 
+    #[test]
+    fn test_nested_operator_grouping() {
+        assert_eq!(
+            or(col("a").eq(lit(1)), col("b").eq(lit(2)))
+                .and(col("c").eq(lit(3)))
+                .to_sql(),
+            "(a = 1 OR b = 2) AND c = 3"
+        );
+        assert_eq!(
+            col("a")
+                .eq(lit(1))
+                .and(or(col("b").eq(lit(2)), col("c").eq(lit(3))))
+                .to_sql(),
+            "a = 1 AND (b = 2 OR c = 3)"
+        );
+        assert_eq!(col("a").add(col("b")).mul(col("c")).to_sql(), "(a + b) * c");
+        assert_eq!(col("a").mul(col("b").add(col("c"))).to_sql(), "a * (b + c)");
+        assert_eq!(col("a").sub(col("b").sub(col("c"))).to_sql(), "a - (b - c)");
+        assert_eq!(col("a").div(col("b").div(col("c"))).to_sql(), "a / (b / c)");
+    }
+
     #[test]
     fn test_cast() {
         let sql = select([col("id").cast("VARCHAR")]).from("users").to_sql();

{polyglot_sql-0.9.0 → polyglot_sql-0.9.2}/crates/polyglot-sql/src/dialects/duckdb.rs

@@ -6120,14 +6120,12 @@ impl DuckDBDialect {
                     trailing_comments: Vec::new(),
                     inferred_type: None,
                 }));
-                let two_pi_u2 = Expression::Mul(Box::new(BinaryOp {
-                    left: two_pi,
-                    right: u2,
-                    left_comments: Vec::new(),
-                    operator_comments: Vec::new(),
-                    trailing_comments: Vec::new(),
-                    inferred_type: None,
-                }));
+                let two_pi_u2 = if let Expression::Div(div) = u2 {
+                    let numerator = Expression::Mul(Box::new(BinaryOp::new(two_pi, div.left)));
+                    Expression::Div(Box::new(BinaryOp::new(numerator, div.right)))
+                } else {
+                    Expression::Mul(Box::new(BinaryOp::new(two_pi, u2)))
+                };
                 let cos_part = Expression::Function(Box::new(Function::new(
                     "COS".to_string(),
                     vec![two_pi_u2],
@@ -6328,6 +6326,7 @@ impl DuckDBDialect {
                 let x_value = Expression::Dot(Box::new(crate::expressions::DotAccess {
                     this: x_ref,
                     field: Identifier::new("value"),
+                    inferred_type: None,
                 }));
                 let x_value_is_null = Expression::IsNull(Box::new(crate::expressions::IsNull {
                     this: x_value,
@@ -7212,6 +7211,24 @@ impl DuckDBDialect {
     ) -> Result<Expression> {
         let name_upper = f.name.to_uppercase();
         match name_upper.as_str() {
+            // Keep the established canonical transpilation for a plain DuckDB
+            // LIST aggregate now that the parser represents it as an aggregate
+            // node. Modifier-bearing LIST calls retain their aggregate shape so
+            // DISTINCT, ORDER BY, FILTER, and LIMIT are not discarded.
+            "LIST"
+                if f.args.len() == 1
+                    && !f.distinct
+                    && f.filter.is_none()
+                    && f.order_by.is_empty()
+                    && f.limit.is_none()
+                    && f.ignore_nulls.is_none() =>
+            {
+                Ok(Expression::Function(Box::new(Function::new(
+                    "ARRAY_AGG".to_string(),
+                    f.args,
+                ))))
+            }
+
             // GROUP_CONCAT -> LISTAGG
             "GROUP_CONCAT" if !f.args.is_empty() => Ok(Expression::Function(Box::new(
                 Function::new("LISTAGG".to_string(), f.args),

{polyglot_sql-0.9.0 → polyglot_sql-0.9.2}/crates/polyglot-sql/src/dialects/mod.rs

@@ -188,7 +188,7 @@ use crate::parser::Parser;
 use crate::tokens::TokenType;
 use crate::tokens::{Token, Tokenizer, TokenizerConfig};
 #[cfg(feature = "transpile")]
-use crate::traversal::ExpressionWalk;
+use crate::traversal::{is_aggregate, ExpressionWalk};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 #[cfg(feature = "transpile")]
@@ -4561,6 +4561,12 @@ impl Dialect {
                         "qualified whole-row aggregate arguments",
                     );
                 }
+                if Self::node_has_subquery_in_aggregate_argument(node) {
+                    Self::push_unsupported_diagnostic(
+                        &mut diagnostics,
+                        "aggregate arguments containing subqueries",
+                    );
+                }
             }
 
             if !Self::target_supports_distinct_on(target) && Self::node_has_distinct_on(node) {
@@ -5368,63 +5374,7 @@ impl Dialect {
     }
 
     fn node_is_aggregate_function(expr: &Expression) -> bool {
-        matches!(
-            expr,
-            Expression::AggregateFunction(_)
-                | Expression::Count(_)
-                | Expression::Sum(_)
-                | Expression::Avg(_)
-                | Expression::Min(_)
-                | Expression::Max(_)
-                | Expression::GroupConcat(_)
-                | Expression::StringAgg(_)
-                | Expression::ListAgg(_)
-                | Expression::ArrayAgg(_)
-                | Expression::CountIf(_)
-                | Expression::SumIf(_)
-                | Expression::Stddev(_)
-                | Expression::StddevPop(_)
-                | Expression::StddevSamp(_)
-                | Expression::Variance(_)
-                | Expression::VarPop(_)
-                | Expression::VarSamp(_)
-                | Expression::Median(_)
-                | Expression::Mode(_)
-                | Expression::First(_)
-                | Expression::Last(_)
-                | Expression::AnyValue(_)
-                | Expression::ApproxDistinct(_)
-                | Expression::ApproxCountDistinct(_)
-                | Expression::ApproxPercentile(_)
-                | Expression::Percentile(_)
-                | Expression::LogicalAnd(_)
-                | Expression::LogicalOr(_)
-                | Expression::Skewness(_)
-                | Expression::BitwiseCount(_)
-                | Expression::BitwiseAndAgg(_)
-                | Expression::BitwiseOrAgg(_)
-                | Expression::BitwiseXorAgg(_)
-                | Expression::ArrayConcatAgg(_)
-                | Expression::ArrayUniqueAgg(_)
-                | Expression::BoolXorAgg(_)
-                | Expression::JsonArrayAgg(_)
-                | Expression::JsonObjectAgg(_)
-                | Expression::ParameterizedAgg(_)
-                | Expression::ArgMax(_)
-                | Expression::ArgMin(_)
-                | Expression::ApproxTopK(_)
-                | Expression::ApproxTopKAccumulate(_)
-                | Expression::ApproxTopKCombine(_)
-                | Expression::ApproxTopKEstimate(_)
-                | Expression::ApproxTopSum(_)
-                | Expression::ApproxQuantiles(_)
-                | Expression::AnonymousAggFunc(_)
-                | Expression::CombinedAggFunc(_)
-                | Expression::CombinedParameterizedAgg(_)
-                | Expression::HashAgg(_)
-                | Expression::ObjectAgg(_)
-                | Expression::AIAgg(_)
-        )
+        is_aggregate(expr)
     }
 
     fn node_has_qualified_whole_row_aggregate_argument(expr: &Expression) -> bool {
@@ -5446,6 +5396,21 @@ impl Dialect {
             && expr.children().into_iter().any(contains_qualified_star)
     }
 
+    fn node_has_subquery_in_aggregate_argument(expr: &Expression) -> bool {
+        fn contains_query(expr: &Expression) -> bool {
+            matches!(
+                expr,
+                Expression::Select(_)
+                    | Expression::Subquery(_)
+                    | Expression::Union(_)
+                    | Expression::Intersect(_)
+                    | Expression::Except(_)
+            ) || expr.children().into_iter().any(contains_query)
+        }
+
+        Self::node_is_aggregate_function(expr) && expr.children().into_iter().any(contains_query)
+    }
+
     fn tsql_apply_has_invalid_outer_aggregate(expr: &Expression) -> bool {
         // SQL Server error 8124: if an aggregate expression contains an outer
         // reference, that reference must be the only column used by the expression.

{polyglot_sql-0.9.0 → polyglot_sql-0.9.2}/crates/polyglot-sql/src/dialects/normalization/aggregates.rs

@@ -32,6 +32,7 @@ pub(super) enum Action {
     CollectListToArrayAgg,
     CollectSetConvert,
     PercentileConvert,
+    DuckDBQuantileConvert,
     CorrIsnanWrap,
     FirstToAnyValue,
     PercentileContConvert,
@@ -191,10 +192,16 @@ pub(super) fn rewrite(
                         } else {
                             "ARG_MIN_NULL"
                         };
-                        Ok(Expression::Function(Box::new(Function::new(
-                            func_name.to_string(),
-                            vec![agg.this, *having_expr],
-                        ))))
+                        Ok(Expression::AggregateFunction(Box::new(AggregateFunction {
+                            name: func_name.to_string(),
+                            args: vec![agg.this, *having_expr],
+                            distinct: agg.distinct,
+                            filter: agg.filter,
+                            order_by: agg.order_by,
+                            limit: agg.limit,
+                            ignore_nulls: agg.ignore_nulls,
+                            inferred_type: agg.inferred_type,
+                        })))
                     } else {
                         Ok(Expression::AnyValue(agg))
                     }
@@ -247,11 +254,10 @@ pub(super) fn rewrite(
                             expressions: quantiles,
                         }));
 
-                        // Preserve DISTINCT modifier
-                        let mut new_func =
-                            Function::new("APPROX_QUANTILE".to_string(), vec![x_expr, array_expr]);
-                        new_func.distinct = agg.distinct;
-                        Ok(Expression::Function(Box::new(new_func)))
+                        let mut new_agg = *agg;
+                        new_agg.name = "APPROX_QUANTILE".to_string();
+                        new_agg.args = vec![x_expr, array_expr];
+                        Ok(Expression::AggregateFunction(Box::new(new_agg)))
                     } else {
                         Ok(Expression::AggregateFunction(agg))
                     }
@@ -1146,6 +1152,80 @@ pub(super) fn rewrite(
                 }
             }
 
+            Action::DuckDBQuantileConvert => {
+                let mut aggregate = if let Expression::AggregateFunction(aggregate) = e {
+                    *aggregate
+                } else {
+                    unreachable!("action only triggered for AggregateFunction expressions")
+                };
+                let name = aggregate.name.to_ascii_uppercase();
+
+                match name.as_str() {
+                    "QUANTILE" => {
+                        aggregate.name = match target {
+                            DialectType::Spark | DialectType::Databricks | DialectType::Hive => {
+                                "PERCENTILE"
+                            }
+                            DialectType::Presto | DialectType::Trino => "APPROX_PERCENTILE",
+                            DialectType::BigQuery => "PERCENTILE_CONT",
+                            _ => "QUANTILE",
+                        }
+                        .to_string();
+                        Ok(Expression::AggregateFunction(Box::new(aggregate)))
+                    }
+                    "APPROX_QUANTILE" => {
+                        if matches!(target, DialectType::Snowflake) {
+                            aggregate.name = "APPROX_PERCENTILE".to_string();
+                        }
+                        Ok(Expression::AggregateFunction(Box::new(aggregate)))
+                    }
+                    "QUANTILE_CONT" | "QUANTILE_DISC"
+                        if aggregate.args.len() == 2
+                            && matches!(
+                                target,
+                                DialectType::PostgreSQL
+                                    | DialectType::Redshift
+                                    | DialectType::Snowflake
+                            ) =>
+                    {
+                        // DISTINCT, an inner ORDER BY, LIMIT, and explicit null
+                        // handling cannot be represented by these targets' ordered-set
+                        // aggregate syntax. Keep the original aggregate intact rather
+                        // than silently dropping any of those modifiers.
+                        if aggregate.distinct
+                            || !aggregate.order_by.is_empty()
+                            || aggregate.limit.is_some()
+                            || aggregate.ignore_nulls.is_some()
+                        {
+                            return Ok(Expression::AggregateFunction(Box::new(aggregate)));
+                        }
+
+                        let mut args = aggregate.args;
+                        let column = args.remove(0);
+                        let percentile = args.remove(0);
+                        let percentile = PercentileFunc {
+                            this: column.clone(),
+                            percentile,
+                            order_by: Some(vec![Ordered {
+                                this: column,
+                                desc: false,
+                                nulls_first: None,
+                                explicit_asc: false,
+                                with_fill: None,
+                            }]),
+                            filter: aggregate.filter,
+                        };
+
+                        if name == "QUANTILE_CONT" {
+                            Ok(Expression::PercentileCont(Box::new(percentile)))
+                        } else {
+                            Ok(Expression::PercentileDisc(Box::new(percentile)))
+                        }
+                    }
+                    _ => Ok(Expression::AggregateFunction(Box::new(aggregate))),
+                }
+            }
+
             Action::CorrIsnanWrap => {
                 // CORR(a, b) -> CASE WHEN ISNAN(CORR(a, b)) THEN NULL ELSE CORR(a, b) END
                 // The CORR expression could be AggregateFunction, WindowFunction, or Filter-wrapped

{polyglot_sql-0.9.0 → polyglot_sql-0.9.2}/crates/polyglot-sql/src/dialects/normalization/mod.rs

@@ -2294,6 +2294,11 @@ pub(super) fn normalize(
                         {
                             Action::Aggregates(aggregates::Action::BigQueryPercentileContToDuckDB)
                         }
+                        "QUANTILE" | "QUANTILE_CONT" | "QUANTILE_DISC" | "APPROX_QUANTILE"
+                            if matches!(source, DialectType::DuckDB) =>
+                        {
+                            Action::Aggregates(aggregates::Action::DuckDBQuantileConvert)
+                        }
                         _ => Action::None,
                     }
                 }

{polyglot_sql-0.9.0 → polyglot_sql-0.9.2}/crates/polyglot-sql/src/dialects/normalization/operators.rs

@@ -1418,26 +1418,23 @@ pub(super) fn rewrite(
                         ],
                     )));
 
-                    // Position offset: pos - 1 when pos > 1, else 0
-                    let pos_offset: Expression = if !is_pos_1 {
+                    // ELSE base: 1 + split_sum + extract_sum
+                    let else_base = Expression::Add(Box::new(BinaryOp::new(
+                        Expression::Add(Box::new(BinaryOp::new(Expression::number(1), split_sum))),
+                        extract_sum,
+                    )));
+
+                    // Append the position offset as a left-associated `+ pos - 1` chain.
+                    let else_expr = if !is_pos_1 {
                         let pos = position.clone().unwrap_or(Expression::number(1));
-                        Expression::Sub(Box::new(BinaryOp::new(pos, Expression::number(1))))
+                        Expression::Sub(Box::new(BinaryOp::new(
+                            Expression::Add(Box::new(BinaryOp::new(else_base, pos))),
+                            Expression::number(1),
+                        )))
                     } else {
-                        Expression::number(0)
+                        Expression::Add(Box::new(BinaryOp::new(else_base, Expression::number(0))))
                     };
 
-                    // ELSE: 1 + split_sum + extract_sum + pos_offset
-                    let else_expr = Expression::Add(Box::new(BinaryOp::new(
-                        Expression::Add(Box::new(BinaryOp::new(
-                            Expression::Add(Box::new(BinaryOp::new(
-                                Expression::number(1),
-                                split_sum,
-                            ))),
-                            extract_sum,
-                        ))),
-                        pos_offset,
-                    )));
-
                     Ok(Expression::Case(Box::new(Case {
                         operand: None,
                         whens: vec![