chore(CI) Update workspace / CI to Rust 1.87

Author: kadai0308

datafusion-examples/examples/flight/flight_sql_server.rs

@@ -115,6 +115,7 @@ impl FlightSqlServiceImpl {
         Ok(uuid)
     }
 
+    #[allow(clippy::result_large_err)]
     fn get_ctx<T>(&self, req: &Request<T>) -> Result<Arc<SessionContext>, Status> {
         // get the token from the authorization header on Request
         let auth = req
@@ -140,6 +141,7 @@ impl FlightSqlServiceImpl {
         }
     }
 
+    #[allow(clippy::result_large_err)]
     fn get_plan(&self, handle: &str) -> Result<LogicalPlan, Status> {
         if let Some(plan) = self.statements.get(handle) {
             Ok(plan.clone())
@@ -148,6 +150,7 @@ impl FlightSqlServiceImpl {
         }
     }
 
+    #[allow(clippy::result_large_err)]
     fn get_result(&self, handle: &str) -> Result<Vec<RecordBatch>, Status> {
         if let Some(result) = self.results.get(handle) {
             Ok(result.clone())
@@ -195,11 +198,13 @@ impl FlightSqlServiceImpl {
         .unwrap()
     }
 
+    #[allow(clippy::result_large_err)]
     fn remove_plan(&self, handle: &str) -> Result<(), Status> {
         self.statements.remove(&handle.to_string());
         Ok(())
     }
 
+    #[allow(clippy::result_large_err)]
     fn remove_result(&self, handle: &str) -> Result<(), Status> {
         self.results.remove(&handle.to_string());
         Ok(())

datafusion/common/src/error.rs

@@ -397,7 +397,7 @@ impl Error for DataFusionError {
 
 impl From<DataFusionError> for io::Error {
     fn from(e: DataFusionError) -> Self {
-        io::Error::new(io::ErrorKind::Other, e)
+        io::Error::other(e)
     }
 }
 
@@ -1120,8 +1120,7 @@ mod test {
         );
 
         // assert wrapping other Error
-        let generic_error: GenericError =
-            Box::new(std::io::Error::new(std::io::ErrorKind::Other, "io error"));
+        let generic_error: GenericError = Box::new(std::io::Error::other("io error"));
         let datafusion_error: DataFusionError = generic_error.into();
         println!("{}", datafusion_error.strip_backtrace());
         assert_eq!(
@@ -1132,8 +1131,7 @@ mod test {
 
     #[test]
     fn external_error_no_recursive() {
-        let generic_error_1: GenericError =
-            Box::new(std::io::Error::new(std::io::ErrorKind::Other, "io error"));
+        let generic_error_1: GenericError = Box::new(std::io::Error::other("io error"));
         let external_error_1: DataFusionError = generic_error_1.into();
         let generic_error_2: GenericError = Box::new(external_error_1);
         let external_error_2: DataFusionError = generic_error_2.into();

datafusion/common/src/stats.rs

@@ -352,6 +352,7 @@ impl Statistics {
             return self;
         };
 
+        #[allow(clippy::large_enum_variant)]
         enum Slot {
             /// The column is taken and put into the specified statistics location
             Taken(usize),

datafusion/datasource-avro/src/avro_to_arrow/arrow_array_reader.rs

@@ -21,7 +21,7 @@ use apache_avro::schema::RecordSchema;
 use apache_avro::{
     schema::{Schema as AvroSchema, SchemaKind},
     types::Value,
-    AvroResult, Error as AvroError, Reader as AvroReader,
+    Error as AvroError, Reader as AvroReader,
 };
 use arrow::array::{
     make_array, Array, ArrayBuilder, ArrayData, ArrayDataBuilder, ArrayRef,
@@ -938,40 +938,31 @@ fn resolve_string(v: &Value) -> ArrowResult<Option<String>> {
     .map_err(|e| SchemaError(format!("expected resolvable string : {e:?}")))
 }
 
-fn resolve_u8(v: &Value) -> AvroResult<u8> {
-    let int = match v {
-        Value::Int(n) => Ok(Value::Int(*n)),
-        Value::Long(n) => Ok(Value::Int(*n as i32)),
-        other => Err(AvroError::GetU8(other.into())),
-    }?;
-    if let Value::Int(n) = int {
-        if n >= 0 && n <= From::from(u8::MAX) {
-            return Ok(n as u8);
-        }
-    }
+fn resolve_u8(v: &Value) -> Option<u8> {
+    let v = match v {
+        Value::Union(_, inner) => inner.as_ref(),
+        _ => v,
+    };
 
-    Err(AvroError::GetU8(int.into()))
+    match v {
+        Value::Int(n) => u8::try_from(*n).ok(),
+        Value::Long(n) => u8::try_from(*n).ok(),
+        _ => None,
+    }
 }
 
 fn resolve_bytes(v: &Value) -> Option<Vec<u8>> {
-    let v = if let Value::Union(_, b) = v { b } else { v };
+    let v = match v {
+        Value::Union(_, inner) => inner.as_ref(),
+        _ => v,
+    };
+
     match v {
-        Value::Bytes(_) => Ok(v.clone()),
-        Value::String(s) => Ok(Value::Bytes(s.clone().into_bytes())),
-        Value::Array(items) => Ok(Value::Bytes(
-            items
-                .iter()
-                .map(resolve_u8)
-                .collect::<Result<Vec<_>, _>>()
-                .ok()?,
-        )),
-        other => Err(AvroError::GetBytes(other.into())),
-    }
-    .ok()
-    .and_then(|v| match v {
-        Value::Bytes(s) => Some(s),
+        Value::Bytes(bytes) => Some(bytes.clone()),
+        Value::String(s) => Some(s.as_bytes().to_vec()),
+        Value::Array(items) => items.iter().map(resolve_u8).collect::<Option<Vec<u8>>>(),
         _ => None,
-    })
+    }
 }
 
 fn resolve_fixed(v: &Value, size: usize) -> Option<Vec<u8>> {

datafusion/expr-common/src/accumulator.rs

@@ -42,7 +42,6 @@ use std::fmt::Debug;
 ///   [`state`] and combine the state from multiple accumulators
 ///   via [`merge_batch`], as part of efficient multi-phase grouping.
 ///
-/// [`GroupsAccumulator`]: crate::GroupsAccumulator
 /// [`update_batch`]: Self::update_batch
 /// [`retract_batch`]: Self::retract_batch
 /// [`state`]: Self::state

datafusion/expr/src/planner.rs

@@ -312,6 +312,7 @@ pub struct RawWindowExpr {
 
 /// Result of planning a raw expr with [`ExprPlanner`]
 #[derive(Debug, Clone)]
+#[allow(clippy::large_enum_variant)]
 pub enum PlannerResult<T> {
     /// The raw expression was successfully planned as a new [`Expr`]
     Planned(Expr),

datafusion/expr/src/simplify.rs

@@ -110,6 +110,7 @@ impl SimplifyInfo for SimplifyContext<'_> {
 
 /// Was the expression simplified?
 #[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
 pub enum ExprSimplifyResult {
     /// The function call was simplified to an entirely new Expr
     Simplified(Expr),

datafusion/expr/src/window_state.rs

@@ -193,11 +193,7 @@ impl WindowFrameContext {
             // UNBOUNDED PRECEDING
             WindowFrameBound::Preceding(ScalarValue::UInt64(None)) => 0,
             WindowFrameBound::Preceding(ScalarValue::UInt64(Some(n))) => {
-                if idx >= n as usize {
-                    idx - n as usize
-                } else {
-                    0
-                }
+                idx.saturating_sub(n as usize)
             }
             WindowFrameBound::CurrentRow => idx,
             // UNBOUNDED FOLLOWING
@@ -602,11 +598,7 @@ impl WindowFrameStateGroups {
 
         // Find the group index of the frame boundary:
         let group_idx = if SEARCH_SIDE {
-            if self.current_group_idx > delta {
-                self.current_group_idx - delta
-            } else {
-                0
-            }
+            self.current_group_idx.saturating_sub(delta)
         } else {
             self.current_group_idx + delta
         };

datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs

@@ -520,6 +520,7 @@ struct ConstEvaluator<'a> {
 
 #[allow(dead_code)]
 /// The simplify result of ConstEvaluator
+#[allow(clippy::large_enum_variant)]
 enum ConstSimplifyResult {
     // Expr was simplified and contains the new expression
     Simplified(ScalarValue),

datafusion/physical-plan/src/aggregates/mod.rs

@@ -346,6 +346,7 @@ impl PartialEq for PhysicalGroupBy {
     }
 }
 
+#[allow(clippy::large_enum_variant)]
 enum StreamType {
     AggregateStream(AggregateStream),
     GroupedHash(GroupedHashAggregateStream),