fix(sql): fold numeric casts of literals as DataFusion does

Type coercion turns a literal compared with a column of another type into
a cast: `latency < 100` on a DOUBLE column became
`latency < CAST(100 AS DOUBLE)`, which summary coverage cannot read as a
constant. Fold a cast of a literal to an integer or float type with
DataFusion's `ScalarValue::cast_to`, the evaluation its constant folding
uses; the predicate lowers as `latency < 100.0`. A cast that fails to
evaluate is kept.

DataFusion's whole SimplifyExpressions rule is not run: it also folds
timestamp casts into timestamp literals, which the IR cannot write yet, and
rewrites REGEXP_LIKE into the `~` operator (#650).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W7qG9aFyPij5uWsyAJCxDW

Author: zzylol

crates/frontend-sql/src/unified/sql/expr.rs

@@ -146,6 +146,25 @@ impl SqlLowerer<'_> {
 
             Expr::IsNotNull(inner) => Ok(Unresolved::IsNotNull(bx(inner)?)),
 
+            // Fold a numeric cast of a literal, as DataFusion's constant folding
+            // does: type coercion turns `latency < 100` on a DOUBLE column into
+            // `latency < CAST(100 AS DOUBLE)`, which lowers as `latency < 100.0`.
+            Expr::Cast(c)
+                if matches!(c.expr.as_ref(), Expr::Literal(..))
+                    && (c.field.data_type().is_integer() || c.field.data_type().is_floating()) =>
+            {
+                let Expr::Literal(sv, _) = c.expr.as_ref() else {
+                    unreachable!()
+                };
+                match sv.cast_to(c.field.data_type()) {
+                    Ok(folded) => scalar_value_to_asap(&folded).map(Unresolved::Literal),
+                    Err(_) => Ok(Unresolved::Cast {
+                        expr: bx(&c.expr)?,
+                        to: arrow_to_dtype(c.field.data_type())?,
+                        try_cast: false,
+                    }),
+                }
+            }
             Expr::Cast(c) => Ok(Unresolved::Cast {
                 expr: bx(&c.expr)?,
                 to: arrow_to_dtype(c.field.data_type())?,

crates/frontend-sql/tests/unified_sql_lowering.rs

@@ -2217,6 +2217,24 @@ async fn now_in_predicate_lowers_to_current_timestamp() {
     );
 }
 
+/// The cast that type coercion puts on `100` against a `DOUBLE` column is
+/// folded into the literal, as DataFusion's constant folding does.
+#[tokio::test]
+async fn coerced_literal_is_folded() {
+    let qe = lower("SELECT * FROM metrics WHERE latency < 100").await;
+    let NonASAPOp::Project { child, .. } = op(&qe) else {
+        panic!("expected Project at root, got {qe:?}");
+    };
+    let NonASAPOp::Scan { predicates, .. } = op(child) else {
+        panic!("expected Scan under the projection, got {child:?}");
+    };
+    assert!(
+        matches!(&predicates[..], [Predicate(ScalarExpr::Compare { right, .. })]
+            if matches!(right.as_ref(), ScalarExpr::Literal(ScalarValue::Float64(v)) if *v == 100.0)),
+        "{predicates:?}"
+    );
+}
+
 /// Same for ClickHouse's `now()`, since #184 was raised specifically against
 /// the ClickHouse dialect.
 #[tokio::test]