feat: allow materializePartitionColumns feature signal in CREATE TABLE

[sanujbasu]

What changes are proposed in this pull request?

Adds TableFeature::MaterializePartitionColumns to ALLOWED_DELTA_FEATURES.

The feature is already fully understood by kernel: KernelSupport::Supported, the write path keeps
partition columns in data files when the feature is on (Transaction::generate_logical_to_physical and TableConfiguration::physical_write_schema), and the read path is correct (scan reconstructs partition columns
from add.partitionValues regardless of whether they are materialized in the file).

The remaining gap was the create_table builder allow-list, which rejected delta.feature.materializePartitionColumns=supported at build time.

There is no delta.* enablement property for materializePartitionColumns in kernel today (MATERIALIZE_PARTITION_COLUMNS_INFO is EnablementCheck::AlwaysIfSupported), so the
only opt-in at create time is the explicit feature signal.

How was this change tested?

1/ New unit test test_create_table_with_materialize_partition_columns_feature_signal_allowed in kernel/tests/create_table/partitioned.rs. asserts that the feature signal lands in writerFeatures exactly once, does not appear in readerFeatures (writer-only), and is_feature_enabled returns true.

2/ Local verification:

• cargo +nightly fmt --check
• cargo clippy --workspace --benches --tests --all-features -- -D warnings
• cargo doc --workspace --all-features --no-deps
• cargo test -p delta_kernel --all-features for affected paths

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 88.43%. Comparing base (8e4c296) to head (66b5a42).
⚠️ Report is 1 commits behind head on main.

Additional details and impacted files

@@           Coverage Diff           @@
##             main    #2481   +/-   ##
=======================================
  Coverage   88.43%   88.43%           
=======================================
  Files         178      178           
  Lines       58417    58417           
  Branches    58417    58417           
=======================================
  Hits        51660    51660           
  Misses       4787     4787           
  Partials     1970     1970           

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

[scottsand-db]

Looks good but I think we can re-use an existing test setup?

[sanujbasu]

Range-diff: main (fe9319d -> 34b6516)

kernel/src/transaction/builder/create_table.rs

@@ -4,13 +4,10 @@
      // the feature on an all-nullable table so a later ALTER TABLE ADD COLUMN NOT NULL does
      // not need a protocol upgrade.
      TableFeature::Invariants,
-+    // MaterializePartitionColumns keeps partition columns in the data files (rather than
-+    // dropping them via the logical-to-physical transform). The feature is fully wired in
-+    // kernel (write: `Transaction::generate_logical_to_physical` and
-+    // `TableConfiguration::physical_write_schema`; read: scan reconstructs from
-+    // `add.partitionValues` regardless), and `KernelSupport::Supported`. There is no
-+    // `delta.*` enablement property for it, so the only opt-in at create time is the
-+    // explicit feature signal `delta.feature.materializePartitionColumns=supported`.
++    // MaterializePartitionColumns keeps partition columns in the data files instead of
++    // dropping them on write. There is no `delta.*` enablement property; the only opt-in at
++    // create time is the explicit feature signal
++    // `delta.feature.materializePartitionColumns=supported`.
 +    TableFeature::MaterializePartitionColumns,
  ];
  

kernel/tests/create_table/main.rs

@@ -0,0 +1,16 @@
+diff --git a/kernel/tests/create_table/main.rs b/kernel/tests/create_table/main.rs
+--- a/kernel/tests/create_table/main.rs
++++ b/kernel/tests/create_table/main.rs
+ #[case("appendOnly", TableFeature::AppendOnly, false, false)]
+ #[case("changeDataFeed", TableFeature::ChangeDataFeed, false, false)]
+ #[case("rowTracking", TableFeature::RowTracking, false, false)]
++// WriterOnly features (AlwaysIfSupported)
++#[case(
++    "materializePartitionColumns",
++    TableFeature::MaterializePartitionColumns,
++    false,
++    true
++)]
+ fn test_create_table_with_feature_signal(
+     #[case] feature_name: &str,
+     #[case] feature: TableFeature,
\ No newline at end of file

kernel/tests/create_table/partitioned.rs

@@ -8,50 +8,52 @@
  use delta_kernel::transaction::create_table::create_table;
  use delta_kernel::transaction::data_layout::DataLayout;
  use delta_kernel::DeltaResult;
+ use rstest::rstest;
+ use test_utils::test_table_setup;
+ 
+-use super::partition_test_schema;
++use super::{partition_test_schema, simple_schema};
+ 
+ #[rstest]
+ #[case::exact_casing("date")]
  
      Ok(())
  }
 +
-+/// CREATE TABLE with `delta.feature.materializePartitionColumns=supported` lands the feature
-+/// in `writerFeatures` exactly once and not in `readerFeatures` (writer-only feature). The
-+/// feature has no `delta.*` enablement property and is not auto-enabled by any schema or
-+/// metadata, so the explicit feature signal is the only opt-in path at create time.
-+#[test]
-+fn test_create_table_with_materialize_partition_columns_feature_signal_allowed() -> DeltaResult<()>
-+{
++/// CREATE TABLE accepts `delta.feature.materializePartitionColumns=supported` regardless of
++/// whether the table is partitioned. The feature is harmless on a non-partitioned table
++/// (nothing to materialize) and Delta-Spark also does not error in that case, so kernel
++/// matches that behavior. Generic feature-signal landing assertions are covered by
++/// `test_create_table_with_feature_signal` in `main.rs`; this test pins only the
++/// partitioned-vs-non-partitioned acceptance.
++#[rstest]
++#[case::partitioned(true)]
++#[case::non_partitioned(false)]
++fn test_create_table_with_materialize_partition_columns_partitioned_and_not(
++    #[case] partitioned: bool,
++) -> DeltaResult<()> {
 +    let (_temp_dir, table_path, engine) = test_table_setup()?;
-+    let schema = partition_test_schema()?;
++    let schema = if partitioned {
++        partition_test_schema()?
++    } else {
++        simple_schema()?
++    };
 +
-+    let _ = create_table(&table_path, schema, "Test/1.0")
-+        .with_data_layout(DataLayout::partitioned(["date"]))
-+        .with_table_properties([("delta.feature.materializePartitionColumns", "supported")])
++    let mut builder = create_table(&table_path, schema, "Test/1.0")
++        .with_table_properties([("delta.feature.materializePartitionColumns", "supported")]);
++    if partitioned {
++        builder = builder.with_data_layout(DataLayout::partitioned(["date"]));
++    }
++    let _ = builder
 +        .build(engine.as_ref(), Box::new(FileSystemCommitter::new()))?
 +        .commit(engine.as_ref())?;
 +
 +    let snapshot = Snapshot::builder_for(&table_path).build(engine.as_ref())?;
-+    let protocol = snapshot.table_configuration().protocol();
-+    let writer_features = protocol
-+        .writer_features()
-+        .expect("writer features should be present");
-+    let count = writer_features
-+        .iter()
-+        .filter(|f| **f == TableFeature::MaterializePartitionColumns)
-+        .count();
-+    assert_eq!(
-+        count, 1,
-+        "MaterializePartitionColumns should appear exactly once in writerFeatures; got {count}"
-+    );
 +    assert!(
-+        !protocol
-+            .reader_features()
-+            .is_some_and(|f| f.contains(&TableFeature::MaterializePartitionColumns)),
-+        "MaterializePartitionColumns is writer-only and must not appear in readerFeatures"
-+    );
-+    assert!(
 +        snapshot
 +            .table_configuration()
 +            .is_feature_enabled(&TableFeature::MaterializePartitionColumns),
-+        "MaterializePartitionColumns should be enabled when listed in writerFeatures"
++        "MaterializePartitionColumns should be enabled (partitioned={partitioned})"
 +    );
 +
 +    Ok(())

_{Reproduce locally: git range-diff 8e4c296..fe9319d 8e4c296..34b6516 | Disable: git config gitstack.push-range-diff false}

[sanujbasu]

Range-diff: main (34b6516 -> 66b5a42)

kernel/tests/create_table/partitioned.rs

@@ -23,9 +23,7 @@
 +/// CREATE TABLE accepts `delta.feature.materializePartitionColumns=supported` regardless of
 +/// whether the table is partitioned. The feature is harmless on a non-partitioned table
 +/// (nothing to materialize) and Delta-Spark also does not error in that case, so kernel
-+/// matches that behavior. Generic feature-signal landing assertions are covered by
-+/// `test_create_table_with_feature_signal` in `main.rs`; this test pins only the
-+/// partitioned-vs-non-partitioned acceptance.
++/// matches that behavior.
 +#[rstest]
 +#[case::partitioned(true)]
 +#[case::non_partitioned(false)]

_{Reproduce locally: git range-diff 8e4c296..34b6516 8e4c296..66b5a42 | Disable: git config gitstack.push-range-diff false}

[scottsand-db]

LGTM!