fix clippy

Author: FANNG1

crates/iceberg/src/expr/predicate.rs

@@ -180,7 +180,7 @@ impl<T: Debug> Debug for BinaryExpression<T> {
 }
 
 impl<T> BinaryExpression<T> {
-    /// Creates a binary expression with the given operator and term.
+    /// Creates a binary expression with the given operator, term and literal.
     ///
     /// # Example
     ///

crates/integrations/datafusion/src/physical_plan/expr_to_predicate.rs

@@ -24,7 +24,7 @@ use iceberg::spec::Datum;
 
 // A datafusion expression could be an Iceberg predicate, column, or literal.
 enum TransformedResult {
-    Predication(Predicate),
+    Predicate(Predicate),
     Column(Reference),
     Literal(Datum),
     NotTransformed,
@@ -49,7 +49,7 @@ pub fn convert_filters_to_predicate(filters: &[Expr]) -> Option<Predicate> {
 
 fn convert_filter_to_predicate(expr: &Expr) -> Option<Predicate> {
     match to_iceberg_predicate(expr) {
-        TransformedResult::Predication(predicate) => Some(predicate),
+        TransformedResult::Predicate(predicate) => Some(predicate),
         TransformedResult::Column(_) | TransformedResult::Literal(_) => {
             unreachable!("Not a valid expression: {:?}", expr)
         }
@@ -60,11 +60,11 @@ fn convert_filter_to_predicate(expr: &Expr) -> Option<Predicate> {
 fn to_iceberg_predicate(expr: &Expr) -> TransformedResult {
     match expr {
         Expr::BinaryExpr(binary) => {
-            let left = to_iceberg_predicate(&binary.left.clone());
-            let right = to_iceberg_predicate(&binary.right.clone());
+            let left = to_iceberg_predicate(&binary.left);
+            let right = to_iceberg_predicate(&binary.right);
             let op = to_iceberg_operation(binary.op);
             match op {
-                OpTransformedResult::Operator(op) => to_iceberg_binary_expr(left, right, op),
+                OpTransformedResult::Operator(op) => to_iceberg_binary_predicate(left, right, op),
                 OpTransformedResult::And => to_iceberg_and_predicate(left, right),
                 OpTransformedResult::Or => to_iceberg_or_predicate(left, right),
                 OpTransformedResult::NotTransformed => TransformedResult::NotTransformed,
@@ -73,7 +73,7 @@ fn to_iceberg_predicate(expr: &Expr) -> TransformedResult {
         Expr::Not(exp) => {
             let expr = to_iceberg_predicate(exp);
             match expr {
-                TransformedResult::Predication(p) => TransformedResult::Predication(!p),
+                TransformedResult::Predicate(p) => TransformedResult::Predicate(!p),
                 _ => TransformedResult::NotTransformed,
             }
         }
@@ -95,16 +95,16 @@ fn to_iceberg_predicate(expr: &Expr) -> TransformedResult {
             let expr = to_iceberg_predicate(&inlist.expr);
             match expr {
                 TransformedResult::Column(r) => match inlist.negated {
-                    false => TransformedResult::Predication(r.is_in(datums)),
-                    true => TransformedResult::Predication(r.is_not_in(datums)),
+                    false => TransformedResult::Predicate(r.is_in(datums)),
+                    true => TransformedResult::Predicate(r.is_not_in(datums)),
                 },
                 _ => TransformedResult::NotTransformed,
             }
         }
         Expr::IsNull(expr) => {
             let p = to_iceberg_predicate(expr);
             match p {
-                TransformedResult::Column(r) => TransformedResult::Predication(Predicate::Unary(
+                TransformedResult::Column(r) => TransformedResult::Predicate(Predicate::Unary(
                     UnaryExpression::new(PredicateOperator::IsNull, r),
                 )),
                 _ => TransformedResult::NotTransformed,
@@ -113,7 +113,7 @@ fn to_iceberg_predicate(expr: &Expr) -> TransformedResult {
         Expr::IsNotNull(expr) => {
             let p = to_iceberg_predicate(expr);
             match p {
-                TransformedResult::Column(r) => TransformedResult::Predication(Predicate::Unary(
+                TransformedResult::Column(r) => TransformedResult::Predicate(Predicate::Unary(
                     UnaryExpression::new(PredicateOperator::NotNull, r),
                 )),
                 _ => TransformedResult::NotTransformed,
@@ -144,25 +144,25 @@ fn to_iceberg_and_predicate(
     right: TransformedResult,
 ) -> TransformedResult {
     match (left, right) {
-        (TransformedResult::Predication(left), TransformedResult::Predication(right)) => {
-            TransformedResult::Predication(left.and(right))
+        (TransformedResult::Predicate(left), TransformedResult::Predicate(right)) => {
+            TransformedResult::Predicate(left.and(right))
         }
-        (TransformedResult::Predication(left), _) => TransformedResult::Predication(left),
-        (_, TransformedResult::Predication(right)) => TransformedResult::Predication(right),
+        (TransformedResult::Predicate(left), _) => TransformedResult::Predicate(left),
+        (_, TransformedResult::Predicate(right)) => TransformedResult::Predicate(right),
         _ => TransformedResult::NotTransformed,
     }
 }
 
 fn to_iceberg_or_predicate(left: TransformedResult, right: TransformedResult) -> TransformedResult {
     match (left, right) {
-        (TransformedResult::Predication(left), TransformedResult::Predication(right)) => {
-            TransformedResult::Predication(left.or(right))
+        (TransformedResult::Predicate(left), TransformedResult::Predicate(right)) => {
+            TransformedResult::Predicate(left.or(right))
         }
         _ => TransformedResult::NotTransformed,
     }
 }
 
-fn to_iceberg_binary_expr(
+fn to_iceberg_binary_predicate(
     left: TransformedResult,
     right: TransformedResult,
     op: PredicateOperator,
@@ -176,7 +176,7 @@ fn to_iceberg_binary_expr(
         }
         _ => return TransformedResult::NotTransformed,
     };
-    TransformedResult::Predication(Predicate::Binary(BinaryExpression::new(op, r, d)))
+    TransformedResult::Predicate(Predicate::Binary(BinaryExpression::new(op, r, d)))
 }
 
 fn reserve_predicate_operator(op: PredicateOperator) -> PredicateOperator {