chore(CI) Update workspace / CI to Rust 1.87

Author: davy-lcw

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

@@ -356,13 +356,13 @@ impl Statistics {
             /// The column is taken and put into the specified statistics location
             Taken(usize),
             /// The original columns is present
-            Present(ColumnStatistics),
+            Present(Box<ColumnStatistics>),
         }
 
         // Convert to Vec<Slot> so we can avoid copying the statistics
         let mut columns: Vec<_> = std::mem::take(&mut self.column_statistics)
             .into_iter()
-            .map(Slot::Present)
+            .map(|stats| Slot::Present(Box::new(stats)))
             .collect();
 
         for idx in projection {
@@ -373,7 +373,7 @@ impl Statistics {
             );
             match slot {
                 // The column was there, so just move it
-                Slot::Present(col) => self.column_statistics.push(col),
+                Slot::Present(col) => self.column_statistics.push(*col),
                 // The column was taken, so copy from the previous location
                 Slot::Taken(prev_idx) => self
                     .column_statistics

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

@@ -20,8 +20,7 @@
 use apache_avro::schema::RecordSchema;
 use apache_avro::{
     schema::{Schema as AvroSchema, SchemaKind},
-    types::Value,
-    AvroResult, Error as AvroError, Reader as AvroReader,
+    types::Value, Error as AvroError, Reader as AvroReader,
 };
 use arrow::array::{
     make_array, Array, ArrayBuilder, ArrayData, ArrayDataBuilder, ArrayRef,
@@ -938,40 +937,37 @@ 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
+        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::<Result<Vec<_>, _>>()
-                .ok()?,
-        )),
-        other => Err(AvroError::GetBytes(other.into())),
-    }
-    .ok()
-    .and_then(|v| match v {
-        Value::Bytes(s) => Some(s),
+                .collect();
+            bytes
+        }
         _ => None,
-    })
+    }
 }
 
 fn resolve_fixed(v: &Value, size: usize) -> Option<Vec<u8>> {

datafusion/expr/src/planner.rs

@@ -314,7 +314,7 @@ pub struct RawWindowExpr {
 #[derive(Debug, Clone)]
 pub enum PlannerResult<T> {
     /// The raw expression was successfully planned as a new [`Expr`]
-    Planned(Expr),
+    Planned(Box<Expr>),
     /// The raw expression could not be planned, and is returned unmodified
     Original(T),
 }

datafusion/expr/src/simplify.rs

@@ -112,7 +112,7 @@ impl SimplifyInfo for SimplifyContext<'_> {
 #[derive(Debug)]
 pub enum ExprSimplifyResult {
     /// The function call was simplified to an entirely new Expr
-    Simplified(Expr),
+    Simplified(Box<Expr>),
     /// The function call could not be simplified, and the arguments
     /// are return unmodified.
     Original(Vec<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/functions-aggregate/src/planner.rs

@@ -108,7 +108,7 @@ impl ExprPlanner for AggregateFunctionPlanner {
             ));
 
             let new_expr = saved_name.restore(new_expr);
-            return Ok(PlannerResult::Planned(new_expr));
+            return Ok(PlannerResult::Planned(Box::new(new_expr)));
         }
 
         Ok(PlannerResult::Original(raw_expr))

datafusion/functions-nested/src/array_has.rs

@@ -150,20 +150,20 @@ impl ScalarUDFImpl for ArrayHas {
                     .map(Expr::Literal)
                     .collect();
 
-                return Ok(ExprSimplifyResult::Simplified(Expr::InList(InList {
+                return Ok(ExprSimplifyResult::Simplified(Box::new(Expr::InList(InList {
                     expr: Box::new(std::mem::take(needle)),
                     list,
                     negated: false,
-                })));
+                }))));
             }
         } else if let Expr::ScalarFunction(ScalarFunction { func, args }) = haystack {
             // make_array has a static set of arguments, so we can pull the arguments out from it
             if func == &make_array_udf() {
-                return Ok(ExprSimplifyResult::Simplified(Expr::InList(InList {
+                return Ok(ExprSimplifyResult::Simplified(Box::new(Expr::InList(InList {
                     expr: Box::new(std::mem::take(needle)),
                     list: std::mem::take(args),
                     negated: false,
-                })));
+                }))));
             }
         }
 

datafusion/functions-nested/src/planner.rs

@@ -69,11 +69,11 @@ impl ExprPlanner for NestedFunctionPlanner {
                 // TODO: concat function ignore null, but string concat takes null into consideration
                 // we can rewrite it to concat if we can configure the behaviour of concat function to the one like `string concat operator`
             } else if left_list_ndims == right_list_ndims {
-                return Ok(PlannerResult::Planned(array_concat(vec![left, right])));
+                return Ok(PlannerResult::Planned(Box::new(array_concat(vec![left, right]))));
             } else if left_list_ndims > right_list_ndims {
-                return Ok(PlannerResult::Planned(array_append(left, right)));
+                return Ok(PlannerResult::Planned(Box::new(array_append(left, right))));
             } else if left_list_ndims < right_list_ndims {
-                return Ok(PlannerResult::Planned(array_prepend(left, right)));
+                return Ok(PlannerResult::Planned(Box::new(array_prepend(left, right))));
             }
         } else if matches!(
             op,
@@ -88,10 +88,10 @@ impl ExprPlanner for NestedFunctionPlanner {
             if left_list_ndims > 0 && right_list_ndims > 0 {
                 if op == sqlparser::ast::BinaryOperator::AtArrow {
                     // array1 @> array2 -> array_has_all(array1, array2)
-                    return Ok(PlannerResult::Planned(array_has_all(left, right)));
+                    return Ok(PlannerResult::Planned(Box::new(array_has_all(left, right))));
                 } else {
                     // array1 <@ array2 -> array_has_all(array2, array1)
-                    return Ok(PlannerResult::Planned(array_has_all(right, left)));
+                    return Ok(PlannerResult::Planned(Box::new(array_has_all(right, left))));
                 }
             }
         }
@@ -104,7 +104,7 @@ impl ExprPlanner for NestedFunctionPlanner {
         exprs: Vec<Expr>,
         _schema: &DFSchema,
     ) -> Result<PlannerResult<Vec<Expr>>> {
-        Ok(PlannerResult::Planned(make_array(exprs)))
+        Ok(PlannerResult::Planned(Box::new(make_array(exprs))))
     }
 
     fn plan_make_map(&self, args: Vec<Expr>) -> Result<PlannerResult<Vec<Expr>>> {
@@ -117,20 +117,20 @@ impl ExprPlanner for NestedFunctionPlanner {
         let keys = make_array(keys.into_iter().map(|(_, e)| e).collect());
         let values = make_array(values.into_iter().map(|(_, e)| e).collect());
 
-        Ok(PlannerResult::Planned(Expr::ScalarFunction(
+        Ok(PlannerResult::Planned(Box::new(Expr::ScalarFunction(
             ScalarFunction::new_udf(map_udf(), vec![keys, values]),
-        )))
+        ))))
     }
 
     fn plan_any(&self, expr: RawBinaryExpr) -> Result<PlannerResult<RawBinaryExpr>> {
         if expr.op == sqlparser::ast::BinaryOperator::Eq {
-            Ok(PlannerResult::Planned(Expr::ScalarFunction(
+            Ok(PlannerResult::Planned(Box::new(Expr::ScalarFunction(
                 ScalarFunction::new_udf(
                     array_has_udf(),
                     // left and right are reversed here so `needle=any(haystack)` -> `array_has(haystack, needle)`
                     vec![expr.right, expr.left],
                 ),
-            )))
+            ))))
         } else {
             plan_err!("Unsupported AnyOp: '{}', only '=' is supported", expr.op)
         }
@@ -150,7 +150,7 @@ impl ExprPlanner for FieldAccessPlanner {
         match field_access {
             // expr["field"] => get_field(expr, "field")
             GetFieldAccess::NamedStructField { name } => {
-                Ok(PlannerResult::Planned(get_field(expr, name)))
+                Ok(PlannerResult::Planned(Box::new(get_field(expr, name))))
             }
             // expr[idx] ==> array_element(expr, idx)
             GetFieldAccess::ListIndex { key: index } => {
@@ -167,40 +167,40 @@ impl ExprPlanner for FieldAccessPlanner {
                                 null_treatment,
                             },
                     }) if is_array_agg(&func) => Ok(PlannerResult::Planned(
-                        Expr::AggregateFunction(AggregateFunction::new_udf(
+                        Box::new(Expr::AggregateFunction(AggregateFunction::new_udf(
                             nth_value_udaf(),
                             args.into_iter().chain(std::iter::once(*index)).collect(),
                             distinct,
                             filter,
                             order_by,
                             null_treatment,
-                        )),
+                        ))),
                     )),
                     // special case for map access with
                     Expr::Column(ref c)
                         if matches!(schema.data_type(c)?, DataType::Map(_, _)) =>
                     {
-                        Ok(PlannerResult::Planned(Expr::ScalarFunction(
+                        Ok(PlannerResult::Planned(Box::new(Expr::ScalarFunction(
                             ScalarFunction::new_udf(
                                 get_field_inner(),
                                 vec![expr, *index],
                             ),
-                        )))
+                        ))))
                     }
-                    _ => Ok(PlannerResult::Planned(array_element(expr, *index))),
+                    _ => Ok(PlannerResult::Planned(Box::new(array_element(expr, *index)))),
                 }
             }
             // expr[start, stop, stride] ==> array_slice(expr, start, stop, stride)
             GetFieldAccess::ListRange {
                 start,
                 stop,
                 stride,
-            } => Ok(PlannerResult::Planned(array_slice(
+            } => Ok(PlannerResult::Planned(Box::new(array_slice(
                 expr,
                 *start,
                 *stop,
                 Some(*stride),
-            ))),
+            )))),
         }
     }
 }

datafusion/functions-window/src/planner.rs

@@ -107,7 +107,7 @@ impl ExprPlanner for WindowFunctionPlanner {
 
             let new_expr = saved_name.restore(new_expr);
 
-            return Ok(PlannerResult::Planned(new_expr));
+            return Ok(PlannerResult::Planned(Box::new(new_expr)));
         }
 
         Ok(PlannerResult::Original(raw_expr))