mtrlz/sql: extract BETWEEN planning into its own function

Author: benesch

src/materialize/sql/mod.rs

@@ -1053,6 +1053,12 @@ impl Planner {
             ASTNode::SQLBinaryExpr { op, left, right } => {
                 self.plan_binary_expr(ctx, op, left, right, plan)
             }
+            ASTNode::SQLBetween {
+                expr,
+                low,
+                high,
+                negated,
+            } => self.plan_between(ctx, expr, low, high, *negated, plan),
             ASTNode::SQLNested(expr) => self.plan_expr(ctx, expr, plan),
             ASTNode::SQLFunction {
                 name,
@@ -1061,41 +1067,6 @@ impl Planner {
                 all,
                 distinct,
             } => self.plan_function(ctx, name, args, over, *all, *distinct, plan),
-            ASTNode::SQLBetween {
-                expr,
-                low,
-                high,
-                negated,
-            } => {
-                let low = ASTNode::SQLBinaryExpr {
-                    left: expr.clone(),
-                    op: if *negated {
-                        SQLOperator::Lt
-                    } else {
-                        SQLOperator::GtEq
-                    },
-                    right: low.clone(),
-                };
-                let high = ASTNode::SQLBinaryExpr {
-                    left: expr.clone(),
-                    op: if *negated {
-                        SQLOperator::Gt
-                    } else {
-                        SQLOperator::LtEq
-                    },
-                    right: high.clone(),
-                };
-                let both = ASTNode::SQLBinaryExpr {
-                    left: Box::new(low),
-                    op: if *negated {
-                        SQLOperator::Or
-                    } else {
-                        SQLOperator::And
-                    },
-                    right: Box::new(high),
-                };
-                self.plan_expr(ctx, &both, plan)
-            }
             _ => bail!(
                 "complicated expressions are not yet supported: {}",
                 e.to_string()
@@ -1301,6 +1272,45 @@ impl Planner {
         Ok((expr, typ))
     }
 
+    fn plan_between<'a>(
+        &self,
+        ctx: &ExprContext,
+        expr: &'a ASTNode,
+        low: &'a ASTNode,
+        high: &'a ASTNode,
+        negated: bool,
+        plan: &SQLPlan,
+    ) -> Result<(Expr, Type), failure::Error> {
+        let low = ASTNode::SQLBinaryExpr {
+            left: Box::new(expr.clone()),
+            op: if negated {
+                SQLOperator::Lt
+            } else {
+                SQLOperator::GtEq
+            },
+            right: Box::new(low.clone()),
+        };
+        let high = ASTNode::SQLBinaryExpr {
+            left: Box::new(expr.clone()),
+            op: if negated {
+                SQLOperator::Gt
+            } else {
+                SQLOperator::LtEq
+            },
+            right: Box::new(high.clone()),
+        };
+        let both = ASTNode::SQLBinaryExpr {
+            left: Box::new(low),
+            op: if negated {
+                SQLOperator::Or
+            } else {
+                SQLOperator::And
+            },
+            right: Box::new(high),
+        };
+        self.plan_expr(ctx, &both, plan)
+    }
+
     fn plan_literal<'a>(&self, l: &'a Value) -> Result<(Expr, Type), failure::Error> {
         let (datum, ftype) = match l {
             Value::Long(i) => (Datum::Int64(*i), FType::Int64),