feat!: support multi-level namespace (#2603)

This PR adds support of multi-level namespace in a LanceDB database,
according to the Lance Namespace spec.

This allows users to create namespace inside a database connection,
perform create, drop, list, list_tables in a namespace. (other
operations like update, describe will be in a follow-up PR)

The 3 types of database connections behave like the following:
1 Local database connections will continue to have just a flat list of
tables for backwards compatibility.
2. Remote database connections will make REST API calls according to the
APIs in the Lance Namespace spec.
3. Lance Namespace connections will invoke the corresponding operations
against the specific namespace implementation which could have different
behaviors regarding these APIs.

All the table APIs now take identifier instead of name, for example
`/v1/table/{name}/create` is now `/v1/table/{id}/create`. If a table is
directly in the root namespace, the API call is identical. If the table
is in a namespace, then the full table ID should be used, with `$` as
the default delimiter (`.` is a special character and creates issues
with URL parsing so `$` is used), for example
`/v1/table/ns1$table1/create`. If a different parameter needs to be
passed in, user can configure the `id_delimiter` in client config and
that becomes a query parameter, for example
`/v1/table/ns1__table1/create?delimiter=__`

The Python and Typescript APIs are kept backwards compatible, but the
following Rust APIs are not:
1. `Connection::drop_table(&self, name: impl AsRef<str>) -> Result<()>`
is now `Connection::drop_table(&self, name: impl AsRef<str>, namespace:
&[String]) -> Result<()>`
2. `Connection::drop_all_tables(&self) -> Result<()>` is now
`Connection::drop_all_tables(&self, name: impl AsRef<str>) ->
Result<()>`

python/python/lancedb/_lancedb.pyi

@@ -21,14 +21,28 @@ class Session:
 
 class Connection(object):
     uri: str
+    async def is_open(self): ...
+    async def close(self): ...
+    async def list_namespaces(
+        self,
+        namespace: List[str],
+        page_token: Optional[str],
+        limit: Optional[int],
+    ) -> List[str]: ...
+    async def create_namespace(self, namespace: List[str]) -> None: ...
+    async def drop_namespace(self, namespace: List[str]) -> None: ...
     async def table_names(
-        self, start_after: Optional[str], limit: Optional[int]
+        self,
+        namespace: List[str],
+        start_after: Optional[str],
+        limit: Optional[int],
     ) -> list[str]: ...
     async def create_table(
         self,
         name: str,
         mode: str,
         data: pa.RecordBatchReader,
+        namespace: List[str] = [],
         storage_options: Optional[Dict[str, str]] = None,
     ) -> Table: ...
     async def create_empty_table(
@@ -36,10 +50,25 @@ class Connection(object):
         name: str,
         mode: str,
         schema: pa.Schema,
+        namespace: List[str] = [],
         storage_options: Optional[Dict[str, str]] = None,
     ) -> Table: ...
-    async def rename_table(self, old_name: str, new_name: str) -> None: ...
-    async def drop_table(self, name: str) -> None: ...
+    async def open_table(
+        self,
+        name: str,
+        namespace: List[str] = [],
+        storage_options: Optional[Dict[str, str]] = None,
+        index_cache_size: Optional[int] = None,
+    ) -> Table: ...
+    async def rename_table(
+        self,
+        cur_name: str,
+        new_name: str,
+        cur_namespace: List[str] = [],
+        new_namespace: List[str] = [],
+    ) -> None: ...
+    async def drop_table(self, name: str, namespace: List[str] = []) -> None: ...
+    async def drop_all_tables(self, namespace: List[str] = []) -> None: ...
 
 class Table:
     def name(self) -> str: ...

python/python/lancedb/db.py

@@ -43,14 +43,69 @@ if TYPE_CHECKING:
 class DBConnection(EnforceOverrides):
     """An active LanceDB connection interface."""
 
+    def list_namespaces(
+        self,
+        namespace: List[str] = [],
+        page_token: Optional[str] = None,
+        limit: int = 10,
+    ) -> Iterable[str]:
+        """List immediate child namespace names in the given namespace.
+
+        Parameters
+        ----------
+        namespace: List[str], default []
+            The parent namespace to list namespaces in.
+            Empty list represents root namespace.
+        page_token: str, optional
+            The token to use for pagination. If not present, start from the beginning.
+        limit: int, default 10
+            The size of the page to return.
+
+        Returns
+        -------
+        Iterable of str
+            List of immediate child namespace names
+        """
+        return []
+
+    def create_namespace(self, namespace: List[str]) -> None:
+        """Create a new namespace.
+
+        Parameters
+        ----------
+        namespace: List[str]
+            The namespace identifier to create.
+        """
+        raise NotImplementedError(
+            "Namespace operations are not supported for this connection type"
+        )
+
+    def drop_namespace(self, namespace: List[str]) -> None:
+        """Drop a namespace.
+
+        Parameters
+        ----------
+        namespace: List[str]
+            The namespace identifier to drop.
+        """
+        raise NotImplementedError(
+            "Namespace operations are not supported for this connection type"
+        )
+
     @abstractmethod
     def table_names(
-        self, page_token: Optional[str] = None, limit: int = 10
+        self,
+        namespace: List[str] = [],
+        page_token: Optional[str] = None,
+        limit: int = 10,
     ) -> Iterable[str]:
         """List all tables in this database, in sorted order
 
         Parameters
         ----------
+        namespace: List[str], default []
+            The namespace to list tables in.
+            Empty list represents root namespace.
         page_token: str, optional
             The token to use for pagination. If not present, start from the beginning.
             Typically, this token is last table name from the previous page.
@@ -77,6 +132,7 @@ class DBConnection(EnforceOverrides):
         fill_value: float = 0.0,
         embedding_functions: Optional[List[EmbeddingFunctionConfig]] = None,
         *,
+        namespace: List[str] = [],
         storage_options: Optional[Dict[str, str]] = None,
         data_storage_version: Optional[str] = None,
         enable_v2_manifest_paths: Optional[bool] = None,
@@ -87,6 +143,9 @@ class DBConnection(EnforceOverrides):
         ----------
         name: str
             The name of the table.
+        namespace: List[str], default []
+            The namespace to create the table in.
+            Empty list represents root namespace.
         data: The data to initialize the table, *optional*
             User must provide at least one of `data` or `schema`.
             Acceptable types are:
@@ -238,6 +297,7 @@ class DBConnection(EnforceOverrides):
         self,
         name: str,
         *,
+        namespace: List[str] = [],
         storage_options: Optional[Dict[str, str]] = None,
         index_cache_size: Optional[int] = None,
     ) -> Table:
@@ -247,6 +307,9 @@ class DBConnection(EnforceOverrides):
         ----------
         name: str
             The name of the table.
+        namespace: List[str], optional
+            The namespace to open the table from.
+            None or empty list represents root namespace.
         index_cache_size: int, default 256
             **Deprecated**: Use session-level cache configuration instead.
             Create a Session with custom cache sizes and pass it to lancedb.connect().
@@ -272,17 +335,26 @@ class DBConnection(EnforceOverrides):
         """
         raise NotImplementedError
 
-    def drop_table(self, name: str):
+    def drop_table(self, name: str, namespace: List[str] = []):
         """Drop a table from the database.
 
         Parameters
         ----------
         name: str
             The name of the table.
+        namespace: List[str], default []
+            The namespace to drop the table from.
+            Empty list represents root namespace.
         """
         raise NotImplementedError
 
-    def rename_table(self, cur_name: str, new_name: str):
+    def rename_table(
+        self,
+        cur_name: str,
+        new_name: str,
+        cur_namespace: List[str] = [],
+        new_namespace: List[str] = [],
+    ):
         """Rename a table in the database.
 
         Parameters
@@ -291,6 +363,12 @@ class DBConnection(EnforceOverrides):
             The current name of the table.
         new_name: str
             The new name of the table.
+        cur_namespace: List[str], optional
+            The namespace of the current table.
+            None or empty list represents root namespace.
+        new_namespace: List[str], optional
+            The namespace to move the table to.
+            If not specified, defaults to the same as cur_namespace.
         """
         raise NotImplementedError
 
@@ -301,9 +379,15 @@ class DBConnection(EnforceOverrides):
         """
         raise NotImplementedError
 
-    def drop_all_tables(self):
+    def drop_all_tables(self, namespace: List[str] = []):
         """
         Drop all tables from the database
+
+        Parameters
+        ----------
+        namespace: List[str], optional
+            The namespace to drop all tables from.
+            None or empty list represents root namespace.
         """
         raise NotImplementedError
 
@@ -404,18 +488,86 @@ class LanceDBConnection(DBConnection):
         conn = AsyncConnection(await lancedb_connect(self.uri))
         return await conn.table_names(start_after=start_after, limit=limit)
 
+    @override
+    def list_namespaces(
+        self,
+        namespace: List[str] = [],
+        page_token: Optional[str] = None,
+        limit: int = 10,
+    ) -> Iterable[str]:
+        """List immediate child namespace names in the given namespace.
+
+        Parameters
+        ----------
+        namespace: List[str], optional
+            The parent namespace to list namespaces in.
+            None or empty list represents root namespace.
+        page_token: str, optional
+            The token to use for pagination. If not present, start from the beginning.
+        limit: int, default 10
+            The size of the page to return.
+
+        Returns
+        -------
+        Iterable of str
+            List of immediate child namespace names
+        """
+        return LOOP.run(
+            self._conn.list_namespaces(
+                namespace=namespace, page_token=page_token, limit=limit
+            )
+        )
+
+    @override
+    def create_namespace(self, namespace: List[str]) -> None:
+        """Create a new namespace.
+
+        Parameters
+        ----------
+        namespace: List[str]
+            The namespace identifier to create.
+        """
+        LOOP.run(self._conn.create_namespace(namespace=namespace))
+
+    @override
+    def drop_namespace(self, namespace: List[str]) -> None:
+        """Drop a namespace.
+
+        Parameters
+        ----------
+        namespace: List[str]
+            The namespace identifier to drop.
+        """
+        return LOOP.run(self._conn.drop_namespace(namespace=namespace))
+
     @override
     def table_names(
-        self, page_token: Optional[str] = None, limit: int = 10
+        self,
+        namespace: List[str] = [],
+        page_token: Optional[str] = None,
+        limit: int = 10,
     ) -> Iterable[str]:
         """Get the names of all tables in the database. The names are sorted.
 
+        Parameters
+        ----------
+        namespace: List[str], optional
+            The namespace to list tables in.
+        page_token: str, optional
+            The token to use for pagination.
+        limit: int, default 10
+            The maximum number of tables to return.
+
         Returns
         -------
         Iterator of str.
             A list of table names.
         """
-        return LOOP.run(self._conn.table_names(start_after=page_token, limit=limit))
+        return LOOP.run(
+            self._conn.table_names(
+                namespace=namespace, start_after=page_token, limit=limit
+            )
+        )
 
     def __len__(self) -> int:
         return len(self.table_names())
@@ -435,12 +587,18 @@ class LanceDBConnection(DBConnection):
         fill_value: float = 0.0,
         embedding_functions: Optional[List[EmbeddingFunctionConfig]] = None,
         *,
+        namespace: List[str] = [],
         storage_options: Optional[Dict[str, str]] = None,
         data_storage_version: Optional[str] = None,
         enable_v2_manifest_paths: Optional[bool] = None,
     ) -> LanceTable:
         """Create a table in the database.
 
+        Parameters
+        ----------
+        namespace: List[str], optional
+            The namespace to create the table in.
+
         See
         ---
         DBConnection.create_table
@@ -459,6 +617,7 @@ class LanceDBConnection(DBConnection):
             on_bad_vectors=on_bad_vectors,
             fill_value=fill_value,
             embedding_functions=embedding_functions,
+            namespace=namespace,
             storage_options=storage_options,
         )
         return tbl
@@ -468,6 +627,7 @@ class LanceDBConnection(DBConnection):
         self,
         name: str,
         *,
+        namespace: List[str] = [],
         storage_options: Optional[Dict[str, str]] = None,
         index_cache_size: Optional[int] = None,
     ) -> LanceTable:
@@ -477,6 +637,8 @@ class LanceDBConnection(DBConnection):
         ----------
         name: str
             The name of the table.
+        namespace: List[str], optional
+            The namespace to open the table from.
 
         Returns
         -------
@@ -496,26 +658,68 @@ class LanceDBConnection(DBConnection):
         return LanceTable.open(
             self,
             name,
+            namespace=namespace,
             storage_options=storage_options,
             index_cache_size=index_cache_size,
         )
 
     @override
-    def drop_table(self, name: str, ignore_missing: bool = False):
+    def drop_table(
+        self,
+        name: str,
+        namespace: List[str] = [],
+        ignore_missing: bool = False,
+    ):
         """Drop a table from the database.
 
         Parameters
         ----------
         name: str
             The name of the table.
+        namespace: List[str], optional
+            The namespace to drop the table from.
         ignore_missing: bool, default False
             If True, ignore if the table does not exist.
         """
-        LOOP.run(self._conn.drop_table(name, ignore_missing=ignore_missing))
+        LOOP.run(
+            self._conn.drop_table(
+                name, namespace=namespace, ignore_missing=ignore_missing
+            )
+        )
 
     @override
-    def drop_all_tables(self):
-        LOOP.run(self._conn.drop_all_tables())
+    def drop_all_tables(self, namespace: List[str] = []):
+        LOOP.run(self._conn.drop_all_tables(namespace=namespace))
+
+    @override
+    def rename_table(
+        self,
+        cur_name: str,
+        new_name: str,
+        cur_namespace: List[str] = [],
+        new_namespace: List[str] = [],
+    ):
+        """Rename a table in the database.
+
+        Parameters
+        ----------
+        cur_name: str
+            The current name of the table.
+        new_name: str
+            The new name of the table.
+        cur_namespace: List[str], optional
+            The namespace of the current table.
+        new_namespace: List[str], optional
+            The namespace to move the table to.
+        """
+        LOOP.run(
+            self._conn.rename_table(
+                cur_name,
+                new_name,
+                cur_namespace=cur_namespace,
+                new_namespace=new_namespace,
+            )
+        )
 
     @deprecation.deprecated(
         deprecated_in="0.15.1",
@@ -588,13 +792,67 @@ class AsyncConnection(object):
     def uri(self) -> str:
         return self._inner.uri
 
+    async def list_namespaces(
+        self,
+        namespace: List[str] = [],
+        page_token: Optional[str] = None,
+        limit: int = 10,
+    ) -> Iterable[str]:
+        """List immediate child namespace names in the given namespace.
+
+        Parameters
+        ----------
+        namespace: List[str], optional
+            The parent namespace to list namespaces in.
+            None or empty list represents root namespace.
+        page_token: str, optional
+            The token to use for pagination. If not present, start from the beginning.
+        limit: int, default 10
+            The size of the page to return.
+
+        Returns
+        -------
+        Iterable of str
+            List of immediate child namespace names (not full paths)
+        """
+        return await self._inner.list_namespaces(
+            namespace=namespace, page_token=page_token, limit=limit
+        )
+
+    async def create_namespace(self, namespace: List[str]) -> None:
+        """Create a new namespace.
+
+        Parameters
+        ----------
+        namespace: List[str]
+            The namespace identifier to create.
+        """
+        await self._inner.create_namespace(namespace)
+
+    async def drop_namespace(self, namespace: List[str]) -> None:
+        """Drop a namespace.
+
+        Parameters
+        ----------
+        namespace: List[str]
+            The namespace identifier to drop.
+        """
+        await self._inner.drop_namespace(namespace)
+
     async def table_names(
-        self, *, start_after: Optional[str] = None, limit: Optional[int] = None
+        self,
+        *,
+        namespace: List[str] = [],
+        start_after: Optional[str] = None,
+        limit: Optional[int] = None,
     ) -> Iterable[str]:
         """List all tables in this database, in sorted order
 
         Parameters
         ----------
+        namespace: List[str], optional
+            The namespace to list tables in.
+            None or empty list represents root namespace.
         start_after: str, optional
             If present, only return names that come lexicographically after the supplied
             value.
@@ -608,7 +866,9 @@ class AsyncConnection(object):
         -------
         Iterable of str
         """
-        return await self._inner.table_names(start_after=start_after, limit=limit)
+        return await self._inner.table_names(
+            namespace=namespace, start_after=start_after, limit=limit
+        )
 
     async def create_table(
         self,
@@ -621,6 +881,7 @@ class AsyncConnection(object):
         fill_value: Optional[float] = None,
         storage_options: Optional[Dict[str, str]] = None,
         *,
+        namespace: List[str] = [],
         embedding_functions: Optional[List[EmbeddingFunctionConfig]] = None,
     ) -> AsyncTable:
         """Create an [AsyncTable][lancedb.table.AsyncTable] in the database.
@@ -629,6 +890,9 @@ class AsyncConnection(object):
         ----------
         name: str
             The name of the table.
+        namespace: List[str], default []
+            The namespace to create the table in.
+            Empty list represents root namespace.
         data: The data to initialize the table, *optional*
             User must provide at least one of `data` or `schema`.
             Acceptable types are:
@@ -807,6 +1071,7 @@ class AsyncConnection(object):
                 name,
                 mode,
                 schema,
+                namespace=namespace,
                 storage_options=storage_options,
             )
         else:
@@ -815,6 +1080,7 @@ class AsyncConnection(object):
                 name,
                 mode,
                 data,
+                namespace=namespace,
                 storage_options=storage_options,
             )
 
@@ -823,6 +1089,8 @@ class AsyncConnection(object):
     async def open_table(
         self,
         name: str,
+        *,
+        namespace: List[str] = [],
         storage_options: Optional[Dict[str, str]] = None,
         index_cache_size: Optional[int] = None,
     ) -> AsyncTable:
@@ -832,6 +1100,9 @@ class AsyncConnection(object):
         ----------
         name: str
             The name of the table.
+        namespace: List[str], optional
+            The namespace to open the table from.
+            None or empty list represents root namespace.
         storage_options: dict, optional
             Additional options for the storage backend. Options already set on the
             connection will be inherited by the table, but can be overridden here.
@@ -855,42 +1126,77 @@ class AsyncConnection(object):
         -------
         A LanceTable object representing the table.
         """
-        table = await self._inner.open_table(name, storage_options, index_cache_size)
+        table = await self._inner.open_table(
+            name,
+            namespace=namespace,
+            storage_options=storage_options,
+            index_cache_size=index_cache_size,
+        )
         return AsyncTable(table)
 
-    async def rename_table(self, old_name: str, new_name: str):
+    async def rename_table(
+        self,
+        cur_name: str,
+        new_name: str,
+        cur_namespace: List[str] = [],
+        new_namespace: List[str] = [],
+    ):
         """Rename a table in the database.
 
         Parameters
         ----------
-        old_name: str
+        cur_name: str
             The current name of the table.
         new_name: str
             The new name of the table.
+        cur_namespace: List[str], optional
+            The namespace of the current table.
+            None or empty list represents root namespace.
+        new_namespace: List[str], optional
+            The namespace to move the table to.
+            If not specified, defaults to the same as cur_namespace.
         """
-        await self._inner.rename_table(old_name, new_name)
+        await self._inner.rename_table(
+            cur_name, new_name, cur_namespace=cur_namespace, new_namespace=new_namespace
+        )
 
-    async def drop_table(self, name: str, *, ignore_missing: bool = False):
+    async def drop_table(
+        self,
+        name: str,
+        *,
+        namespace: List[str] = [],
+        ignore_missing: bool = False,
+    ):
         """Drop a table from the database.
 
         Parameters
         ----------
         name: str
             The name of the table.
+        namespace: List[str], default []
+            The namespace to drop the table from.
+            Empty list represents root namespace.
         ignore_missing: bool, default False
             If True, ignore if the table does not exist.
         """
         try:
-            await self._inner.drop_table(name)
+            await self._inner.drop_table(name, namespace=namespace)
         except ValueError as e:
             if not ignore_missing:
                 raise e
             if f"Table '{name}' was not found" not in str(e):
                 raise e
 
-    async def drop_all_tables(self):
-        """Drop all tables from the database."""
-        await self._inner.drop_all_tables()
+    async def drop_all_tables(self, namespace: List[str] = []):
+        """Drop all tables from the database.
+
+        Parameters
+        ----------
+        namespace: List[str], optional
+            The namespace to drop all tables from.
+            None or empty list represents root namespace.
+        """
+        await self._inner.drop_all_tables(namespace=namespace)
 
     @deprecation.deprecated(
         deprecated_in="0.15.1",

python/python/lancedb/namespace.py

@@ -26,6 +26,9 @@ from lance_namespace_urllib3_client.models import (
     DescribeTableRequest,
     CreateTableRequest,
     DropTableRequest,
+    ListNamespacesRequest,
+    CreateNamespaceRequest,
+    DropNamespaceRequest,
     JsonArrowSchema,
     JsonArrowField,
     JsonArrowDataType,
@@ -134,10 +137,12 @@ class LanceNamespaceDBConnection(DBConnection):
 
     @override
     def table_names(
-        self, page_token: Optional[str] = None, limit: int = 10
+        self,
+        namespace: List[str] = [],
+        page_token: Optional[str] = None,
+        limit: int = 10,
     ) -> Iterable[str]:
-        # Use namespace to list tables
-        request = ListTablesRequest(id=None, page_token=page_token, limit=limit)
+        request = ListTablesRequest(id=namespace, page_token=page_token, limit=limit)
         response = self._ns.list_tables(request)
         return response.tables if response.tables else []
 
@@ -153,6 +158,7 @@ class LanceNamespaceDBConnection(DBConnection):
         fill_value: float = 0.0,
         embedding_functions: Optional[List[EmbeddingFunctionConfig]] = None,
         *,
+        namespace: List[str] = [],
         storage_options: Optional[Dict[str, str]] = None,
         data_storage_version: Optional[str] = None,
         enable_v2_manifest_paths: Optional[bool] = None,
@@ -183,8 +189,9 @@ class LanceNamespaceDBConnection(DBConnection):
         # Convert PyArrow schema to JsonArrowSchema
         json_schema = _convert_pyarrow_schema_to_json(schema)
 
-        # Create table request
-        request = CreateTableRequest(id=[name], var_schema=json_schema)
+        # Create table request with namespace
+        table_id = (namespace or []) + [name]
+        request = CreateTableRequest(id=table_id, var_schema=json_schema)
 
         # Create empty Arrow IPC stream bytes
         import pyarrow.ipc as ipc
@@ -199,17 +206,21 @@ class LanceNamespaceDBConnection(DBConnection):
         request_data = buffer.getvalue()
 
         self._ns.create_table(request, request_data)
-        return self.open_table(name, storage_options=storage_options)
+        return self.open_table(
+            name, namespace=namespace, storage_options=storage_options
+        )
 
     @override
     def open_table(
         self,
         name: str,
         *,
+        namespace: List[str] = [],
         storage_options: Optional[Dict[str, str]] = None,
         index_cache_size: Optional[int] = None,
     ) -> Table:
-        request = DescribeTableRequest(id=[name])
+        table_id = (namespace or []) + [name]
+        request = DescribeTableRequest(id=table_id)
         response = self._ns.describe_table(request)
 
         merged_storage_options = dict()
@@ -225,13 +236,20 @@ class LanceNamespaceDBConnection(DBConnection):
         )
 
     @override
-    def drop_table(self, name: str):
+    def drop_table(self, name: str, namespace: Optional[List[str]] = None):
         # Use namespace drop_table directly
-        request = DropTableRequest(id=[name])
+        table_id = (namespace or []) + [name]
+        request = DropTableRequest(id=table_id)
         self._ns.drop_table(request)
 
     @override
-    def rename_table(self, cur_name: str, new_name: str):
+    def rename_table(
+        self,
+        cur_name: str,
+        new_name: str,
+        cur_namespace: Optional[List[str]] = None,
+        new_namespace: Optional[List[str]] = None,
+    ):
         raise NotImplementedError(
             "rename_table is not supported for namespace connections"
         )
@@ -243,9 +261,66 @@ class LanceNamespaceDBConnection(DBConnection):
         )
 
     @override
-    def drop_all_tables(self):
-        for table_name in self.table_names():
-            self.drop_table(table_name)
+    def drop_all_tables(self, namespace: Optional[List[str]] = None):
+        for table_name in self.table_names(namespace=namespace):
+            self.drop_table(table_name, namespace=namespace)
+
+    @override
+    def list_namespaces(
+        self,
+        namespace: List[str] = [],
+        page_token: Optional[str] = None,
+        limit: int = 10,
+    ) -> Iterable[str]:
+        """
+        List child namespaces under the given namespace.
+
+        Parameters
+        ----------
+        namespace : Optional[List[str]]
+            The parent namespace to list children from.
+            If None, lists root-level namespaces.
+        page_token : Optional[str]
+            Pagination token for listing results.
+        limit : int
+            Maximum number of namespaces to return.
+
+        Returns
+        -------
+        Iterable[str]
+            Names of child namespaces.
+        """
+        request = ListNamespacesRequest(
+            id=namespace, page_token=page_token, limit=limit
+        )
+        response = self._ns.list_namespaces(request)
+        return response.namespaces if response.namespaces else []
+
+    @override
+    def create_namespace(self, namespace: List[str]) -> None:
+        """
+        Create a new namespace.
+
+        Parameters
+        ----------
+        namespace : List[str]
+            The namespace path to create.
+        """
+        request = CreateNamespaceRequest(id=namespace)
+        self._ns.create_namespace(request)
+
+    @override
+    def drop_namespace(self, namespace: List[str]) -> None:
+        """
+        Drop a namespace.
+
+        Parameters
+        ----------
+        namespace : List[str]
+            The namespace path to drop.
+        """
+        request = DropNamespaceRequest(id=namespace)
+        self._ns.drop_namespace(request)
 
     def _lance_table_from_uri(
         self,

python/python/lancedb/remote/__init__.py

@@ -118,6 +118,7 @@ class ClientConfig:
     retry_config: RetryConfig = field(default_factory=RetryConfig)
     timeout_config: Optional[TimeoutConfig] = field(default_factory=TimeoutConfig)
     extra_headers: Optional[dict] = None
+    id_delimiter: Optional[str] = None
 
     def __post_init__(self):
         if isinstance(self.retry_config, dict):

python/python/lancedb/remote/db.py

@@ -96,14 +96,72 @@ class RemoteDBConnection(DBConnection):
     def __repr__(self) -> str:
         return f"RemoteConnect(name={self.db_name})"
 
+    @override
+    def list_namespaces(
+        self,
+        namespace: List[str] = [],
+        page_token: Optional[str] = None,
+        limit: int = 10,
+    ) -> Iterable[str]:
+        """List immediate child namespace names in the given namespace.
+
+        Parameters
+        ----------
+        namespace: List[str], optional
+            The parent namespace to list namespaces in.
+            None or empty list represents root namespace.
+        page_token: str, optional
+            The token to use for pagination. If not present, start from the beginning.
+        limit: int, default 10
+            The size of the page to return.
+
+        Returns
+        -------
+        Iterable of str
+            List of immediate child namespace names
+        """
+        return LOOP.run(
+            self._conn.list_namespaces(
+                namespace=namespace, page_token=page_token, limit=limit
+            )
+        )
+
+    @override
+    def create_namespace(self, namespace: List[str]) -> None:
+        """Create a new namespace.
+
+        Parameters
+        ----------
+        namespace: List[str]
+            The namespace identifier to create.
+        """
+        LOOP.run(self._conn.create_namespace(namespace=namespace))
+
+    @override
+    def drop_namespace(self, namespace: List[str]) -> None:
+        """Drop a namespace.
+
+        Parameters
+        ----------
+        namespace: List[str]
+            The namespace identifier to drop.
+        """
+        return LOOP.run(self._conn.drop_namespace(namespace=namespace))
+
     @override
     def table_names(
-        self, page_token: Optional[str] = None, limit: int = 10
+        self,
+        namespace: List[str] = [],
+        page_token: Optional[str] = None,
+        limit: int = 10,
     ) -> Iterable[str]:
         """List the names of all tables in the database.
 
         Parameters
         ----------
+        namespace: List[str], default []
+            The namespace to list tables in.
+            Empty list represents root namespace.
         page_token: str
             The last token to start the new page.
         limit: int, default 10
@@ -113,13 +171,18 @@ class RemoteDBConnection(DBConnection):
         -------
         An iterator of table names.
         """
-        return LOOP.run(self._conn.table_names(start_after=page_token, limit=limit))
+        return LOOP.run(
+            self._conn.table_names(
+                namespace=namespace, start_after=page_token, limit=limit
+            )
+        )
 
     @override
     def open_table(
         self,
         name: str,
         *,
+        namespace: List[str] = [],
         storage_options: Optional[Dict[str, str]] = None,
         index_cache_size: Optional[int] = None,
     ) -> Table:
@@ -129,6 +192,9 @@ class RemoteDBConnection(DBConnection):
         ----------
         name: str
             The name of the table.
+        namespace: List[str], optional
+            The namespace to open the table from.
+            None or empty list represents root namespace.
 
         Returns
         -------
@@ -142,7 +208,7 @@ class RemoteDBConnection(DBConnection):
                 " (there is no local cache to configure)"
             )
 
-        table = LOOP.run(self._conn.open_table(name))
+        table = LOOP.run(self._conn.open_table(name, namespace=namespace))
         return RemoteTable(table, self.db_name)
 
     @override
@@ -155,6 +221,8 @@ class RemoteDBConnection(DBConnection):
         fill_value: float = 0.0,
         mode: Optional[str] = None,
         embedding_functions: Optional[List[EmbeddingFunctionConfig]] = None,
+        *,
+        namespace: List[str] = [],
     ) -> Table:
         """Create a [Table][lancedb.table.Table] in the database.
 
@@ -162,6 +230,9 @@ class RemoteDBConnection(DBConnection):
         ----------
         name: str
             The name of the table.
+        namespace: List[str], optional
+            The namespace to create the table in.
+            None or empty list represents root namespace.
         data: The data to initialize the table, *optional*
             User must provide at least one of `data` or `schema`.
             Acceptable types are:
@@ -262,6 +333,7 @@ class RemoteDBConnection(DBConnection):
             self._conn.create_table(
                 name,
                 data,
+                namespace=namespace,
                 mode=mode,
                 schema=schema,
                 on_bad_vectors=on_bad_vectors,
@@ -271,18 +343,27 @@ class RemoteDBConnection(DBConnection):
         return RemoteTable(table, self.db_name)
 
     @override
-    def drop_table(self, name: str):
+    def drop_table(self, name: str, namespace: Optional[List[str]] = None):
         """Drop a table from the database.
 
         Parameters
         ----------
         name: str
             The name of the table.
+        namespace: List[str], optional
+            The namespace to drop the table from.
+            None or empty list represents root namespace.
         """
-        LOOP.run(self._conn.drop_table(name))
+        LOOP.run(self._conn.drop_table(name, namespace=namespace))
 
     @override
-    def rename_table(self, cur_name: str, new_name: str):
+    def rename_table(
+        self,
+        cur_name: str,
+        new_name: str,
+        cur_namespace: Optional[List[str]] = None,
+        new_namespace: Optional[List[str]] = None,
+    ):
         """Rename a table in the database.
 
         Parameters
@@ -292,7 +373,14 @@ class RemoteDBConnection(DBConnection):
         new_name: str
             The new name of the table.
         """
-        LOOP.run(self._conn.rename_table(cur_name, new_name))
+        LOOP.run(
+            self._conn.rename_table(
+                cur_name,
+                new_name,
+                cur_namespace=cur_namespace,
+                new_namespace=new_namespace,
+            )
+        )
 
     async def close(self):
         """Close the connection to the database."""

python/python/lancedb/table.py

@@ -1700,13 +1700,16 @@ class LanceTable(Table):
         connection: "LanceDBConnection",
         name: str,
         *,
+        namespace: List[str] = [],
         storage_options: Optional[Dict[str, str]] = None,
         index_cache_size: Optional[int] = None,
     ):
         self._conn = connection
+        self._namespace = namespace
         self._table = LOOP.run(
             connection._conn.open_table(
                 name,
+                namespace=namespace,
                 storage_options=storage_options,
                 index_cache_size=index_cache_size,
             )
@@ -1717,8 +1720,8 @@ class LanceTable(Table):
         return self._table.name
 
     @classmethod
-    def open(cls, db, name, **kwargs):
-        tbl = cls(db, name, **kwargs)
+    def open(cls, db, name, *, namespace: List[str] = [], **kwargs):
+        tbl = cls(db, name, namespace=namespace, **kwargs)
 
         # check the dataset exists
         try:
@@ -2539,6 +2542,7 @@ class LanceTable(Table):
         fill_value: float = 0.0,
         embedding_functions: Optional[List[EmbeddingFunctionConfig]] = None,
         *,
+        namespace: List[str] = [],
         storage_options: Optional[Dict[str, str | bool]] = None,
         data_storage_version: Optional[str] = None,
         enable_v2_manifest_paths: Optional[bool] = None,
@@ -2598,6 +2602,7 @@ class LanceTable(Table):
         """
         self = cls.__new__(cls)
         self._conn = db
+        self._namespace = namespace
 
         if data_storage_version is not None:
             warnings.warn(
@@ -2630,6 +2635,7 @@ class LanceTable(Table):
                 on_bad_vectors=on_bad_vectors,
                 fill_value=fill_value,
                 embedding_functions=embedding_functions,
+                namespace=namespace,
                 storage_options=storage_options,
             )
         )

python/python/tests/test_db.py

@@ -728,3 +728,93 @@ def test_bypass_vector_index_sync(tmp_db: lancedb.DBConnection):
         table.search(sample_key).bypass_vector_index().explain_plan(verbose=True)
     )
     assert "KNN" in plan_without_index
+
+
+def test_local_namespace_operations(tmp_path):
+    """Test that local mode namespace operations behave as expected."""
+    # Create a local database connection
+    db = lancedb.connect(tmp_path)
+
+    # Test list_namespaces returns empty list
+    namespaces = list(db.list_namespaces())
+    assert namespaces == []
+
+    # Test list_namespaces with parameters still returns empty list
+    namespaces_with_params = list(
+        db.list_namespaces(namespace=["test"], page_token="token", limit=5)
+    )
+    assert namespaces_with_params == []
+
+
+def test_local_create_namespace_not_supported(tmp_path):
+    """Test that create_namespace is not supported in local mode."""
+    db = lancedb.connect(tmp_path)
+
+    with pytest.raises(
+        NotImplementedError,
+        match="Namespace operations are not supported for listing database",
+    ):
+        db.create_namespace(["test_namespace"])
+
+
+def test_local_drop_namespace_not_supported(tmp_path):
+    """Test that drop_namespace is not supported in local mode."""
+    db = lancedb.connect(tmp_path)
+
+    with pytest.raises(
+        NotImplementedError,
+        match="Namespace operations are not supported for listing database",
+    ):
+        db.drop_namespace(["test_namespace"])
+
+
+def test_local_table_operations_with_namespace_raise_error(tmp_path):
+    """
+    Test that table operations with namespace parameter
+    raise ValueError in local mode.
+    """
+    db = lancedb.connect(tmp_path)
+
+    # Create some test data
+    data = [{"vector": [1.0, 2.0], "item": "test"}]
+    schema = pa.schema(
+        [pa.field("vector", pa.list_(pa.float32(), 2)), pa.field("item", pa.string())]
+    )
+
+    # Test create_table with namespace - should raise ValueError
+    with pytest.raises(
+        NotImplementedError,
+        match="Namespace parameter is not supported for listing database",
+    ):
+        db.create_table(
+            "test_table_with_ns", data=data, schema=schema, namespace=["test_ns"]
+        )
+
+    # Create table normally for other tests
+    db.create_table("test_table", data=data, schema=schema)
+    assert "test_table" in db.table_names()
+
+    # Test open_table with namespace - should raise ValueError
+    with pytest.raises(
+        NotImplementedError,
+        match="Namespace parameter is not supported for listing database",
+    ):
+        db.open_table("test_table", namespace=["test_ns"])
+
+    # Test table_names with namespace - should raise ValueError
+    with pytest.raises(
+        NotImplementedError,
+        match="Namespace parameter is not supported for listing database",
+    ):
+        list(db.table_names(namespace=["test_ns"]))
+
+    # Test drop_table with namespace - should raise ValueError
+    with pytest.raises(
+        NotImplementedError,
+        match="Namespace parameter is not supported for listing database",
+    ):
+        db.drop_table("test_table", namespace=["test_ns"])
+
+    # Test table_names without namespace - should work normally
+    tables_root = list(db.table_names())
+    assert "test_table" in tables_root

python/python/tests/test_namespace.py

@@ -23,6 +23,12 @@ from lance_namespace_urllib3_client.models import (
     CreateTableResponse,
     DropTableRequest,
     DropTableResponse,
+    ListNamespacesRequest,
+    ListNamespacesResponse,
+    CreateNamespaceRequest,
+    CreateNamespaceResponse,
+    DropNamespaceRequest,
+    DropNamespaceResponse,
 )
 
 
@@ -31,6 +37,8 @@ class TempNamespace(LanceNamespace):
 
     # Class-level storage to persist table registry across instances
     _global_registry: Dict[str, Dict[str, str]] = {}
+    # Class-level storage for namespaces (supporting 1-level namespace)
+    _global_namespaces: Dict[str, set] = {}
 
     def __init__(self, **properties):
         """Initialize the test namespace.
@@ -44,20 +52,48 @@ class TempNamespace(LanceNamespace):
         root = self.config.root
         if root not in self._global_registry:
             self._global_registry[root] = {}
+        if root not in self._global_namespaces:
+            self._global_namespaces[root] = set()
         self.tables = self._global_registry[root]  # Reference to shared registry
+        self.namespaces = self._global_namespaces[
+            root
+        ]  # Reference to shared namespaces
 
     def list_tables(self, request: ListTablesRequest) -> ListTablesResponse:
         """List all tables in the namespace."""
-        # For simplicity, ignore namespace ID validation
-        tables = list(self.tables.keys())
+        if not request.id:
+            # List all tables in root namespace
+            tables = [name for name in self.tables.keys() if "." not in name]
+        else:
+            # List tables in specific namespace (1-level only)
+            if len(request.id) == 1:
+                namespace_name = request.id[0]
+                prefix = f"{namespace_name}."
+                tables = [
+                    name[len(prefix) :]
+                    for name in self.tables.keys()
+                    if name.startswith(prefix)
+                ]
+            else:
+                # Multi-level namespaces not supported
+                raise ValueError("Only 1-level namespaces are supported")
         return ListTablesResponse(tables=tables)
 
     def describe_table(self, request: DescribeTableRequest) -> DescribeTableResponse:
         """Describe a table by returning its location."""
-        if not request.id or len(request.id) != 1:
+        if not request.id:
             raise ValueError("Invalid table ID")
 
-        table_name = request.id[0]
+        if len(request.id) == 1:
+            # Root namespace table
+            table_name = request.id[0]
+        elif len(request.id) == 2:
+            # Namespaced table (1-level namespace)
+            namespace_name, table_name = request.id
+            table_name = f"{namespace_name}.{table_name}"
+        else:
+            raise ValueError("Only 1-level namespaces are supported")
+
         if table_name not in self.tables:
             raise RuntimeError(f"Table does not exist: {table_name}")
 
@@ -68,10 +104,22 @@ class TempNamespace(LanceNamespace):
         self, request: CreateTableRequest, request_data: bytes
     ) -> CreateTableResponse:
         """Create a table in the namespace."""
-        if not request.id or len(request.id) != 1:
+        if not request.id:
             raise ValueError("Invalid table ID")
 
-        table_name = request.id[0]
+        if len(request.id) == 1:
+            # Root namespace table
+            table_name = request.id[0]
+            table_uri = f"{self.config.root}/{table_name}.lance"
+        elif len(request.id) == 2:
+            # Namespaced table (1-level namespace)
+            namespace_name, base_table_name = request.id
+            # Add namespace to our namespace set
+            self.namespaces.add(namespace_name)
+            table_name = f"{namespace_name}.{base_table_name}"
+            table_uri = f"{self.config.root}/{namespace_name}/{base_table_name}.lance"
+        else:
+            raise ValueError("Only 1-level namespaces are supported")
 
         # Check if table already exists
         if table_name in self.tables:
@@ -81,13 +129,14 @@ class TempNamespace(LanceNamespace):
             else:
                 raise RuntimeError(f"Table already exists: {table_name}")
 
-        # Generate table URI based on root directory
-        table_uri = f"{self.config.root}/{table_name}.lance"
-
         # Parse the Arrow IPC stream to get the schema and create the actual table
         import pyarrow.ipc as ipc
         import io
         import lance
+        import os
+
+        # Create directory if needed for namespaced tables
+        os.makedirs(os.path.dirname(table_uri), exist_ok=True)
 
         # Read the IPC stream
         reader = ipc.open_stream(io.BytesIO(request_data))
@@ -103,10 +152,19 @@ class TempNamespace(LanceNamespace):
 
     def drop_table(self, request: DropTableRequest) -> DropTableResponse:
         """Drop a table from the namespace."""
-        if not request.id or len(request.id) != 1:
+        if not request.id:
             raise ValueError("Invalid table ID")
 
-        table_name = request.id[0]
+        if len(request.id) == 1:
+            # Root namespace table
+            table_name = request.id[0]
+        elif len(request.id) == 2:
+            # Namespaced table (1-level namespace)
+            namespace_name, base_table_name = request.id
+            table_name = f"{namespace_name}.{base_table_name}"
+        else:
+            raise ValueError("Only 1-level namespaces are supported")
+
         if table_name not in self.tables:
             raise RuntimeError(f"Table does not exist: {table_name}")
 
@@ -152,6 +210,78 @@ class TempNamespace(LanceNamespace):
         del self.tables[table_name]
         return DeregisterTableResponse()
 
+    def list_namespaces(self, request: ListNamespacesRequest) -> ListNamespacesResponse:
+        """List child namespaces."""
+        if not request.id:
+            # List root-level namespaces
+            namespaces = list(self.namespaces)
+        elif len(request.id) == 1:
+            # For 1-level namespace, there are no child namespaces
+            namespaces = []
+        else:
+            raise ValueError("Only 1-level namespaces are supported")
+
+        return ListNamespacesResponse(namespaces=namespaces)
+
+    def create_namespace(
+        self, request: CreateNamespaceRequest
+    ) -> CreateNamespaceResponse:
+        """Create a namespace."""
+        if not request.id:
+            raise ValueError("Invalid namespace ID")
+
+        if len(request.id) == 1:
+            # Create 1-level namespace
+            namespace_name = request.id[0]
+            self.namespaces.add(namespace_name)
+
+            # Create directory for the namespace
+            import os
+
+            namespace_dir = f"{self.config.root}/{namespace_name}"
+            os.makedirs(namespace_dir, exist_ok=True)
+        else:
+            raise ValueError("Only 1-level namespaces are supported")
+
+        return CreateNamespaceResponse()
+
+    def drop_namespace(self, request: DropNamespaceRequest) -> DropNamespaceResponse:
+        """Drop a namespace."""
+        if not request.id:
+            raise ValueError("Invalid namespace ID")
+
+        if len(request.id) == 1:
+            # Drop 1-level namespace
+            namespace_name = request.id[0]
+
+            if namespace_name not in self.namespaces:
+                raise RuntimeError(f"Namespace does not exist: {namespace_name}")
+
+            # Check if namespace has any tables
+            prefix = f"{namespace_name}."
+            tables_in_namespace = [
+                name for name in self.tables.keys() if name.startswith(prefix)
+            ]
+            if tables_in_namespace:
+                raise RuntimeError(
+                    f"Cannot drop namespace '{namespace_name}': contains tables"
+                )
+
+            # Remove namespace
+            self.namespaces.remove(namespace_name)
+
+            # Remove directory
+            import shutil
+            import os
+
+            namespace_dir = f"{self.config.root}/{namespace_name}"
+            if os.path.exists(namespace_dir):
+                shutil.rmtree(namespace_dir, ignore_errors=True)
+        else:
+            raise ValueError("Only 1-level namespaces are supported")
+
+        return DropNamespaceResponse()
+
 
 class TempNamespaceConfig:
     """Configuration for TestNamespace."""
@@ -187,12 +317,16 @@ class TestNamespaceConnection:
         # Clear the TestNamespace registry for this test
         if self.temp_dir in TempNamespace._global_registry:
             TempNamespace._global_registry[self.temp_dir].clear()
+        if self.temp_dir in TempNamespace._global_namespaces:
+            TempNamespace._global_namespaces[self.temp_dir].clear()
 
     def teardown_method(self):
         """Clean up test fixtures."""
         # Clear the TestNamespace registry
         if self.temp_dir in TempNamespace._global_registry:
             del TempNamespace._global_registry[self.temp_dir]
+        if self.temp_dir in TempNamespace._global_namespaces:
+            del TempNamespace._global_namespaces[self.temp_dir]
         shutil.rmtree(self.temp_dir, ignore_errors=True)
 
     def test_connect_namespace_test(self):
@@ -412,3 +546,153 @@ class TestNamespaceConnection:
             ]
         )
         db.create_table("test_table", schema=schema, storage_options=table_opts)
+
+    def test_namespace_operations(self):
+        """Test namespace management operations."""
+        db = lancedb.connect_namespace("temp", {"root": self.temp_dir})
+
+        # Initially no namespaces
+        assert len(list(db.list_namespaces())) == 0
+
+        # Create a namespace
+        db.create_namespace(["test_namespace"])
+
+        # Verify namespace exists
+        namespaces = list(db.list_namespaces())
+        assert "test_namespace" in namespaces
+        assert len(namespaces) == 1
+
+        # Create table in namespace
+        schema = pa.schema(
+            [
+                pa.field("id", pa.int64()),
+                pa.field("vector", pa.list_(pa.float32(), 2)),
+            ]
+        )
+        table = db.create_table(
+            "test_table", schema=schema, namespace=["test_namespace"]
+        )
+        assert table is not None
+
+        # Verify table exists in namespace
+        tables_in_namespace = list(db.table_names(namespace=["test_namespace"]))
+        assert "test_table" in tables_in_namespace
+        assert len(tables_in_namespace) == 1
+
+        # Open table from namespace
+        table = db.open_table("test_table", namespace=["test_namespace"])
+        assert table is not None
+        assert table.name == "test_table"
+
+        # Drop table from namespace
+        db.drop_table("test_table", namespace=["test_namespace"])
+
+        # Verify table no longer exists in namespace
+        tables_in_namespace = list(db.table_names(namespace=["test_namespace"]))
+        assert len(tables_in_namespace) == 0
+
+        # Drop namespace
+        db.drop_namespace(["test_namespace"])
+
+        # Verify namespace no longer exists
+        namespaces = list(db.list_namespaces())
+        assert len(namespaces) == 0
+
+    def test_namespace_with_tables_cannot_be_dropped(self):
+        """Test that namespaces containing tables cannot be dropped."""
+        db = lancedb.connect_namespace("temp", {"root": self.temp_dir})
+
+        # Create namespace and table
+        db.create_namespace(["test_namespace"])
+        schema = pa.schema(
+            [
+                pa.field("id", pa.int64()),
+                pa.field("vector", pa.list_(pa.float32(), 2)),
+            ]
+        )
+        db.create_table("test_table", schema=schema, namespace=["test_namespace"])
+
+        # Try to drop namespace with tables - should fail
+        with pytest.raises(RuntimeError, match="contains tables"):
+            db.drop_namespace(["test_namespace"])
+
+        # Drop table first
+        db.drop_table("test_table", namespace=["test_namespace"])
+
+        # Now dropping namespace should work
+        db.drop_namespace(["test_namespace"])
+
+    def test_same_table_name_different_namespaces(self):
+        db = lancedb.connect_namespace("temp", {"root": self.temp_dir})
+
+        # Create two namespaces
+        db.create_namespace(["namespace_a"])
+        db.create_namespace(["namespace_b"])
+
+        # Define schema
+        schema = pa.schema(
+            [
+                pa.field("id", pa.int64()),
+                pa.field("vector", pa.list_(pa.float32(), 2)),
+                pa.field("text", pa.string()),
+            ]
+        )
+
+        # Create table with same name in both namespaces
+        table_a = db.create_table(
+            "same_name_table", schema=schema, namespace=["namespace_a"]
+        )
+        table_b = db.create_table(
+            "same_name_table", schema=schema, namespace=["namespace_b"]
+        )
+
+        # Add different data to each table
+        data_a = [
+            {"id": 1, "vector": [1.0, 2.0], "text": "data_from_namespace_a"},
+            {"id": 2, "vector": [3.0, 4.0], "text": "also_from_namespace_a"},
+        ]
+        table_a.add(data_a)
+
+        data_b = [
+            {"id": 10, "vector": [10.0, 20.0], "text": "data_from_namespace_b"},
+            {"id": 20, "vector": [30.0, 40.0], "text": "also_from_namespace_b"},
+            {"id": 30, "vector": [50.0, 60.0], "text": "more_from_namespace_b"},
+        ]
+        table_b.add(data_b)
+
+        # Verify data in namespace_a table
+        opened_table_a = db.open_table("same_name_table", namespace=["namespace_a"])
+        result_a = opened_table_a.to_pandas().sort_values("id").reset_index(drop=True)
+        assert len(result_a) == 2
+        assert result_a["id"].tolist() == [1, 2]
+        assert result_a["text"].tolist() == [
+            "data_from_namespace_a",
+            "also_from_namespace_a",
+        ]
+        assert [v.tolist() for v in result_a["vector"]] == [[1.0, 2.0], [3.0, 4.0]]
+
+        # Verify data in namespace_b table
+        opened_table_b = db.open_table("same_name_table", namespace=["namespace_b"])
+        result_b = opened_table_b.to_pandas().sort_values("id").reset_index(drop=True)
+        assert len(result_b) == 3
+        assert result_b["id"].tolist() == [10, 20, 30]
+        assert result_b["text"].tolist() == [
+            "data_from_namespace_b",
+            "also_from_namespace_b",
+            "more_from_namespace_b",
+        ]
+        assert [v.tolist() for v in result_b["vector"]] == [
+            [10.0, 20.0],
+            [30.0, 40.0],
+            [50.0, 60.0],
+        ]
+
+        # Verify root namespace doesn't have this table
+        root_tables = list(db.table_names())
+        assert "same_name_table" not in root_tables
+
+        # Clean up
+        db.drop_table("same_name_table", namespace=["namespace_a"])
+        db.drop_table("same_name_table", namespace=["namespace_b"])
+        db.drop_namespace(["namespace_a"])
+        db.drop_namespace(["namespace_b"])

python/src/connection.rs

@@ -63,14 +63,16 @@ impl Connection {
         self.get_inner().map(|inner| inner.uri().to_string())
     }
 
-    #[pyo3(signature = (start_after=None, limit=None))]
+    #[pyo3(signature = (namespace=vec![], start_after=None, limit=None))]
     pub fn table_names(
         self_: PyRef<'_, Self>,
+        namespace: Vec<String>,
         start_after: Option<String>,
         limit: Option<u32>,
     ) -> PyResult<Bound<'_, PyAny>> {
         let inner = self_.get_inner()?.clone();
         let mut op = inner.table_names();
+        op = op.namespace(namespace);
         if let Some(start_after) = start_after {
             op = op.start_after(start_after);
         }
@@ -80,12 +82,13 @@ impl Connection {
         future_into_py(self_.py(), async move { op.execute().await.infer_error() })
     }
 
-    #[pyo3(signature = (name, mode, data, storage_options=None))]
+    #[pyo3(signature = (name, mode, data, namespace=vec![], storage_options=None))]
     pub fn create_table<'a>(
         self_: PyRef<'a, Self>,
         name: String,
         mode: &str,
         data: Bound<'_, PyAny>,
+        namespace: Vec<String>,
         storage_options: Option<HashMap<String, String>>,
     ) -> PyResult<Bound<'a, PyAny>> {
         let inner = self_.get_inner()?.clone();
@@ -93,8 +96,10 @@ impl Connection {
         let mode = Self::parse_create_mode_str(mode)?;
 
         let batches = ArrowArrayStreamReader::from_pyarrow_bound(&data)?;
+
         let mut builder = inner.create_table(name, batches).mode(mode);
 
+        builder = builder.namespace(namespace);
         if let Some(storage_options) = storage_options {
             builder = builder.storage_options(storage_options);
         }
@@ -105,12 +110,13 @@ impl Connection {
         })
     }
 
-    #[pyo3(signature = (name, mode, schema, storage_options=None))]
+    #[pyo3(signature = (name, mode, schema, namespace=vec![], storage_options=None))]
     pub fn create_empty_table<'a>(
         self_: PyRef<'a, Self>,
         name: String,
         mode: &str,
         schema: Bound<'_, PyAny>,
+        namespace: Vec<String>,
         storage_options: Option<HashMap<String, String>>,
     ) -> PyResult<Bound<'a, PyAny>> {
         let inner = self_.get_inner()?.clone();
@@ -121,6 +127,7 @@ impl Connection {
 
         let mut builder = inner.create_empty_table(name, Arc::new(schema)).mode(mode);
 
+        builder = builder.namespace(namespace);
         if let Some(storage_options) = storage_options {
             builder = builder.storage_options(storage_options);
         }
@@ -131,49 +138,115 @@ impl Connection {
         })
     }
 
-    #[pyo3(signature = (name, storage_options = None, index_cache_size = None))]
+    #[pyo3(signature = (name, namespace=vec![], storage_options = None, index_cache_size = None))]
     pub fn open_table(
         self_: PyRef<'_, Self>,
         name: String,
+        namespace: Vec<String>,
         storage_options: Option<HashMap<String, String>>,
         index_cache_size: Option<u32>,
     ) -> PyResult<Bound<'_, PyAny>> {
         let inner = self_.get_inner()?.clone();
+
         let mut builder = inner.open_table(name);
+        builder = builder.namespace(namespace);
         if let Some(storage_options) = storage_options {
             builder = builder.storage_options(storage_options);
         }
         if let Some(index_cache_size) = index_cache_size {
             builder = builder.index_cache_size(index_cache_size);
         }
+
         future_into_py(self_.py(), async move {
             let table = builder.execute().await.infer_error()?;
             Ok(Table::new(table))
         })
     }
 
+    #[pyo3(signature = (cur_name, new_name, cur_namespace=vec![], new_namespace=vec![]))]
     pub fn rename_table(
         self_: PyRef<'_, Self>,
-        old_name: String,
+        cur_name: String,
         new_name: String,
+        cur_namespace: Vec<String>,
+        new_namespace: Vec<String>,
     ) -> PyResult<Bound<'_, PyAny>> {
         let inner = self_.get_inner()?.clone();
         future_into_py(self_.py(), async move {
-            inner.rename_table(old_name, new_name).await.infer_error()
+            inner
+                .rename_table(cur_name, new_name, &cur_namespace, &new_namespace)
+                .await
+                .infer_error()
         })
     }
 
-    pub fn drop_table(self_: PyRef<'_, Self>, name: String) -> PyResult<Bound<'_, PyAny>> {
+    #[pyo3(signature = (name, namespace=vec![]))]
+    pub fn drop_table(
+        self_: PyRef<'_, Self>,
+        name: String,
+        namespace: Vec<String>,
+    ) -> PyResult<Bound<'_, PyAny>> {
         let inner = self_.get_inner()?.clone();
         future_into_py(self_.py(), async move {
-            inner.drop_table(name).await.infer_error()
+            inner.drop_table(name, &namespace).await.infer_error()
         })
     }
 
-    pub fn drop_all_tables(self_: PyRef<'_, Self>) -> PyResult<Bound<'_, PyAny>> {
+    #[pyo3(signature = (namespace=vec![],))]
+    pub fn drop_all_tables(
+        self_: PyRef<'_, Self>,
+        namespace: Vec<String>,
+    ) -> PyResult<Bound<'_, PyAny>> {
         let inner = self_.get_inner()?.clone();
         future_into_py(self_.py(), async move {
-            inner.drop_all_tables().await.infer_error()
+            inner.drop_all_tables(&namespace).await.infer_error()
+        })
+    }
+
+    // Namespace management methods
+
+    #[pyo3(signature = (namespace=vec![], page_token=None, limit=None))]
+    pub fn list_namespaces(
+        self_: PyRef<'_, Self>,
+        namespace: Vec<String>,
+        page_token: Option<String>,
+        limit: Option<u32>,
+    ) -> PyResult<Bound<'_, PyAny>> {
+        let inner = self_.get_inner()?.clone();
+        future_into_py(self_.py(), async move {
+            use lancedb::database::ListNamespacesRequest;
+            let request = ListNamespacesRequest {
+                namespace,
+                page_token,
+                limit,
+            };
+            inner.list_namespaces(request).await.infer_error()
+        })
+    }
+
+    #[pyo3(signature = (namespace,))]
+    pub fn create_namespace(
+        self_: PyRef<'_, Self>,
+        namespace: Vec<String>,
+    ) -> PyResult<Bound<'_, PyAny>> {
+        let inner = self_.get_inner()?.clone();
+        future_into_py(self_.py(), async move {
+            use lancedb::database::CreateNamespaceRequest;
+            let request = CreateNamespaceRequest { namespace };
+            inner.create_namespace(request).await.infer_error()
+        })
+    }
+
+    #[pyo3(signature = (namespace,))]
+    pub fn drop_namespace(
+        self_: PyRef<'_, Self>,
+        namespace: Vec<String>,
+    ) -> PyResult<Bound<'_, PyAny>> {
+        let inner = self_.get_inner()?.clone();
+        future_into_py(self_.py(), async move {
+            use lancedb::database::DropNamespaceRequest;
+            let request = DropNamespaceRequest { namespace };
+            inner.drop_namespace(request).await.infer_error()
         })
     }
 }
@@ -227,6 +300,7 @@ pub struct PyClientConfig {
     retry_config: Option<PyClientRetryConfig>,
     timeout_config: Option<PyClientTimeoutConfig>,
     extra_headers: Option<HashMap<String, String>>,
+    id_delimiter: Option<String>,
 }
 
 #[derive(FromPyObject)]
@@ -281,6 +355,7 @@ impl From<PyClientConfig> for lancedb::remote::ClientConfig {
             retry_config: value.retry_config.map(Into::into).unwrap_or_default(),
             timeout_config: value.timeout_config.map(Into::into).unwrap_or_default(),
             extra_headers: value.extra_headers.unwrap_or_default(),
+            id_delimiter: value.id_delimiter,
         }
     }
 }