feat: add table description and name API for Python

Add convenient methods to set table description and name through the Python API.

Signed-off-by: Florian VALEYE <[email protected]>

Author: fvaleye

crates/core/src/operations/mod.rs

@@ -25,6 +25,7 @@ use self::filesystem_check::FileSystemCheckBuilder;
 use self::optimize::OptimizeBuilder;
 use self::restore::RestoreBuilder;
 use self::set_tbl_properties::SetTablePropertiesBuilder;
+use self::update_table_metadata::UpdateTableMetadataBuilder;
 use self::vacuum::VacuumBuilder;
 #[cfg(feature = "datafusion")]
 use self::{
@@ -46,6 +47,7 @@ pub mod drop_constraints;
 pub mod filesystem_check;
 pub mod restore;
 pub mod update_field_metadata;
+pub mod update_table_metadata;
 pub mod vacuum;
 
 #[cfg(feature = "datafusion")]
@@ -303,6 +305,11 @@ impl DeltaOps {
     pub fn update_field_metadata(self) -> UpdateFieldMetadataBuilder {
         UpdateFieldMetadataBuilder::new(self.0.log_store, self.0.state.unwrap())
     }
+
+    /// Update table metadata
+    pub fn update_table_metadata(self) -> UpdateTableMetadataBuilder {
+        UpdateTableMetadataBuilder::new(self.0.log_store, self.0.state.unwrap())
+    }
 }
 
 impl From<DeltaTable> for DeltaOps {

crates/core/src/operations/update_table_metadata.rs

@@ -0,0 +1,167 @@
+//! Update table metadata operation
+
+use std::sync::Arc;
+
+use futures::future::BoxFuture;
+
+use super::{CustomExecuteHandler, Operation};
+use crate::kernel::transaction::{CommitBuilder, CommitProperties};
+use crate::kernel::Action;
+use crate::logstore::LogStoreRef;
+use crate::protocol::DeltaOperation;
+use crate::table::state::DeltaTableState;
+use crate::DeltaTable;
+use crate::{DeltaResult, DeltaTableError};
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub enum TableMetadataUpdate {
+    /// Update the table name
+    TableName(String),
+    /// Update the table description
+    TableDescription(String),
+}
+
+impl TableMetadataUpdate {
+    /// Create a validated table name update
+    pub fn table_name(name: impl Into<String>) -> DeltaResult<Self> {
+        let name = name.into();
+        if name.len() > 255 {
+            return Err(DeltaTableError::MetadataError(format!(
+                "Table name cannot exceed 255 characters. Provided name has {} characters.",
+                name.len()
+            )));
+        }
+        Ok(TableMetadataUpdate::TableName(name))
+    }
+
+    /// Create a validated table description update
+    pub fn table_description(description: impl Into<String>) -> DeltaResult<Self> {
+        let description = description.into();
+        let max_description_length = 4000;
+        if description.len() > max_description_length {
+            return Err(DeltaTableError::MetadataError(format!(
+                "Table description cannot exceed {} characters. Provided description has {} characters.",
+                max_description_length,
+                description.len()
+            )));
+        }
+        Ok(TableMetadataUpdate::TableDescription(description))
+    }
+}
+
+/// Update table metadata operation
+pub struct UpdateTableMetadataBuilder {
+    /// A snapshot of the table's state
+    snapshot: DeltaTableState,
+    /// The metadata update to apply
+    update: Option<TableMetadataUpdate>,
+    /// Delta object store for handling data files
+    log_store: LogStoreRef,
+    /// Additional information to add to the commit
+    commit_properties: CommitProperties,
+    custom_execute_handler: Option<Arc<dyn CustomExecuteHandler>>,
+}
+
+impl super::Operation<()> for UpdateTableMetadataBuilder {
+    fn log_store(&self) -> &LogStoreRef {
+        &self.log_store
+    }
+    fn get_custom_execute_handler(&self) -> Option<Arc<dyn CustomExecuteHandler>> {
+        self.custom_execute_handler.clone()
+    }
+}
+
+impl UpdateTableMetadataBuilder {
+    /// Create a new builder
+    pub fn new(log_store: LogStoreRef, snapshot: DeltaTableState) -> Self {
+        Self {
+            update: None,
+            snapshot,
+            log_store,
+            commit_properties: CommitProperties::default(),
+            custom_execute_handler: None,
+        }
+    }
+
+    pub fn with_update(mut self, update: TableMetadataUpdate) -> Self {
+        self.update = Some(update);
+        self
+    }
+
+    pub fn with_commit_properties(mut self, commit_properties: CommitProperties) -> Self {
+        self.commit_properties = commit_properties;
+        self
+    }
+
+    pub fn with_custom_execute_handler(mut self, handler: Arc<dyn CustomExecuteHandler>) -> Self {
+        self.custom_execute_handler = Some(handler);
+        self
+    }
+}
+
+impl std::future::IntoFuture for UpdateTableMetadataBuilder {
+    type Output = DeltaResult<DeltaTable>;
+
+    type IntoFuture = BoxFuture<'static, Self::Output>;
+
+    fn into_future(self) -> Self::IntoFuture {
+        let this = self;
+
+        Box::pin(async move {
+            let operation_id = this.get_operation_id();
+            this.pre_execute(operation_id).await?;
+
+            let update = this.update.ok_or_else(|| {
+                DeltaTableError::MetadataError("No metadata update specified".to_string())
+            })?;
+
+            let mut metadata = this.snapshot.metadata().clone();
+
+            match update.clone() {
+                TableMetadataUpdate::TableName(name) => {
+                    if name.len() > 255 {
+                        return Err(DeltaTableError::MetadataError(format!(
+                            "Table name cannot exceed 255 characters. Provided name has {} characters.",
+                            name.len()
+                        )));
+                    }
+                    metadata.name = Some(name.clone());
+                }
+                TableMetadataUpdate::TableDescription(description) => {
+                    if description.len() > 4000 {
+                        return Err(DeltaTableError::MetadataError(format!(
+                            "Table description cannot exceed 4,000 characters. Provided description has {} characters.",
+                            description.len()
+                        )));
+                    }
+                    metadata.description = Some(description.clone());
+                }
+            }
+
+            let operation = DeltaOperation::UpdateTableMetadata {
+                metadata_update: update,
+            };
+
+            let actions = vec![Action::Metadata(metadata)];
+
+            let commit = CommitBuilder::from(this.commit_properties.clone())
+                .with_actions(actions)
+                .with_operation_id(operation_id)
+                .with_post_commit_hook_handler(this.custom_execute_handler.clone())
+                .build(
+                    Some(&this.snapshot),
+                    this.log_store.clone(),
+                    operation.clone(),
+                )
+                .await?;
+
+            if let Some(handler) = this.custom_execute_handler {
+                handler.post_execute(&this.log_store, operation_id).await?;
+            }
+            Ok(DeltaTable::new_with_state(
+                this.log_store,
+                commit.snapshot(),
+            ))
+        })
+    }
+}

crates/core/src/protocol/mod.rs

@@ -456,6 +456,12 @@ pub enum DeltaOperation {
         /// Fields added to existing schema
         fields: Vec<StructField>,
     },
+    /// Update table metadata operations
+    #[serde(rename_all = "camelCase")]
+    UpdateTableMetadata {
+        /// The metadata update to apply
+        metadata_update: crate::operations::update_table_metadata::TableMetadataUpdate,
+    },
 }
 
 impl DeltaOperation {
@@ -484,6 +490,7 @@ impl DeltaOperation {
             DeltaOperation::DropConstraint { .. } => "DROP CONSTRAINT",
             DeltaOperation::AddFeature { .. } => "ADD FEATURE",
             DeltaOperation::UpdateFieldMetadata { .. } => "UPDATE FIELD METADATA",
+            DeltaOperation::UpdateTableMetadata { .. } => "UPDATE TABLE METADATA",
         }
     }
 
@@ -521,6 +528,7 @@ impl DeltaOperation {
         match self {
             Self::Optimize { .. }
             | Self::UpdateFieldMetadata { .. }
+            | Self::UpdateTableMetadata { .. }
             | Self::SetTableProperties { .. }
             | Self::AddColumn { .. }
             | Self::AddFeature { .. }