@lancedb/lancedb 0.39.0-beta.1 → 0.39.0-beta.10

package/dist/arrow.d.ts

@@ -14,6 +14,22 @@ export type FieldLike = Field | {
     nullable: boolean;
     metadata?: Map<string, string>;
 };
+/**
+ * Create an Arrow field backed by LanceDB's JSON extension type.
+ *
+ * @param name - The field name.
+ * @param nullable - Whether the field accepts null values.
+ * @example
+ * ```ts
+ * import { connect, makeJsonField } from "@lancedb/lancedb";
+ * import { Schema } from "apache-arrow";
+ *
+ * const schema = new Schema([makeJsonField("metadata")]);
+ * const db = await connect("/path/to/database");
+ * await db.createTable("items", [{ metadata: '{"source":"api"}' }], { schema });
+ * ```
+ */
+export declare function makeJsonField(name: string, nullable?: boolean): Field;
 export type DataLike = import("apache-arrow").Data | {
     type: any;
     length: number;
@@ -208,7 +224,7 @@ export declare function makeEmptyTable(schema: SchemaLike, metadata?: Map<string
  * customized by the `embeddingDataType` property of the embedding function.
  *
  * If a schema is provided in `makeTableOptions` then it should include the
- * embedding columns.  If no schema is provded then embedding columns will
+ * embedding columns.  If no schema is provided then embedding columns will
  * be placed at the end of the table, after all of the input columns.
  */
 export declare function convertToTable(data: Array<Record<string, unknown>>, embeddings?: EmbeddingFunctionConfig, makeTableOptions?: Partial<MakeArrowTableOptions>): Promise<ArrowTable>;

package/dist/arrow.js

@@ -17,6 +17,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MakeArrowTableOptions = exports.VectorColumnOptions = void 0;
+exports.makeJsonField = makeJsonField;
 exports.isMultiVector = isMultiVector;
 exports.isIntoVector = isIntoVector;
 exports.extractVectorBuffer = extractVectorBuffer;
@@ -57,10 +58,29 @@ exports.ensureNestedFieldsExist = ensureNestedFieldsExist;
 exports.dataTypeToJson = dataTypeToJson;
 const apache_arrow_1 = require("apache-arrow");
 const arrow_type_1 = require("./arrow_type");
+const blob_1 = require("./blob");
 const registry_1 = require("./embedding/registry");
 const sanitize_1 = require("./sanitize");
 const schema_1 = require("./schema");
 __exportStar(require("apache-arrow"), exports);
+/**
+ * Create an Arrow field backed by LanceDB's JSON extension type.
+ *
+ * @param name - The field name.
+ * @param nullable - Whether the field accepts null values.
+ * @example
+ * ```ts
+ * import { connect, makeJsonField } from "@lancedb/lancedb";
+ * import { Schema } from "apache-arrow";
+ *
+ * const schema = new Schema([makeJsonField("metadata")]);
+ * const db = await connect("/path/to/database");
+ * await db.createTable("items", [{ metadata: '{"source":"api"}' }], { schema });
+ * ```
+ */
+function makeJsonField(name, nullable = true) {
+    return new apache_arrow_1.Field(name, new apache_arrow_1.Utf8(), nullable, new Map([["ARROW:extension:name", "arrow.json"]]));
+}
 function isMultiVector(value) {
     return Array.isArray(value) && isIntoVector(value[0]);
 }
@@ -348,17 +368,39 @@ function makeArrowTable(data, options, metadata) {
         }
         else {
             schema = new apache_arrow_1.Schema(schema.fields, schemaMetadata);
+            validateBlobSchema(schema);
             return new apache_arrow_1.Table(schema);
         }
     }
     let inferredSchema = (0, schema_1.inferSchema)(data, schema, opt);
     inferredSchema = new apache_arrow_1.Schema(inferredSchema.fields, schemaMetadata);
+    validateBlobSchema(inferredSchema);
     const finalColumns = {};
     for (const field of inferredSchema.fields) {
         finalColumns[field.name] = transposeData(data, field);
     }
     return new apache_arrow_1.Table(inferredSchema, finalColumns);
 }
+function validateBlobSchema(schema) {
+    for (const field of schema.fields) {
+        validateBlobField(field);
+    }
+}
+function validateBlobField(field) {
+    if (isFixedSizeList(field.type) &&
+        containsBlobField(field.type.children[0])) {
+        throw new Error("Blob fields inside FixedSizeList are not supported. Use List instead.");
+    }
+    for (const child of field.type.children ?? []) {
+        validateBlobField(child);
+    }
+}
+function containsBlobField(field) {
+    if ((0, blob_1.isBlobField)(field)) {
+        return true;
+    }
+    return (field.type.children ?? []).some((child) => containsBlobField(child));
+}
 function isObject(value) {
     return (typeof value === "object" &&
         value !== null &&
@@ -387,6 +429,27 @@ function valueAtPath(datum, path) {
 }
 function transposeData(data, field, path = []) {
     const valuesPath = [...path, field.name];
+    if ((0, blob_1.isBlobField)(field) && field.type instanceof apache_arrow_1.Struct) {
+        const blobRows = data.map((datum) => (0, blob_1.coerceBlobValue)(valueAtPath(datum, valuesPath)));
+        const childVectors = field.type.children.map((child) => {
+            const values = blobRows.map((row) => row == null ? null : (row[child.name] ?? null));
+            return makeVector(values, child.type, undefined, child.nullable);
+        });
+        const nullCount = blobRows.filter((row) => row === null).length;
+        const structData = (0, apache_arrow_1.makeData)({
+            type: field.type,
+            length: blobRows.length,
+            nullCount,
+            nullBitmap: nullCount > 0
+                ? apache_arrow_1.util.packBools(blobRows.map((row) => row !== null))
+                : undefined,
+            children: childVectors.map((v) => v.data[0]),
+        });
+        return (0, apache_arrow_1.makeVector)(structData);
+    }
+    if (isList(field.type) && containsBlobField(field.type.children[0])) {
+        return transposeListData(data, field, valuesPath);
+    }
     const values = data.map((datum) => valueAtPath(datum, valuesPath));
     if (field.type instanceof apache_arrow_1.Struct) {
         const childFields = field.type.children;
@@ -401,7 +464,7 @@ function transposeData(data, field, path = []) {
             nullBitmap: nullCount > 0
                 ? apache_arrow_1.util.packBools(values.map((value) => value !== null))
                 : undefined,
-            children: childVectors,
+            children: childVectors.map((v) => v.data[0]),
         });
         return (0, apache_arrow_1.makeVector)(structData);
     }
@@ -409,6 +472,39 @@ function transposeData(data, field, path = []) {
         return makeVector(values, field.type, undefined, field.nullable);
     }
 }
+function transposeListData(data, field, valuesPath) {
+    const listType = field.type;
+    const childField = listType.children[0];
+    const lists = data.map((datum) => valueAtPath(datum, valuesPath));
+    const flattened = [];
+    const validity = [];
+    const offsets = [0];
+    for (const list of lists) {
+        if (list == null) {
+            validity.push(false);
+            offsets.push(flattened.length);
+            continue;
+        }
+        if (!Array.isArray(list)) {
+            throw new Error(`expected an array for list field '${field.name}'`);
+        }
+        validity.push(true);
+        for (const element of list) {
+            flattened.push({ [childField.name]: element });
+        }
+        offsets.push(flattened.length);
+    }
+    const childVector = transposeData(flattened, childField, []);
+    const nullCount = validity.filter((valid) => !valid).length;
+    return (0, apache_arrow_1.makeVector)((0, apache_arrow_1.makeData)({
+        type: listType,
+        length: lists.length,
+        nullCount,
+        nullBitmap: nullCount > 0 ? apache_arrow_1.util.packBools(validity) : undefined,
+        valueOffsets: Int32Array.from(offsets),
+        child: childVector.data[0],
+    }));
+}
 /**
  * Create an empty Arrow table with the provided schema
  */
@@ -497,7 +593,7 @@ function makeVector(values, type, stringAsDictionary, nullable) {
         return vectorFromArray(values, type);
     }
     if (values.length === 0) {
-        throw Error("makeVector requires at least one value or the type must be specfied");
+        throw Error("makeVector requires at least one value or the type must be specified");
     }
     const sampleValue = values.find((val) => val !== null && val !== undefined);
     if (sampleValue === undefined) {
@@ -688,7 +784,7 @@ async function applyEmbeddings(table, embeddings, schema) {
  * customized by the `embeddingDataType` property of the embedding function.
  *
  * If a schema is provided in `makeTableOptions` then it should include the
- * embedding columns.  If no schema is provded then embedding columns will
+ * embedding columns.  If no schema is provided then embedding columns will
  * be placed at the end of the table, after all of the input columns.
  */
 async function convertToTable(data, embeddings, makeTableOptions) {
@@ -752,6 +848,7 @@ async function fromTableToBuffer(table, embeddings, schema) {
         schema = (0, sanitize_1.sanitizeSchema)(schema);
     }
     const tableWithEmbeddings = await applyEmbeddings(table, embeddings, schema);
+    validateBlobSchema(tableWithEmbeddings.schema);
     const writer = apache_arrow_1.RecordBatchFileWriter.writeAll(tableWithEmbeddings);
     return Buffer.from(await writer.toUint8Array());
 }

package/dist/blob.d.ts

@@ -0,0 +1,92 @@
+import { Field } from "apache-arrow";
+import { BlobFile as NativeBlobFile } from "./native";
+export type BlobInput = {
+    data: Buffer | Uint8Array | null;
+    uri: string | null;
+};
+export type BlobOptions = {
+    /** Defaults to true. */
+    nullable?: boolean;
+    /**
+     * Max payload bytes kept inline in the data file. Zero is allowed. Must be a
+     * safe integer.
+     */
+    inlineSizeThreshold?: number;
+    /**
+     * Max payload bytes stored in a packed sidecar before a dedicated file. Must
+     * be a positive safe integer.
+     */
+    dedicatedSizeThreshold?: number;
+    /**
+     * Max bytes in one packed sidecar before starting another. Must be a positive
+     * safe integer.
+     */
+    packFileSizeThreshold?: number;
+};
+/**
+ * Declares a `lance.blob.v2` column.
+ *
+ * Query results are descriptors, not payload bytes. Use {@link Table.fetchBlobs}
+ * or {@link Table.fetchBlobFiles} to read bytes.
+ *
+ * @example
+ * ```ts
+ * import { readFile } from "node:fs/promises";
+ * import { Field, Int64, Schema } from "apache-arrow";
+ * import { blob, connect } from "@lancedb/lancedb";
+ *
+ * const db = await connect("./data");
+ * const video = await readFile("clip.mp4");
+ * const table = await db.createTable(
+ *   "videos",
+ *   [{ id: 1n, video }],
+ *   {
+ *     schema: new Schema([
+ *       new Field("id", new Int64()),
+ *       blob("video"),
+ *     ]),
+ *   },
+ * );
+ *
+ * const rows = await table.query().select(["id"]).withRowId().toArray();
+ * const rowIds = rows.map((row) => row._rowid as bigint);
+ * const bytes = await table.fetchBlobs("video", rowIds);
+ *
+ * const [handle] = await table.fetchBlobFiles("video", rowIds);
+ * const size = handle!.size();
+ * const header = await handle!.readRange(0n, size < 65536n ? size : 65536n);
+ * ```
+ */
+export declare function blob(name: string, options?: BlobOptions): Field;
+/**
+ * Checks for the `lance.blob.v2` extension marker. Does not validate the
+ * field's storage type.
+ */
+export declare function isBlobField(field: Field): boolean;
+/**
+ * A lazy handle to blob bytes. Create one with {@link Table.fetchBlobFiles}.
+ *
+ * @hideconstructor
+ */
+export declare class BlobFile {
+    private readonly inner;
+    private constructor();
+    /** @ignore */
+    static fromNative(inner: NativeBlobFile): BlobFile;
+    /** Returns the blob size in bytes. */
+    size(): bigint;
+    /**
+     * Reads from the cursor to the end and advances the cursor.
+     *
+     * A second call returns an empty buffer. {@link BlobFile.readRange} does
+     * not move the cursor.
+     */
+    read(): Promise<Buffer>;
+    /**
+     * Reads the half-open byte range `[start, end)`.
+     *
+     * Fails when `end` is past the blob size. Does not move the cursor.
+     */
+    readRange(start: bigint, end: bigint): Promise<Buffer>;
+}
+export declare function coerceBlobValue(value: unknown): BlobInput | null;

package/dist/blob.js

@@ -0,0 +1,165 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The LanceDB Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlobFile = void 0;
+exports.blob = blob;
+exports.isBlobField = isBlobField;
+exports.coerceBlobValue = coerceBlobValue;
+const apache_arrow_1 = require("apache-arrow");
+const native_1 = require("./native");
+const BLOB_V2_EXTENSION_NAME = "lance.blob.v2";
+const INLINE_SIZE_THRESHOLD_KEY = "lance-encoding:blob-inline-size-threshold";
+const DEDICATED_SIZE_THRESHOLD_KEY = "lance-encoding:blob-dedicated-size-threshold";
+const PACK_FILE_SIZE_THRESHOLD_KEY = "lance-encoding:blob-pack-file-size-threshold";
+/**
+ * Declares a `lance.blob.v2` column.
+ *
+ * Query results are descriptors, not payload bytes. Use {@link Table.fetchBlobs}
+ * or {@link Table.fetchBlobFiles} to read bytes.
+ *
+ * @example
+ * ```ts
+ * import { readFile } from "node:fs/promises";
+ * import { Field, Int64, Schema } from "apache-arrow";
+ * import { blob, connect } from "@lancedb/lancedb";
+ *
+ * const db = await connect("./data");
+ * const video = await readFile("clip.mp4");
+ * const table = await db.createTable(
+ *   "videos",
+ *   [{ id: 1n, video }],
+ *   {
+ *     schema: new Schema([
+ *       new Field("id", new Int64()),
+ *       blob("video"),
+ *     ]),
+ *   },
+ * );
+ *
+ * const rows = await table.query().select(["id"]).withRowId().toArray();
+ * const rowIds = rows.map((row) => row._rowid as bigint);
+ * const bytes = await table.fetchBlobs("video", rowIds);
+ *
+ * const [handle] = await table.fetchBlobFiles("video", rowIds);
+ * const size = handle!.size();
+ * const header = await handle!.readRange(0n, size < 65536n ? size : 65536n);
+ * ```
+ */
+function blob(name, options = {}) {
+    const metadata = new Map([
+        ["ARROW:extension:name", BLOB_V2_EXTENSION_NAME],
+    ]);
+    setThreshold(metadata, INLINE_SIZE_THRESHOLD_KEY, "inlineSizeThreshold", options.inlineSizeThreshold, 0);
+    setThreshold(metadata, DEDICATED_SIZE_THRESHOLD_KEY, "dedicatedSizeThreshold", options.dedicatedSizeThreshold, 1);
+    setThreshold(metadata, PACK_FILE_SIZE_THRESHOLD_KEY, "packFileSizeThreshold", options.packFileSizeThreshold, 1);
+    return new apache_arrow_1.Field(name, new apache_arrow_1.Struct([
+        new apache_arrow_1.Field("data", new apache_arrow_1.LargeBinary(), true),
+        new apache_arrow_1.Field("uri", new apache_arrow_1.Utf8(), true),
+    ]), options.nullable ?? true, metadata);
+}
+/**
+ * Checks for the `lance.blob.v2` extension marker. Does not validate the
+ * field's storage type.
+ */
+function isBlobField(field) {
+    return field.metadata?.get("ARROW:extension:name") === BLOB_V2_EXTENSION_NAME;
+}
+/**
+ * A lazy handle to blob bytes. Create one with {@link Table.fetchBlobFiles}.
+ *
+ * @hideconstructor
+ */
+class BlobFile {
+    inner;
+    constructor(inner) {
+        if (!(inner instanceof native_1.BlobFile)) {
+            throw new Error("BlobFile handles come from Table.fetchBlobFiles");
+        }
+        this.inner = inner;
+    }
+    /** @ignore */
+    static fromNative(inner) {
+        return new BlobFile(inner);
+    }
+    /** Returns the blob size in bytes. */
+    size() {
+        return this.inner.size();
+    }
+    /**
+     * Reads from the cursor to the end and advances the cursor.
+     *
+     * A second call returns an empty buffer. {@link BlobFile.readRange} does
+     * not move the cursor.
+     */
+    read() {
+        return this.inner.read();
+    }
+    /**
+     * Reads the half-open byte range `[start, end)`.
+     *
+     * Fails when `end` is past the blob size. Does not move the cursor.
+     */
+    readRange(start, end) {
+        return this.inner.readRange(start, end);
+    }
+}
+exports.BlobFile = BlobFile;
+function coerceBlobValue(value) {
+    if (value == null) {
+        return null;
+    }
+    if (isBlobBytes(value)) {
+        return { data: value, uri: null };
+    }
+    if (ArrayBuffer.isView(value)) {
+        throw new Error("Blob data must be Buffer or Uint8Array");
+    }
+    if (typeof value === "string") {
+        if (value === "") {
+            throw new Error("Blob uri cannot be empty");
+        }
+        return { data: null, uri: value };
+    }
+    if (typeof value === "object") {
+        const record = value;
+        if (!("data" in record) && !("uri" in record)) {
+            throw new Error("Blob struct values must include a 'data' or 'uri' field");
+        }
+        const uri = record.uri;
+        if (uri === "") {
+            throw new Error("Blob uri cannot be empty");
+        }
+        if (uri != null && typeof uri !== "string") {
+            throw new Error(`Blob uri must be a string or null, got ${typeof uri}`);
+        }
+        const data = record.data;
+        if (data != null && !isBlobBytes(data)) {
+            throw new Error("Blob data must be Buffer, Uint8Array, or null");
+        }
+        const bytes = data ?? null;
+        const uriValue = uri ?? null;
+        if ((bytes == null) === (uriValue == null)) {
+            throw new Error("Blob struct values must set exactly one of 'data' or 'uri'");
+        }
+        return { data: bytes, uri: uriValue };
+    }
+    throw new Error("Blob column values must be Buffer, Uint8Array, a URI string, null, or { data?, uri? }");
+}
+function isBlobBytes(value) {
+    return Buffer.isBuffer(value) || value instanceof Uint8Array;
+}
+function setThreshold(metadata, key, optionName, value, minimum) {
+    if (value === undefined) {
+        return;
+    }
+    if (!Number.isSafeInteger(value)) {
+        throw new Error(`${optionName} must be a safe integer`);
+    }
+    if (value < minimum) {
+        throw new Error(minimum <= 0
+            ? `${optionName} must be non-negative`
+            : `${optionName} must be positive`);
+    }
+    metadata.set(key, String(value));
+}

package/dist/connection.d.ts

@@ -1,9 +1,9 @@
 import { Data, SchemaLike, TableLike } from "./arrow";
-import { Table as ArrowTable } from "./arrow";
 import { EmbeddingFunctionConfig } from "./embedding/registry";
+import { Job } from "./job";
 import { MaterializedView, MaterializedViewSelect } from "./materialized_view";
 import { Connection as LanceDbConnection } from "./native";
-import type { CreateNamespaceResponse, DescribeNamespaceResponse, DropNamespaceResponse, Job, JobDescription, JobInfo, ListNamespacesResponse, ListTablesResponse } from "./native";
+import type { CreateNamespaceResponse, DescribeNamespaceResponse, DropNamespaceResponse, JobInfo, ListNamespacesResponse, ListTablesResponse } from "./native";
 export type { CreateNamespaceResponse, DescribeNamespaceResponse, DropNamespaceResponse, ListNamespacesResponse, ListTablesResponse, };
 import { Table } from "./table";
 export interface CreateTableOptions {
@@ -256,18 +256,19 @@ export declare abstract class Connection {
     /**
      * 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 view is populated before creation returns. Set `withNoData` to create
+     * only its definition and empty backing table. 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.
+     * a table exists.
      */
     abstract createMaterializedView(name: string, source: string, options?: {
         select?: MaterializedViewSelect;
         where?: string;
         limit?: number;
+        withNoData?: boolean;
     }): Promise<MaterializedView>;
     /**
      * Open the materialized view named `name`.
@@ -281,6 +282,22 @@ export declare abstract class Connection {
      * Found by reading every table's schema, so this costs an open per table.
      */
     abstract listMaterializedViews(): Promise<string[]>;
+    /**
+     * Drop the materialized view named `name`.
+     *
+     * The view may become unavailable before physical cleanup finishes. Use
+     * {@link dropMaterializedViewAsync} to retain and wait for the cleanup job.
+     *
+     * Rejects a table that exists but is not a materialized view.
+     */
+    abstract dropMaterializedView(name: string, namespacePath?: string[]): Promise<void>;
+    /**
+     * Start dropping the materialized view named `name` and return its cleanup
+     * job without waiting for completion.
+     *
+     * Rejects a table that exists but is not a materialized view.
+     */
+    abstract dropMaterializedViewAsync(name: string, namespacePath?: string[]): Promise<Job>;
     abstract openTable(name: string, namespacePath?: string[], options?: Partial<OpenTableOptions>): Promise<Table>;
     /**
      * Creates a new Table and initialize it with new data.
@@ -428,21 +445,17 @@ export declare abstract class Connection {
      */
     abstract renameTable(currentName: string, newName: string, options?: RenameTableOptions): Promise<void>;
     /**
-     * A {@link Job} handle for a server-side job by id.
+     * Open a server-side job by id, returning a handle with its record already
+     * populated. Rejects when the server has no such job, the way
+     * {@link Connection.openTable} does for a missing table.
      *
-     * The handle is constructed without a server round trip; an unknown id
-     * surfaces when the handle is used. Dropping the handle has no effect on
-     * the job itself.
+     * The returned {@link Job} answers for its own state, specification,
+     * result, failure and event history, so there is no separate
+     * connection-level call for any of them.
      */
-    abstract job(jobId: string): Job;
+    abstract openJob(jobId: string): Promise<Job>;
     /** List server-side jobs across the database's tables. */
     abstract listJobs(): Promise<JobInfo[]>;
-    /**
-     * Describe a single server-side job by id.
-     *
-     * Resolves to `null` when the server has no such job.
-     */
-    abstract getJob(jobId: string): Promise<JobDescription | null>;
     /**
      * Request cancellation of a server-side job by id.
      *
@@ -450,12 +463,6 @@ export declare abstract class Connection {
      * such job exists. Cancelling an already-terminal job is a no-op success.
      */
     abstract cancelJob(jobId: string): Promise<boolean>;
-    /**
-     * The lifecycle event history of a server-side job, as an Arrow table.
-     *
-     * Lists history across all jobs when `jobId` is omitted.
-     */
-    abstract jobHistory(jobId?: string): Promise<ArrowTable>;
 }
 /** @hideconstructor */
 export declare class LocalConnection extends Connection {
@@ -470,9 +477,12 @@ export declare class LocalConnection extends Connection {
         select?: MaterializedViewSelect;
         where?: string;
         limit?: number;
+        withNoData?: boolean;
     }): Promise<MaterializedView>;
     openMaterializedView(name: string): Promise<MaterializedView>;
     listMaterializedViews(): Promise<string[]>;
+    dropMaterializedView(name: string, namespacePath?: string[]): Promise<void>;
+    dropMaterializedViewAsync(name: string, namespacePath?: string[]): Promise<Job>;
     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?: {
@@ -496,11 +506,9 @@ export declare class LocalConnection extends Connection {
     createNamespace(namespacePath: string[], options?: Partial<CreateNamespaceOptions>): Promise<CreateNamespaceResponse>;
     dropNamespace(namespacePath: string[], options?: Partial<DropNamespaceOptions>): Promise<DropNamespaceResponse>;
     renameTable(currentName: string, newName: string, options?: RenameTableOptions): Promise<void>;
-    job(jobId: string): Job;
+    openJob(jobId: string): Promise<Job>;
     listJobs(): Promise<JobInfo[]>;
-    getJob(jobId: string): Promise<JobDescription | null>;
     cancelJob(jobId: string): Promise<boolean>;
-    jobHistory(jobId?: string): Promise<ArrowTable>;
 }
 /**
  * Takes storage options and makes all the keys snake case.

package/dist/connection.js

@@ -4,10 +4,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalConnection = exports.Connection = void 0;
 exports.cleanseStorageOptions = cleanseStorageOptions;
-const apache_arrow_1 = require("apache-arrow");
 const arrow_1 = require("./arrow");
 const arrow_2 = require("./arrow");
 const registry_1 = require("./embedding/registry");
+const job_1 = require("./job");
 const materialized_view_1 = require("./materialized_view");
 const sanitize_1 = require("./sanitize");
 const table_1 = require("./table");
@@ -71,7 +71,7 @@ class LocalConnection extends Connection {
     }
     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);
+        const innerTable = await this.inner.createMaterializedView(name, source, (0, materialized_view_1.normalizeSelect)(options?.select), options?.where, options?.limit, options?.withNoData ?? false);
         return new materialized_view_1.MaterializedView(new table_1.LocalTable(innerTable));
     }
     async openMaterializedView(name) {
@@ -81,6 +81,12 @@ class LocalConnection extends Connection {
     async listMaterializedViews() {
         return await this.inner.listMaterializedViews();
     }
+    async dropMaterializedView(name, namespacePath) {
+        return this.inner.dropMaterializedView(name, namespacePath ?? []);
+    }
+    async dropMaterializedViewAsync(name, namespacePath) {
+        return new job_1.Job(await this.inner.dropMaterializedViewAsync(name, namespacePath ?? []));
+    }
     async listTables(namespacePathOrOptions, options) {
         // Detect if first argument is namespacePath array or options object
         const namespacePath = Array.isArray(namespacePathOrOptions)
@@ -198,7 +204,7 @@ class LocalConnection extends Connection {
         return this.inner.dropTable(name, namespacePath ?? []);
     }
     async dropTableAsync(name, namespacePath) {
-        return this.inner.dropTableAsync(name, namespacePath ?? []);
+        return new job_1.Job(await this.inner.dropTableAsync(name, namespacePath ?? []));
     }
     async dropAllTables(namespacePath) {
         return this.inner.dropAllTables(namespacePath ?? []);
@@ -218,25 +224,15 @@ class LocalConnection extends Connection {
     async renameTable(currentName, newName, options) {
         return this.inner.renameTable(currentName, newName, options?.namespacePath ?? [], options?.newNamespacePath);
     }
-    job(jobId) {
-        return this.inner.job(jobId);
+    async openJob(jobId) {
+        return new job_1.Job(await this.inner.openJob(jobId));
     }
     async listJobs() {
         return this.inner.listJobs();
     }
-    async getJob(jobId) {
-        return this.inner.getJob(jobId);
-    }
     async cancelJob(jobId) {
         return this.inner.cancelJob(jobId);
     }
-    async jobHistory(jobId) {
-        const buf = await this.inner.jobHistory(jobId);
-        if (buf.length === 0) {
-            return new arrow_2.Table();
-        }
-        return (0, apache_arrow_1.tableFromIPC)(buf);
-    }
 }
 exports.LocalConnection = LocalConnection;
 /**