chore(CI) Update workspace / CI to Rust 1.87

Author: kadai0308

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)
     }
 }
 

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,34 @@ 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(), // &Box<Value> -> &Value
+        _ => v,
+    };
 
-    Err(AvroError::GetU8(int.into()))
+    match v {
+        Value::Int(n) if (0..=u8::MAX as i32).contains(n) => Some(*n as u8),
+        Value::Long(n) if (0..=u8::MAX as i64).contains(n) => Some(*n as u8),
+        _ => 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) => {
+            let bytes: Option<Vec<u8>> = items.iter().map(resolve_u8).collect();
+            bytes
+        }
         _ => None,
-    })
+    }
 }
 
 fn resolve_fixed(v: &Value, size: usize) -> Option<Vec<u8>> {

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),

datafusion/sql/src/resolve.rs

@@ -78,7 +78,7 @@ impl Visitor for RelationVisitor {
                 if !with.recursive {
                     // This is a bit hackish as the CTE will be visited again as part of visiting `q`,
                     // but thankfully `insert_relation` is idempotent.
-                    cte.visit(self);
+                    let _ = cte.visit(self);
                 }
                 self.ctes_in_scope
                     .push(ObjectName::from(vec![cte.alias.name.clone()]));
@@ -143,7 +143,7 @@ fn visit_statement(statement: &DFStatement, visitor: &mut RelationVisitor) {
                 visitor.insert_relation(table_name);
             }
             CopyToSource::Query(query) => {
-                query.visit(visitor);
+                let _ = query.visit(visitor);
             }
         },
         DFStatement::Explain(explain) => visit_statement(&explain.statement, visitor),

datafusion/sql/src/select.rs

@@ -885,7 +885,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {
             | SelectItem::UnnamedExpr(expr) = proj
             {
                 let mut err = None;
-                visit_expressions_mut(expr, |expr| {
+                let _ = visit_expressions_mut(expr, |expr| {
                     if let SQLExpr::Function(f) = expr {
                         if let Some(WindowType::NamedWindow(ident)) = &f.over {
                             let normalized_ident =