Keep both

Author: liurenjie1024

crates/catalog/loader/src/lib.rs

@@ -1,57 +1,47 @@
+use std::future::Future;
 use std::sync::Arc;
 
 use iceberg::{Catalog, CatalogBuilder, Error, ErrorKind, Result};
 use iceberg_catalog_rest::RestCatalogBuilder;
 
-pub enum CatalogBuilderDef {
-    Rest(RestCatalogBuilder),
+pub trait BoxedCatalogBuilder {
+    fn name(&mut self, name: String);
+    fn uri(&mut self, uri: String);
+    fn warehouse(&mut self, warehouse: String);
+    fn with_prop(&mut self, key: String, value: String);
+
+    fn build(self: Box<Self>) -> Box<dyn Future<Output = Result<Arc<dyn Catalog>>>>;
 }
 
-pub fn load(r#type: &str) -> Result<CatalogBuilderDef> {
-    match r#type {
-        "rest" => Ok(CatalogBuilderDef::Rest(RestCatalogBuilder::default())),
-        _ => Err(Error::new(
-            ErrorKind::FeatureUnsupported,
-            format!("Unsupported catalog type: {}", r#type),
-        )),
+impl<T: CatalogBuilder + 'static> BoxedCatalogBuilder for T {
+    fn name(&mut self, name: String) {
+        self.name(name);
     }
-}
 
-impl CatalogBuilderDef {
-    pub fn name(self, name: impl Into<String>) -> Self {
-        match self {
-            CatalogBuilderDef::Rest(builder) => CatalogBuilderDef::Rest(builder.name(name)),
-        }
+    fn uri(&mut self, uri: String) {
+        self.uri(uri);
     }
 
-    pub fn uri(self, uri: impl Into<String>) -> Self {
-        match self {
-            CatalogBuilderDef::Rest(builder) => CatalogBuilderDef::Rest(builder.uri(uri)),
-        }
+    fn warehouse(&mut self, warehouse: String) {
+        self.warehouse(warehouse);
     }
 
-    pub fn warehouse(self, warehouse: impl Into<String>) -> Self {
-        match self {
-            CatalogBuilderDef::Rest(builder) => {
-                CatalogBuilderDef::Rest(builder.warehouse(warehouse))
-            }
-        }
+    fn with_prop(&mut self, key: String, value: String) {
+        self.with_prop(key, value);
     }
 
-    pub fn with_prop(self, key: impl Into<String>, value: impl Into<String>) -> Self {
-        match self {
-            CatalogBuilderDef::Rest(builder) => {
-                CatalogBuilderDef::Rest(builder.with_prop(key, value))
-            }
-        }
+    fn build(self: Box<Self>) -> Box<dyn Future<Output = Result<Arc<dyn Catalog>>>> {
+        let builder = *self;
+        Box::new(async move { Ok(Arc::new(builder.build().await.unwrap()) as Arc<dyn Catalog>) })
     }
+}
 
-    pub async fn build(self) -> Result<Arc<dyn Catalog>> {
-        match self {
-            CatalogBuilderDef::Rest(builder) => builder
-                .build()
-                .await
-                .map(|c| Arc::new(c) as Arc<dyn Catalog>),
-        }
+pub fn load(r#type: &str) -> Result<Box<dyn BoxedCatalogBuilder>> {
+    match r#type {
+        "rest" => Ok(Box::new(RestCatalogBuilder::default()) as Box<dyn BoxedCatalogBuilder>),
+        _ => Err(Error::new(
+            ErrorKind::FeatureUnsupported,
+            format!("Unsupported catalog type: {}", r#type),
+        )),
     }
 }

crates/catalog/rest/src/catalog.rs

@@ -245,22 +245,22 @@ impl Default for RestCatalogBuilder {
 impl CatalogBuilder for RestCatalogBuilder {
     type C = RestCatalog;
 
-    fn name(mut self, name: impl Into<String>) -> Self {
+    fn name(&mut self, name: impl Into<String>) -> &mut Self {
         self.0.name = Some(name.into());
         self
     }
 
-    fn uri(mut self, uri: impl Into<String>) -> Self {
+    fn uri(&mut self, uri: impl Into<String>) -> &mut Self {
         self.0.uri = uri.into();
         self
     }
 
-    fn warehouse(mut self, warehouse: impl Into<String>) -> Self {
+    fn warehouse(&mut self, warehouse: impl Into<String>) -> &mut Self {
         self.0.warehouse = Some(warehouse.into());
         self
     }
 
-    fn with_prop(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
+    fn with_prop(&mut self, key: impl Into<String>, value: impl Into<String>) -> &mut Self {
         self.0.props.insert(key.into(), value.into());
         self
     }
@@ -288,7 +288,7 @@ impl CatalogBuilder for RestCatalogBuilder {
 
 impl RestCatalogBuilder {
     /// Configures the catalog with a custom HTTP client.
-    pub fn with_client(mut self, client: Client) -> Self {
+    pub fn with_client(&mut self, client: Client) -> &mut Self {
         self.0.client = Some(client);
         self
     }
@@ -2331,13 +2331,13 @@ mod tests {
 
     #[tokio::test]
     async fn test_create_rest_catalog() {
-        let catalog = RestCatalogBuilder::default()
+        let mut builder = RestCatalogBuilder::default();
+        builder
             .name("test")
             .uri("http://localhost:8080")
             .with_client(Client::new())
-            .with_prop("a", "b")
-            .build()
-            .await;
+            .with_prop("a", "b");
+        let catalog = builder.build().await;
 
         assert!(catalog.is_ok());
     }

crates/iceberg/src/catalog/mod.rs

@@ -101,14 +101,14 @@ pub trait Catalog: Debug + Sync + Send {
 pub trait CatalogBuilder: Default + Debug + Send + Sync {
     /// The catalog type that this builder creates.
     type C: Catalog;
-    /// Configure name of the catalog.
-    fn name(self, name: impl Into<String>) -> Self;
+    /// Configure the name of the catalog.
+    fn name(&mut self, name: impl Into<String>) -> &mut Self;
     /// Configure uri of the catalog.
-    fn uri(self, uri: impl Into<String>) -> Self;
-    /// Configure warehouse location of the catalog.
-    fn warehouse(self, warehouse: impl Into<String>) -> Self;
+    fn uri(&mut self, uri: impl Into<String>) -> &mut Self;
+    /// Configure the warehouse location of the catalog.
+    fn warehouse(&mut self, warehouse: impl Into<String>) -> &mut Self;
     /// Configure properties of the catalog.
-    fn with_prop(self, key: impl Into<String>, value: impl Into<String>) -> Self;
+    fn with_prop(&mut self, key: impl Into<String>, value: impl Into<String>) -> &mut Self;
     /// Create the catalog
     fn build(self) -> impl Future<Output = Result<Self::C>>;
 }