impl From<Condition> and From<ConditionExpression> for SimpleExpr (#886)

Author: Expurple

src/backend/query_builder.rs

@@ -1389,7 +1389,7 @@ pub trait QueryBuilder:
     #[doc(hidden)]
     /// Translate part of a condition to part of a "WHERE" clause.
     fn prepare_condition_where(&self, condition: &Condition, sql: &mut dyn SqlWriter) {
-        let simple_expr = condition.to_simple_expr();
+        let simple_expr = condition.clone().into();
         self.prepare_simple_expr(&simple_expr, sql);
     }
 

src/query/condition.rs

@@ -260,39 +260,50 @@ impl Condition {
     pub fn len(&self) -> usize {
         self.conditions.len()
     }
+}
 
-    pub(crate) fn to_simple_expr(&self) -> SimpleExpr {
+impl From<Condition> for SimpleExpr {
+    fn from(cond: Condition) -> Self {
         let mut inner_exprs = vec![];
-        for ce in &self.conditions {
+        for ce in cond.conditions {
             inner_exprs.push(match ce {
-                ConditionExpression::Condition(c) => c.to_simple_expr(),
-                ConditionExpression::SimpleExpr(e) => e.clone(),
+                ConditionExpression::Condition(c) => c.into(),
+                ConditionExpression::SimpleExpr(e) => e,
             });
         }
         let mut inner_exprs_into_iter = inner_exprs.into_iter();
         let expr = if let Some(first_expr) = inner_exprs_into_iter.next() {
             let mut out_expr = first_expr;
             for e in inner_exprs_into_iter {
-                out_expr = match self.condition_type {
+                out_expr = match cond.condition_type {
                     ConditionType::Any => out_expr.or(e),
                     ConditionType::All => out_expr.and(e),
                 };
             }
             out_expr
         } else {
-            SimpleExpr::Constant(match self.condition_type {
+            SimpleExpr::Constant(match cond.condition_type {
                 ConditionType::Any => false.into(),
                 ConditionType::All => true.into(),
             })
         };
-        if self.negate {
+        if cond.negate {
             expr.not()
         } else {
             expr
         }
     }
 }
 
+impl From<ConditionExpression> for SimpleExpr {
+    fn from(ce: ConditionExpression) -> Self {
+        match ce {
+            ConditionExpression::Condition(c) => c.into(),
+            ConditionExpression::SimpleExpr(e) => e,
+        }
+    }
+}
+
 impl From<Condition> for ConditionExpression {
     fn from(condition: Condition) -> Self {
         ConditionExpression::Condition(condition)