feat: Implement BETWEEN expression support in SQL parser and planner, enhancing expression handling and type coercion for decimal comparisons

Author: longshan.lu

qurious/src/execution/session.rs

@@ -385,26 +385,14 @@ mod tests {
             .sql(
                 "
 select
-    o_orderpriority,
-    count(*) as order_count
+    sum(l_extendedprice * l_discount) as revenue
 from
-    orders
+    lineitem
 where
-        o_orderdate >= '1993-07-01'
-  and o_orderdate < date '1993-07-01' + interval '3' month
-  and exists (
-        select
-            *
-        from
-            lineitem
-        where
-                l_orderkey = o_orderkey
-          and l_commitdate < l_receiptdate
-    )
-group by
-    o_orderpriority
-order by
-    o_orderpriority;
+        l_shipdate >= date '1994-01-01'
+  and l_shipdate < date '1995-01-01'
+  and l_discount between 0.06 - 0.01 and 0.06 + 0.01
+  and l_quantity < 24;
 ",
             )
             .unwrap();

qurious/src/planner/sql.rs

@@ -1021,6 +1021,24 @@ impl<'a> SqlQueryPlanner<'a> {
                 expr: Box::new(self.sql_to_expr(*left)?),
                 pattern: Box::new(self.sql_to_expr(*right)?),
             })),
+            Expression::Between {
+                negated,
+                expr,
+                low,
+                high,
+            } => {
+                let expr = self.sql_to_expr(*expr)?;
+                let low = self.sql_to_expr(*low)?;
+                let high = self.sql_to_expr(*high)?;
+
+                if negated {
+                    // `expr NOT BETWEEN low AND high`  ==>  (expr < low) OR (expr > high)
+                    Ok(or(lt(expr.clone(), low), gt(expr, high)))
+                } else {
+                    // `expr BETWEEN low AND high`  ==>  (expr >= low) AND (expr <= high)
+                    Ok(and(gt_eq(expr.clone(), low), lt_eq(expr, high)))
+                }
+            }
             Expression::Exists { subquery, negated } => Ok(LogicalExpr::Exists(Exists {
                 negated,
                 subquery: Box::new(self.new_context_scope(|planner| planner.select_to_plan(*subquery))?),

qurious/src/utils/type_coercion.rs

@@ -58,15 +58,32 @@ fn coercion_types(lhs: &DataType, op: &Operator, rhs: &DataType) -> Result<Binar
                     rhs: rhs.clone(),
                     ret: DataType::Boolean,
                 }),
-                // Decimal comparisons against integral types: cast integral to decimal with scale 0.
-                (Decimal128(_, _), Int8 | Int16 | Int32 | Int64) => Ok(BinaryTypes {
-                    lhs: lhs.clone(),
-                    rhs: coerce_numeric_type_to_decimal(rhs)?,
+                // Decimal comparisons against integral types: cast the integral side to the SAME decimal
+                // precision/scale as the decimal side. Arrow doesn't allow comparing decimals with differing
+                // precision/scale (e.g. Decimal128(15,2) < Decimal128(20,0)).
+                (Decimal128(p, s), Int8 | Int16 | Int32 | Int64) => Ok(BinaryTypes {
+                    lhs: DataType::Decimal128(*p, *s),
+                    rhs: DataType::Decimal128(*p, *s),
                     ret: DataType::Boolean,
                 }),
-                (Int8 | Int16 | Int32 | Int64, Decimal128(_, _)) => Ok(BinaryTypes {
-                    lhs: coerce_numeric_type_to_decimal(lhs)?,
-                    rhs: rhs.clone(),
+                (Int8 | Int16 | Int32 | Int64, Decimal128(p, s)) => Ok(BinaryTypes {
+                    lhs: DataType::Decimal128(*p, *s),
+                    rhs: DataType::Decimal128(*p, *s),
+                    ret: DataType::Boolean,
+                }),
+                // Decimal comparisons against float types: cast float to the same decimal type as the decimal side.
+                //
+                // This is important for predicates like:
+                //   decimal_col BETWEEN 0.06 - 0.01 AND 0.06 + 0.01
+                // where the RHS is parsed as Float64 literals.
+                (Decimal128(p, s), Float32 | Float64) => Ok(BinaryTypes {
+                    lhs: DataType::Decimal128(*p, *s),
+                    rhs: DataType::Decimal128(*p, *s),
+                    ret: DataType::Boolean,
+                }),
+                (Float32 | Float64, Decimal128(p, s)) => Ok(BinaryTypes {
+                    lhs: DataType::Decimal128(*p, *s),
+                    rhs: DataType::Decimal128(*p, *s),
                     ret: DataType::Boolean,
                 }),
                 // Fallback: keep as-is (may error later if Arrow can't compare them)

qurious/tests/tpch/q5.slt

@@ -0,0 +1,31 @@
+query TR
+select
+    n_name,
+    sum(l_extendedprice * (1 - l_discount)) as revenue
+from
+    customer,
+    orders,
+    lineitem,
+    supplier,
+    nation,
+    region
+where
+        c_custkey = o_custkey
+  and l_orderkey = o_orderkey
+  and l_suppkey = s_suppkey
+  and c_nationkey = s_nationkey
+  and s_nationkey = n_nationkey
+  and n_regionkey = r_regionkey
+  and r_name = 'ASIA'
+  and o_orderdate >= date '1994-01-01'
+  and o_orderdate < date '1995-01-01'
+group by
+    n_name
+order by
+    revenue desc;
+----
+VIETNAM   1000926.6999
+CHINA     740210.7570 
+JAPAN     660651.2425 
+INDONESIA 566379.5276 
+INDIA     422874.6844 

qurious/tests/tpch/q6.slt

@@ -0,0 +1,12 @@
+query R
+select
+    sum(l_extendedprice * l_discount) as revenue
+from
+    lineitem
+where
+        l_shipdate >= date '1994-01-01'
+  and l_shipdate < date '1995-01-01'
+  and l_discount between 0.06 - 0.01 and 0.06 + 0.01
+  and l_quantity < 24;
+----
+1193053.2253

sqlparser/src/ast.rs

@@ -673,6 +673,13 @@ pub enum Expression {
         left: Box<Expression>,
         right: Box<Expression>,
     },
+    /// `[ NOT ] BETWEEN <low> AND <high>`
+    Between {
+        negated: bool,
+        expr: Box<Expression>,
+        low: Box<Expression>,
+        high: Box<Expression>,
+    },
     /// `INTERVAL <expr> <field>`
     Interval {
         expr: Box<Expression>,
@@ -811,6 +818,21 @@ impl Display for Expression {
             Expression::Like { negated, left, right } => {
                 write!(f, "{} {} LIKE {}", left, if *negated { "NOT" } else { "" }, right)
             }
+            Expression::Between {
+                negated,
+                expr,
+                low,
+                high,
+            } => {
+                write!(
+                    f,
+                    "{} {} BETWEEN {} AND {}",
+                    expr,
+                    if *negated { "NOT" } else { "" },
+                    low,
+                    high
+                )
+            }
             Expression::Interval { expr, field } => write!(f, "INTERVAL {} {}", expr, field),
             Expression::Exists { subquery, negated } => {
                 write!(f, "{} EXISTS ({})", if *negated { "NOT" } else { "" }, subquery)

sqlparser/src/parser.rs

@@ -875,6 +875,18 @@ impl<'a> Parser<'a> {
                     left: Box::new(lhs),
                     right: self.parse_expression(infix.precedence()).map(Box::new)?,
                 },
+                InfixOperator::Between => {
+                    let low = self.parse_expression(infix.precedence())?;
+                    self.next_except(TokenType::Keyword(Keyword::And))?;
+                    let high = self.parse_expression(infix.precedence())?;
+
+                    Expression::Between {
+                        negated,
+                        expr: Box::new(lhs),
+                        low: Box::new(low),
+                        high: Box::new(high),
+                    }
+                }
                 InfixOperator::In => self.parse_in_expr(lhs, negated)?,
                 InfixOperator::DoubleColon => self.parse_data_type().map(|dt| Expression::Cast {
                     expr: Box::new(lhs),
@@ -1253,6 +1265,7 @@ enum InfixOperator {
     And,
     Or,
     In,
+    Between,
     DoubleColon,
     Is,
     Like,
@@ -1275,6 +1288,7 @@ impl Operator for InfixOperator {
             TokenType::Keyword(Keyword::And) => Some(InfixOperator::And),
             TokenType::Keyword(Keyword::Or) => Some(InfixOperator::Or),
             TokenType::Keyword(Keyword::In) => Some(InfixOperator::In),
+            TokenType::Keyword(Keyword::Between) => Some(InfixOperator::Between),
             TokenType::Keyword(Keyword::Is) => Some(InfixOperator::Is),
             TokenType::Keyword(Keyword::Like) => Some(InfixOperator::Like),
             _ => None,
@@ -1285,7 +1299,7 @@ impl Operator for InfixOperator {
         match self {
             InfixOperator::Or => 1,
             InfixOperator::And => 2,
-            InfixOperator::Eq | InfixOperator::NotEq | InfixOperator::Like => 3,
+            InfixOperator::Eq | InfixOperator::NotEq | InfixOperator::Like | InfixOperator::Between => 3,
             InfixOperator::Gt | InfixOperator::Gte | InfixOperator::Lt | InfixOperator::Lte => 4,
             InfixOperator::Add | InfixOperator::Sub => 5,
             InfixOperator::Mul | InfixOperator::Div => 6,
@@ -4584,6 +4598,35 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_parse_between_expression() {
+        let stmt = parse_stmt("SELECT * FROM tbl WHERE id BETWEEN 1 AND 3").unwrap();
+
+        assert_eq!(
+            stmt,
+            ast::Statement::Select(Box::new(ast::Select {
+                with: None,
+                distinct: None,
+                columns: vec![ast::SelectItem::Wildcard],
+                from: vec![ast::From::Table {
+                    name: "tbl".to_owned(),
+                    alias: None
+                }],
+                r#where: Some(ast::Expression::Between {
+                    negated: false,
+                    expr: Box::new(ast::Expression::Identifier("id".into())),
+                    low: Box::new(ast::Expression::Literal(ast::Literal::Int(1))),
+                    high: Box::new(ast::Expression::Literal(ast::Literal::Int(3))),
+                }),
+                group_by: None,
+                having: None,
+                order_by: None,
+                limit: None,
+                offset: None,
+            }))
+        );
+    }
+
     fn parse_stmt(input: &str) -> Result<Statement> {
         let mut parser = Parser::new(input);
         parser.parse()

sqlparser/src/token.rs

@@ -41,6 +41,7 @@ pub enum Keyword {
     Distinct,
     Having,
     In,
+    Between,
     On,
     As,
     Is,
@@ -179,6 +180,7 @@ impl TokenType {
             "on" => TokenType::Keyword(Keyword::On),
             "set" => TokenType::Keyword(Keyword::Set),
             "in" => TokenType::Keyword(Keyword::In),
+            "between" => TokenType::Keyword(Keyword::Between),
             "distinct" => TokenType::Keyword(Keyword::Distinct),
             "having" => TokenType::Keyword(Keyword::Having),
             "true" => TokenType::Keyword(Keyword::True),