chore: update lance dependency to v1.0.0-beta.15

Cargo.toml

@@ -15,20 +15,20 @@ categories = ["database-implementations"]
 rust-version = "1.78.0"
 
 [workspace.dependencies]
-lance = { "version" = "=1.0.0-beta.16", default-features = false, "tag" = "v1.0.0-beta.16", "git" = "https://github.com/lance-format/lance.git" }
+lance = { "version" = "=1.0.0-beta.15", default-features = false, "tag" = "v1.0.0-beta.15", "git" = "https://github.com/lance-format/lance.git" }
-lance-core = { "version" = "=1.0.0-beta.16", "tag" = "v1.0.0-beta.16", "git" = "https://github.com/lance-format/lance.git" }
+lance-core = { "version" = "=1.0.0-beta.15", "tag" = "v1.0.0-beta.15", "git" = "https://github.com/lance-format/lance.git" }
-lance-datagen = { "version" = "=1.0.0-beta.16", "tag" = "v1.0.0-beta.16", "git" = "https://github.com/lance-format/lance.git" }
+lance-datagen = { "version" = "=1.0.0-beta.15", "tag" = "v1.0.0-beta.15", "git" = "https://github.com/lance-format/lance.git" }
-lance-file = { "version" = "=1.0.0-beta.16", "tag" = "v1.0.0-beta.16", "git" = "https://github.com/lance-format/lance.git" }
+lance-file = { "version" = "=1.0.0-beta.15", "tag" = "v1.0.0-beta.15", "git" = "https://github.com/lance-format/lance.git" }
-lance-io = { "version" = "=1.0.0-beta.16", default-features = false, "tag" = "v1.0.0-beta.16", "git" = "https://github.com/lance-format/lance.git" }
+lance-io = { "version" = "=1.0.0-beta.15", default-features = false, "tag" = "v1.0.0-beta.15", "git" = "https://github.com/lance-format/lance.git" }
-lance-index = { "version" = "=1.0.0-beta.16", "tag" = "v1.0.0-beta.16", "git" = "https://github.com/lance-format/lance.git" }
+lance-index = { "version" = "=1.0.0-beta.15", "tag" = "v1.0.0-beta.15", "git" = "https://github.com/lance-format/lance.git" }
-lance-linalg = { "version" = "=1.0.0-beta.16", "tag" = "v1.0.0-beta.16", "git" = "https://github.com/lance-format/lance.git" }
+lance-linalg = { "version" = "=1.0.0-beta.15", "tag" = "v1.0.0-beta.15", "git" = "https://github.com/lance-format/lance.git" }
-lance-namespace = { "version" = "=1.0.0-beta.16", "tag" = "v1.0.0-beta.16", "git" = "https://github.com/lance-format/lance.git" }
+lance-namespace = { "version" = "=1.0.0-beta.15", "tag" = "v1.0.0-beta.15", "git" = "https://github.com/lance-format/lance.git" }
-lance-namespace-impls = { "version" = "=1.0.0-beta.16", default-features = false, "tag" = "v1.0.0-beta.16", "git" = "https://github.com/lance-format/lance.git" }
+lance-namespace-impls = { "version" = "=1.0.0-beta.15", default-features = false, "tag" = "v1.0.0-beta.15", "git" = "https://github.com/lance-format/lance.git" }
-lance-table = { "version" = "=1.0.0-beta.16", "tag" = "v1.0.0-beta.16", "git" = "https://github.com/lance-format/lance.git" }
+lance-table = { "version" = "=1.0.0-beta.15", "tag" = "v1.0.0-beta.15", "git" = "https://github.com/lance-format/lance.git" }
-lance-testing = { "version" = "=1.0.0-beta.16", "tag" = "v1.0.0-beta.16", "git" = "https://github.com/lance-format/lance.git" }
+lance-testing = { "version" = "=1.0.0-beta.15", "tag" = "v1.0.0-beta.15", "git" = "https://github.com/lance-format/lance.git" }
-lance-datafusion = { "version" = "=1.0.0-beta.16", "tag" = "v1.0.0-beta.16", "git" = "https://github.com/lance-format/lance.git" }
+lance-datafusion = { "version" = "=1.0.0-beta.15", "tag" = "v1.0.0-beta.15", "git" = "https://github.com/lance-format/lance.git" }
-lance-encoding = { "version" = "=1.0.0-beta.16", "tag" = "v1.0.0-beta.16", "git" = "https://github.com/lance-format/lance.git" }
+lance-encoding = { "version" = "=1.0.0-beta.15", "tag" = "v1.0.0-beta.15", "git" = "https://github.com/lance-format/lance.git" }
-lance-arrow = { "version" = "=1.0.0-beta.16", "tag" = "v1.0.0-beta.16", "git" = "https://github.com/lance-format/lance.git" }
+lance-arrow = { "version" = "=1.0.0-beta.15", "tag" = "v1.0.0-beta.15", "git" = "https://github.com/lance-format/lance.git" }
 ahash = "0.8"
 # Note that this one does not include pyarrow
 arrow = { version = "56.2", optional = false }

python/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.25.4-beta.3"
+current_version = "0.25.4-beta.2"
 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.25.4-beta.3"
+version = "0.25.4-beta.2"
 edition.workspace = true
 description = "Python bindings for LanceDB"
 license.workspace = true

python/python/lancedb/db.py

@@ -194,10 +194,6 @@ class DBConnection(EnforceOverrides):
             connection will be inherited by the table, but can be overridden here.
             See available options at
             <https://lancedb.com/docs/storage/>
-
-            To enable stable row IDs (row IDs remain stable after compaction,
-            update, delete, and merges), set `new_table_enable_stable_row_ids`
-            to `"true"` in storage_options when connecting to the database.
         data_storage_version: optional, str, default "stable"
             Deprecated.  Set `storage_options` when connecting to the database and set
             `new_table_data_storage_version` in the options.
@@ -1083,10 +1079,6 @@ class AsyncConnection(object):
             See available options at
             <https://lancedb.com/docs/storage/>
 
-            To enable stable row IDs (row IDs remain stable after compaction,
-            update, delete, and merges), set `new_table_enable_stable_row_ids`
-            to `"true"` in storage_options when connecting to the database.
-
         Returns
         -------
         AsyncTable

python/python/lancedb/query.py

@@ -2429,8 +2429,9 @@ class AsyncQueryBase(object):
         >>> from lancedb import connect_async
         >>> async def doctest_example():
         ...     conn = await connect_async("./.lancedb")
-        ...     table = await conn.create_table("my_table", [{"vector": [99.0, 99.0]}])
+        ...     table = await conn.create_table("my_table", [{"vector": [99, 99]}])
-        ...     plan = await table.query().nearest_to([1.0, 2.0]).explain_plan(True)
+        ...     query = [100, 100]
+        ...     plan = await table.query().nearest_to([1, 2]).explain_plan(True)
         ...     print(plan)
         >>> asyncio.run(doctest_example()) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
         ProjectionExec: expr=[vector@0 as vector, _distance@2 as _distance]
@@ -2439,7 +2440,6 @@ class AsyncQueryBase(object):
               SortExec: TopK(fetch=10), expr=[_distance@2 ASC NULLS LAST, _rowid@1 ASC NULLS LAST], preserve_partitioning=[false]
                 KNNVectorDistance: metric=l2
                   LanceRead: uri=..., projection=[vector], ...
-        <BLANKLINE>
 
         Parameters
         ----------
@@ -3141,9 +3141,10 @@ class AsyncHybridQuery(AsyncStandardQuery, AsyncVectorQueryBase):
         >>> from lancedb.index import FTS
         >>> async def doctest_example():
         ...     conn = await connect_async("./.lancedb")
-        ...     table = await conn.create_table("my_table", [{"vector": [99.0, 99.0], "text": "hello world"}])
+        ...     table = await conn.create_table("my_table", [{"vector": [99, 99], "text": "hello world"}])
         ...     await table.create_index("text", config=FTS(with_position=False))
-        ...     plan = await table.query().nearest_to([1.0, 2.0]).nearest_to_text("hello").explain_plan(True)
+        ...     query = [100, 100]
+        ...     plan = await table.query().nearest_to([1, 2]).nearest_to_text("hello").explain_plan(True)
         ...     print(plan)
         >>> asyncio.run(doctest_example()) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
         Vector Search Plan:
@@ -3417,8 +3418,9 @@ class BaseQueryBuilder(object):
         >>> from lancedb import connect_async
         >>> async def doctest_example():
         ...     conn = await connect_async("./.lancedb")
-        ...     table = await conn.create_table("my_table", [{"vector": [99.0, 99.0]}])
+        ...     table = await conn.create_table("my_table", [{"vector": [99, 99]}])
-        ...     plan = await table.query().nearest_to([1.0, 2.0]).explain_plan(True)
+        ...     query = [100, 100]
+        ...     plan = await table.query().nearest_to([1, 2]).explain_plan(True)
         ...     print(plan)
         >>> asyncio.run(doctest_example()) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
         ProjectionExec: expr=[vector@0 as vector, _distance@2 as _distance]
@@ -3427,7 +3429,6 @@ class BaseQueryBuilder(object):
               SortExec: TopK(fetch=10), expr=[_distance@2 ASC NULLS LAST, _rowid@1 ASC NULLS LAST], preserve_partitioning=[false]
                 KNNVectorDistance: metric=l2
                   LanceRead: uri=..., projection=[vector], ...
-        <BLANKLINE>
 
         Parameters
         ----------

python/python/tests/test_db.py

@@ -441,150 +441,6 @@ async def test_create_table_v2_manifest_paths_async(tmp_path):
         assert re.match(r"\d{20}\.manifest", manifest)
 
 
-@pytest.mark.asyncio
-async def test_create_table_stable_row_ids_via_storage_options(tmp_path):
-    """Test stable_row_ids via storage_options at connect time."""
-    import lance
-
-    # Connect with stable row IDs enabled as default for new tables
-    db_with = await lancedb.connect_async(
-        tmp_path, storage_options={"new_table_enable_stable_row_ids": "true"}
-    )
-    # Connect without stable row IDs (default)
-    db_without = await lancedb.connect_async(
-        tmp_path, storage_options={"new_table_enable_stable_row_ids": "false"}
-    )
-
-    # Create table using connection with stable row IDs enabled
-    await db_with.create_table(
-        "with_stable_via_opts",
-        data=[{"id": i} for i in range(10)],
-    )
-    lance_ds_with = lance.dataset(tmp_path / "with_stable_via_opts.lance")
-    fragments_with = lance_ds_with.get_fragments()
-    assert len(fragments_with) > 0
-    assert fragments_with[0].metadata.row_id_meta is not None
-
-    # Create table using connection without stable row IDs
-    await db_without.create_table(
-        "without_stable_via_opts",
-        data=[{"id": i} for i in range(10)],
-    )
-    lance_ds_without = lance.dataset(tmp_path / "without_stable_via_opts.lance")
-    fragments_without = lance_ds_without.get_fragments()
-    assert len(fragments_without) > 0
-    assert fragments_without[0].metadata.row_id_meta is None
-
-
-def test_create_table_stable_row_ids_via_storage_options_sync(tmp_path):
-    """Test that enable_stable_row_ids can be set via storage_options (sync API)."""
-    # Connect with stable row IDs enabled as default for new tables
-    db_with = lancedb.connect(
-        tmp_path, storage_options={"new_table_enable_stable_row_ids": "true"}
-    )
-    # Connect without stable row IDs (default)
-    db_without = lancedb.connect(
-        tmp_path, storage_options={"new_table_enable_stable_row_ids": "false"}
-    )
-
-    # Create table using connection with stable row IDs enabled
-    tbl_with = db_with.create_table(
-        "with_stable_sync",
-        data=[{"id": i} for i in range(10)],
-    )
-    lance_ds_with = tbl_with.to_lance()
-    fragments_with = lance_ds_with.get_fragments()
-    assert len(fragments_with) > 0
-    assert fragments_with[0].metadata.row_id_meta is not None
-
-    # Create table using connection without stable row IDs
-    tbl_without = db_without.create_table(
-        "without_stable_sync",
-        data=[{"id": i} for i in range(10)],
-    )
-    lance_ds_without = tbl_without.to_lance()
-    fragments_without = lance_ds_without.get_fragments()
-    assert len(fragments_without) > 0
-    assert fragments_without[0].metadata.row_id_meta is None
-
-
-@pytest.mark.asyncio
-async def test_create_table_stable_row_ids_table_level_override(tmp_path):
-    """Test that stable_row_ids can be enabled/disabled at create_table level."""
-    import lance
-
-    # Connect without any stable row ID setting
-    db_default = await lancedb.connect_async(tmp_path)
-
-    # Connect with stable row IDs enabled at connection level
-    db_with_stable = await lancedb.connect_async(
-        tmp_path, storage_options={"new_table_enable_stable_row_ids": "true"}
-    )
-
-    # Case 1: No connection setting, enable at table level
-    await db_default.create_table(
-        "table_level_enabled",
-        data=[{"id": i} for i in range(10)],
-        storage_options={"new_table_enable_stable_row_ids": "true"},
-    )
-    lance_ds = lance.dataset(tmp_path / "table_level_enabled.lance")
-    fragments = lance_ds.get_fragments()
-    assert len(fragments) > 0
-    assert fragments[0].metadata.row_id_meta is not None, (
-        "Table should have stable row IDs when enabled at table level"
-    )
-
-    # Case 2: Connection has stable row IDs, override with false at table level
-    await db_with_stable.create_table(
-        "table_level_disabled",
-        data=[{"id": i} for i in range(10)],
-        storage_options={"new_table_enable_stable_row_ids": "false"},
-    )
-    lance_ds = lance.dataset(tmp_path / "table_level_disabled.lance")
-    fragments = lance_ds.get_fragments()
-    assert len(fragments) > 0
-    assert fragments[0].metadata.row_id_meta is None, (
-        "Table should NOT have stable row IDs when disabled at table level"
-    )
-
-
-def test_create_table_stable_row_ids_table_level_override_sync(tmp_path):
-    """Test that stable_row_ids can be enabled/disabled at create_table level (sync)."""
-    # Connect without any stable row ID setting
-    db_default = lancedb.connect(tmp_path)
-
-    # Connect with stable row IDs enabled at connection level
-    db_with_stable = lancedb.connect(
-        tmp_path, storage_options={"new_table_enable_stable_row_ids": "true"}
-    )
-
-    # Case 1: No connection setting, enable at table level
-    tbl = db_default.create_table(
-        "table_level_enabled_sync",
-        data=[{"id": i} for i in range(10)],
-        storage_options={"new_table_enable_stable_row_ids": "true"},
-    )
-    lance_ds = tbl.to_lance()
-    fragments = lance_ds.get_fragments()
-    assert len(fragments) > 0
-    assert fragments[0].metadata.row_id_meta is not None, (
-        "Table should have stable row IDs when enabled at table level"
-    )
-
-    # Case 2: Connection has stable row IDs, override with false at table level
-    tbl = db_with_stable.create_table(
-        "table_level_disabled_sync",
-        data=[{"id": i} for i in range(10)],
-        storage_options={"new_table_enable_stable_row_ids": "false"},
-    )
-    lance_ds = tbl.to_lance()
-    fragments = lance_ds.get_fragments()
-    assert len(fragments) > 0
-    assert fragments[0].metadata.row_id_meta is None, (
-        "Table should NOT have stable row IDs when disabled at table level"
-    )
-
-
 def test_open_table_sync(tmp_db: lancedb.DBConnection):
     tmp_db.create_table("test", data=[{"id": 0}])
     assert tmp_db.open_table("test").count_rows() == 1

rust/lancedb/src/database/listing.rs

@@ -35,7 +35,6 @@ pub const LANCE_FILE_EXTENSION: &str = "lance";
 
 pub const OPT_NEW_TABLE_STORAGE_VERSION: &str = "new_table_data_storage_version";
 pub const OPT_NEW_TABLE_V2_MANIFEST_PATHS: &str = "new_table_enable_v2_manifest_paths";
-pub const OPT_NEW_TABLE_ENABLE_STABLE_ROW_IDS: &str = "new_table_enable_stable_row_ids";
 
 /// Controls how new tables should be created
 #[derive(Clone, Debug, Default)]
@@ -49,12 +48,6 @@ pub struct NewTableConfig {
     /// V2 manifest paths are more efficient than V2 manifest paths but are not
     /// supported by old clients.
     pub enable_v2_manifest_paths: Option<bool>,
-    /// Whether to enable stable row IDs for new tables
-    ///
-    /// When enabled, row IDs remain stable after compaction, update, delete,
-    /// and merges. This is useful for materialized views and other use cases
-    /// that need to track source rows across these operations.
-    pub enable_stable_row_ids: Option<bool>,
 }
 
 /// Options specific to the listing database
@@ -94,14 +87,6 @@ impl ListingDatabaseOptions {
                     })
                 })
                 .transpose()?,
-            enable_stable_row_ids: map
-                .get(OPT_NEW_TABLE_ENABLE_STABLE_ROW_IDS)
-                .map(|s| {
-                    s.parse::<bool>().map_err(|_| Error::InvalidInput {
-                        message: format!("enable_stable_row_ids must be a boolean, received {}", s),
-                    })
-                })
-                .transpose()?,
         };
         // We just assume that any options that are not new table config options are storage options
         let storage_options = map
@@ -109,7 +94,6 @@ impl ListingDatabaseOptions {
             .filter(|(key, _)| {
                 key.as_str() != OPT_NEW_TABLE_STORAGE_VERSION
                     && key.as_str() != OPT_NEW_TABLE_V2_MANIFEST_PATHS
-                    && key.as_str() != OPT_NEW_TABLE_ENABLE_STABLE_ROW_IDS
             })
             .map(|(key, value)| (key.clone(), value.clone()))
             .collect();
@@ -134,12 +118,6 @@ impl DatabaseOptions for ListingDatabaseOptions {
                 enable_v2_manifest_paths.to_string(),
             );
         }
-        if let Some(enable_stable_row_ids) = self.new_table_config.enable_stable_row_ids {
-            map.insert(
-                OPT_NEW_TABLE_ENABLE_STABLE_ROW_IDS.to_string(),
-                enable_stable_row_ids.to_string(),
-            );
-        }
     }
 }
 
@@ -519,7 +497,7 @@ impl ListingDatabase {
     fn extract_storage_overrides(
         &self,
         request: &CreateTableRequest,
-    ) -> Result<(Option<LanceFileVersion>, Option<bool>, Option<bool>)> {
+    ) -> Result<(Option<LanceFileVersion>, Option<bool>)> {
         let storage_options = request
             .write_options
             .lance_write_params
@@ -540,19 +518,7 @@ impl ListingDatabase {
                 message: "enable_v2_manifest_paths must be a boolean".to_string(),
             })?;
 
-        let stable_row_ids_override = storage_options
+        Ok((storage_version_override, v2_manifest_override))
-            .and_then(|opts| opts.get(OPT_NEW_TABLE_ENABLE_STABLE_ROW_IDS))
-            .map(|s| s.parse::<bool>())
-            .transpose()
-            .map_err(|_| Error::InvalidInput {
-                message: "enable_stable_row_ids must be a boolean".to_string(),
-            })?;
-
-        Ok((
-            storage_version_override,
-            v2_manifest_override,
-            stable_row_ids_override,
-        ))
     }
 
     /// Prepare write parameters for table creation
@@ -561,7 +527,6 @@ impl ListingDatabase {
         request: &CreateTableRequest,
         storage_version_override: Option<LanceFileVersion>,
         v2_manifest_override: Option<bool>,
-        stable_row_ids_override: Option<bool>,
     ) -> lance::dataset::WriteParams {
         let mut write_params = request
             .write_options
@@ -606,13 +571,6 @@ impl ListingDatabase {
             write_params.enable_v2_manifest_paths = enable_v2_manifest_paths;
         }
 
-        // Apply enable_stable_row_ids: table-level override takes precedence over connection config
-        if let Some(enable_stable_row_ids) =
-            stable_row_ids_override.or(self.new_table_config.enable_stable_row_ids)
-        {
-            write_params.enable_stable_row_ids = enable_stable_row_ids;
-        }
-
         if matches!(&request.mode, CreateTableMode::Overwrite) {
             write_params.mode = WriteMode::Overwrite;
         }
@@ -748,15 +706,11 @@ impl Database for ListingDatabase {
             .clone()
             .unwrap_or_else(|| self.table_uri(&request.name).unwrap());
 
-        let (storage_version_override, v2_manifest_override, stable_row_ids_override) =
+        let (storage_version_override, v2_manifest_override) =
             self.extract_storage_overrides(&request)?;
 
-        let write_params = self.prepare_write_params(
+        let write_params =
-            &request,
+            self.prepare_write_params(&request, storage_version_override, v2_manifest_override);
-            storage_version_override,
-            v2_manifest_override,
-            stable_row_ids_override,
-        );
 
         let data_schema = request.data.arrow_schema();
 
@@ -967,7 +921,7 @@ impl Database for ListingDatabase {
 mod tests {
     use super::*;
     use crate::connection::ConnectRequest;
-    use crate::database::{CreateTableData, CreateTableMode, CreateTableRequest, WriteOptions};
+    use crate::database::{CreateTableData, CreateTableMode, CreateTableRequest};
     use crate::table::{Table, TableDefinition};
     use arrow_array::{Int32Array, RecordBatch, StringArray};
     use arrow_schema::{DataType, Field, Schema};
@@ -1667,267 +1621,4 @@ mod tests {
         // Cloned table should have all 8 rows from the latest version
         assert_eq!(cloned_table.count_rows(None).await.unwrap(), 8);
     }
-
-    #[tokio::test]
-    async fn test_create_table_with_stable_row_ids_connection_level() {
-        let tempdir = tempdir().unwrap();
-        let uri = tempdir.path().to_str().unwrap();
-
-        // Create database with stable row IDs enabled at connection level
-        let mut options = HashMap::new();
-        options.insert(
-            OPT_NEW_TABLE_ENABLE_STABLE_ROW_IDS.to_string(),
-            "true".to_string(),
-        );
-
-        let request = ConnectRequest {
-            uri: uri.to_string(),
-            #[cfg(feature = "remote")]
-            client_config: Default::default(),
-            options,
-            read_consistency_interval: None,
-            session: None,
-        };
-
-        let db = ListingDatabase::connect_with_options(&request)
-            .await
-            .unwrap();
-
-        // Verify the config was parsed correctly
-        assert_eq!(db.new_table_config.enable_stable_row_ids, Some(true));
-
-        // Create a table - it should inherit the stable row IDs setting
-        let schema = Arc::new(Schema::new(vec![Field::new("id", DataType::Int32, false)]));
-
-        let batch = RecordBatch::try_new(
-            schema.clone(),
-            vec![Arc::new(Int32Array::from(vec![1, 2, 3]))],
-        )
-        .unwrap();
-
-        let reader = Box::new(arrow_array::RecordBatchIterator::new(
-            vec![Ok(batch)],
-            schema.clone(),
-        ));
-
-        let table = db
-            .create_table(CreateTableRequest {
-                name: "test_stable".to_string(),
-                namespace: vec![],
-                data: CreateTableData::Data(reader),
-                mode: CreateTableMode::Create,
-                write_options: Default::default(),
-                location: None,
-            })
-            .await
-            .unwrap();
-
-        // Verify table was created successfully
-        assert_eq!(table.count_rows(None).await.unwrap(), 3);
-    }
-
-    #[tokio::test]
-    async fn test_create_table_with_stable_row_ids_table_level() {
-        let (_tempdir, db) = setup_database().await;
-
-        // Verify connection has no stable row IDs config
-        assert_eq!(db.new_table_config.enable_stable_row_ids, None);
-
-        // Create a table with stable row IDs enabled at table level via storage_options
-        let schema = Arc::new(Schema::new(vec![Field::new("id", DataType::Int32, false)]));
-
-        let batch = RecordBatch::try_new(
-            schema.clone(),
-            vec![Arc::new(Int32Array::from(vec![1, 2, 3]))],
-        )
-        .unwrap();
-
-        let reader = Box::new(arrow_array::RecordBatchIterator::new(
-            vec![Ok(batch)],
-            schema.clone(),
-        ));
-
-        let mut storage_options = HashMap::new();
-        storage_options.insert(
-            OPT_NEW_TABLE_ENABLE_STABLE_ROW_IDS.to_string(),
-            "true".to_string(),
-        );
-
-        let write_options = WriteOptions {
-            lance_write_params: Some(lance::dataset::WriteParams {
-                store_params: Some(lance::io::ObjectStoreParams {
-                    storage_options: Some(storage_options),
-                    ..Default::default()
-                }),
-                ..Default::default()
-            }),
-        };
-
-        let table = db
-            .create_table(CreateTableRequest {
-                name: "test_stable_table_level".to_string(),
-                namespace: vec![],
-                data: CreateTableData::Data(reader),
-                mode: CreateTableMode::Create,
-                write_options,
-                location: None,
-            })
-            .await
-            .unwrap();
-
-        // Verify table was created successfully
-        assert_eq!(table.count_rows(None).await.unwrap(), 3);
-    }
-
-    #[tokio::test]
-    async fn test_create_table_stable_row_ids_table_overrides_connection() {
-        let tempdir = tempdir().unwrap();
-        let uri = tempdir.path().to_str().unwrap();
-
-        // Create database with stable row IDs enabled at connection level
-        let mut options = HashMap::new();
-        options.insert(
-            OPT_NEW_TABLE_ENABLE_STABLE_ROW_IDS.to_string(),
-            "true".to_string(),
-        );
-
-        let request = ConnectRequest {
-            uri: uri.to_string(),
-            #[cfg(feature = "remote")]
-            client_config: Default::default(),
-            options,
-            read_consistency_interval: None,
-            session: None,
-        };
-
-        let db = ListingDatabase::connect_with_options(&request)
-            .await
-            .unwrap();
-
-        assert_eq!(db.new_table_config.enable_stable_row_ids, Some(true));
-
-        // Create table with stable row IDs disabled at table level (overrides connection)
-        let schema = Arc::new(Schema::new(vec![Field::new("id", DataType::Int32, false)]));
-
-        let batch = RecordBatch::try_new(
-            schema.clone(),
-            vec![Arc::new(Int32Array::from(vec![1, 2, 3]))],
-        )
-        .unwrap();
-
-        let reader = Box::new(arrow_array::RecordBatchIterator::new(
-            vec![Ok(batch)],
-            schema.clone(),
-        ));
-
-        let mut storage_options = HashMap::new();
-        storage_options.insert(
-            OPT_NEW_TABLE_ENABLE_STABLE_ROW_IDS.to_string(),
-            "false".to_string(),
-        );
-
-        let write_options = WriteOptions {
-            lance_write_params: Some(lance::dataset::WriteParams {
-                store_params: Some(lance::io::ObjectStoreParams {
-                    storage_options: Some(storage_options),
-                    ..Default::default()
-                }),
-                ..Default::default()
-            }),
-        };
-
-        let table = db
-            .create_table(CreateTableRequest {
-                name: "test_override".to_string(),
-                namespace: vec![],
-                data: CreateTableData::Data(reader),
-                mode: CreateTableMode::Create,
-                write_options,
-                location: None,
-            })
-            .await
-            .unwrap();
-
-        // Verify table was created successfully
-        assert_eq!(table.count_rows(None).await.unwrap(), 3);
-    }
-
-    #[tokio::test]
-    async fn test_stable_row_ids_invalid_value() {
-        let tempdir = tempdir().unwrap();
-        let uri = tempdir.path().to_str().unwrap();
-
-        // Try to create database with invalid stable row IDs value
-        let mut options = HashMap::new();
-        options.insert(
-            OPT_NEW_TABLE_ENABLE_STABLE_ROW_IDS.to_string(),
-            "not_a_boolean".to_string(),
-        );
-
-        let request = ConnectRequest {
-            uri: uri.to_string(),
-            #[cfg(feature = "remote")]
-            client_config: Default::default(),
-            options,
-            read_consistency_interval: None,
-            session: None,
-        };
-
-        let result = ListingDatabase::connect_with_options(&request).await;
-
-        assert!(result.is_err());
-        assert!(matches!(
-            result.unwrap_err(),
-            Error::InvalidInput { message } if message.contains("enable_stable_row_ids must be a boolean")
-        ));
-    }
-
-    #[test]
-    fn test_stable_row_ids_config_serialization() {
-        // Test that ListingDatabaseOptions correctly serializes stable_row_ids
-        let mut options = HashMap::new();
-        options.insert(
-            OPT_NEW_TABLE_ENABLE_STABLE_ROW_IDS.to_string(),
-            "true".to_string(),
-        );
-
-        // Parse the options
-        let db_options = ListingDatabaseOptions::parse_from_map(&options).unwrap();
-        assert_eq!(
-            db_options.new_table_config.enable_stable_row_ids,
-            Some(true)
-        );
-
-        // Serialize back to map
-        let mut serialized = HashMap::new();
-        db_options.serialize_into_map(&mut serialized);
-
-        assert_eq!(
-            serialized.get(OPT_NEW_TABLE_ENABLE_STABLE_ROW_IDS),
-            Some(&"true".to_string())
-        );
-    }
-
-    #[test]
-    fn test_stable_row_ids_config_parse_false() {
-        let mut options = HashMap::new();
-        options.insert(
-            OPT_NEW_TABLE_ENABLE_STABLE_ROW_IDS.to_string(),
-            "false".to_string(),
-        );
-
-        let db_options = ListingDatabaseOptions::parse_from_map(&options).unwrap();
-        assert_eq!(
-            db_options.new_table_config.enable_stable_row_ids,
-            Some(false)
-        );
-    }
-
-    #[test]
-    fn test_stable_row_ids_config_not_set() {
-        let options = HashMap::new();
-
-        let db_options = ListingDatabaseOptions::parse_from_map(&options).unwrap();
-        assert_eq!(db_options.new_table_config.enable_stable_row_ids, None);
-    }
 }