feat: Introduce TableCreationConfig for table creation property handling

1. Adds the ability to explicitly enable table features via table properties
using the delta.feature.<featureName> = supported syntax, matching the
Java Kernel's behavior. Only ALLOWED_DELTA_FEATURES can be set during
create. Features get added to protocol features.

2. Allows the min reader/ writer versions to be updated in the protocol using
signal flags. Only protocol versions (3, 7) are supported.

Key Changes:
- Add SET_TABLE_FEATURE_SUPPORTED_PREFIX and SET_TABLE_FEATURE_SUPPORTED_VALUE
  constants to table_features module. Move the feature/ property allow/
  deny list to the table property configuration module
- Add TableFeature::from_name() to parse feature names from strings
- Add TableFeature::is_reader_writer() to check feature type
- Add TableCreationConfig struct to encapsulate parsing and validation of
user-provided table properties during CREATE TABLE operations.
- Extract delta.feature.* signal flags into reader/writer feature lists
- Extract delta.minReaderVersion/minWriterVersion into protocol hints
- Strip signal flags from properties, pass remaining to metadata
- Reject unknown features and invalid feature flag values

Usage:
create_table("/path/to/table", schema, "MyApp/1.0")
    .with_table_properties([
        ("delta.minReaderVersion", "3"),
        ("delta.minWriterVersion", "7"),
    ])
    .build(&engine, Box::new(FileSystemCommitter::new()))?
    .commit(&engine)?;

The delta.feature.* properties are consumed during build() and not stored
in the final Metadata configuration, matching Java Kernel behavior.

Author: sanujbasu

kernel/src/lib.rs

@@ -103,6 +103,7 @@ pub mod table_changes;
 pub mod table_configuration;
 pub mod table_features;
 pub mod table_properties;
+mod table_property_protocol_config;
 pub mod transaction;
 pub(crate) mod transforms;
 

kernel/src/table_configuration.rs

@@ -1,3 +1,5 @@
+//! Configuration for reading existing Delta tables.
+//!
 //! This module defines [`TableConfiguration`], a high level api to check feature support and
 //! feature enablement for a table at a given version. This encapsulates [`Protocol`], [`Metadata`],
 //! [`Schema`], [`TableProperties`], and [`ColumnMappingMode`]. These structs in isolation should
@@ -7,6 +9,12 @@
 //! reader/writer features, and ensure that the deletion vector table property is enabled in the
 //! [`TableProperties`].
 //!
+//! # Related Modules
+//!
+//! - [`crate::table_property_protocol_config`]: For **creating/modifying** tables. Parses
+//!   user-provided properties to extract signal flags and create protocols. Use this when building
+//!   new tables or modifying existing table properties.
+//!
 //! [`Schema`]: crate::schema::Schema
 use std::sync::Arc;
 

kernel/src/table_features/mod.rs

@@ -1,4 +1,6 @@
 use itertools::Itertools;
+use std::str::FromStr;
+
 use serde::{Deserialize, Serialize};
 use strum::{AsRefStr, Display as StrumDisplay, EnumCount, EnumString};
 
@@ -679,6 +681,20 @@ impl TableFeature {
             TableFeature::Unknown(_) => None,
         }
     }
+
+    /// Parse a feature name string into a TableFeature.
+    ///
+    /// Known feature names are parsed into their corresponding variants.
+    /// Unknown feature names are wrapped in `TableFeature::Unknown`.
+    pub(crate) fn from_name(name: &str) -> Self {
+        TableFeature::from_str(name).unwrap_or_else(|_| TableFeature::Unknown(name.to_string()))
+    }
+
+    /// Returns true if this is a ReaderWriter feature (appears in both reader and writer feature lists).
+    /// Returns false for Writer-only features and Unknown features.
+    pub(crate) fn is_reader_writer(&self) -> bool {
+        matches!(self.feature_type(), FeatureType::ReaderWriter)
+    }
 }
 
 impl ToDataType for TableFeature {
@@ -829,4 +845,49 @@ mod tests {
             assert_eq!(from_str, feature);
         }
     }
+
+    #[test]
+    fn test_from_name() {
+        // Known features
+        assert_eq!(
+            TableFeature::from_name("deletionVectors"),
+            TableFeature::DeletionVectors
+        );
+        assert_eq!(
+            TableFeature::from_name("changeDataFeed"),
+            TableFeature::ChangeDataFeed
+        );
+        assert_eq!(
+            TableFeature::from_name("columnMapping"),
+            TableFeature::ColumnMapping
+        );
+        assert_eq!(
+            TableFeature::from_name("timestampNtz"),
+            TableFeature::TimestampWithoutTimezone
+        );
+
+        // Unknown features
+        assert_eq!(
+            TableFeature::from_name("unknownFeature"),
+            TableFeature::Unknown("unknownFeature".to_string())
+        );
+    }
+
+    #[test]
+    fn test_is_reader_writer() {
+        // ReaderWriter features
+        assert!(TableFeature::DeletionVectors.is_reader_writer());
+        assert!(TableFeature::ColumnMapping.is_reader_writer());
+        assert!(TableFeature::TimestampWithoutTimezone.is_reader_writer());
+        assert!(TableFeature::V2Checkpoint.is_reader_writer());
+
+        // Writer-only features
+        assert!(!TableFeature::ChangeDataFeed.is_reader_writer());
+        assert!(!TableFeature::AppendOnly.is_reader_writer());
+        assert!(!TableFeature::DomainMetadata.is_reader_writer());
+        assert!(!TableFeature::RowTracking.is_reader_writer());
+
+        // Unknown features
+        assert!(!TableFeature::unknown("something").is_reader_writer());
+    }
 }

kernel/src/table_properties.rs

@@ -26,6 +26,14 @@ pub use deserialize::ParseIntervalError;
 /// Prefix for delta table properties (e.g., `delta.enableChangeDataFeed`, `delta.appendOnly`).
 pub const DELTA_PROPERTY_PREFIX: &str = "delta.";
 
+/// Table property key for specifying the minimum reader protocol version.
+/// This is a signal flag property - it affects protocol creation but is not stored in metadata.
+pub const MIN_READER_VERSION_PROP: &str = "delta.minReaderVersion";
+
+/// Table property key for specifying the minimum writer protocol version.
+/// This is a signal flag property - it affects protocol creation but is not stored in metadata.
+pub const MIN_WRITER_VERSION_PROP: &str = "delta.minWriterVersion";
+
 /// Delta table properties. These are parsed from the 'configuration' map in the most recent
 /// 'Metadata' action of a table.
 ///