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
- 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/table_configuration.rs

@@ -568,6 +568,189 @@ impl TableConfiguration {
     }
 }
 
+/// Configuration parsed from user-provided table properties during table creation.
+///
+/// This struct extracts signal flags (protocol versions, feature overrides) from
+/// the input properties and separates them from the table properties that will
+/// be stored in metadata.
+///
+/// Signal flags include:
+/// - `delta.feature.<name> = supported` - Explicit feature enablement
+/// - `delta.minReaderVersion` - Protocol reader version hint
+/// - `delta.minWriterVersion` - Protocol writer version hint
+///
+/// These signal flags affect protocol creation but are not stored in the table's
+/// metadata configuration.
+///
+/// # Example
+/// ```ignore
+/// let props = HashMap::from([
+///     ("delta.feature.deletionVectors".to_string(), "supported".to_string()),
+///     ("delta.minReaderVersion".to_string(), "3".to_string()),
+///     ("myapp.version".to_string(), "1.0".to_string()),
+/// ]);
+/// let config = TableCreationConfig::try_from(props)?;
+/// config.validate_for_create()?;
+/// // config.reader_features = [TableFeature::DeletionVectors]
+/// // config.writer_features = [TableFeature::DeletionVectors]
+/// // config.min_reader_version = Some(3)
+/// // config.table_properties = {"myapp.version": "1.0"}
+/// ```
+#[derive(Debug, Default)]
+pub(crate) struct TableCreationConfig {
+    /// Features explicitly enabled via `delta.feature.<name> = supported`.
+    /// Contains only ReaderWriter features.
+    pub(crate) reader_features: Vec<TableFeature>,
+    /// Features explicitly enabled via `delta.feature.<name> = supported`.
+    /// Contains all features (Writer-only + ReaderWriter).
+    pub(crate) writer_features: Vec<TableFeature>,
+    /// Protocol reader version from `delta.minReaderVersion` (if provided).
+    pub(crate) min_reader_version: Option<i32>,
+    /// Protocol writer version from `delta.minWriterVersion` (if provided).
+    pub(crate) min_writer_version: Option<i32>,
+    /// Remaining properties to store in Metadata.configuration.
+    /// Signal flags are stripped out.
+    pub(crate) table_properties: std::collections::HashMap<String, String>,
+}
+
+impl TryFrom<std::collections::HashMap<String, String>> for TableCreationConfig {
+    type Error = Error;
+
+    fn try_from(properties: std::collections::HashMap<String, String>) -> DeltaResult<Self> {
+        use crate::table_features::{
+            SET_TABLE_FEATURE_SUPPORTED_PREFIX, SET_TABLE_FEATURE_SUPPORTED_VALUE,
+        };
+        use crate::table_properties::{MIN_READER_VERSION_PROP, MIN_WRITER_VERSION_PROP};
+
+        let mut config = TableCreationConfig::default();
+        let mut all_features = Vec::new();
+
+        for (key, value) in properties {
+            if let Some(feature_name) = key.strip_prefix(SET_TABLE_FEATURE_SUPPORTED_PREFIX) {
+                // Parse delta.feature.* signal flags
+                if value != SET_TABLE_FEATURE_SUPPORTED_VALUE {
+                    return Err(Error::generic(format!(
+                        "Invalid value '{}' for '{}'. Only '{}' is allowed.",
+                        value, key, SET_TABLE_FEATURE_SUPPORTED_VALUE
+                    )));
+                }
+                let feature = TableFeature::from_name(feature_name);
+                if matches!(feature, TableFeature::Unknown(_)) {
+                    return Err(Error::generic(format!(
+                        "Unknown table feature '{}'. Cannot create table with unsupported features.",
+                        feature_name
+                    )));
+                }
+                all_features.push(feature);
+            } else if key == MIN_READER_VERSION_PROP {
+                // Parse delta.minReaderVersion
+                let version: i32 = value.parse().map_err(|_| {
+                    Error::generic(format!(
+                        "Invalid value '{}' for '{}'. Must be an integer.",
+                        value, key
+                    ))
+                })?;
+                config.min_reader_version = Some(version);
+            } else if key == MIN_WRITER_VERSION_PROP {
+                // Parse delta.minWriterVersion
+                let version: i32 = value.parse().map_err(|_| {
+                    Error::generic(format!(
+                        "Invalid value '{}' for '{}'. Must be an integer.",
+                        value, key
+                    ))
+                })?;
+                config.min_writer_version = Some(version);
+            } else {
+                // Pass through to table properties
+                config.table_properties.insert(key, value);
+            }
+        }
+
+        // Partition features: ReaderWriter -> reader list, all -> writer list
+        config.reader_features = all_features
+            .iter()
+            .filter(|f| f.is_reader_writer())
+            .cloned()
+            .collect();
+        config.writer_features = all_features;
+
+        Ok(config)
+    }
+}
+
+impl TableCreationConfig {
+    /// Delta properties allowed during CREATE TABLE.
+    /// Expand this list as more features are supported (e.g., column mapping, clustering).
+    const ALLOWED_DELTA_PROPERTIES: &[&str] = &[
+        // Currently empty - no delta.* properties allowed yet
+        // Future: "delta.enableDeletionVectors", "delta.columnMapping.mode", etc.
+    ];
+
+    /// Table features allowed during CREATE TABLE.
+    /// Expand this list as more features are supported.
+    const ALLOWED_DELTA_FEATURES: &[TableFeature] = &[
+        // Currently empty - no explicit feature overrides allowed yet
+        // Future: TableFeature::DeletionVectors, TableFeature::ColumnMapping, etc.
+    ];
+
+    /// Validates the configuration for CREATE TABLE.
+    ///
+    /// Checks:
+    /// - Protocol versions (if specified) must be (3, 7)
+    /// - Only allowed delta properties can be set
+    /// - Only allowed features can be explicitly enabled
+    pub(crate) fn validate_for_create(&self) -> DeltaResult<()> {
+        use crate::table_features::{
+            TABLE_FEATURES_MIN_READER_VERSION, TABLE_FEATURES_MIN_WRITER_VERSION,
+        };
+        use crate::table_properties::{
+            DELTA_PROPERTY_PREFIX, MIN_READER_VERSION_PROP, MIN_WRITER_VERSION_PROP,
+        };
+
+        // Validate protocol versions
+        if let Some(v) = self.min_reader_version {
+            if v != TABLE_FEATURES_MIN_READER_VERSION {
+                return Err(Error::generic(format!(
+                    "Invalid value '{}' for '{}'. Only '{}' is supported.",
+                    v, MIN_READER_VERSION_PROP, TABLE_FEATURES_MIN_READER_VERSION
+                )));
+            }
+        }
+        if let Some(v) = self.min_writer_version {
+            if v != TABLE_FEATURES_MIN_WRITER_VERSION {
+                return Err(Error::generic(format!(
+                    "Invalid value '{}' for '{}'. Only '{}' is supported.",
+                    v, MIN_WRITER_VERSION_PROP, TABLE_FEATURES_MIN_WRITER_VERSION
+                )));
+            }
+        }
+
+        // Validate delta properties against allow-list
+        for key in self.table_properties.keys() {
+            if key.starts_with(DELTA_PROPERTY_PREFIX)
+                && !Self::ALLOWED_DELTA_PROPERTIES.contains(&key.as_str())
+            {
+                return Err(Error::generic(format!(
+                    "Setting delta property '{}' is not supported during CREATE TABLE",
+                    key
+                )));
+            }
+        }
+
+        // Validate features against allow-list
+        for feature in &self.writer_features {
+            if !Self::ALLOWED_DELTA_FEATURES.contains(feature) {
+                return Err(Error::generic(format!(
+                    "Enabling feature '{}' is not supported during CREATE TABLE",
+                    feature
+                )));
+            }
+        }
+
+        Ok(())
+    }
+}
+
 #[cfg(test)]
 mod test {
     use std::collections::HashMap;
@@ -1398,4 +1581,195 @@ mod test {
         let config = create_mock_table_config(&[], &[TableFeature::CatalogOwnedPreview]);
         assert!(config.ensure_operation_supported(Operation::Write).is_ok());
     }
+
+    // TableCreationConfig tests
+
+    #[test]
+    fn test_table_creation_config_basic() {
+        use super::TableCreationConfig;
+
+        let props = HashMap::from([
+            (
+                "delta.feature.deletionVectors".to_string(),
+                "supported".to_string(),
+            ),
+            (
+                "delta.enableDeletionVectors".to_string(),
+                "true".to_string(),
+            ),
+        ]);
+
+        let config = TableCreationConfig::try_from(props).unwrap();
+
+        // DeletionVectors is a ReaderWriter feature
+        assert_eq!(config.reader_features.len(), 1);
+        assert_eq!(config.reader_features[0], TableFeature::DeletionVectors);
+        assert_eq!(config.writer_features.len(), 1);
+        assert_eq!(config.writer_features[0], TableFeature::DeletionVectors);
+
+        // Feature override should be removed from table_properties
+        assert!(!config
+            .table_properties
+            .contains_key("delta.feature.deletionVectors"));
+        // Regular property should be retained
+        assert_eq!(
+            config.table_properties.get("delta.enableDeletionVectors"),
+            Some(&"true".to_string())
+        );
+    }
+
+    #[test]
+    fn test_table_creation_config_multiple_features() {
+        use super::TableCreationConfig;
+
+        let props = HashMap::from([
+            (
+                "delta.feature.deletionVectors".to_string(),
+                "supported".to_string(),
+            ),
+            (
+                "delta.feature.changeDataFeed".to_string(),
+                "supported".to_string(),
+            ),
+            (
+                "delta.feature.appendOnly".to_string(),
+                "supported".to_string(),
+            ),
+            (
+                "delta.enableDeletionVectors".to_string(),
+                "true".to_string(),
+            ),
+        ]);
+
+        let config = TableCreationConfig::try_from(props).unwrap();
+
+        // All 3 features go into writer_features
+        assert_eq!(config.writer_features.len(), 3);
+        assert!(config
+            .writer_features
+            .contains(&TableFeature::DeletionVectors));
+        assert!(config
+            .writer_features
+            .contains(&TableFeature::ChangeDataFeed));
+        assert!(config.writer_features.contains(&TableFeature::AppendOnly));
+
+        // Only ReaderWriter features go into reader_features (DeletionVectors)
+        // ChangeDataFeed and AppendOnly are Writer-only features
+        assert_eq!(config.reader_features.len(), 1);
+        assert!(config
+            .reader_features
+            .contains(&TableFeature::DeletionVectors));
+
+        // Only the regular property should remain
+        assert_eq!(config.table_properties.len(), 1);
+        assert_eq!(
+            config.table_properties.get("delta.enableDeletionVectors"),
+            Some(&"true".to_string())
+        );
+    }
+
+    #[test]
+    fn test_table_creation_config_no_features() {
+        use super::TableCreationConfig;
+
+        let props = HashMap::from([
+            (
+                "delta.enableDeletionVectors".to_string(),
+                "true".to_string(),
+            ),
+            ("delta.appendOnly".to_string(), "true".to_string()),
+            ("custom.property".to_string(), "value".to_string()),
+        ]);
+
+        let config = TableCreationConfig::try_from(props).unwrap();
+
+        assert!(config.reader_features.is_empty());
+        assert!(config.writer_features.is_empty());
+        assert_eq!(config.table_properties.len(), 3);
+    }
+
+    #[test]
+    fn test_table_creation_config_parsing_failures() {
+        use super::TableCreationConfig;
+
+        // Invalid feature value ("enabled" instead of "supported")
+        let props = HashMap::from([(
+            "delta.feature.deletionVectors".to_string(),
+            "enabled".to_string(),
+        )]);
+        assert_result_error_with_message(
+            TableCreationConfig::try_from(props),
+            "Invalid value 'enabled'",
+        );
+
+        // Unknown feature name
+        let props = HashMap::from([(
+            "delta.feature.futureFeature".to_string(),
+            "supported".to_string(),
+        )]);
+        assert_result_error_with_message(
+            TableCreationConfig::try_from(props),
+            "Unknown table feature 'futureFeature'",
+        );
+    }
+
+    #[test]
+    fn test_table_creation_config_protocol_version_handling() {
+        use super::TableCreationConfig;
+        use crate::table_properties::{MIN_READER_VERSION_PROP, MIN_WRITER_VERSION_PROP};
+
+        // Valid protocol versions: parsing and validation
+        let props = HashMap::from([
+            (MIN_READER_VERSION_PROP.to_string(), "3".to_string()),
+            (MIN_WRITER_VERSION_PROP.to_string(), "7".to_string()),
+            ("custom.property".to_string(), "value".to_string()),
+        ]);
+        let config = TableCreationConfig::try_from(props).unwrap();
+        // Versions correctly extracted
+        assert_eq!(config.min_reader_version, Some(3));
+        assert_eq!(config.min_writer_version, Some(7));
+        // Protocol version properties stripped from table_properties
+        assert!(!config
+            .table_properties
+            .contains_key(MIN_READER_VERSION_PROP));
+        assert!(!config
+            .table_properties
+            .contains_key(MIN_WRITER_VERSION_PROP));
+        // Other properties remain
+        assert_eq!(
+            config.table_properties.get("custom.property"),
+            Some(&"value".to_string())
+        );
+        // Validation passes
+        assert!(config.validate_for_create().is_ok());
+
+        // Invalid reader version (only 3 supported)
+        let props = HashMap::from([(MIN_READER_VERSION_PROP.to_string(), "2".to_string())]);
+        let config = TableCreationConfig::try_from(props).unwrap();
+        assert_result_error_with_message(config.validate_for_create(), "Only '3' is supported");
+
+        // Invalid writer version (only 7 supported)
+        let props = HashMap::from([(MIN_WRITER_VERSION_PROP.to_string(), "5".to_string())]);
+        let config = TableCreationConfig::try_from(props).unwrap();
+        assert_result_error_with_message(config.validate_for_create(), "Only '7' is supported");
+
+        // Features not on allow list
+        let props = HashMap::from([(
+            "delta.feature.deletionVectors".to_string(),
+            "supported".to_string(),
+        )]);
+        let config = TableCreationConfig::try_from(props).unwrap();
+        assert_result_error_with_message(
+            config.validate_for_create(),
+            "Enabling feature 'deletionVectors' is not supported",
+        );
+
+        // Delta properties not on allow list
+        let props = HashMap::from([("delta.appendOnly".to_string(), "true".to_string())]);
+        let config = TableCreationConfig::try_from(props).unwrap();
+        assert_result_error_with_message(
+            config.validate_for_create(),
+            "Setting delta property 'delta.appendOnly' is not supported",
+        );
+    }
 }