clippy: apply suggestions

datafusion/core/src/datasource/avro_to_arrow/arrow_array_reader.rs

@@ -60,7 +60,7 @@ pub struct AvroArrowArrayReader<'a, R: Read> {
     schema_lookup: BTreeMap<String, usize>,
 }
 
-impl<'a, R: Read> AvroArrowArrayReader<'a, R> {
+impl<R: Read> AvroArrowArrayReader<'_, R> {
     pub fn try_new(
         reader: R,
         schema: SchemaRef,

datafusion/core/src/datasource/avro_to_arrow/reader.rs

@@ -128,7 +128,7 @@ pub struct Reader<'a, R: Read> {
     batch_size: usize,
 }
 
-impl<'a, R: Read> Reader<'a, R> {
+impl<R: Read> Reader<'_, R> {
     /// Create a new Avro Reader from any value that implements the `Read` trait.
     ///
     /// If reading a `File`, you can customise the Reader, such as to enable schema
@@ -157,7 +157,7 @@ impl<'a, R: Read> Reader<'a, R> {
     }
 }
 
-impl<'a, R: Read> Iterator for Reader<'a, R> {
+impl<R: Read> Iterator for Reader<'_, R> {
     type Item = ArrowResult<RecordBatch>;
 
     /// Returns the next batch of results (defined by `self.batch_size`), or `None` if there

datafusion/execution/src/metrics/value.rs

@@ -313,7 +313,7 @@ pub struct ScopedTimerGuard<'a> {
     start: Option<Instant>,
 }
 
-impl<'a> ScopedTimerGuard<'a> {
+impl ScopedTimerGuard<'_> {
     /// Stop the timer timing and record the time taken
     pub fn stop(&mut self) {
         if let Some(start) = self.start.take() {
@@ -332,7 +332,7 @@ impl<'a> ScopedTimerGuard<'a> {
     }
 }
 
-impl<'a> Drop for ScopedTimerGuard<'a> {
+impl Drop for ScopedTimerGuard<'_> {
     fn drop(&mut self) {
         self.stop()
     }

datafusion/expr/src/expr.rs

@@ -1865,7 +1865,7 @@ macro_rules! expr_vec_fmt {
 }
 
 struct SchemaDisplay<'a>(&'a Expr);
-impl<'a> Display for SchemaDisplay<'a> {
+impl Display for SchemaDisplay<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self.0 {
             // The same as Display

datafusion/expr/src/logical_plan/ddl.rs

@@ -122,7 +122,7 @@ impl DdlStatement {
     /// See [crate::LogicalPlan::display] for an example
     pub fn display(&self) -> impl fmt::Display + '_ {
         struct Wrapper<'a>(&'a DdlStatement);
-        impl<'a> Display for Wrapper<'a> {
+        impl Display for Wrapper<'_> {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 match self.0 {
                     DdlStatement::CreateExternalTable(CreateExternalTable {

datafusion/expr/src/logical_plan/display.rs

@@ -112,7 +112,7 @@ impl<'n, 'a, 'b> TreeNodeVisitor<'n> for IndentVisitor<'a, 'b> {
 pub fn display_schema(schema: &Schema) -> impl fmt::Display + '_ {
     struct Wrapper<'a>(&'a Schema);
 
-    impl<'a> fmt::Display for Wrapper<'a> {
+    impl fmt::Display for Wrapper<'_> {
         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
             write!(f, "[")?;
             for (idx, field) in self.0.fields().iter().enumerate() {

datafusion/expr/src/logical_plan/plan.rs

@@ -1530,7 +1530,7 @@ impl LogicalPlan {
         // Boilerplate structure to wrap LogicalPlan with something
         // that that can be formatted
         struct Wrapper<'a>(&'a LogicalPlan);
-        impl<'a> Display for Wrapper<'a> {
+        impl Display for Wrapper<'_> {
             fn fmt(&self, f: &mut Formatter) -> fmt::Result {
                 let with_schema = false;
                 let mut visitor = IndentVisitor::new(f, with_schema);
@@ -1573,7 +1573,7 @@ impl LogicalPlan {
         // Boilerplate structure to wrap LogicalPlan with something
         // that that can be formatted
         struct Wrapper<'a>(&'a LogicalPlan);
-        impl<'a> Display for Wrapper<'a> {
+        impl Display for Wrapper<'_> {
             fn fmt(&self, f: &mut Formatter) -> fmt::Result {
                 let with_schema = true;
                 let mut visitor = IndentVisitor::new(f, with_schema);
@@ -1593,7 +1593,7 @@ impl LogicalPlan {
         // Boilerplate structure to wrap LogicalPlan with something
         // that that can be formatted
         struct Wrapper<'a>(&'a LogicalPlan);
-        impl<'a> Display for Wrapper<'a> {
+        impl Display for Wrapper<'_> {
             fn fmt(&self, f: &mut Formatter) -> fmt::Result {
                 let mut visitor = PgJsonVisitor::new(f);
                 visitor.with_schema(true);
@@ -1639,7 +1639,7 @@ impl LogicalPlan {
         // Boilerplate structure to wrap LogicalPlan with something
         // that that can be formatted
         struct Wrapper<'a>(&'a LogicalPlan);
-        impl<'a> Display for Wrapper<'a> {
+        impl Display for Wrapper<'_> {
             fn fmt(&self, f: &mut Formatter) -> fmt::Result {
                 let mut visitor = GraphvizVisitor::new(f);
 
@@ -1690,7 +1690,7 @@ impl LogicalPlan {
         // Boilerplate structure to wrap LogicalPlan with something
         // that that can be formatted
         struct Wrapper<'a>(&'a LogicalPlan);
-        impl<'a> Display for Wrapper<'a> {
+        impl Display for Wrapper<'_> {
             fn fmt(&self, f: &mut Formatter) -> fmt::Result {
                 match self.0 {
                     LogicalPlan::EmptyRelation(_) => write!(f, "EmptyRelation"),

datafusion/expr/src/logical_plan/statement.rs

@@ -62,7 +62,7 @@ impl Statement {
     /// See [crate::LogicalPlan::display] for an example
     pub fn display(&self) -> impl fmt::Display + '_ {
         struct Wrapper<'a>(&'a Statement);
-        impl<'a> Display for Wrapper<'a> {
+        impl Display for Wrapper<'_> {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 match self.0 {
                     Statement::TransactionStart(TransactionStart {

datafusion/expr/src/simplify.rs

@@ -71,7 +71,7 @@ impl<'a> SimplifyContext<'a> {
     }
 }
 
-impl<'a> SimplifyInfo for SimplifyContext<'a> {
+impl SimplifyInfo for SimplifyContext<'_> {
     /// returns true if this Expr has boolean type
     fn is_boolean_type(&self, expr: &Expr) -> Result<bool> {
         if let Some(schema) = &self.schema {

datafusion/expr/src/udwf.rs

@@ -496,7 +496,7 @@ impl WindowUDFImpl for AliasedWindowUDFImpl {
         let inner = self.inner.resolve_placeholders(param_values)?;
         Ok(if let Some(inner) = inner {
             Some(Arc::new(Self {
-                inner: inner,
+                inner,
                 aliases: self.aliases.clone(),
             }))
         } else {

datafusion/functions-aggregate-common/src/merge_arrays.rs

@@ -65,7 +65,7 @@ impl<'a> CustomElement<'a> {
 // Overwrite ordering implementation such that
 // - `self.ordering` values are used for comparison,
 // - When used inside `BinaryHeap` it is a min-heap.
-impl<'a> Ord for CustomElement<'a> {
+impl Ord for CustomElement<'_> {
     fn cmp(&self, other: &Self) -> Ordering {
         // Compares according to custom ordering
         self.ordering(&self.ordering, &other.ordering)
@@ -78,7 +78,7 @@ impl<'a> Ord for CustomElement<'a> {
     }
 }
 
-impl<'a> PartialOrd for CustomElement<'a> {
+impl PartialOrd for CustomElement<'_> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
     }

datafusion/functions-nested/src/planner.rs

@@ -184,5 +184,5 @@ impl ExprPlanner for FieldAccessPlanner {
 }
 
 fn is_array_agg(agg_func: &datafusion_expr::expr::AggregateFunction) -> bool {
-    return agg_func.func.name() == "array_agg";
+    agg_func.func.name() == "array_agg"
 }

datafusion/functions/src/string/common.rs

@@ -259,7 +259,7 @@ pub(crate) enum ColumnarValueRef<'a> {
     NonNullableStringViewArray(&'a StringViewArray),
 }
 
-impl<'a> ColumnarValueRef<'a> {
+impl ColumnarValueRef<'_> {
     #[inline]
     pub fn is_valid(&self, i: usize) -> bool {
         match &self {

datafusion/optimizer/src/analyzer/type_coercion.rs

@@ -257,7 +257,7 @@ impl<'a> TypeCoercionRewriter<'a> {
     }
 }
 
-impl<'a> TreeNodeRewriter for TypeCoercionRewriter<'a> {
+impl TreeNodeRewriter for TypeCoercionRewriter<'_> {
     type Node = Expr;
 
     fn f_up(&mut self, expr: Expr) -> Result<Transformed<Expr>> {

datafusion/optimizer/src/join_key_set.rs

@@ -148,7 +148,7 @@ impl<'a> ExprPair<'a> {
     }
 }
 
-impl<'a> Equivalent<(Expr, Expr)> for ExprPair<'a> {
+impl Equivalent<(Expr, Expr)> for ExprPair<'_> {
     fn equivalent(&self, other: &(Expr, Expr)) -> bool {
         self.0 == &other.0 && self.1 == &other.1
     }

datafusion/optimizer/src/optimizer.rs

@@ -308,7 +308,7 @@ impl<'a> Rewriter<'a> {
     }
 }
 
-impl<'a> TreeNodeRewriter for Rewriter<'a> {
+impl TreeNodeRewriter for Rewriter<'_> {
     type Node = LogicalPlan;
 
     fn f_down(&mut self, node: LogicalPlan) -> Result<Transformed<LogicalPlan>> {

datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs

@@ -484,7 +484,7 @@ enum ConstSimplifyResult {
     SimplifyRuntimeError(DataFusionError, Expr),
 }
 
-impl<'a> TreeNodeRewriter for ConstEvaluator<'a> {
+impl TreeNodeRewriter for ConstEvaluator<'_> {
     type Node = Expr;
 
     fn f_down(&mut self, expr: Expr) -> Result<Transformed<Expr>> {
@@ -705,7 +705,7 @@ impl<'a, S> Simplifier<'a, S> {
     }
 }
 
-impl<'a, S: SimplifyInfo> TreeNodeRewriter for Simplifier<'a, S> {
+impl<S: SimplifyInfo> TreeNodeRewriter for Simplifier<'_, S> {
     type Node = Expr;
 
     /// rewrite the expression simplifying any constant expressions

datafusion/optimizer/src/simplify_expressions/guarantees.rs

@@ -57,7 +57,7 @@ impl<'a> GuaranteeRewriter<'a> {
     }
 }
 
-impl<'a> TreeNodeRewriter for GuaranteeRewriter<'a> {
+impl TreeNodeRewriter for GuaranteeRewriter<'_> {
     type Node = Expr;
 
     fn f_up(&mut self, expr: Expr) -> Result<Transformed<Expr>> {

datafusion/physical-expr-common/src/binary_view_map.rs

@@ -113,7 +113,7 @@ impl ArrowBytesViewSet {
 /// This map is used by the special `COUNT DISTINCT` aggregate function to
 /// store the distinct values, and by the `GROUP BY` operator to store
 /// group values when they are a single string array.
-
+///
 pub struct ArrowBytesViewMap<V>
 where
     V: Debug + PartialEq + Eq + Clone + Copy + Default,

datafusion/physical-expr-common/src/sort_expr.rs

@@ -105,7 +105,7 @@ impl PhysicalSortExpr {
     /// Returns a [`Display`]able list of `PhysicalSortExpr`.
     pub fn format_list(input: &[PhysicalSortExpr]) -> impl Display + '_ {
         struct DisplayableList<'a>(&'a [PhysicalSortExpr]);
-        impl<'a> Display for DisplayableList<'a> {
+        impl Display for DisplayableList<'_> {
             fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                 let mut first = true;
                 for sort_expr in self.0 {
@@ -155,7 +155,7 @@ impl From<PhysicalSortRequirement> for PhysicalSortExpr {
     /// If options is `None`, the default sort options `ASC, NULLS LAST` is used.
     ///
     /// The default is picked to be consistent with
-    /// PostgreSQL: <https://www.postgresql.org/docs/current/queries-order.html>    
+    /// PostgreSQL: <https://www.postgresql.org/docs/current/queries-order.html>
     fn from(value: PhysicalSortRequirement) -> Self {
         let options = value.options.unwrap_or(SortOptions {
             descending: false,
@@ -207,9 +207,9 @@ impl PhysicalSortRequirement {
     /// Returns whether this requirement is equal or more specific than `other`.
     pub fn compatible(&self, other: &PhysicalSortRequirement) -> bool {
         self.expr.eq(&other.expr)
-            && other.options.map_or(true, |other_opts| {
-                self.options.map_or(false, |opts| opts == other_opts)
-            })
+            && other
+                .options
+                .map_or(true, |other_opts| self.options == Some(other_opts))
     }
 
     /// Returns [`PhysicalSortRequirement`] that requires the exact

datafusion/physical-expr/src/aggregate.rs

@@ -539,10 +539,8 @@ impl AggregateFunctionExpr {
         param_values: &Option<ParamValues>,
     ) -> Result<Option<Arc<Self>>> {
         Ok(
-            if let Some(resolved_args) =
-                resolve_placeholders_seq(&self.args, param_values)?
-            {
-                Some(Arc::new(AggregateFunctionExpr {
+            resolve_placeholders_seq(&self.args, param_values)?.map(|resolved_args| {
+                Arc::new(AggregateFunctionExpr {
                     fun: self.fun.clone(),
                     args: resolved_args,
                     data_type: self.data_type.clone(),
@@ -555,11 +553,8 @@ impl AggregateFunctionExpr {
                     is_reversed: self.is_reversed,
                     input_types: self.input_types.clone(),
                     is_nullable: self.is_nullable,
-                }))
-            } else {
-                // Args do not contain placeholders at all.
-                None
-            },
+                })
+            }),
         )
     }
 }

datafusion/physical-expr/src/expressions/in_list.rs

@@ -244,7 +244,7 @@ trait IsEqual: HashValue {
     fn is_equal(&self, other: &Self) -> bool;
 }
 
-impl<'a, T: IsEqual + ?Sized> IsEqual for &'a T {
+impl<T: IsEqual + ?Sized> IsEqual for &T {
     fn is_equal(&self, other: &Self) -> bool {
         T::is_equal(self, other)
     }

datafusion/physical-expr/src/expressions/placeholder.rs

@@ -123,7 +123,7 @@ pub fn resolve_placeholders(
         param_values: &'a Option<ParamValues>,
     }
 
-    impl<'a> TreeNodeRewriter for PlaceholderRewriter<'a> {
+    impl TreeNodeRewriter for PlaceholderRewriter<'_> {
         type Node = Arc<dyn PhysicalExpr>;
 
         fn f_up(&mut self, node: Self::Node) -> Result<Transformed<Self::Node>> {
@@ -132,7 +132,7 @@ pub fn resolve_placeholders(
                     if let Some(param_values) = self.param_values {
                         /* Extract a value and cast to the target type. */
                         let value = param_values
-                            .get_placeholders_with_values(&id)?
+                            .get_placeholders_with_values(id)?
                             .cast_to(data_type)?;
                         Ok(Transformed::yes(lit(value)))
                     } else {
@@ -145,9 +145,7 @@ pub fn resolve_placeholders(
         }
     }
 
-    let rewrited = Arc::clone(&expr).rewrite(&mut PlaceholderRewriter {
-        param_values: &param_values,
-    })?;
+    let rewrited = Arc::clone(expr).rewrite(&mut PlaceholderRewriter { param_values })?;
 
     Ok((rewrited.data, rewrited.transformed))
 }

datafusion/physical-expr/src/utils/guarantee.rs

@@ -124,7 +124,7 @@ impl LiteralGuarantee {
             // for an `AND` conjunction to be true, all terms individually must be true
             .fold(GuaranteeBuilder::new(), |builder, expr| {
                 if let Some(cel) = ColOpLit::try_new(expr) {
-                    return builder.aggregate_conjunct(cel);
+                    builder.aggregate_conjunct(cel)
                 } else if let Some(inlist) = expr
                     .as_any()
                     .downcast_ref::<crate::expressions::InListExpr>()

datafusion/physical-expr/src/utils/mod.rs

@@ -147,9 +147,7 @@ struct PhysicalExprDAEGBuilder<'a, T, F: Fn(&ExprTreeNode<NodeIndex>) -> Result<
     constructor: &'a F,
 }
 
-impl<'a, T, F: Fn(&ExprTreeNode<NodeIndex>) -> Result<T>>
-    PhysicalExprDAEGBuilder<'a, T, F>
-{
+impl<T, F: Fn(&ExprTreeNode<NodeIndex>) -> Result<T>> PhysicalExprDAEGBuilder<'_, T, F> {
     // This method mutates an expression node by transforming it to a physical expression
     // and adding it to the graph. The method returns the mutated expression node.
     fn mutate(

datafusion/physical-expr/src/window/aggregate.rs

@@ -94,14 +94,14 @@ pub(super) fn resolve_physical_sort_placeholders(
         }
         resolved_exprs.push(PhysicalSortExpr {
             expr: resolved,
-            options: expr.options.clone(),
+            options: expr.options,
         });
         for j in (i + 1)..exprs.len() {
             let e = &exprs[j];
             let (resolved, _) = resolve_placeholders(&e.expr, param_values)?;
             resolved_exprs.push(PhysicalSortExpr {
                 expr: resolved,
-                options: e.options.clone(),
+                options: e.options,
             });
         }
     }

datafusion/physical-expr/src/window/nth_value.rs

@@ -160,7 +160,7 @@ impl BuiltInWindowFunctionExpr for NthValue {
                 name: self.name.clone(),
                 expr: resolved,
                 data_type: self.data_type.clone(),
-                kind: self.kind.clone(),
+                kind: self.kind,
                 ignore_nulls: self.ignore_nulls,
             }))
         } else {