chore: upgrade Rust toolchain to 1.97.0 (#7712)

Bumps the pinned toolchain from 1.94.0 to 1.97.0 in
`rust-toolchain.toml` (the `python/` and `java/lance-jni/` copies are
symlinks to it) and fixes the clippy lints newly reported by 1.97 across
the workspace.

New lints fixed:
- `manual_filter`, `manual_checked_ops`, `question_mark`
- `useless_conversion`, `useless_borrows_in_formatting`
- `collapsible_match`, `while_let_loop`, `explicit_counter_loop`,
`unnecessary_sort_by`

All fixes are behavior-preserving. `cargo clippy -- -D warnings` is
clean across the main workspace (all features, all targets), `python/`,
and `java/lance-jni/`; `cargo fmt --check` passes on all three.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **Bug Fixes**
* Improved handling of floating-point `NaN` values in range queries for
more conservative, reliable results.
* Prevented potential division-by-zero issues in decoding and statistics
calculations.
* Preserved correct behavior when processing all-null data and missing
fields.

* **Maintenance**
  * Updated the Rust toolchain used to build the project.
* Simplified internal processing across indexing, scanning, encoding,
storage, and query-planning components without changing expected
behavior.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: wjones127

rust-toolchain.toml

@@ -1,5 +1,5 @@
 # We keep this pinned to keep clippy and rustfmt in sync between local and CI.
 # Feel free to upgrade to bring in new lints.
 [toolchain]
-channel = "1.94.0"
+channel = "1.97.0"
 components = ["rustfmt", "clippy", "rust-analyzer"]

rust/lance-arrow/src/lib.rs

@@ -1022,13 +1022,7 @@ fn merge_list_struct(left: &dyn Array, right: &dyn Array) -> Arc<dyn Array> {
 fn normalize_validity(
     validity: Option<&arrow_buffer::NullBuffer>,
 ) -> Option<&arrow_buffer::NullBuffer> {
-    validity.and_then(|v| {
-        if v.null_count() == v.len() {
-            None
-        } else {
-            Some(v)
-        }
-    })
+    validity.filter(|v| v.null_count() != v.len())
 }
 
 /// Helper function to merge validity buffers from two struct arrays

rust/lance-datafusion/src/logical_expr.rs

@@ -51,14 +51,10 @@ pub fn resolve_column_type(expr: &Expr, schema: &Schema) -> Option<DataType> {
                 field_path.push(c.name.as_str());
                 break;
             }
-            Expr::ScalarFunction(udf) => {
-                if udf.name() == GetFieldFunc::default().name() {
-                    let name = get_as_string_scalar_opt(&udf.args[1])?;
-                    field_path.push(name);
-                    current_expr = &udf.args[0];
-                } else {
-                    return None;
-                }
+            Expr::ScalarFunction(udf) if udf.name() == GetFieldFunc::default().name() => {
+                let name = get_as_string_scalar_opt(&udf.args[1])?;
+                field_path.push(name);
+                current_expr = &udf.args[0];
             }
             _ => return None,
         }

rust/lance-datafusion/src/planner.rs

@@ -503,7 +503,7 @@ impl Planner {
             }
             _ => Err(Error::invalid_input(format!(
                 "Unsupported function args: {:?}",
-                &func.args
+                func.args
             ))),
         }
     }
@@ -1062,13 +1062,9 @@ impl TreeNodeVisitor<'_> for ColumnCapturingVisitor {
                 self.columns.insert(path);
                 self.current_path.clear();
             }
-            Expr::ScalarFunction(udf) => {
-                if udf.name() == GetFieldFunc::default().name() {
-                    if let Some(name) = get_as_string_scalar_opt(&udf.args[1]) {
-                        self.current_path.push_front(name.to_string())
-                    } else {
-                        self.current_path.clear();
-                    }
+            Expr::ScalarFunction(udf) if udf.name() == GetFieldFunc::default().name() => {
+                if let Some(name) = get_as_string_scalar_opt(&udf.args[1]) {
+                    self.current_path.push_front(name.to_string())
                 } else {
                     self.current_path.clear();
                 }

rust/lance-encoding/src/decoder.rs

@@ -1949,8 +1949,7 @@ impl StructuralBatchDecodeStream {
                     next_task.into_batch(emitted_batch_size_warning)?
                 };
                 let num_rows = batch.num_rows() as u64;
-                if num_rows > 0 {
-                    let bpr = data_size / num_rows;
+                if let Some(bpr) = data_size.checked_div(num_rows) {
                     let prev = bytes_per_row_feedback.load(Ordering::Relaxed);
                     let next = if prev == 0 || bpr >= prev {
                         // First batch or actual size is larger than estimate:

rust/lance-encoding/src/encodings/physical/packed.rs

@@ -323,7 +323,7 @@ impl PerValueCompressor for PackedStructVariablePerValueEncoder {
         let mut field_data = Vec::with_capacity(self.fields.len());
         let mut field_metadata = Vec::with_capacity(self.fields.len());
 
-        for (field, child_block) in self.fields.iter().zip(struct_block.children.into_iter()) {
+        for (field, child_block) in self.fields.iter().zip(struct_block.children) {
             let compressor = crate::compression::CompressionStrategy::create_per_value(
                 &self.strategy,
                 field,
@@ -688,7 +688,7 @@ impl VariablePerValueDecompressor for PackedStructVariablePerValueDecompressor {
         }
 
         let mut children = Vec::with_capacity(self.fields.len());
-        for (field, accumulator) in self.fields.iter().zip(accumulators.into_iter()) {
+        for (field, accumulator) in self.fields.iter().zip(accumulators) {
             match (field, accumulator) {
                 (
                     VariablePackedStructFieldDecoder {

rust/lance-encoding/src/previous/encodings/logical/blob.rs

@@ -318,7 +318,7 @@ impl BlobFieldEncoder {
             .nulls()
             .cloned()
             .unwrap_or(NullBuffer::new_valid(binarray.len()));
-        for (w, is_valid) in binarray.value_offsets().windows(2).zip(nulls.into_iter()) {
+        for (w, is_valid) in binarray.value_offsets().windows(2).zip(&nulls) {
             if is_valid {
                 let start = w[0] as u64;
                 let end = w[1] as u64;

rust/lance-file/src/reader.rs

@@ -1939,7 +1939,7 @@ impl FileMetadataProvider {
                 .collect::<Vec<_>>();
             let metadata_bytes = io.submit_request(ranges, 0).await?;
             for ((result_index, column_index, _), bytes) in
-                missing_columns.into_iter().zip(metadata_bytes.into_iter())
+                missing_columns.into_iter().zip(metadata_bytes)
             {
                 let column_metadata = pbfile::ColumnMetadata::decode(bytes)?;
                 let column_info = FileReader::meta_to_col_info(

rust/lance-index/src/scalar/bitmap.rs

@@ -891,8 +891,7 @@ impl BitmapBatchWriter {
             return Ok(());
         }
         let keys_array =
-            ScalarValue::iter_to_array(self.keys.drain(..).collect::<Vec<_>>().into_iter())
-                .unwrap();
+            ScalarValue::iter_to_array(self.keys.drain(..).collect::<Vec<_>>()).unwrap();
         let total_size: usize = self.serialized.iter().map(|b| b.len()).sum();
         let mut binary_builder = BinaryBuilder::with_capacity(self.serialized.len(), total_size);
         for b in self.serialized.drain(..) {
@@ -1123,10 +1122,7 @@ async fn drain_same_key_bitmaps(
     let merged_key = OrderableScalarValue(key);
     advance_cursor_and_push(cursors, heap, item.shard_idx).await?;
 
-    loop {
-        let Some(Reverse(next_item)) = heap.peek() else {
-            break;
-        };
+    while let Some(Reverse(next_item)) = heap.peek() {
         if next_item.key != merged_key {
             break;
         }
@@ -1280,7 +1276,7 @@ impl BitmapIndexPlugin {
             let bitmap_size = bytes.len();
 
             if cur_bytes + bitmap_size > MAX_BITMAP_ARRAY_LENGTH {
-                let keys_array = ScalarValue::iter_to_array(cur_keys.clone().into_iter()).unwrap();
+                let keys_array = ScalarValue::iter_to_array(cur_keys.clone()).unwrap();
                 let mut binary_builder = BinaryBuilder::new();
                 for b in &cur_bitmaps {
                     binary_builder.append_value(b);

rust/lance-index/src/scalar/btree.rs

@@ -5327,12 +5327,8 @@ mod tests {
             mapping.insert(old_id, None);
         }
 
-        let mut new_id_counter = 100_000;
-
         // Remap all other rows
-        for old_id in (0..1000).chain(10000..15000) {
-            let new_id = new_id_counter;
-            new_id_counter += 1;
+        for (new_id, old_id) in (100_000..).zip((0..1000).chain(10000..15000)) {
             mapping.insert(old_id, Some(new_id));
         }