datafusion: bump MSRV

Author: askalt

Cargo.toml

@@ -57,7 +57,7 @@ homepage = "https://datafusion.apache.org"
 license = "Apache-2.0"
 readme = "README.md"
 repository = "https://github.com/apache/datafusion"
-rust-version = "1.76"
+rust-version = "1.82.0"
 version = "42.2.0"
 
 [workspace.dependencies]

datafusion/common/src/table_reference.rs

@@ -193,17 +193,16 @@ impl TableReference {
         match self {
             TableReference::Bare { table } => **table == *other.table(),
             TableReference::Partial { schema, table } => {
-                **table == *other.table()
-                    && other.schema().map_or(true, |s| *s == **schema)
+                **table == *other.table() && other.schema().is_none_or(|s| *s == **schema)
             }
             TableReference::Full {
                 catalog,
                 schema,
                 table,
             } => {
                 **table == *other.table()
-                    && other.schema().map_or(true, |s| *s == **schema)
-                    && other.catalog().map_or(true, |c| *c == **catalog)
+                    && other.schema().is_none_or(|s| *s == **schema)
+                    && other.catalog().is_none_or(|c| *c == **catalog)
             }
         }
     }

datafusion/expr/src/utils.rs

@@ -811,7 +811,7 @@ pub fn exprlist_len(
                             .enumerate()
                             .filter_map(|(idx, field)| {
                                 let (maybe_table_ref, _) = schema.qualified_field(idx);
-                                if maybe_table_ref.map_or(true, |q| q == qualifier) {
+                                if maybe_table_ref.is_none_or(|q| q == qualifier) {
                                     Some((maybe_table_ref.cloned(), Arc::clone(field)))
                                 } else {
                                     None

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

@@ -92,13 +92,11 @@ impl PhysicalSortExpr {
         let nullable = self.expr.nullable(schema).unwrap_or(true);
         self.expr.eq(&requirement.expr)
             && if nullable {
-                requirement
-                    .options
-                    .map_or(true, |opts| self.options == opts)
+                requirement.options.is_none_or(|opts| self.options == opts)
             } else {
                 requirement
                     .options
-                    .map_or(true, |opts| self.options.descending == opts.descending)
+                    .is_none_or(|opts| self.options.descending == opts.descending)
             }
     }
 
@@ -209,7 +207,7 @@ impl PhysicalSortRequirement {
         self.expr.eq(&other.expr)
             && other
                 .options
-                .map_or(true, |other_opts| self.options == Some(other_opts))
+                .is_none_or(|other_opts| self.options == Some(other_opts))
     }
 
     /// Returns [`PhysicalSortRequirement`] that requires the exact