From 13e084351d094642008caafd0dc3d2eba2d60371 Mon Sep 17 00:00:00 2001
From: PThorpe92 <preston@unlockedlabs.org>
Date: Fri, 4 Apr 2025 12:38:18 -0400
Subject: [PATCH] Change parse_limit function to accept reference value to
 ast::Limit

---
 core/translate/delete.rs  |  2 +-
 core/translate/planner.rs | 23 +++++++++++++----------
 core/translate/select.rs  |  2 +-
 core/translate/update.rs  |  6 +++++-
 4 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/core/translate/delete.rs b/core/translate/delete.rs
index ba841f3ff..9652048fe 100644
--- a/core/translate/delete.rs
+++ b/core/translate/delete.rs
@@ -68,7 +68,7 @@ pub fn prepare_delete_plan(
     )?;
 
     // Parse the LIMIT/OFFSET clause
-    let (resolved_limit, resolved_offset) = limit.map_or(Ok((None, None)), |l| parse_limit(*l))?;
+    let (resolved_limit, resolved_offset) = limit.map_or(Ok((None, None)), |l| parse_limit(&l))?;
 
     let plan = DeletePlan {
         table_references,
diff --git a/core/translate/planner.rs b/core/translate/planner.rs
index 953a15e59..1b78c954c 100644
--- a/core/translate/planner.rs
+++ b/core/translate/planner.rs
@@ -850,30 +850,33 @@ fn parse_join<'a>(
     Ok(())
 }
 
-pub fn parse_limit(limit: Limit) -> Result<(Option<isize>, Option<isize>)> {
-    let offset_val = match limit.offset {
+pub fn parse_limit(limit: &Limit) -> Result<(Option<isize>, Option<isize>)> {
+    let offset_val = match &limit.offset {
         Some(offset_expr) => match offset_expr {
             Expr::Literal(ast::Literal::Numeric(n)) => n.parse().ok(),
             // If OFFSET is negative, the result is as if OFFSET is zero
-            Expr::Unary(UnaryOperator::Negative, expr) => match *expr {
-                Expr::Literal(ast::Literal::Numeric(n)) => n.parse::<isize>().ok().map(|num| -num),
-                _ => crate::bail_parse_error!("Invalid OFFSET clause"),
-            },
+            Expr::Unary(UnaryOperator::Negative, expr) => {
+                if let Expr::Literal(ast::Literal::Numeric(ref n)) = &**expr {
+                    n.parse::<isize>().ok().map(|num| -num)
+                } else {
+                    crate::bail_parse_error!("Invalid OFFSET clause");
+                }
+            }
             _ => crate::bail_parse_error!("Invalid OFFSET clause"),
         },
         None => Some(0),
     };
 
-    if let Expr::Literal(ast::Literal::Numeric(n)) = limit.expr {
+    if let Expr::Literal(ast::Literal::Numeric(n)) = &limit.expr {
         Ok((n.parse().ok(), offset_val))
-    } else if let Expr::Unary(UnaryOperator::Negative, expr) = limit.expr {
-        if let Expr::Literal(ast::Literal::Numeric(n)) = *expr {
+    } else if let Expr::Unary(UnaryOperator::Negative, expr) = &limit.expr {
+        if let Expr::Literal(ast::Literal::Numeric(n)) = &**expr {
             let limit_val = n.parse::<isize>().ok().map(|num| -num);
             Ok((limit_val, offset_val))
         } else {
             crate::bail_parse_error!("Invalid LIMIT clause");
         }
-    } else if let Expr::Id(id) = limit.expr {
+    } else if let Expr::Id(id) = &limit.expr {
         if id.0.eq_ignore_ascii_case("true") {
             Ok((Some(1), offset_val))
         } else if id.0.eq_ignore_ascii_case("false") {
diff --git a/core/translate/select.rs b/core/translate/select.rs
index fe7656f16..bde61880f 100644
--- a/core/translate/select.rs
+++ b/core/translate/select.rs
@@ -370,7 +370,7 @@ pub fn prepare_select_plan<'a>(
 
             // Parse the LIMIT/OFFSET clause
             (plan.limit, plan.offset) =
-                select.limit.map_or(Ok((None, None)), |l| parse_limit(*l))?;
+                select.limit.map_or(Ok((None, None)), |l| parse_limit(&l))?;
 
             // Return the unoptimized query plan
             Ok(Plan::Select(plan))
diff --git a/core/translate/update.rs b/core/translate/update.rs
index 4fd3385e0..f282fff24 100644
--- a/core/translate/update.rs
+++ b/core/translate/update.rs
@@ -151,17 +151,21 @@ pub fn prepare_update_plan(schema: &Schema, body: &mut Update) -> crate::Result<
             })
             .collect()
     });
+    // Parse the WHERE clause
     parse_where(
         body.where_clause.as_ref().map(|w| *w.clone()),
         &table_references,
         Some(&result_columns),
         &mut where_clause,
     )?;
+
+    // Parse the LIMIT/OFFSET clause
     let (limit, offset) = body
         .limit
         .as_ref()
-        .map(|l| parse_limit(*l.clone()))
+        .map(|l| parse_limit(l))
         .unwrap_or(Ok((None, None)))?;
+
     Ok(Plan::Update(UpdatePlan {
         table_references,
         set_clauses,