@lancedb/lancedb 0.37.1 → 0.38.0-beta.12

package/dist/arrow.d.ts

@@ -14,13 +14,16 @@ export type FieldLike = Field | {
     nullable: boolean;
     metadata?: Map<string, string>;
 };
-export type DataLike = import("apache-arrow").Data<Struct<any>> | {
+export type DataLike = import("apache-arrow").Data | {
     type: any;
     length: number;
     offset: number;
     stride: number;
     nullable: boolean;
     children: DataLike[];
+    dictionary?: {
+        data: readonly DataLike[];
+    };
     get nullCount(): number;
     values: Buffers<any>[BufferType.DATA];
     typeIds: Buffers<any>[BufferType.TYPE];

package/dist/arrow.js

@@ -56,15 +56,10 @@ exports.createEmptyTable = createEmptyTable;
 exports.ensureNestedFieldsExist = ensureNestedFieldsExist;
 exports.dataTypeToJson = dataTypeToJson;
 const apache_arrow_1 = require("apache-arrow");
+const arrow_type_1 = require("./arrow_type");
 const registry_1 = require("./embedding/registry");
 const sanitize_1 = require("./sanitize");
-/**
- * Check if a field name indicates a vector column.
- */
-function nameSuggestsVectorColumn(fieldName) {
-    const nameLower = fieldName.toLowerCase();
-    return nameLower.includes("vector") || nameLower.includes("embedding");
-}
+const schema_1 = require("./schema");
 __exportStar(require("apache-arrow"), exports);
 function isMultiVector(value) {
     return Array.isArray(value) && isIntoVector(value[0]);
@@ -356,7 +351,7 @@ function makeArrowTable(data, options, metadata) {
             return new apache_arrow_1.Table(schema);
         }
     }
-    let inferredSchema = inferSchema(data, schema, opt);
+    let inferredSchema = (0, schema_1.inferSchema)(data, schema, opt);
     inferredSchema = new apache_arrow_1.Schema(inferredSchema.fields, schemaMetadata);
     const finalColumns = {};
     for (const field of inferredSchema.fields) {
@@ -364,95 +359,6 @@ function makeArrowTable(data, options, metadata) {
     }
     return new apache_arrow_1.Table(inferredSchema, finalColumns);
 }
-function inferSchema(data, schema, opts) {
-    // We will collect all fields we see in the data.
-    const pathTree = new PathTree();
-    for (const [rowI, row] of data.entries()) {
-        for (const [path, value] of rowPathsAndValues(row)) {
-            if (!pathTree.has(path)) {
-                // First time seeing this field.
-                if (schema !== undefined) {
-                    const field = getFieldForPath(schema, path);
-                    if (field === undefined) {
-                        throw new Error(`Found field not in schema: ${path.join(".")} at row ${rowI}`);
-                    }
-                    else {
-                        pathTree.set(path, field.type);
-                    }
-                }
-                else {
-                    const inferredType = inferType(value, path, opts);
-                    if (inferredType === undefined) {
-                        throw new Error(`Failed to infer data type for field ${path.join(".")} at row ${rowI}. \
-                             Consider providing an explicit schema.`);
-                    }
-                    pathTree.set(path, inferredType);
-                }
-            }
-            else if (schema === undefined) {
-                const currentType = pathTree.get(path);
-                const newType = inferType(value, path, opts);
-                if (currentType !== newType) {
-                    new Error(`Failed to infer schema for data. Previously inferred type \
-                     ${currentType} but found ${newType} at row ${rowI}. Consider \
-                     providing an explicit schema.`);
-                }
-            }
-        }
-    }
-    if (schema === undefined) {
-        function fieldsFromPathTree(pathTree) {
-            const fields = [];
-            for (const [name, value] of pathTree.map.entries()) {
-                if (value instanceof PathTree) {
-                    const children = fieldsFromPathTree(value);
-                    fields.push(new apache_arrow_1.Field(name, new apache_arrow_1.Struct(children), true));
-                }
-                else {
-                    fields.push(new apache_arrow_1.Field(name, value, true));
-                }
-            }
-            return fields;
-        }
-        const fields = fieldsFromPathTree(pathTree);
-        return new apache_arrow_1.Schema(fields);
-    }
-    else {
-        function takeMatchingFields(fields, pathTree) {
-            const outFields = [];
-            for (const field of fields) {
-                if (pathTree.map.has(field.name)) {
-                    const value = pathTree.get([field.name]);
-                    if (value instanceof PathTree) {
-                        const struct = field.type;
-                        const children = takeMatchingFields(struct.children, value);
-                        outFields.push(new apache_arrow_1.Field(field.name, new apache_arrow_1.Struct(children), field.nullable));
-                    }
-                    else {
-                        outFields.push(new apache_arrow_1.Field(field.name, value, field.nullable));
-                    }
-                }
-            }
-            return outFields;
-        }
-        const fields = takeMatchingFields(schema.fields, pathTree);
-        return new apache_arrow_1.Schema(fields);
-    }
-}
-function* rowPathsAndValues(row, basePath = []) {
-    for (const [key, value] of Object.entries(row)) {
-        if (isObject(value)) {
-            yield* rowPathsAndValues(value, [...basePath, key]);
-        }
-        else {
-            // Skip undefined values - they should be treated the same as missing fields
-            // for embedding function purposes
-            if (value !== undefined) {
-                yield [[...basePath, key], value];
-            }
-        }
-    }
-}
 function isObject(value) {
     return (typeof value === "object" &&
         value !== null &&
@@ -464,179 +370,42 @@ function isObject(value) {
         !(value instanceof Buffer) &&
         !ArrayBuffer.isView(value));
 }
-function getFieldForPath(schema, path) {
-    let current = schema;
+function valueAtPath(datum, path) {
+    let current = datum;
     for (const key of path) {
-        if (current instanceof apache_arrow_1.Schema) {
-            const field = current.fields.find((f) => f.name === key);
-            if (field === undefined) {
-                return undefined;
-            }
-            current = field;
-        }
-        else if (current instanceof apache_arrow_1.Field && apache_arrow_1.DataType.isStruct(current.type)) {
-            const struct = current.type;
-            const field = struct.children.find((f) => f.name === key);
-            if (field === undefined) {
-                return undefined;
-            }
-            current = field;
+        if (current == null) {
+            return null;
         }
-        else {
-            return undefined;
-        }
-    }
-    if (current instanceof apache_arrow_1.Field) {
-        return current;
-    }
-    else {
-        return undefined;
-    }
-}
-/**
- * Try to infer which Arrow type to use for a given value.
- *
- * May return undefined if the type cannot be inferred.
- */
-function inferType(value, path, opts) {
-    if (typeof value === "bigint") {
-        return new apache_arrow_1.Int64();
-    }
-    else if (typeof value === "number") {
-        // Even if it's an integer, it's safer to assume Float64. Users can
-        // always provide an explicit schema or use BigInt if they mean integer.
-        return new apache_arrow_1.Float64();
-    }
-    else if (typeof value === "string") {
-        if (opts.dictionaryEncodeStrings) {
-            return new apache_arrow_1.Dictionary(new apache_arrow_1.Utf8(), new apache_arrow_1.Int32());
+        if (isObject(current) && (Object.hasOwn(current, key) || key in current)) {
+            current = current[key];
         }
         else {
-            return new apache_arrow_1.Utf8();
-        }
-    }
-    else if (typeof value === "boolean") {
-        return new apache_arrow_1.Bool();
-    }
-    else if (value instanceof Buffer) {
-        return new apache_arrow_1.Binary();
-    }
-    else if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
-        const info = typedArrayToArrowType(value);
-        if (info !== undefined) {
-            const child = new apache_arrow_1.Field("item", info.elementType, true);
-            return new apache_arrow_1.FixedSizeList(info.length, child);
-        }
-        return undefined;
-    }
-    else if (Array.isArray(value)) {
-        if (value.length === 0) {
-            return undefined; // Without any values we can't infer the type
-        }
-        if (path.length === 1 && Object.hasOwn(opts.vectorColumns, path[0])) {
-            const floatType = (0, sanitize_1.sanitizeType)(opts.vectorColumns[path[0]].type);
-            return new apache_arrow_1.FixedSizeList(value.length, new apache_arrow_1.Field("item", floatType, true));
-        }
-        const valueType = inferType(value[0], path, opts);
-        if (valueType === undefined) {
             return undefined;
         }
-        // Try to automatically detect embedding columns.
-        if (nameSuggestsVectorColumn(path[path.length - 1])) {
-            // Check if value is a Uint8Array for integer vector type determination
-            if (value instanceof Uint8Array) {
-                // For integer vectors, we default to Uint8 (matching Python implementation)
-                const child = new apache_arrow_1.Field("item", new apache_arrow_1.Uint8(), true);
-                return new apache_arrow_1.FixedSizeList(value.length, child);
-            }
-            else {
-                // For float vectors, we default to Float32
-                const child = new apache_arrow_1.Field("item", new apache_arrow_1.Float32(), true);
-                return new apache_arrow_1.FixedSizeList(value.length, child);
-            }
-        }
-        else {
-            const child = new apache_arrow_1.Field("item", valueType, true);
-            return new apache_arrow_1.List(child);
-        }
-    }
-    else {
-        // TODO: timestamp
-        return undefined;
-    }
-}
-class PathTree {
-    map;
-    constructor(entries) {
-        this.map = new Map();
-        if (entries !== undefined) {
-            for (const [path, value] of entries) {
-                this.set(path, value);
-            }
-        }
-    }
-    has(path) {
-        let ref = this;
-        for (const part of path) {
-            if (!(ref instanceof PathTree) || !ref.map.has(part)) {
-                return false;
-            }
-            ref = ref.map.get(part);
-        }
-        return true;
-    }
-    get(path) {
-        let ref = this;
-        for (const part of path) {
-            if (!(ref instanceof PathTree) || !ref.map.has(part)) {
-                return undefined;
-            }
-            ref = ref.map.get(part);
-        }
-        return ref;
-    }
-    set(path, value) {
-        let ref = this;
-        for (const part of path.slice(0, path.length - 1)) {
-            if (!ref.map.has(part)) {
-                ref.map.set(part, new PathTree());
-            }
-            ref = ref.map.get(part);
-        }
-        ref.map.set(path[path.length - 1], value);
     }
+    return current;
 }
 function transposeData(data, field, path = []) {
+    const valuesPath = [...path, field.name];
+    const values = data.map((datum) => valueAtPath(datum, valuesPath));
     if (field.type instanceof apache_arrow_1.Struct) {
         const childFields = field.type.children;
-        const fullPath = [...path, field.name];
         const childVectors = childFields.map((child) => {
-            return transposeData(data, child, fullPath);
+            return transposeData(data, child, valuesPath);
         });
+        const nullCount = values.filter((value) => value === null).length;
         const structData = (0, apache_arrow_1.makeData)({
             type: field.type,
+            length: values.length,
+            nullCount,
+            nullBitmap: nullCount > 0
+                ? apache_arrow_1.util.packBools(values.map((value) => value !== null))
+                : undefined,
             children: childVectors,
         });
         return (0, apache_arrow_1.makeVector)(structData);
     }
     else {
-        const valuesPath = [...path, field.name];
-        const values = data.map((datum) => {
-            let current = datum;
-            for (const key of valuesPath) {
-                if (current == null) {
-                    return null;
-                }
-                if (isObject(current) &&
-                    (Object.hasOwn(current, key) || key in current)) {
-                    current = current[key];
-                }
-                else {
-                    return null;
-                }
-            }
-            return current;
-        });
         return makeVector(values, field.type, undefined, field.nullable);
     }
 }
@@ -673,29 +442,6 @@ function makeListVector(lists) {
     }
     return listBuilder.finish().toVector();
 }
-/**
- * Map a JS TypedArray instance to the corresponding Arrow element DataType
- * and its length. Returns undefined if the value is not a recognized TypedArray.
- */
-function typedArrayToArrowType(value) {
-    if (value instanceof Float32Array)
-        return { elementType: new apache_arrow_1.Float32(), length: value.length };
-    if (value instanceof Float64Array)
-        return { elementType: new apache_arrow_1.Float64(), length: value.length };
-    if (value instanceof Uint8Array)
-        return { elementType: new apache_arrow_1.Uint8(), length: value.length };
-    if (value instanceof Uint16Array)
-        return { elementType: new apache_arrow_1.Uint16(), length: value.length };
-    if (value instanceof Uint32Array)
-        return { elementType: new apache_arrow_1.Uint32(), length: value.length };
-    if (value instanceof Int8Array)
-        return { elementType: new apache_arrow_1.Int8(), length: value.length };
-    if (value instanceof Int16Array)
-        return { elementType: new apache_arrow_1.Int16(), length: value.length };
-    if (value instanceof Int32Array)
-        return { elementType: new apache_arrow_1.Int32(), length: value.length };
-    return undefined;
-}
 /** Helper function to convert an Array of JS values to an Arrow Vector */
 function makeVector(values, type, stringAsDictionary, nullable) {
     if (type !== undefined) {
@@ -758,7 +504,7 @@ function makeVector(values, type, stringAsDictionary, nullable) {
         throw Error("makeVector cannot infer the type if all values are null or undefined");
     }
     if (ArrayBuffer.isView(sampleValue) && !(sampleValue instanceof DataView)) {
-        const info = typedArrayToArrowType(sampleValue);
+        const info = (0, arrow_type_1.typedArrayToArrowType)(sampleValue);
         if (info !== undefined) {
             const fslType = new apache_arrow_1.FixedSizeList(info.length, new apache_arrow_1.Field("item", info.elementType, true));
             return vectorFromArray(values, fslType);
@@ -793,7 +539,7 @@ async function applyEmbeddingsFromMetadata(table, schema) {
     ]));
     for (const functionEntry of functions.values()) {
         const sourceColumn = columns[functionEntry.sourceColumn];
-        const destColumn = functionEntry.vectorColumn ?? "vector";
+        const destColumn = functionEntry.vectorColumn;
         if (sourceColumn === undefined) {
             throw new Error(`Cannot apply embedding function because the source column '${functionEntry.sourceColumn}' was not present in the data`);
         }
@@ -1128,9 +874,8 @@ function validateSchemaEmbeddings(schema, data, embeddings) {
                 let hasEmbeddingFunction = false;
                 // Check schema metadata for embedding functions
                 if (schema.metadata.has("embedding_functions")) {
-                    const embeddings = JSON.parse(schema.metadata.get("embedding_functions"));
-                    // biome-ignore lint/suspicious/noExplicitAny: we don't know the type of `f`
-                    if (embeddings.find((f) => f["vectorColumn"] === field.name)) {
+                    const entries = (0, registry_1.parseEmbeddingMetadata)(schema.metadata.get("embedding_functions"));
+                    if (entries.some((f) => f.vectorColumn === field.name)) {
                         hasEmbeddingFunction = true;
                     }
                 }
@@ -1190,8 +935,12 @@ function ensureNestedFieldsExist(data, schema) {
                 }
             }
             else {
-                // Field is missing from the data - set to null
-                completeRow[field.name] = null;
+                // Keep a missing struct valid while filling each of its children with
+                // null. This is distinct from an explicitly null struct value.
+                completeRow[field.name] =
+                    field.type.constructor.name === "Struct"
+                        ? ensureStructFieldsExist({}, field.type)
+                        : null;
             }
         }
         return completeRow;
@@ -1217,8 +966,12 @@ function ensureStructFieldsExist(data, structType) {
             }
         }
         else {
-            // Field is missing - set to null
-            completeStruct[childField.name] = null;
+            // Keep a missing struct valid while filling each of its children with
+            // null. This is distinct from an explicitly null struct value.
+            completeStruct[childField.name] =
+                childField.type.constructor.name === "Struct"
+                    ? ensureStructFieldsExist({}, childField.type)
+                    : null;
         }
     }
     return completeStruct;

package/dist/arrow_type.d.ts

@@ -0,0 +1,9 @@
+import { type DataType } from "apache-arrow";
+/**
+ * Map a JS TypedArray instance to the corresponding Arrow element type and
+ * length. Returns undefined when the view is not a supported TypedArray.
+ */
+export declare function typedArrayToArrowType(value: ArrayBufferView): {
+    elementType: DataType;
+    length: number;
+} | undefined;

package/dist/arrow_type.js

@@ -0,0 +1,29 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The LanceDB Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typedArrayToArrowType = typedArrayToArrowType;
+const apache_arrow_1 = require("apache-arrow");
+/**
+ * Map a JS TypedArray instance to the corresponding Arrow element type and
+ * length. Returns undefined when the view is not a supported TypedArray.
+ */
+function typedArrayToArrowType(value) {
+    if (value instanceof Float32Array)
+        return { elementType: new apache_arrow_1.Float32(), length: value.length };
+    if (value instanceof Float64Array)
+        return { elementType: new apache_arrow_1.Float64(), length: value.length };
+    if (value instanceof Uint8Array)
+        return { elementType: new apache_arrow_1.Uint8(), length: value.length };
+    if (value instanceof Uint16Array)
+        return { elementType: new apache_arrow_1.Uint16(), length: value.length };
+    if (value instanceof Uint32Array)
+        return { elementType: new apache_arrow_1.Uint32(), length: value.length };
+    if (value instanceof Int8Array)
+        return { elementType: new apache_arrow_1.Int8(), length: value.length };
+    if (value instanceof Int16Array)
+        return { elementType: new apache_arrow_1.Int16(), length: value.length };
+    if (value instanceof Int32Array)
+        return { elementType: new apache_arrow_1.Int32(), length: value.length };
+    return undefined;
+}

package/dist/connection.d.ts

@@ -1,9 +1,10 @@
 import { Data, SchemaLike, TableLike } from "./arrow";
 import { Table as ArrowTable } from "./arrow";
 import { EmbeddingFunctionConfig } from "./embedding/registry";
+import { MaterializedView, MaterializedViewSelect } from "./materialized_view";
 import { Connection as LanceDbConnection } from "./native";
-import type { CreateNamespaceResponse, DescribeNamespaceResponse, DropNamespaceResponse, Job, JobDescription, JobInfo, ListNamespacesResponse } from "./native";
-export type { CreateNamespaceResponse, DescribeNamespaceResponse, DropNamespaceResponse, ListNamespacesResponse, };
+import type { CreateNamespaceResponse, DescribeNamespaceResponse, DropNamespaceResponse, Job, JobDescription, JobInfo, ListNamespacesResponse, ListTablesResponse } from "./native";
+export type { CreateNamespaceResponse, DescribeNamespaceResponse, DropNamespaceResponse, ListNamespacesResponse, ListTablesResponse, };
 import { Table } from "./table";
 export interface CreateTableOptions {
     /**
@@ -92,6 +93,10 @@ export interface OpenTableOptions {
      */
     indexCacheSize?: number;
 }
+/**
+ * @deprecated Use {@link ListTablesOptions} with {@link Connection.listTables}
+ * instead.
+ */
 export interface TableNamesOptions {
     /**
      * If present, only return names that come lexicographically after the
@@ -104,6 +109,23 @@ export interface TableNamesOptions {
     /** An optional limit to the number of results to return. */
     limit?: number;
 }
+export interface ListTablesOptions {
+    /**
+     * Token from a previous response, to resume listing where it left off.
+     *
+     * The token is opaque: it carries whatever the database needs to resume, and
+     * callers should not construct or interpret one.
+     */
+    pageToken?: string;
+    /**
+     * An upper bound on how many tables to return.
+     *
+     * A page may hold fewer than this and still not be the last one, so keep
+     * going while the response carries a page token rather than while pages are
+     * full.
+     */
+    limit?: number;
+}
 export interface ListNamespacesOptions {
     /** Token from a previous response for pagination. */
     pageToken?: string;
@@ -177,6 +199,7 @@ export declare abstract class Connection {
      * @param {Partial<TableNamesOptions>} options - options to control the
      * paging / start point (backwards compatibility)
      *
+     * @deprecated Use {@link Connection.listTables} instead.
      */
     abstract tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
     /**
@@ -187,14 +210,77 @@ export declare abstract class Connection {
      * @param {Partial<TableNamesOptions>} options - options to control the
      * paging / start point
      *
+     * @deprecated Use {@link Connection.listTables} instead.
      */
     abstract tableNames(namespacePath?: string[], options?: Partial<TableNamesOptions>): Promise<string[]>;
+    /**
+     * List a page of the tables in this database.
+     *
+     * To retrieve the tables after the page, pass the `pageToken` the response
+     * carries back in. A page can be shorter than `limit` without being the last
+     * one, so walk until a response carries no page token:
+     *
+     * ```ts
+     * const names = [];
+     * let pageToken = undefined;
+     * do {
+     *   const page = await conn.listTables({ pageToken, limit: 100 });
+     *   names.push(...page.tables);
+     *   pageToken = page.pageToken;
+     * } while (pageToken);
+     * ```
+     *
+     * @param {Partial<ListTablesOptions>} options - Pagination options
+     *   (`pageToken`, `limit`).
+     * @returns {Promise<ListTablesResponse>} A page of table names and an
+     *   optional token for the tables after it.
+     */
+    abstract listTables(options?: Partial<ListTablesOptions>): Promise<ListTablesResponse>;
+    /**
+     * List a page of the tables in this database.
+     *
+     * @param {string[]} namespacePath - The namespace path to list tables from
+     *   (defaults to root namespace)
+     * @param {Partial<ListTablesOptions>} options - Pagination options
+     *   (`pageToken`, `limit`).
+     * @returns {Promise<ListTablesResponse>} A page of table names and an
+     *   optional token for the tables after it.
+     */
+    abstract listTables(namespacePath?: string[], options?: Partial<ListTablesOptions>): Promise<ListTablesResponse>;
     /**
      * Open a table in the database.
      * @param {string} name - The name of the table
      * @param {string[]} namespacePath - The namespace path of the table (defaults to root namespace)
      * @param {Partial<OpenTableOptions>} options - Additional options
      */
+    /**
+     * Define a materialized view named `name` over the table `source`.
+     *
+     * The view is created empty, with the query recorded in its schema
+     * metadata; `view.refresh()` computes the rows. The view is a normal
+     * table: it can be queried, indexed and searched, and it appears in
+     * `tableNames`. The source table must have stable row ids (create it with
+     * the `newTableEnableStableRowIds` storage option); they keep the view's
+     * provenance valid across source compactions and cannot be enabled after
+     * a table exists. Local databases only.
+     */
+    abstract createMaterializedView(name: string, source: string, options?: {
+        select?: MaterializedViewSelect;
+        where?: string;
+        limit?: number;
+    }): Promise<MaterializedView>;
+    /**
+     * Open the materialized view named `name`.
+     *
+     * Rejects a table that exists but is not a materialized view.
+     */
+    abstract openMaterializedView(name: string): Promise<MaterializedView>;
+    /**
+     * The names of the materialized views in this database.
+     *
+     * Found by reading every table's schema, so this costs an open per table.
+     */
+    abstract listMaterializedViews(): Promise<string[]>;
     abstract openTable(name: string, namespacePath?: string[], options?: Partial<OpenTableOptions>): Promise<Table>;
     /**
      * Creates a new Table and initialize it with new data.
@@ -246,6 +332,13 @@ export declare abstract class Connection {
      * @param {string[]} namespacePath The namespace path of the table (defaults to root namespace).
      */
     abstract dropTable(name: string, namespacePath?: string[]): Promise<void>;
+    /**
+     * Start dropping a table and return its cleanup job.
+     *
+     * The table may become unavailable before its data files are removed. Wait
+     * on the returned job to know when cleanup has finished.
+     */
+    abstract dropTableAsync(name: string, namespacePath?: string[]): Promise<Job>;
     /**
      * Drop all tables in the database.
      * @param {string[]} namespacePath The namespace path to drop tables from (defaults to root namespace).
@@ -373,6 +466,14 @@ export declare class LocalConnection extends Connection {
     close(): void;
     display(): string;
     tableNames(namespacePathOrOptions?: string[] | Partial<TableNamesOptions>, options?: Partial<TableNamesOptions>): Promise<string[]>;
+    createMaterializedView(name: string, source: string, options?: {
+        select?: MaterializedViewSelect;
+        where?: string;
+        limit?: number;
+    }): Promise<MaterializedView>;
+    openMaterializedView(name: string): Promise<MaterializedView>;
+    listMaterializedViews(): Promise<string[]>;
+    listTables(namespacePathOrOptions?: string[] | Partial<ListTablesOptions>, options?: Partial<ListTablesOptions>): Promise<ListTablesResponse>;
     openTable(name: string, namespacePath?: string[], options?: Partial<OpenTableOptions>): Promise<Table>;
     cloneTable(targetTableName: string, sourceUri: string, options?: {
         targetNamespacePath?: string[];
@@ -388,6 +489,7 @@ export declare class LocalConnection extends Connection {
     private _createTableImpl;
     createEmptyTable(name: string, schema: import("./arrow").SchemaLike, namespacePathOrOptions?: string[] | Partial<CreateTableOptions>, options?: Partial<CreateTableOptions>): Promise<Table>;
     dropTable(name: string, namespacePath?: string[]): Promise<void>;
+    dropTableAsync(name: string, namespacePath?: string[]): Promise<Job>;
     dropAllTables(namespacePath?: string[]): Promise<void>;
     describeNamespace(namespacePath: string[]): Promise<DescribeNamespaceResponse>;
     listNamespaces(namespacePath?: string[], options?: Partial<ListNamespacesOptions>): Promise<ListNamespacesResponse>;

package/dist/connection.js

@@ -8,6 +8,7 @@ const apache_arrow_1 = require("apache-arrow");
 const arrow_1 = require("./arrow");
 const arrow_2 = require("./arrow");
 const registry_1 = require("./embedding/registry");
+const materialized_view_1 = require("./materialized_view");
 const sanitize_1 = require("./sanitize");
 const table_1 = require("./table");
 /**
@@ -68,6 +69,28 @@ class LocalConnection extends Connection {
         }
         return this.inner.tableNames(namespacePath ?? [], tableNamesOptions?.startAfter, tableNamesOptions?.limit);
     }
+    async createMaterializedView(name, source, options) {
+        (0, materialized_view_1.validateNonNegativeInteger)(options?.limit, "limit");
+        const innerTable = await this.inner.createMaterializedView(name, source, (0, materialized_view_1.normalizeSelect)(options?.select), options?.where, options?.limit);
+        return new materialized_view_1.MaterializedView(new table_1.LocalTable(innerTable));
+    }
+    async openMaterializedView(name) {
+        const innerTable = await this.inner.openMaterializedView(name);
+        return new materialized_view_1.MaterializedView(new table_1.LocalTable(innerTable));
+    }
+    async listMaterializedViews() {
+        return await this.inner.listMaterializedViews();
+    }
+    async listTables(namespacePathOrOptions, options) {
+        // Detect if first argument is namespacePath array or options object
+        const namespacePath = Array.isArray(namespacePathOrOptions)
+            ? namespacePathOrOptions
+            : undefined;
+        const listTablesOptions = Array.isArray(namespacePathOrOptions)
+            ? options
+            : namespacePathOrOptions;
+        return this.inner.listTables(namespacePath ?? [], listTablesOptions?.pageToken, listTablesOptions?.limit);
+    }
     async openTable(name, namespacePath, options) {
         const innerTable = await this.inner.openTable(name, namespacePath ?? [], cleanseStorageOptions(options?.storageOptions), options?.indexCacheSize);
         let table = new table_1.LocalTable(innerTable);
@@ -174,6 +197,9 @@ class LocalConnection extends Connection {
     async dropTable(name, namespacePath) {
         return this.inner.dropTable(name, namespacePath ?? []);
     }
+    async dropTableAsync(name, namespacePath) {
+        return this.inner.dropTableAsync(name, namespacePath ?? []);
+    }
     async dropAllTables(namespacePath) {
         return this.inner.dropAllTables(namespacePath ?? []);
     }