refactor(python): use namespace-backed rust connection

python/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.31.0-beta.8"
+current_version = "0.31.0-beta.7"
 parse = """(?x)
     (?P<major>0|[1-9]\\d*)\\.
     (?P<minor>0|[1-9]\\d*)\\.

python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lancedb-python"
-version = "0.31.0-beta.8"
+version = "0.31.0-beta.7"
 edition.workspace = true
 description = "Python bindings for LanceDB"
 license.workspace = true

rust/lancedb/src/database/namespace.rs

@@ -26,7 +26,6 @@ use crate::connection::NamespaceClientPushdownOperation;
 use crate::database::ReadConsistency;
 use crate::error::{Error, Result};
 use crate::table::NativeTable;
-use lance::dataset::WriteMode;
 
 use super::{
     BaseTable, CloneTableRequest, CreateTableMode, CreateTableRequest as DbCreateTableRequest,
@@ -185,7 +184,6 @@ impl Database for LanceNamespaceDatabase {
     async fn create_table(&self, request: DbCreateTableRequest) -> Result<Arc<dyn BaseTable>> {
         let mut table_id = request.namespace_path.clone();
         table_id.push(request.name.clone());
-        let mut existing_table = None;
 
         match request.mode {
             CreateTableMode::Create => {}
@@ -194,7 +192,20 @@ impl Database for LanceNamespaceDatabase {
                     id: Some(table_id.clone()),
                     ..Default::default()
                 };
-                existing_table = self.namespace.describe_table(describe_request).await.ok();
+                let describe_result = self.namespace.describe_table(describe_request).await;
+                if describe_result.is_ok() {
+                    // Drop the existing table - must succeed
+                    let drop_request = DropTableRequest {
+                        id: Some(table_id.clone()),
+                        ..Default::default()
+                    };
+                    self.namespace
+                        .drop_table(drop_request)
+                        .await
+                        .map_err(|e| Error::Runtime {
+                            message: format!("Failed to drop existing table for overwrite: {}", e),
+                        })?;
+                }
             }
             CreateTableMode::ExistOk(_) => {
                 let describe_request = DescribeTableRequest {
@@ -229,55 +240,40 @@ impl Database for LanceNamespaceDatabase {
         };
 
         let (location, initial_storage_options, managed_versioning) = {
-            if let Some(response) = existing_table {
+            let response = self
-                let loc = response.location.ok_or_else(|| Error::Runtime {
+                .namespace
-                    message: "Table location is missing from describe_table response".to_string(),
+                .declare_table(declare_request)
-                })?;
+                .await
-                let opts = response
+                .map_err(|e| {
-                    .storage_options
+                    let err_str = e.to_string();
-                    .or_else(|| Some(self.storage_options.clone()))
+                    if matches!(request.mode, CreateTableMode::Create)
-                    .filter(|o| !o.is_empty());
+                        && (err_str.contains("already exists")
-                (loc, opts, response.managed_versioning)
+                            || err_str.contains("TableAlreadyExists")
-            } else {
+                            || err_str.contains("table already exists"))
-                let response = self
+                    {
-                    .namespace
+                        Error::TableAlreadyExists {
-                    .declare_table(declare_request)
+                            name: request.name.clone(),
-                    .await
-                    .map_err(|e| {
-                        let err_str = e.to_string();
-                        if matches!(request.mode, CreateTableMode::Create)
-                            && (err_str.contains("already exists")
-                                || err_str.contains("TableAlreadyExists")
-                                || err_str.contains("table already exists"))
-                        {
-                            Error::TableAlreadyExists {
-                                name: request.name.clone(),
-                            }
-                        } else {
-                            Error::Runtime {
-                                message: format!("Failed to declare table: {}", e),
-                            }
                         }
-                    })?;
+                    } else {
-                let loc = response.location.ok_or_else(|| Error::Runtime {
+                        Error::Runtime {
-                    message: "Table location is missing from declare_table response".to_string(),
+                            message: format!("Failed to declare table: {}", e),
+                        }
+                    }
                 })?;
-                // Use storage options from response, fall back to self.storage_options
+            let loc = response.location.ok_or_else(|| Error::Runtime {
-                let opts = response
+                message: "Table location is missing from declare_table response".to_string(),
-                    .storage_options
+            })?;
-                    .or_else(|| Some(self.storage_options.clone()))
+            // Use storage options from response, fall back to self.storage_options
-                    .filter(|o| !o.is_empty());
+            let opts = response
-                (loc, opts, response.managed_versioning)
+                .storage_options
-            }
+                .or_else(|| Some(self.storage_options.clone()))
+                .filter(|o| !o.is_empty());
+            (loc, opts, response.managed_versioning)
         };
 
         // Build write params with storage options and commit handler
         let mut params = request.write_options.lance_write_params.unwrap_or_default();
 
-        if matches!(request.mode, CreateTableMode::Overwrite) {
-            params.mode = WriteMode::Overwrite;
-        }
-
         // Set up storage options if provided
         if let Some(storage_opts) = initial_storage_options {
             let store_params = params