Merge branch 'main' into refactor/wal-naming

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-13 15:22:30 +00:00 · 2026-10-12 15:30:00 -05:00
parent ab74aa620c 25fcfc696a
commit d5544cd5d9
636 changed files with 118151 additions and 22369 deletions
@@ -350,7 +350,7 @@ input to this method would be:

 #### Parameters

-* **columns**: `string` \| `string`[] \| `Record`&lt;`string`, `string`&gt; \| `Map`&lt;`string`, `string`&gt;
+* **columns**: `string` \| `string`[] \| `Map`&lt;`string`, `string`&gt; \| `Record`&lt;`string`, `string`&gt;

 #### Returns

@@ -417,6 +417,8 @@ Collect the results as an Arrow

 ArrowTable.

+Empty results retain the query's output schema.
+
 #### Inherited from

 `StandardQueryBase.toArrow`
@@ -0,0 +1,158 @@
+[**@lancedb/lancedb**](../README.md) • **Docs**
+
+***
+
+[@lancedb/lancedb](../globals.md) / BlobFile
+
+# Class: BlobFile
+
+A lazy handle to blob bytes. Create one with [Table.fetchBlobFiles](Table.md#fetchblobfiles).
+
+## Methods
+
+### close()
+
+```ts
+close(): Promise<void>
+```
+
+Releases the handle. Reads after `close()` fail. Calling it again does
+nothing.
+
+#### Returns
+
+`Promise`&lt;`void`&gt;
+
+***
+
+### isClosed()
+
+```ts
+isClosed(): boolean
+```
+
+Returns true after [BlobFile.close](BlobFile.md#close).
+
+#### Returns
+
+`boolean`
+
+***
+
+### read()
+
+```ts
+read(maxBytes?, options?): Promise<Buffer>
+```
+
+Reads from the cursor and advances the cursor.
+
+Reads to the end when `maxBytes` is omitted, or at most `maxBytes` bytes
+otherwise. Returns an empty buffer at the end of the blob.
+[BlobFile.readRange](BlobFile.md#readrange) does not move the cursor.
+
+#### Parameters
+
+* **maxBytes?**: `bigint`
+
+* **options?**: [`BlobReadOptions`](../type-aliases/BlobReadOptions.md)
+
+#### Returns
+
+`Promise`&lt;`Buffer`&gt;
+
+***
+
+### readRange()
+
+```ts
+readRange(
+   start,
+   end,
+   options?): Promise<Buffer>
+```
+
+Reads the half-open byte range `[start, end)`.
+
+Fails when `end` is past the blob size. Does not move the cursor.
+
+#### Parameters
+
+* **start**: `bigint`
+
+* **end**: `bigint`
+
+* **options?**: [`BlobReadOptions`](../type-aliases/BlobReadOptions.md)
+
+#### Returns
+
+`Promise`&lt;`Buffer`&gt;
+
+***
+
+### readRanges()
+
+```ts
+readRanges(ranges, options?): Promise<Buffer[]>
+```
+
+Reads several half-open byte ranges. Returns one buffer per range, in
+the order given.
+
+Fails when any `end` is past the blob size. Does not move the cursor.
+
+#### Parameters
+
+* **ranges**: [`BlobRange`](../type-aliases/BlobRange.md)[]
+
+* **options?**: [`BlobReadOptions`](../type-aliases/BlobReadOptions.md)
+
+#### Returns
+
+`Promise`&lt;`Buffer`[]&gt;
+
+***
+
+### seek()
+
+```ts
+seek(position): Promise<void>
+```
+
+Moves the cursor to `position`, in bytes from the start of the blob.
+
+#### Parameters
+
+* **position**: `bigint`
+
+#### Returns
+
+`Promise`&lt;`void`&gt;
+
+***
+
+### size()
+
+```ts
+size(): bigint
+```
+
+Returns the blob size in bytes.
+
+#### Returns
+
+`bigint`
+
+***
+
+### tell()
+
+```ts
+tell(): Promise<bigint>
+```
+
+Returns the cursor position in bytes.
+
+#### Returns
+
+`Promise`&lt;`bigint`&gt;
@@ -0,0 +1,118 @@
+[**@lancedb/lancedb**](../README.md) • **Docs**
+
+***
+
+[@lancedb/lancedb](../globals.md) / Catalog
+
+# Class: Catalog
+
+A remote catalog manages databases through the server's root namespace.
+
+## Accessors
+
+### uri
+
+```ts
+get uri(): string
+```
+
+The root namespace endpoint.
+
+#### Returns
+
+`string`
+
+## Methods
+
+### connectDatabase()
+
+```ts
+connectDatabase(name): Promise<Connection>
+```
+
+Connect to an existing database by its logical name.
+
+#### Parameters
+
+* **name**: `string`
+
+#### Returns
+
+`Promise`&lt;[`Connection`](Connection.md)&gt;
+
+***
+
+### createDatabase()
+
+```ts
+createDatabase(name, options): Promise<Connection>
+```
+
+Create a database, or open an existing database when existOk is true.
+
+#### Parameters
+
+* **name**: `string`
+
+* **options** = `{}`
+
+* **options.existOk?**: `boolean`
+
+#### Returns
+
+`Promise`&lt;[`Connection`](Connection.md)&gt;
+
+***
+
+### dropDatabase()
+
+```ts
+dropDatabase(name, options): Promise<void>
+```
+
+Drop an empty database. The server rejects nonempty databases.
+
+#### Parameters
+
+* **name**: `string`
+
+* **options** = `{}`
+
+* **options.ignoreMissing?**: `boolean`
+
+#### Returns
+
+`Promise`&lt;`void`&gt;
+
+***
+
+### listDatabases()
+
+```ts
+listDatabases(options): DatabaseNames
+```
+
+Iterate lazily over all database names using `for await...of`.
+pageToken resumes from a saved token; omitted starts at the beginning.
+pageLimit limits each REST response, not the total; omitted uses the server default.
+Request errors are raised during iteration and terminate the iterator.
+
+#### Parameters
+
+* **options** = `{}`
+
+* **options.pageLimit?**: `number`
+
+* **options.pageToken?**: `string`
+
+#### Returns
+
+[`DatabaseNames`](DatabaseNames.md)
+
+#### Example
+
+```ts
+for await (const name of catalog.listDatabases({ pageLimit: 20 })) {
+  console.log(name);
+}
+```
@@ -180,13 +180,9 @@ abstract createMaterializedView(

 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.
+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`.

 #### Parameters

@@ -202,6 +198,8 @@ a table exists. Local databases only.

 * **options.where?**: `string`

+* **options.withNoData?**: `boolean`
+
 #### Returns

 `Promise`&lt;[`MaterializedView`](MaterializedView.md)&gt;
@@ -317,6 +315,38 @@ Creates a new Table and initialize it with new data.

 ***

+### createView()
+
+```ts
+abstract createView(
+   name,
+   query,
+   namespacePath?): Promise<ViewDescription>
+```
+
+Create a view: a named query the database plans on every read.
+
+The query is planned once, at creation, so one that cannot be planned is
+rejected now rather than at the first read. A view holds no rows, and its
+readers see its sources as they are at read time.
+
+There is no replace: a name already taken is an error, and changing a
+view is a drop followed by a create.
+
+#### Parameters
+
+* **name**: `string`
+
+* **query**: `string`
+
+* **namespacePath?**: `string`[]
+
+#### Returns
+
+`Promise`&lt;[`ViewDescription`](../interfaces/ViewDescription.md)&gt;
+
+***
+
 ### describeNamespace()

 ```ts
@@ -340,6 +370,27 @@ The namespace's properties

 ***

+### describeView()
+
+```ts
+abstract describeView(name, namespacePath?): Promise<ViewDescription>
+```
+
+What this database records about the view named `name`: its defining
+query and the schema that query resolved to.
+
+#### Parameters
+
+* **name**: `string`
+
+* **namespacePath?**: `string`[]
+
+#### Returns
+
+`Promise`&lt;[`ViewDescription`](../interfaces/ViewDescription.md)&gt;
+
+***
+
 ### display()

 ```ts
@@ -373,6 +424,54 @@ Drop all tables in the database.

 ***

+### dropMaterializedView()
+
+```ts
+abstract dropMaterializedView(name, namespacePath?): Promise<void>
+```
+
+Drop the materialized view named `name`.
+
+The view may become unavailable before physical cleanup finishes. Use
+[dropMaterializedViewAsync](Connection.md#dropmaterializedviewasync) to retain and wait for the cleanup job.
+
+Rejects a table that exists but is not a materialized view.
+
+#### Parameters
+
+* **name**: `string`
+
+* **namespacePath?**: `string`[]
+
+#### Returns
+
+`Promise`&lt;`void`&gt;
+
+***
+
+### dropMaterializedViewAsync()
+
+```ts
+abstract dropMaterializedViewAsync(name, namespacePath?): Promise<Job>
+```
+
+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.
+
+#### Parameters
+
+* **name**: `string`
+
+* **namespacePath?**: `string`[]
+
+#### Returns
+
+`Promise`&lt;[`Job`](Job.md)&gt;
+
+***
+
 ### dropNamespace()

 ```ts
@@ -448,23 +547,50 @@ on the returned job to know when cleanup has finished.

 ***

-### getJob()
+### dropView()

 ```ts
-abstract getJob(jobId): Promise<null | JobDescription>
+abstract dropView(name, namespacePath?): Promise<void>
 ```

-Describe a single server-side job by id.
+Drop the view named `name` and wait for its definition to be deleted.

-Resolves to `null` when the server has no such job.
+The tables it reads are untouched: a view holds no rows of its own. Use
+[dropViewAsync](Connection.md#dropviewasync) to retain the cleanup job instead of waiting on it.

 #### Parameters

-* **jobId**: `string`
+* **name**: `string`
+
+* **namespacePath?**: `string`[]

 #### Returns

-`Promise`&lt;`null` \| [`JobDescription`](../interfaces/JobDescription.md)&gt;
+`Promise`&lt;`void`&gt;
+
+***
+
+### dropViewAsync()
+
+```ts
+abstract dropViewAsync(name, namespacePath?): Promise<Job>
+```
+
+Start dropping the view named `name` and return the job deleting its
+definition, without waiting for completion.
+
+The name is free before this resolves. When nothing was bound to it, the
+returned job is already finished and has no id.
+
+#### Parameters
+
+* **name**: `string`
+
+* **namespacePath?**: `string`[]
+
+#### Returns
+
+`Promise`&lt;[`Job`](Job.md)&gt;

 ***

@@ -482,75 +608,45 @@ Return true if the connection has not been closed

 ***

-### job()
-
-```ts
-abstract job(jobId): Job
-```
-
-A [Job](Job.md) handle for a server-side job by id.
-
-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.
-
-#### Parameters
-
-* **jobId**: `string`
-
-#### Returns
-
-[`Job`](Job.md)
-
-***
-
-### jobHistory()
-
-```ts
-abstract jobHistory(jobId?): Promise<Table<any>>
-```
-
-The lifecycle event history of a server-side job, as an Arrow table.
-
-Lists history across all jobs when `jobId` is omitted.
-
-#### Parameters
-
-* **jobId?**: `string`
-
-#### Returns
-
-`Promise`&lt;`Table`&lt;`any`&gt;&gt;
-
-***
-
 ### listJobs()

 ```ts
-abstract listJobs(): Promise<JobInfo[]>
+abstract listJobs(options?): Listing<JobInfo>
 ```

-List server-side jobs across the database's tables.
+Iterate lazily over server-side jobs across the database's tables.
+Use `for await...of`. Options control page size and the starting token.
+See [Listing](Listing.md) for pagination state and error behavior.
+
+#### Parameters
+
+* **options?**: [`ListingOptions`](../interfaces/ListingOptions.md)

 #### Returns

-`Promise`&lt;[`JobInfo`](../interfaces/JobInfo.md)[]&gt;
+[`Listing`](Listing.md)&lt;[`JobInfo`](../interfaces/JobInfo.md)&gt;

 ***

 ### listMaterializedViews()

 ```ts
-abstract listMaterializedViews(): Promise<string[]>
+abstract listMaterializedViews(options?): Listing<string>
 ```

 The names of the materialized views in this database.

-Found by reading every table's schema, so this costs an open per table.
+Iterate lazily with `for await...of`. Local listings inspect table schemas
+one page at a time. Options control page size and the starting token.
+See [Listing](Listing.md) for pagination state and error behavior.
+
+#### Parameters
+
+* **options?**: [`ListingOptions`](../interfaces/ListingOptions.md)

 #### Returns

-`Promise`&lt;`string`[]&gt;
+[`Listing`](Listing.md)&lt;`string`&gt;

 ***

@@ -648,6 +744,54 @@ A page of table names and an

 ***

+### listViews()
+
+```ts
+abstract listViews(namespacePath?, options?): Listing<string>
+```
+
+The names of the views in one namespace.
+
+Names only; a definition comes from [describeView](Connection.md#describeview).
+Iterate lazily with `for await...of`. See [Listing](Listing.md) for pagination
+state and error behavior; options control page size and the starting token.
+
+#### Parameters
+
+* **namespacePath?**: `string`[]
+
+* **options?**: [`ListingOptions`](../interfaces/ListingOptions.md)
+
+#### Returns
+
+[`Listing`](Listing.md)&lt;`string`&gt;
+
+***
+
+### openJob()
+
+```ts
+abstract openJob(jobId): Promise<Job>
+```
+
+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
+[Connection.openTable](Connection.md#opentable) does for a missing table.
+
+The returned [Job](Job.md) answers for its own state, specification,
+result, failure and event history, so there is no separate
+connection-level call for any of them.
+
+#### Parameters
+
+* **jobId**: `string`
+
+#### Returns
+
+`Promise`&lt;[`Job`](Job.md)&gt;
+
+***
+
 ### openMaterializedView()

 ```ts
@@ -691,6 +835,28 @@ abstract openTable(

 ***

+### pauseJob()
+
+```ts
+abstract pauseJob(jobId): Promise<string>
+```
+
+Pause a server-side job by id.
+
+The job's workers drain and it stays parked until resumed. Resolves to
+"pausing", "already_paused", or "committing" -- a job finalizing its
+results cannot be parked; retry shortly.
+
+#### Parameters
+
+* **jobId**: `string`
+
+#### Returns
+
+`Promise`&lt;`string`&gt;
+
+***
+
 ### renameTable()

 ```ts
@@ -724,6 +890,28 @@ a "not supported" error.

 ***

+### resumeJob()
+
+```ts
+abstract resumeJob(jobId): Promise<string>
+```
+
+Resume a paused server-side job by id.
+
+Its workers pick their work back up from checkpoints. Resolves to
+"resumed", "still_pausing" -- the pause's worker drain is not confirmed
+yet; retry shortly -- or "not_paused".
+
+#### Parameters
+
+* **jobId**: `string`
+
+#### Returns
+
+`Promise`&lt;`string`&gt;
+
+***
+
 ### ~~tableNames()~~

 #### tableNames(options)
@@ -0,0 +1,79 @@
+[**@lancedb/lancedb**](../README.md) • **Docs**
+
+***
+
+[@lancedb/lancedb](../globals.md) / DatabaseNames
+
+# Class: DatabaseNames
+
+A lazy async iterator of database names with pagination state.
+Returned by [Catalog.listDatabases](Catalog.md#listdatabases).
+
+## Implements
+
+- `AsyncIterableIterator`&lt;`string`&gt;
+
+## Methods
+
+### \[asyncIterator\]()
+
+```ts
+asyncIterator: AsyncIterableIterator<string>
+```
+
+#### Returns
+
+`AsyncIterableIterator`&lt;`string`&gt;
+
+#### Implementation of
+
+`AsyncIterableIterator.[asyncIterator]`
+
+***
+
+### next()
+
+```ts
+next(): Promise<IteratorResult<string, any>>
+```
+
+Fetch the next name, requesting another page only when needed.
+
+#### Returns
+
+`Promise`&lt;`IteratorResult`&lt;`string`, `any`&gt;&gt;
+
+#### Implementation of
+
+`AsyncIterableIterator.next`
+
+***
+
+### numPageResults()
+
+```ts
+numPageResults(): number
+```
+
+Number of names available without another REST request.
+
+#### Returns
+
+`number`
+
+***
+
+### pageToken()
+
+```ts
+pageToken(): undefined | string
+```
+
+Token for the next REST request. Initially this is the supplied starting token.
+Returns undefined after the final page is fetched, even if names remain cached.
+Drain the cache before saving a token to avoid skipping names when resuming.
+A failed request terminates iteration and retains its token for a new iterator.
+
+#### Returns
+
+`undefined` \| `string`
@@ -8,19 +8,46 @@

 A handle to an operation that may still be running.

-## Constructors
+The operation may already be complete when the handle is created.

-### new Job()
+The detail getters read what the handle last observed. Submitting an
+operation returns only a job id, so populating them eagerly would cost an
+extra round trip on every call:
+
+- [Job.refresh](Job.md#refresh) and [Job.status](Job.md#status) fetch the whole record.
+- [Job.wait](Job.md#wait) records the terminal state it establishes, but not the
+  rest of the record.
+- Everything is null until one of those runs.
+
+## Accessors
+
+### creationMs

 ```ts
-new Job(): Job
+get creationMs(): null | number
 ```

+When the job was created, in milliseconds since the epoch.
+
 #### Returns

-[`Job`](Job.md)
+`null` \| `number`

-## Accessors
+***
+
+### failure
+
+```ts
+get failure(): null | JobFailureInfo
+```
+
+Why the job failed, when it failed and the server reports a reason.
+
+#### Returns
+
+`null` \| [`JobFailureInfo`](../interfaces/JobFailureInfo.md)
+
+***

 ### id

@@ -28,8 +55,69 @@ new Job(): Job
 get id(): null | string
 ```

-Identifies the operation on the server that is running it. Operations
-that run in this process have no server id. The value is opaque.
+Identifies the operation on the server that is running it.
+
+Operations that run in this process have no server id. The value is
+opaque: parsing it or storing it to resume the job later is not supported.
+
+#### Returns
+
+`null` \| `string`
+
+***
+
+### jobType
+
+```ts
+get jobType(): null | string
+```
+
+The job's type, as the server names it. Null for an in-process job, which
+has no server-side record.
+
+#### Returns
+
+`null` \| `string`
+
+***
+
+### result
+
+```ts
+get result(): any
+```
+
+The job-type-specific terminal result. Null until the job succeeds, so a
+job that never terminates reports its progress through [Job.events](Job.md#events)
+instead.
+
+#### Returns
+
+`any`
+
+***
+
+### spec
+
+```ts
+get spec(): any
+```
+
+The job-type-specific specification it was submitted with.
+
+#### Returns
+
+`any`
+
+***
+
+### state
+
+```ts
+get state(): null | string
+```
+
+The last observed lifecycle state, without contacting the backend.

 #### Returns

@@ -51,18 +139,61 @@ Request cancellation. Cancelling a finished operation is a no-op.

 ***

+### events()
+
+```ts
+events(options?): Promise<Table<any>>
+```
+
+This job's recorded lifecycle events.
+
+Where the getters above report a terminal result only once the job reaches
+one, events are written as the job runs and outlive the workers that
+produced them. A distributed job records a `claim`/`claim_complete` pair
+per unit of work, each carrying `rows_processed`, so a job that never
+finishes still accounts for what it did.
+
+The server caps results at 1000 rows by default and 10,000 at most, and
+truncates without saying so, so pass `limit` for a job that emits an event
+per fragment. `filter` is a SQL-like expression over the `state`,
+`updated_by`, `emitted_from`, `emitted_by`, and `claim_entity` columns.
+
+#### Parameters
+
+* **options?**: [`JobEventsOptions`](../interfaces/JobEventsOptions.md)
+
+#### Returns
+
+`Promise`&lt;`Table`&lt;`any`&gt;&gt;
+
+***
+
+### refresh()
+
+```ts
+refresh(): Promise<void>
+```
+
+Ask the backend for this job's current state, and for a server-side job
+its full record, then cache it for the getters above.
+
+#### Returns
+
+`Promise`&lt;`void`&gt;
+
+***
+
 ### status()

 ```ts
 status(): Promise<string>
 ```

-The operation's current lifecycle state: "running", "finished",
-"failed", or "cancelled".
+The operation's current lifecycle state: "running", "finished", "failed",
+or "cancelled".

-A point snapshot; unlike [Job.wait](Job.md#wait) it does not block or reject
-on a terminal failure state. States a newer server reports that this
-client version does not know pass through as-is.
+A point snapshot; unlike [Job.wait](Job.md#wait) it does not block or reject on a
+terminal failure state. Also refreshes the getters above.

 #### Returns

@@ -70,6 +201,22 @@ client version does not know pass through as-is.

 ***

+### toString()
+
+```ts
+toString(): string
+```
+
+Every field the handle currently knows, one per line, with the JSON
+payloads indented -- a refresh job's spec and result are the point of
+printing it.
+
+#### Returns
+
+`string`
+
+***
+
 ### wait()

 ```ts
@@ -0,0 +1,91 @@
+[**@lancedb/lancedb**](../README.md) • **Docs**
+
+***
+
+[@lancedb/lancedb](../globals.md) / Listing
+
+# Class: Listing&lt;T&gt;
+
+A lazy async iterator over database resources with pagination state.
+Requests occur during iteration; request errors terminate the iterator.
+
+## Example
+
+```ts
+for await (const name of connection.listViews([], { pageLimit: 20 })) {
+  console.log(name);
+}
+```
+
+## Type Parameters
+
+• **T**
+
+## Implements
+
+- `AsyncIterableIterator`&lt;`T`&gt;
+
+## Methods
+
+### \[asyncIterator\]()
+
+```ts
+asyncIterator: AsyncIterableIterator<T>
+```
+
+#### Returns
+
+`AsyncIterableIterator`&lt;`T`&gt;
+
+#### Implementation of
+
+`AsyncIterableIterator.[asyncIterator]`
+
+***
+
+### next()
+
+```ts
+next(): Promise<IteratorResult<T, any>>
+```
+
+Fetch the next item, requesting another page only when needed.
+
+#### Returns
+
+`Promise`&lt;`IteratorResult`&lt;`T`, `any`&gt;&gt;
+
+#### Implementation of
+
+`AsyncIterableIterator.next`
+
+***
+
+### numPageResults()
+
+```ts
+numPageResults(): number
+```
+
+Number of cached items available without another request.
+
+#### Returns
+
+`number`
+
+***
+
+### pageToken()
+
+```ts
+pageToken(): undefined | string
+```
+
+Token for the next request. Initially this is the supplied starting token.
+Returns undefined after fetching the final page, even with cached items.
+Drain the cache before saving a token to avoid skipping items on resumption.
+Failed requests terminate iteration and retain their token for a new iterator.
+
+#### Returns
+
+`undefined` \| `string`
@@ -49,7 +49,7 @@ get name(): string
 definition(): Promise<MaterializedViewDefinition>
 ```

-The query that defines the view, read from its stored schema.
+The query that defines the view.

 #### Returns

@@ -65,21 +65,14 @@ refresh(options?): Promise<RefreshMaterializedViewResult>

 Recompute the view from its source.

-The refresh is incremental when the source's changes can be reconciled
-into the view -- rows added, changed or removed since the last one --
-and otherwise rebuilds. `full` forces a rebuild; `sourceVersion`
-refreshes to that source version instead of the latest.
-
-Concurrent refreshes of one view do not duplicate its rows. Two that
-plan the same source rows conflict on commit, and the loser throws
-rather than writing them a second time.
+Every refresh rebuilds the complete view. For local views,
+`sourceVersion` refreshes to that source version instead of the latest;
+remote SQL refreshes do not support source-version pinning.

 #### Parameters

 * **options?**

-* **options.full?**: `boolean`
-
 * **options.sourceVersion?**: `number`

 #### Returns
@@ -141,7 +141,7 @@ Currently this causes multiple copies of the row to be created
 but that behavior is subject to change.

 An optional condition may be specified.  If it is, then only
-matched rows that satisfy the condtion will be updated.  Any
+matched rows that satisfy the condition will be updated.  Any
 rows that do not satisfy the condition will be left as they
 are.  Failing to satisfy the condition does not cause a
 "matched row" to become a "not matched" row.
@@ -0,0 +1,105 @@
+[**@lancedb/lancedb**](../README.md) • **Docs**
+
+***
+
+[@lancedb/lancedb](../globals.md) / OAuthSession
+
+# Class: OAuthSession
+
+Explicit OAuth session lifecycle for the persistent token cache: eager
+`login`, non-secret `status`, and local `logout`.
+
+A session is built from the same [OAuthConfig](../interfaces/OAuthConfig.md) used to connect
+(including its `tokenCache` options). A connection created with the same
+configuration shares the cache, so logging in here prepares tokens for
+later processes without any database request.
+
+`login` always runs the configured interactive flow and replaces the cached
+session (the most recent login wins). `logout` removes only the local
+credential; it does not revoke anything with the provider and does not sign
+out of a browser SSO session.
+
+## Example
+
+```typescript
+const config: OAuthConfig = {
+  issuerUrl: "https://issuer.example.com",
+  clientId: "my-app",
+  scopes: ["openid", "offline_access"],
+  flow: OAuthFlowType.DeviceCode,
+  tokenCache: { cacheDir: "/tmp/my-app/oauth-cache" },
+};
+const session = new OAuthSession(config);
+const status = await session.login();
+```
+
+## Constructors
+
+### new OAuthSession()
+
+```ts
+new OAuthSession(config): OAuthSession
+```
+
+Create a session manager for the given OAuth configuration.
+
+#### Parameters
+
+* **config**: [`OAuthConfig`](../interfaces/OAuthConfig.md)
+
+#### Returns
+
+[`OAuthSession`](OAuthSession.md)
+
+## Methods
+
+### login()
+
+```ts
+login(): Promise<SessionStatus>
+```
+
+Eagerly run the configured authentication flow and store the session.
+
+A successful login always replaces any prior cached session for this
+identity; if the provider does not issue a refresh token (for example
+without `offline_access`), the previous record is removed and the status
+reports `refreshable == false`.
+
+#### Returns
+
+`Promise`&lt;[`SessionStatus`](../interfaces/SessionStatus.md)&gt;
+
+***
+
+### logout()
+
+```ts
+logout(): Promise<SessionLogout>
+```
+
+Remove the matching local cached credential.
+
+This only deletes the local cache entry. It does not revoke the refresh
+token with the provider and does not sign out of a browser SSO session.
+Repeated calls succeed; `removed` reports whether a credential existed.
+
+#### Returns
+
+`Promise`&lt;[`SessionLogout`](../interfaces/SessionLogout.md)&gt;
+
+***
+
+### status()
+
+```ts
+status(): Promise<SessionStatus>
+```
+
+Report whether a matching cached session exists, with safe metadata.
+
+This never contacts the identity provider and never exposes token values.
+
+#### Returns
+
+`Promise`&lt;[`SessionStatus`](../interfaces/SessionStatus.md)&gt;
@@ -424,7 +424,7 @@ input to this method would be:

 #### Parameters

-* **columns**: `string` \| `string`[] \| `Record`&lt;`string`, `string`&gt; \| `Map`&lt;`string`, `string`&gt;
+* **columns**: `string` \| `string`[] \| `Map`&lt;`string`, `string`&gt; \| `Record`&lt;`string`, `string`&gt;

 #### Returns

@@ -491,6 +491,8 @@ Collect the results as an Arrow

 ArrowTable.

+Empty results retain the query's output schema.
+
 #### Inherited from

 `StandardQueryBase.toArrow`
@@ -193,7 +193,7 @@ input to this method would be:

 #### Parameters

-* **columns**: `string` \| `string`[] \| `Record`&lt;`string`, `string`&gt; \| `Map`&lt;`string`, `string`&gt;
+* **columns**: `string` \| `string`[] \| `Map`&lt;`string`, `string`&gt; \| `Record`&lt;`string`, `string`&gt;

 #### Returns

@@ -252,6 +252,8 @@ Collect the results as an Arrow

 ArrowTable.

+Empty results retain the query's output schema.
+
 ***

 ### withRowId()
@@ -74,10 +74,10 @@ now: the column is committed with no values, and rows get them from
 [Table#refreshColumn](Table.md#refreshcolumn). Declaring one therefore costs the same on a
 large table as on an empty one.

-A refresh does not revisit rows it has already filled, so mutating an
-input leaves the value computed at fill time; recomputing means dropping
-the column and declaring it again. While a declaration reads a column,
-that column cannot be renamed, retyped or dropped.
+A refresh also recomputes the rows whose inputs changed since they were
+computed, so a mutated input is reflected by the next refresh. While a
+declaration reads a column, that column cannot be renamed, retyped or
+dropped.

 On LanceDB Cloud and Enterprise the expression is planned by the
 server, and the refresh runs as a server job -- see
@@ -137,6 +137,20 @@ containing the new version number of the table after altering the columns.

 ***

+### blobColumns()
+
+```ts
+abstract blobColumns(): Promise<string[]>
+```
+
+Blob v2 columns, including nested dotted paths.
+
+#### Returns
+
+`Promise`&lt;`string`[]&gt;
+
+***
+
 ### branches()

 ```ts
@@ -499,6 +513,68 @@ Drop an index from the table.

 ***

+### fetchBlobFiles()
+
+```ts
+abstract fetchBlobFiles(
+   column,
+   rowIds,
+   options?): Promise<(null | BlobFile)[]>
+```
+
+Opens lazy blob handles for `column` at the given row IDs using the
+table's current checkout.
+
+Preserves input order, duplicates, and nulls. Use this for large payloads.
+See [Table.fetchBlobs](Table.md#fetchblobs) for row-ID validity across versions.
+
+#### Parameters
+
+* **column**: `string`
+
+* **rowIds**: readonly (`number` \| `bigint`)[]
+
+* **options?**: [`BlobReadOptions`](../type-aliases/BlobReadOptions.md)
+
+#### Returns
+
+`Promise`&lt;(`null` \| [`BlobFile`](BlobFile.md))[]&gt;
+
+***
+
+### fetchBlobs()
+
+```ts
+abstract fetchBlobs(
+   column,
+   rowIds,
+   options?): Promise<(null | Buffer)[]>
+```
+
+Bytes for `column` at row IDs from [Query.withRowId](Query.md#withrowid).
+
+Reads the table's current checkout. IDs from another version can fail after
+compaction unless stable row ids are enabled. Results keep input order and
+duplicates. Null blobs are `null`. Empty blobs are empty buffers.
+Remote servers limit each request to 1024 row IDs and 64 MiB of blob bytes.
+The client splits requests automatically and reads an individual larger
+blob through the Range route. This method still materializes all bytes in
+memory; use [Table.fetchBlobFiles](Table.md#fetchblobfiles) for large values.
+
+#### Parameters
+
+* **column**: `string`
+
+* **rowIds**: readonly (`number` \| `bigint`)[]
+
+* **options?**: [`BlobReadOptions`](../type-aliases/BlobReadOptions.md)
+
+#### Returns
+
+`Promise`&lt;(`null` \| `Buffer`)[]&gt;
+
+***
+
 ### flushLsm()

 ```ts
@@ -516,6 +592,41 @@ so this is safe to call repeatedly.

 ***

+### functionErrors()
+
+```ts
+abstract functionErrors(options?): Promise<FunctionErrors>
+```
+
+The per-row errors Function refreshes recorded on this table.
+
+A refresh running under a skip policy records each row it skipped with
+the input that failed and the error. This lists those records, newest
+job first, plus a summary for any fragment whose per-row detail was
+capped. LanceDB Cloud and Enterprise only; reading errors needs read
+access to the table, since a message carries the value that failed.
+
+#### Parameters
+
+* **options?**: [`FunctionErrorsOptions`](../interfaces/FunctionErrorsOptions.md)
+    Optional filters: `jobId`,
+    `column`, and `limit` (server default 10000, cap 100000).
+
+#### Returns
+
+`Promise`&lt;[`FunctionErrors`](../interfaces/FunctionErrors.md)&gt;
+
+The records, the capped fragments,
+and whether the listing stopped at its limit.
+
+#### Example
+
+```ts
+const { records, truncated } = await table.functionErrors({ column: "embedding" });
+```
+
+***
+
 ### getLsmStats()

 ```ts
@@ -551,10 +662,9 @@ Read the [LsmWriteSpec](../interfaces/LsmWriteSpec.md) currently installed on th

 Resolves to `undefined` when the MemWAL LSM write path is not enabled (no
 spec has been set, or it was removed with [Table#unsetLsmWriteSpec](Table.md#unsetlsmwritespec)).
-The returned spec mirrors what was passed to
-[Table#setLsmWriteSpec](Table.md#setlsmwritespec), except that `maintainedIndexes` always
-reports the concrete list resolved when the spec was set — `undefined`
-never round-trips.
+The spec is the one installed, including its maintained-index selection:
+an absent `maintainedIndexes` for every index the table has, an empty
+array for none.

 #### Returns

@@ -676,9 +786,17 @@ List all the versions of the table
 abstract mergeInsert(on): MergeInsertBuilder
 ```

+Create a [MergeInsertBuilder](MergeInsertBuilder.md), which combines new data with the
+existing table in a single transaction — inserting, updating and deleting
+rows depending on how they match.
+
 #### Parameters

 * **on**: `string` \| `string`[]
+    The column, or columns, to match source rows against target
+    rows on. Typically a key or id column. Several columns match on the
+    composite key: a source row updates a target row only when it agrees on
+    every one of them.

 #### Returns

@@ -846,10 +964,10 @@ abstract refreshColumn(column): Promise<RefreshColumnResult>

 Fill the rows of a computed column that hold no value yet.

-Rows appended since the last refresh are filled by the next one; rows
-already filled are left as they are, so the call is idempotent and does
-not observe a mutated input. Local tables only: a remote refresh runs
-as a server job, through [Table#refreshColumnAsync](Table.md#refreshcolumnasync).
+Rows appended since the last refresh are filled by the next one, and
+rows whose inputs changed since they were computed are recomputed;
+everything else is left as it is. Local tables only: a remote refresh
+runs as a server job, through [Table#refreshColumnAsync](Table.md#refreshcolumnasync).

 #### Parameters

@@ -988,8 +1106,8 @@ All variants require the table to have an unenforced primary key
 ([Table#setUnenforcedPrimaryKey](Table.md#setunenforcedprimarykey)); bucket sharding additionally
 requires it to be the single column being bucketed.

-Omitting `maintainedIndexes` maintains every index on the table, resolved
-here, failing if one cannot be maintained — name them to install anyway.
+Omitting `maintainedIndexes` maintains every index the table has,
+including ones created later, and skips a kind the MemWAL cannot maintain.
 Naming them pins an exact set, and a still-building index is rejected
 rather than quietly omitted.

@@ -1258,11 +1376,11 @@ value is 0")
 Note: if your condition is something like "some_id_column == 7" and
 you are updating many rows (with different ids) then you will get
 better performance with a single [`merge_insert`] call instead of
-repeatedly calilng this method.
+repeatedly calling this method.

 ##### Parameters

-* **updates**: `Record`&lt;`string`, `string`&gt; \| `Map`&lt;`string`, `string`&gt;
+* **updates**: `Map`&lt;`string`, `string`&gt; \| `Record`&lt;`string`, `string`&gt;
    the
    columns to update

@@ -200,7 +200,7 @@ input to this method would be:

 #### Parameters

-* **columns**: `string` \| `string`[] \| `Record`&lt;`string`, `string`&gt; \| `Map`&lt;`string`, `string`&gt;
+* **columns**: `string` \| `string`[] \| `Map`&lt;`string`, `string`&gt; \| `Record`&lt;`string`, `string`&gt;

 #### Returns

@@ -267,6 +267,8 @@ Collect the results as an Arrow

 ArrowTable.

+Empty results retain the query's output schema.
+
 #### Inherited from

 [`QueryBase`](QueryBase.md).[`toArrow`](QueryBase.md#toarrow)
@@ -447,6 +447,8 @@ nprobes(nprobes): VectorQuery

 Set the number of partitions to search (probe)

+The number of probes must be greater than 0.
+
 This argument is only used when the vector column has an IVF PQ index.
 If there is no index then this value is ignored.

@@ -458,17 +460,16 @@ exhaustiely searched to find matches.  This parameter controls how many
 partitions should be searched.

 Increasing this value will increase the recall of your query but will
-also increase the latency of your query.  The default value is 20.  This
-default is good for many cases but the best value to use will depend on
-your data and the recall that you need to achieve.
+also increase the latency of your query. If this method is not called,
+Lance's adaptive probe defaults are used.

 For best results we recommend tuning this parameter with a benchmark against
 your actual data to find the smallest possible value that will still give
 you the desired recall.

-For more fine grained control over behavior when you have a very narrow filter
-you can use `minimumNprobes` and `maximumNprobes`.  This method sets both
-the minimum and maximum to the same value.
+The value is retained as `nprobes` through client and server request
+construction. Lance sets both probe bounds to this value. Explicit minimum
+or maximum settings can override their respective bounds.

 #### Parameters

@@ -645,6 +646,38 @@ rerank(reranker): VectorQuery

 ***

+### searchEffort()
+
+```ts
+searchEffort(searchEffort): VectorQuery
+```
+
+Set the initial IVF search effort to a finite value in [0, 1].
+
+The default, null, uses Auto (internally 0.5). Zero starts at the caller
+minimum; one searches all partitions within the caller maximum. Later
+probing may continue when too few candidates are found.
+Any explicit effort, including 0.5, overrides nprobes in either call order.
+Explicit minimum and maximum bounds still apply. This is not a recall
+guarantee and does not change refinement or HNSW ef. The MemWAL LSM
+scanner does not yet support this option.
+
+#### Parameters
+
+* **searchEffort**: `null` \| `number`
+
+#### Returns
+
+[`VectorQuery`](VectorQuery.md)
+
+#### Example
+
+```ts
+table.vectorSearch([0.1, 0.2]).searchEffort(0.75).limit(10);
+```
+
+***
+
 ### select()

 ```ts
@@ -673,7 +706,7 @@ input to this method would be:

 #### Parameters

-* **columns**: `string` \| `string`[] \| `Record`&lt;`string`, `string`&gt; \| `Map`&lt;`string`, `string`&gt;
+* **columns**: `string` \| `string`[] \| `Map`&lt;`string`, `string`&gt; \| `Record`&lt;`string`, `string`&gt;

 #### Returns

@@ -740,6 +773,8 @@ Collect the results as an Arrow

 ArrowTable.

+Empty results retain the query's output schema.
+
 #### Inherited from

 `StandardQueryBase.toArrow`