@lancedb/lancedb 0.21.4-beta.0 → 0.22.0-beta.0

package/dist/connection.d.ts

@@ -128,48 +128,82 @@ export declare abstract class Connection {
      *
      * Tables will be returned in lexicographical order.
      * @param {Partial<TableNamesOptions>} options - options to control the
-     * paging / start point
+     * paging / start point (backwards compatibility)
      *
      */
     abstract tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
+    /**
+     * List all the table names in this database.
+     *
+     * Tables will be returned in lexicographical order.
+     * @param {string[]} namespace - The namespace to list tables from (defaults to root namespace)
+     * @param {Partial<TableNamesOptions>} options - options to control the
+     * paging / start point
+     *
+     */
+    abstract tableNames(namespace?: string[], options?: Partial<TableNamesOptions>): Promise<string[]>;
     /**
      * Open a table in the database.
      * @param {string} name - The name of the table
+     * @param {string[]} namespace - The namespace of the table (defaults to root namespace)
+     * @param {Partial<OpenTableOptions>} options - Additional options
      */
-    abstract openTable(name: string, options?: Partial<OpenTableOptions>): Promise<Table>;
+    abstract openTable(name: string, namespace?: string[], options?: Partial<OpenTableOptions>): Promise<Table>;
     /**
      * Creates a new Table and initialize it with new data.
      * @param {object} options - The options object.
      * @param {string} options.name - The name of the table.
      * @param {Data} options.data - Non-empty Array of Records to be inserted into the table
+     * @param {string[]} namespace - The namespace to create the table in (defaults to root namespace)
      *
      */
     abstract createTable(options: {
         name: string;
         data: Data;
-    } & Partial<CreateTableOptions>): Promise<Table>;
+    } & Partial<CreateTableOptions>, namespace?: string[]): Promise<Table>;
     /**
      * Creates a new Table and initialize it with new data.
      * @param {string} name - The name of the table.
      * @param {Record<string, unknown>[] | TableLike} data - Non-empty Array of Records
      * to be inserted into the table
+     * @param {Partial<CreateTableOptions>} options - Additional options (backwards compatibility)
      */
     abstract createTable(name: string, data: Record<string, unknown>[] | TableLike, options?: Partial<CreateTableOptions>): Promise<Table>;
+    /**
+     * Creates a new Table and initialize it with new data.
+     * @param {string} name - The name of the table.
+     * @param {Record<string, unknown>[] | TableLike} data - Non-empty Array of Records
+     * to be inserted into the table
+     * @param {string[]} namespace - The namespace to create the table in (defaults to root namespace)
+     * @param {Partial<CreateTableOptions>} options - Additional options
+     */
+    abstract createTable(name: string, data: Record<string, unknown>[] | TableLike, namespace?: string[], options?: Partial<CreateTableOptions>): Promise<Table>;
     /**
      * Creates a new empty Table
      * @param {string} name - The name of the table.
      * @param {Schema} schema - The schema of the table
+     * @param {Partial<CreateTableOptions>} options - Additional options (backwards compatibility)
      */
     abstract createEmptyTable(name: string, schema: import("./arrow").SchemaLike, options?: Partial<CreateTableOptions>): Promise<Table>;
+    /**
+     * Creates a new empty Table
+     * @param {string} name - The name of the table.
+     * @param {Schema} schema - The schema of the table
+     * @param {string[]} namespace - The namespace to create the table in (defaults to root namespace)
+     * @param {Partial<CreateTableOptions>} options - Additional options
+     */
+    abstract createEmptyTable(name: string, schema: import("./arrow").SchemaLike, namespace?: string[], options?: Partial<CreateTableOptions>): Promise<Table>;
     /**
      * Drop an existing table.
      * @param {string} name The name of the table to drop.
+     * @param {string[]} namespace The namespace of the table (defaults to root namespace).
      */
-    abstract dropTable(name: string): Promise<void>;
+    abstract dropTable(name: string, namespace?: string[]): Promise<void>;
     /**
      * Drop all tables in the database.
+     * @param {string[]} namespace The namespace to drop tables from (defaults to root namespace).
      */
-    abstract dropAllTables(): Promise<void>;
+    abstract dropAllTables(namespace?: string[]): Promise<void>;
 }
 /** @hideconstructor */
 export declare class LocalConnection extends Connection {
@@ -179,16 +213,17 @@ export declare class LocalConnection extends Connection {
     isOpen(): boolean;
     close(): void;
     display(): string;
-    tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
-    openTable(name: string, options?: Partial<OpenTableOptions>): Promise<Table>;
+    tableNames(namespaceOrOptions?: string[] | Partial<TableNamesOptions>, options?: Partial<TableNamesOptions>): Promise<string[]>;
+    openTable(name: string, namespace?: string[], options?: Partial<OpenTableOptions>): Promise<Table>;
     private getStorageOptions;
     createTable(nameOrOptions: string | ({
         name: string;
         data: Data;
-    } & Partial<CreateTableOptions>), data?: Record<string, unknown>[] | TableLike, options?: Partial<CreateTableOptions>): Promise<Table>;
-    createEmptyTable(name: string, schema: import("./arrow").SchemaLike, options?: Partial<CreateTableOptions>): Promise<Table>;
-    dropTable(name: string): Promise<void>;
-    dropAllTables(): Promise<void>;
+    } & Partial<CreateTableOptions>), dataOrNamespace?: Record<string, unknown>[] | TableLike | string[], namespaceOrOptions?: string[] | Partial<CreateTableOptions>, options?: Partial<CreateTableOptions>): Promise<Table>;
+    private _createTableImpl;
+    createEmptyTable(name: string, schema: import("./arrow").SchemaLike, namespaceOrOptions?: string[] | Partial<CreateTableOptions>, options?: Partial<CreateTableOptions>): Promise<Table>;
+    dropTable(name: string, namespace?: string[]): Promise<void>;
+    dropAllTables(namespace?: string[]): Promise<void>;
 }
 /**
  * Takes storage options and makes all the keys snake case.

package/dist/connection.js

@@ -51,11 +51,24 @@ class LocalConnection extends Connection {
     display() {
         return this.inner.display();
     }
-    async tableNames(options) {
-        return this.inner.tableNames(options?.startAfter, options?.limit);
+    async tableNames(namespaceOrOptions, options) {
+        // Detect if first argument is namespace array or options object
+        let namespace;
+        let tableNamesOptions;
+        if (Array.isArray(namespaceOrOptions)) {
+            // First argument is namespace array
+            namespace = namespaceOrOptions;
+            tableNamesOptions = options;
+        }
+        else {
+            // First argument is options object (backwards compatibility)
+            namespace = undefined;
+            tableNamesOptions = namespaceOrOptions;
+        }
+        return this.inner.tableNames(namespace ?? [], tableNamesOptions?.startAfter, tableNamesOptions?.limit);
     }
-    async openTable(name, options) {
-        const innerTable = await this.inner.openTable(name, cleanseStorageOptions(options?.storageOptions), options?.indexCacheSize);
+    async openTable(name, namespace, options) {
+        const innerTable = await this.inner.openTable(name, namespace ?? [], cleanseStorageOptions(options?.storageOptions), options?.indexCacheSize);
         return new table_1.LocalTable(innerTable);
     }
     getStorageOptions(options) {
@@ -75,42 +88,76 @@ class LocalConnection extends Connection {
         }
         return cleanseStorageOptions(options?.storageOptions);
     }
-    async createTable(nameOrOptions, data, options) {
+    async createTable(nameOrOptions, dataOrNamespace, namespaceOrOptions, options) {
         if (typeof nameOrOptions !== "string" && "name" in nameOrOptions) {
-            const { name, data, ...options } = nameOrOptions;
-            return this.createTable(name, data, options);
+            // First overload: createTable(options, namespace?)
+            const { name, data, ...createOptions } = nameOrOptions;
+            const namespace = dataOrNamespace;
+            return this._createTableImpl(name, data, namespace, createOptions);
+        }
+        // Second overload: createTable(name, data, namespace?, options?)
+        const name = nameOrOptions;
+        const data = dataOrNamespace;
+        // Detect if third argument is namespace array or options object
+        let namespace;
+        let createOptions;
+        if (Array.isArray(namespaceOrOptions)) {
+            // Third argument is namespace array
+            namespace = namespaceOrOptions;
+            createOptions = options;
+        }
+        else {
+            // Third argument is options object (backwards compatibility)
+            namespace = undefined;
+            createOptions = namespaceOrOptions;
         }
+        return this._createTableImpl(name, data, namespace, createOptions);
+    }
+    async _createTableImpl(name, data, namespace, options) {
         if (data === undefined) {
             throw new Error("data is required");
         }
         const { buf, mode } = await parseTableData(data, options);
         const storageOptions = this.getStorageOptions(options);
-        const innerTable = await this.inner.createTable(nameOrOptions, buf, mode, storageOptions);
+        const innerTable = await this.inner.createTable(name, buf, mode, namespace ?? [], storageOptions);
         return new table_1.LocalTable(innerTable);
     }
-    async createEmptyTable(name, schema, options) {
-        let mode = options?.mode ?? "create";
-        const existOk = options?.existOk ?? false;
+    async createEmptyTable(name, schema, namespaceOrOptions, options) {
+        // Detect if third argument is namespace array or options object
+        let namespace;
+        let createOptions;
+        if (Array.isArray(namespaceOrOptions)) {
+            // Third argument is namespace array
+            namespace = namespaceOrOptions;
+            createOptions = options;
+        }
+        else {
+            // Third argument is options object (backwards compatibility)
+            namespace = undefined;
+            createOptions = namespaceOrOptions;
+        }
+        let mode = createOptions?.mode ?? "create";
+        const existOk = createOptions?.existOk ?? false;
         if (mode === "create" && existOk) {
             mode = "exist_ok";
         }
         let metadata = undefined;
-        if (options?.embeddingFunction !== undefined) {
-            const embeddingFunction = options.embeddingFunction;
+        if (createOptions?.embeddingFunction !== undefined) {
+            const embeddingFunction = createOptions.embeddingFunction;
             const registry = (0, registry_1.getRegistry)();
             metadata = registry.getTableMetadata([embeddingFunction]);
         }
-        const storageOptions = this.getStorageOptions(options);
+        const storageOptions = this.getStorageOptions(createOptions);
         const table = (0, arrow_2.makeEmptyTable)(schema, metadata);
         const buf = await (0, arrow_2.fromTableToBuffer)(table);
-        const innerTable = await this.inner.createEmptyTable(name, buf, mode, storageOptions);
+        const innerTable = await this.inner.createEmptyTable(name, buf, mode, namespace ?? [], storageOptions);
         return new table_1.LocalTable(innerTable);
     }
-    async dropTable(name) {
-        return this.inner.dropTable(name);
+    async dropTable(name, namespace) {
+        return this.inner.dropTable(name, namespace ?? []);
     }
-    async dropAllTables() {
-        return this.inner.dropAllTables();
+    async dropAllTables(namespace) {
+        return this.inner.dropAllTables(namespace ?? []);
     }
 }
 exports.LocalConnection = LocalConnection;

package/dist/native.d.ts

@@ -86,6 +86,7 @@ export interface ClientConfig {
   retryConfig?: RetryConfig
   timeoutConfig?: TimeoutConfig
   extraHeaders?: Record<string, string>
+  idDelimiter?: string
 }
 export interface RerankerCallbacks {
   rerankHybrid: (...args: any[]) => any
@@ -316,7 +317,7 @@ export class Connection {
   isOpen(): boolean
   close(): void
   /** List all tables in the dataset. */
-  tableNames(startAfter?: string | undefined | null, limit?: number | undefined | null): Promise<Array<string>>
+  tableNames(namespace: Array<string>, startAfter?: string | undefined | null, limit?: number | undefined | null): Promise<Array<string>>
   /**
    * Create table from a Apache Arrow IPC (file) buffer.
    *
@@ -325,12 +326,12 @@ export class Connection {
    * - buf: The buffer containing the IPC file.
    *
    */
-  createTable(name: string, buf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null): Promise<Table>
-  createEmptyTable(name: string, schemaBuf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null): Promise<Table>
-  openTable(name: string, storageOptions?: Record<string, string> | undefined | null, indexCacheSize?: number | undefined | null): Promise<Table>
+  createTable(name: string, buf: Buffer, mode: string, namespace: Array<string>, storageOptions?: Record<string, string> | undefined | null): Promise<Table>
+  createEmptyTable(name: string, schemaBuf: Buffer, mode: string, namespace: Array<string>, storageOptions?: Record<string, string> | undefined | null): Promise<Table>
+  openTable(name: string, namespace: Array<string>, storageOptions?: Record<string, string> | undefined | null, indexCacheSize?: number | undefined | null): Promise<Table>
   /** Drop table with the name. Or raise an error if the table does not exist. */
-  dropTable(name: string): Promise<void>
-  dropAllTables(): Promise<void>
+  dropTable(name: string, namespace: Array<string>): Promise<void>
+  dropAllTables(namespace: Array<string>): Promise<void>
 }
 export class Index {
   static ivfPq(distanceType?: string | undefined | null, numPartitions?: number | undefined | null, numSubVectors?: number | undefined | null, numBits?: number | undefined | null, maxIterations?: number | undefined | null, sampleRate?: number | undefined | null): Index

package/package.json

@@ -11,7 +11,7 @@
     "ann"
   ],
   "private": false,
-  "version": "0.21.4-beta.0",
+  "version": "0.22.0-beta.0",
   "main": "dist/index.js",
   "exports": {
     ".": "./dist/index.js",
@@ -100,14 +100,14 @@
     "reflect-metadata": "^0.2.2"
   },
   "optionalDependencies": {
-    "@lancedb/lancedb-darwin-x64": "0.21.4-beta.0",
-    "@lancedb/lancedb-darwin-arm64": "0.21.4-beta.0",
-    "@lancedb/lancedb-linux-x64-gnu": "0.21.4-beta.0",
-    "@lancedb/lancedb-linux-arm64-gnu": "0.21.4-beta.0",
-    "@lancedb/lancedb-linux-x64-musl": "0.21.4-beta.0",
-    "@lancedb/lancedb-linux-arm64-musl": "0.21.4-beta.0",
-    "@lancedb/lancedb-win32-x64-msvc": "0.21.4-beta.0",
-    "@lancedb/lancedb-win32-arm64-msvc": "0.21.4-beta.0"
+    "@lancedb/lancedb-darwin-x64": "0.22.0-beta.0",
+    "@lancedb/lancedb-darwin-arm64": "0.22.0-beta.0",
+    "@lancedb/lancedb-linux-x64-gnu": "0.22.0-beta.0",
+    "@lancedb/lancedb-linux-arm64-gnu": "0.22.0-beta.0",
+    "@lancedb/lancedb-linux-x64-musl": "0.22.0-beta.0",
+    "@lancedb/lancedb-linux-arm64-musl": "0.22.0-beta.0",
+    "@lancedb/lancedb-win32-x64-msvc": "0.22.0-beta.0",
+    "@lancedb/lancedb-win32-arm64-msvc": "0.22.0-beta.0"
   },
   "peerDependencies": {
     "apache-arrow": ">=15.0.0 <=18.1.0"