chore: fix

Author: ovr

rust/cubesql/cubesql/src/compile/engine/df/optimizers/plan_normalize.rs

@@ -859,15 +859,7 @@ fn expr_normalize(ctx: &Box<PlanNormalizeContext>, expr: &Expr) -> Result<Box<Ex
             expr,
             list,
             negated,
-        } => in_list_expr_normalize(
-            optimizer,
-            expr,
-            list,
-            *negated,
-            schema,
-            remapped_columns,
-            optimizer_config,
-        ),
+        } => in_list_expr_normalize(ctx, expr, list, *negated),
 
         Expr::InSubquery {
             expr,
@@ -1021,20 +1013,20 @@ fn binary_expr_normalize(
     // and cast the `DATE` to `TIMESTAMP` to match the types.
     match (&left_type, &right_type) {
         (DataType::Timestamp(_, _), DataType::Date32) => {
-            let new_right = evaluate_expr(optimizer, right.cast_to(&left_type, schema)?)?;
-            return Ok(Expr::BinaryExpr {
+            let new_right = evaluate_expr(ctx, right.cast_to(&left_type, ctx.schema)?)?;
+            return Ok(Box::new(Expr::BinaryExpr {
                 left,
                 op,
-                right: Box::new(new_right),
-            });
+                right: new_right,
+            }));
         }
         (DataType::Date32, DataType::Timestamp(_, _)) => {
-            let new_left = evaluate_expr(optimizer, left.cast_to(&right_type, schema)?)?;
-            return Ok(Expr::BinaryExpr {
-                left: Box::new(new_left),
+            let new_left = evaluate_expr(ctx, left.cast_to(&right_type, ctx.schema)?)?;
+            return Ok(Box::new(Expr::BinaryExpr {
+                left: new_left,
                 op,
                 right,
-            });
+            }));
         }
         _ => (),
     };
@@ -1121,57 +1113,47 @@ fn binary_expr_cast_literal(op: &Operator, other_type: &DataType) -> Option<Data
 /// - IN list expressions where expression being tested is `TIMESTAMP`
 ///   and values are `DATE` to values casted to `TIMESTAMP`
 fn in_list_expr_normalize(
-    optimizer: &PlanNormalize,
+    ctx: &Box<PlanNormalizeContext>,
     expr: &Expr,
     list: &[Expr],
     negated: bool,
-    schema: &DFSchema,
-    remapped_columns: &HashMap<Column, Column>,
-    optimizer_config: &OptimizerConfig,
-) -> Result<Expr> {
-    let expr = Box::new(expr_normalize(
-        optimizer,
-        expr,
-        schema,
-        remapped_columns,
-        optimizer_config,
-    )?);
-    let expr_type = expr.get_type(schema)?;
+) -> Result<Box<Expr>> {
+    let expr = expr_normalize(ctx, expr)?;
+    let expr_type = expr.get_type(ctx.schema)?;
     let expr_is_timestamp = matches!(expr_type, DataType::Timestamp(_, _));
     let list = list
         .iter()
         .map(|list_expr| {
-            let list_expr_normalized = expr_normalize(
-                optimizer,
-                list_expr,
-                schema,
-                remapped_columns,
-                optimizer_config,
-            )?;
+            let list_expr_normalized = expr_normalize_stack(ctx, list_expr)?;
             if !expr_is_timestamp {
                 return Ok(list_expr_normalized);
             }
-            let list_expr_type = list_expr_normalized.get_type(schema)?;
+
+            let list_expr_type = list_expr_normalized.get_type(ctx.schema)?;
             if !matches!(list_expr_type, DataType::Date32) {
                 return Ok(list_expr_normalized);
             }
-            evaluate_expr(optimizer, list_expr_normalized.cast_to(&expr_type, schema)?)
+
+            evaluate_expr_stacked(ctx, list_expr_normalized.cast_to(&expr_type, ctx.schema)?)
         })
         .collect::<Result<Vec<_>>>()?;
-    Ok(Expr::InList {
+
+    Ok(Box::new(Expr::InList {
         expr,
         list,
         negated,
-    })
+    }))
 }
 
-/// Evaluates an expression to a constant if possible.
-fn evaluate_expr(ctx: &Box<PlanNormalizeContext>, expr: Expr) -> Result<Box<Expr>> {
+fn evaluate_expr_stacked(ctx: &Box<PlanNormalizeContext>, expr: Expr) -> Result<Expr> {
     let execution_props = &ctx.optimizer.cube_ctx.state.execution_props;
     let mut const_evaluator = ConstEvaluator::new(execution_props);
-    let expr = expr.rewrite(&mut const_evaluator)?;
+    expr.rewrite(&mut const_evaluator)
+}
 
-    Ok(Box::new(expr))
+/// Evaluates an expression to a constant if possible.
+fn evaluate_expr(ctx: &Box<PlanNormalizeContext>, expr: Expr) -> Result<Box<Expr>> {
+    Ok(Box::new(evaluate_expr_stacked(ctx, expr)?))
 }
 
 #[cfg(test)]
@@ -1223,7 +1205,7 @@ mod tests {
             .expect("Failed to build plan");
 
         // Create a deeply nested OR expression (should cause stack overflow)
-        let deeply_nested_filter = create_deeply_nested_or_expr("value", 100);
+        let deeply_nested_filter = create_deeply_nested_or_expr("value", 96);
 
         // Build the plan with the filter
         let plan = LogicalPlanBuilder::from(table_scan)