feat: add set_nullable support for ALTER TABLE (delta-io#2388)

## What changes are proposed in this pull request?

Adds the `SetNullable` operation to the ALTER TABLE framework, allowing
columns to be changed
from NOT NULL to nullable. Supports nested columns via `ColumnName`
paths.

`modify_field_at_path` function to recurse through struct and rebuild
bottom-up to update nullable field.

## How was this change tested?

- Unit tests for `modify_field_at_path`: top-level, nested, sibling
preservation, nonexistent
  field, non-struct traversal, case-insensitive lookup
- Unit tests for `SetNullable` via `apply_schema_operations`:
required->nullable, already
  nullable noop, deeply nested (3 levels), chained with add_column
- Integration tests in `kernel/tests/alter_table.rs`: set_nullable with
schema reload,
already-nullable noop, nonexistent column error, chained add_column +
set_nullable

Author: william-ch-databricks

kernel/src/schema/mod.rs

@@ -817,6 +817,56 @@ impl StructType {
         self.fields.into_values()
     }
 
+    /// Gets a mutable reference to the underlying field map.
+    pub(crate) fn field_map_mut(&mut self) -> &mut IndexMap<String, StructField> {
+        &mut self.fields
+    }
+
+    /// Walk a pre-segmented column path through this schema and return the leaf field.
+    ///
+    /// `path` is the path's individual name segments (one per nesting level), already split by
+    /// the caller. Lookup at each level is case-insensitive. The Delta protocol uses `.` as the
+    /// dotted-path separator at the API surface, but `field_at_path` itself does not split --
+    /// callers typically pass [`ColumnName::path()`](crate::expressions::ColumnName::path),
+    /// which yields the segments directly.
+    ///
+    /// Panics if any segment is missing or an intermediate field is not a struct. Intended for
+    /// use in test assertions.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// // Schema:
+    /// //   id:      INTEGER  not null
+    /// //   address: STRUCT { city: STRING not null, zip: STRING }
+    /// let path = vec!["address".to_string(), "city".to_string()];
+    /// let city = schema.field_at_path(&path);
+    /// assert_eq!(city.name(), "city");
+    /// assert!(!city.is_nullable());
+    /// ```
+    #[cfg(any(test, feature = "test-utils"))]
+    #[allow(clippy::panic, clippy::expect_used)]
+    pub fn field_at_path<'a>(&'a self, path: &[String]) -> &'a StructField {
+        fn find_ci<'a>(
+            mut fields: impl Iterator<Item = &'a StructField>,
+            name: &str,
+        ) -> &'a StructField {
+            let lowered = name.to_lowercase();
+            fields
+                .find(|f| f.name().to_lowercase() == lowered)
+                .unwrap_or_else(|| panic!("field '{name}' not found"))
+        }
+        let (first, rest) = path.split_first().expect("non-empty path");
+        let mut field = find_ci(self.fields(), first);
+        for seg in rest {
+            let DataType::Struct(s) = field.data_type() else {
+                panic!("expected struct at intermediate segment '{seg}'");
+            };
+            field = find_ci(s.fields(), seg);
+        }
+        field
+    }
+
     /// Gets all the field names in this struct type in the order they are defined.
     pub fn field_names(&self) -> impl ExactSizeIterator<Item = &String> {
         self.fields.keys()

kernel/src/transaction/builder/alter_table.rs

@@ -28,6 +28,7 @@ use std::marker::PhantomData;
 use std::sync::Arc;
 
 use crate::committer::Committer;
+use crate::expressions::ColumnName;
 use crate::schema::StructField;
 use crate::snapshot::SnapshotRef;
 use crate::table_configuration::TableConfiguration;
@@ -112,6 +113,16 @@ impl<S: Chainable> AlterTableTransactionBuilder<S> {
         self.operations.push(SchemaOperation::AddColumn { field });
         self.transition()
     }
+
+    /// Change a column's nullability from NOT NULL to nullable. If the column is already
+    /// nullable, the op is a no-op but still generates a commit.
+    ///
+    /// Note: this matches Spark's behavior.
+    pub fn set_nullable(mut self, column: ColumnName) -> AlterTableTransactionBuilder<Modifying> {
+        self.operations
+            .push(SchemaOperation::SetNullable { column });
+        self.transition()
+    }
 }
 
 impl AlterTableTransactionBuilder<Modifying> {