.

Author: neilconway

datafusion/expr-common/src/type_coercion/binary.rs

@@ -891,7 +891,7 @@ pub fn type_union_coercion(lhs_type: &DataType, rhs_type: &DataType) -> Option<D
 /// inspect whether an operand is a literal. This allows `int_col < '5'`
 /// (cast the literal) while rejecting `text_col < 5` (type mismatch).
 pub fn comparison_coercion(lhs_type: &DataType, rhs_type: &DataType) -> Option<DataType> {
-    if lhs_type == rhs_type {
+    if lhs_type.equals_datatype(rhs_type) {
         // same type => equality is possible
         return Some(lhs_type.clone());
     }

datafusion/optimizer/src/analyzer/type_coercion.rs

@@ -31,7 +31,7 @@ use datafusion_common::config::ConfigOptions;
 use datafusion_common::tree_node::{Transformed, TreeNode, TreeNodeRewriter};
 use datafusion_common::{
     Column, DFSchema, DFSchemaRef, DataFusionError, Result, ScalarValue, TableReference,
-    exec_err, internal_datafusion_err, internal_err, not_impl_err, plan_datafusion_err,
+    exec_err, internal_err, not_impl_err, plan_datafusion_err,
     plan_err,
 };
 use datafusion_expr::expr::{
@@ -662,31 +662,40 @@ impl TreeNodeRewriter for TypeCoercionRewriter<'_> {
                 high,
             }) => {
                 let expr_type = expr.get_type(self.schema)?;
-                // Cast string literal bounds to the expression's numeric type
+                let low_type = low.get_type(self.schema)?;
+                // Try casting string literals to the other side's numeric
+                // type in both directions, mirroring BinaryExpr behavior.
+                // This handles both `int_col BETWEEN '1' AND '10'` and
+                // `'5' BETWEEN 1 AND 10`.
                 let low = try_cast_string_literal_to_type(&low, &expr_type)?
                     .map(Box::new)
                     .unwrap_or(low);
                 let high = try_cast_string_literal_to_type(&high, &expr_type)?
                     .map(Box::new)
                     .unwrap_or(high);
+                let expr =
+                    try_cast_string_literal_to_type(&expr, &low_type)?
+                        .map(Box::new)
+                        .unwrap_or(expr);
+                let expr_type = expr.get_type(self.schema)?;
                 let low_type = low.get_type(self.schema)?;
                 let low_coerced_type = comparison_coercion(&expr_type, &low_type)
                     .ok_or_else(|| {
-                        internal_datafusion_err!(
+                        plan_datafusion_err!(
                             "Failed to coerce types {expr_type} and {low_type} in BETWEEN expression"
                         )
                     })?;
                 let high_type = high.get_type(self.schema)?;
                 let high_coerced_type = comparison_coercion(&expr_type, &high_type)
                     .ok_or_else(|| {
-                        internal_datafusion_err!(
+                        plan_datafusion_err!(
                             "Failed to coerce types {expr_type} and {high_type} in BETWEEN expression"
                         )
                     })?;
                 let coercion_type =
                     comparison_coercion(&low_coerced_type, &high_coerced_type)
                         .ok_or_else(|| {
-                            internal_datafusion_err!(
+                            plan_datafusion_err!(
                                 "Failed to coerce types {expr_type} and {high_type} in BETWEEN expression"
                             )
                         })?;

datafusion/sqllogictest/test_files/string_numeric_coercion.slt

@@ -242,6 +242,30 @@ SELECT * FROM t_int WHERE column1 NOT BETWEEN '5' AND '100';
 325
 499
 
+# -------------------------------------------------
+# String literal expression with numeric bounds
+# (reverse direction: cast the expression, not just the bounds)
+# -------------------------------------------------
+
+query B
+SELECT '5' BETWEEN 1 AND 10;
+----
+true
+
+query B
+SELECT '0' BETWEEN 1 AND 10;
+----
+false
+
+query B
+SELECT '5' NOT BETWEEN 1 AND 10;
+----
+false
+
+# Non-numeric string literal with numeric bounds should error
+statement error Arrow error: Cast error: Cannot cast string 'hello' to value of Int64 type
+SELECT 'hello' BETWEEN 1 AND 10;
+
 # -------------------------------------------------
 # Decimal column with string literal comparisons
 # -------------------------------------------------
@@ -300,6 +324,10 @@ SELECT * FROM t_mixed WHERE column2 = column1;
 statement error Can not find compatible types to compare Utf8 with \[Int64, Int64\]
 SELECT * FROM t_mixed WHERE column2 IN (5, 10);
 
+# text column BETWEEN numeric literals
+statement error Failed to coerce types Utf8 and Int64 in BETWEEN expression
+SELECT * FROM t_mixed WHERE column2 BETWEEN 1 AND 10;
+
 statement ok
 DROP TABLE t_mixed;