fix: support old Rust versions

prql-compiler/Cargo.toml

@@ -1,14 +1,13 @@
 [package]
 description = "PRQL is a modern language for transforming data — a simple, powerful, pipelined SQL replacement."
+edition = "2021"
+license = "Apache-2.0"
 name = "prql-compiler"
 
-edition.workspace = true
-license.workspace = true
-repository.workspace = true
-rust-version.workspace = true
-version.workspace = true
+repository = "https://github.com/PRQL/prql"
+version = "0.8.1"
 
-metadata.msrv = "1.65.0"
+metadata.msrv = "1.61.0"
 
 [dependencies]
 anyhow = {version = "1.0.57", features = ["backtrace"]}

prql-compiler/src/semantic/lowering.rs

@@ -492,7 +492,9 @@ impl Lowerer {
     ) -> Result<Vec<CId>> {
         let mut r = Vec::with_capacity(exprs.len());
         for expr in exprs {
-            let pl::ExprKind::All { except, .. } = expr.kind else {
+            let except = if let pl::ExprKind::All { except, .. } = expr.kind {
+                except
+            } else {
                 // base case
                 r.push(self.declare_as_column(expr, is_aggregation)?);
                 continue;

prql-compiler/src/sql/gen_expr.rs

@@ -130,7 +130,9 @@ fn try_into_binary_op(expr: Expr, ctx: &mut Context) -> Result<Result<sql_ast::E
         StringConcat,
     ];
 
-    let Some((decl, _)) = try_unpack(&expr, DECLS)? else {
+    let decl = if let Some((decl, _)) = try_unpack(&expr, DECLS)? {
+        decl
+    } else {
         return Ok(Err(expr));
     };
 
@@ -150,9 +152,12 @@ fn try_into_unary_op(expr: Expr, ctx: &mut Context) -> Result<Result<sql_ast::Ex
     const DECLS: [super::std::FunctionDecl<1>; 2] = [STD_NEG, STD_NOT];
     const OPS: [UnaryOperator; 2] = [Minus, Not];
 
-    let Some((decl, _)) = try_unpack(&expr, DECLS)? else {
+    let decl = if let Some((decl, _)) = try_unpack(&expr, DECLS)? {
+        decl
+    } else {
         return Ok(Err(expr));
     };
+
     // this lookup is O(N), but 13 is not that big of a N
     let decl_index = DECLS.iter().position(|x| x == &decl).unwrap();
     let op = OPS[decl_index];
@@ -191,7 +196,9 @@ fn try_into_concat_function(expr: Expr, ctx: &mut Context) -> Result<Result<sql_
 }
 
 fn try_unpack_concat(expr: Expr) -> Result<Result<Vec<Expr>, Expr>> {
-    let Some((_, _)) = try_unpack(&expr, [STD_CONCAT])? else {
+    let () = if let Some((_, _)) = try_unpack(&expr, [STD_CONCAT])? {
+        ()
+    } else {
         return Ok(Err(expr));
     };
     let [left, right] = unpack(expr, STD_CONCAT);
@@ -531,8 +538,10 @@ pub(super) fn translate_select_item(cid: CId, ctx: &mut Context) -> Result<Selec
 ///
 /// Outer Result contains an error, inner Result contains the unmatched expr.
 fn try_into_is_null(expr: Expr, ctx: &mut Context) -> Result<Result<sql_ast::Expr, Expr>> {
-    let Some((decl, [a, b])) = try_unpack(&expr, [STD_EQ, STD_NE])? else {
-        return Ok(Err(expr))
+    let (decl, a, b) = if let Some((decl, [a, b])) = try_unpack(&expr, [STD_EQ, STD_NE])? {
+        (decl, a, b)
+    } else {
+        return Ok(Err(expr));
     };
 
     let take_a = if matches!(a.kind, ExprKind::Literal(Literal::Null)) {
@@ -565,14 +574,21 @@ fn try_into_is_null(expr: Expr, ctx: &mut Context) -> Result<Result<sql_ast::Exp
 fn try_into_between(expr: Expr, ctx: &mut Context) -> Result<Result<sql_ast::Expr, Expr>> {
     // validate that this expr matches the criteria
 
-    let Some((_, [a, b])) = try_unpack(&expr, [STD_AND])? else {
+    let (a, b) = if let Some((_, [a, b])) = try_unpack(&expr, [STD_AND])? {
+        (a, b)
+    } else {
         return Ok(Err(expr));
     };
 
-    let Some((_, [a_l, _a_r])) = try_unpack(a, [STD_GTE])? else {
+    let (a_l, a_r) = if let Some((_, [a_l, a_r])) = try_unpack(a, [STD_GTE])? {
+        (a_l, a_r)
+    } else {
         return Ok(Err(expr));
     };
-    let Some((_, [b_l, _b_r])) = try_unpack(b, [STD_LTE])? else {
+
+    let (b_l, b_r) = if let Some((_, [b_l, b_r])) = try_unpack(b, [STD_LTE])? {
+        (b_l, b_r)
+    } else {
         return Ok(Err(expr));
     };
 

prql-compiler/src/sql/gen_projection.rs

@@ -27,11 +27,13 @@ pub(super) fn try_into_exprs(
     for cid in cids {
         let decl = ctx.anchor.column_decls.get(&cid).unwrap();
 
-        let ColumnDecl::RelationColumn(tiid, _, RelationColumn::Wildcard) = decl else {
-            // base case
-            res.push(translate_cid(cid, ctx)?);
-            continue;
-        };
+            let tiid = if let ColumnDecl::RelationColumn(tiid, _, RelationColumn::Wildcard) = decl {
+                tiid
+            } else {
+                // base case
+                res.push(translate_cid(cid, ctx)?);
+                continue;
+            };
 
         // star
         let t = &ctx.anchor.table_instances[tiid];
@@ -72,7 +74,11 @@ pub(super) fn translate_wildcards(ctx: &AnchorContext, cols: Vec<CId>) -> (Vec<C
     // requested.
     // This function adds that column to the exclusion list.
     fn exclude(star: &mut Option<(CId, HashSet<CId>)>, excluded: &mut Excluded) {
-        let Some((cid, in_star)) = star.take() else { return };
+        let (cid, in_star) = if let Some((cid, in_star)) = star.take() {
+            (cid, in_star)
+        } else {
+            return;
+        };
         if in_star.is_empty() {
             return;
         }
@@ -128,9 +134,11 @@ pub(super) fn translate_select_items(
         .map(|cid| {
             let decl = ctx.anchor.column_decls.get(&cid).unwrap();
 
-            let ColumnDecl::RelationColumn(tiid, _, RelationColumn::Wildcard) = decl else {
-                // general case
-                return translate_select_item(cid, ctx)
+            let tiid = if let ColumnDecl::RelationColumn(tiid, _, RelationColumn::Wildcard) = decl {
+                tiid
+            } else {
+                // base case
+                return translate_select_item(cid, ctx);
             };
 
             // wildcard case
@@ -161,7 +169,9 @@ fn translate_exclude(
 ) -> Option<WildcardAdditionalOptions> {
     let excluded = as_col_names(&excluded, &ctx.anchor);
 
-    let Some(supported) = ctx.dialect.column_exclude() else {
+    let supported = if let Some(supported) = ctx.dialect.column_exclude() {
+        supported
+    } else {
         // TODO: eventually this should throw an error
         //   I don't want to do this now, because we have no way around it.
         //   We could also ask the user to add table definitions.

prql-compiler/src/sql/preprocess.rs

@@ -238,7 +238,9 @@ pub(super) fn union(pipeline: Vec<SqlTransform>) -> Vec<SqlTransform> {
     let mut res = Vec::with_capacity(pipeline.len());
     let mut pipeline = pipeline.into_iter().peekable();
     while let Some(t) = pipeline.next() {
-        let Super(Append(bottom)) = t else {
+        let bottom = if let Super(Append(bottom)) = t {
+            bottom
+        } else {
             res.push(t);
             continue;
         };
@@ -270,8 +272,21 @@ pub(super) fn except(pipeline: Vec<SqlTransform>, ctx: &Context) -> Result<Vec<S
         if res.len() < 2 {
             continue;
         }
-        let Super(Join { side: JoinSide::Left, filter: join_cond, with }) = &res[res.len() - 2] else { continue };
-        let Super(Filter(filter)) = &res[res.len() - 1] else { continue };
+        let (with, join_cond) = if let Super(Join {
+            side: JoinSide::Left,
+            filter: join_cond,
+            with,
+        }) = &res[res.len() - 2]
+        {
+            (with, join_cond)
+        } else {
+            continue;
+        };
+        let filter = if let Super(Filter(filter)) = &res[res.len() - 1] {
+            filter
+        } else {
+            continue;
+        };
 
         let top = AnchorContext::determine_select_columns(&res[0..res.len() - 2]);
         let bottom = with.columns.iter().map(|(_, c)| *c).collect_vec();
@@ -352,7 +367,16 @@ pub(super) fn intersect(pipeline: Vec<SqlTransform>, ctx: &Context) -> Result<Ve
         if res.is_empty() {
             continue;
         }
-        let Super(Join { side: JoinSide::Inner, filter: join_cond, with }) = &res[res.len() - 1] else { continue };
+        let (with, join_cond) = if let Super(Join {
+            side: JoinSide::Inner,
+            filter: join_cond,
+            with,
+        }) = &res[res.len() - 1]
+        {
+            (with, join_cond)
+        } else {
+            continue;
+        };
 
         let top = AnchorContext::determine_select_columns(&res[0..res.len() - 1]);
         let bottom = with.columns.iter().map(|(_, c)| *c).collect_vec();
@@ -514,7 +538,9 @@ impl RqFold for Normalizer {
             ..expr
         };
 
-        let Some((decl, _)) = super::std::try_unpack(&expr, [super::std::STD_EQ])? else {
+        let decl = if let Some((decl, _)) = super::std::try_unpack(&expr, [super::std::STD_EQ])? {
+            decl
+        } else {
             return Ok(expr);
         };
         let name = decl.name.to_string();