LanceDB.Query (LanceDB v0.2.0)

Pure, reusable queries. Construction validates options without accessing storage.

all/1, stream/2, stream_batches/2, explain/2, analyze/1 and schema/1 execute the same query. Scan limits default to 100; use limit(query, nil) for an unlimited scan. Searches default to 10 results. Re-execution of a live table may observe new data; use a table snapshot for repeatable reads.

Both constructors take the table first: new(table, opts) builds a scan; new(table, source, opts) selects an explicit source. Immediate helpers such as search/3 and query/2 execute these same query values. Result maps have string keys; operational failures return LanceDB.Error, and stream failures raise it during enumeration.

Summary

Types

t()

Functions

all(query)

Collects the complete query result in memory.

analyze(query)

Executes once and returns execution diagnostics.

batch_search(table, vectors, opts \\ [])

Runs independent vector queries immediately.

explain(query, opts \\ [])

Explains this query without executing it.

full_text_search(table, text, opts \\ [])

Runs a full-text query immediately.

hybrid(query, vector, text)

Selects hybrid search. Rerankers are supplied through options/2.

hybrid_search(table, vector, text, opts \\ [])

Runs a hybrid query immediately.

limit(query, limit)

Sets the maximum result count; nil allows unlimited scans.

multivector(query, vectors)

Selects document multivector search.

multivector_search(table, vectors, opts \\ [])

Runs document multivector search immediately.

nearest_to(query, vector)

Selects vector search, retaining filters, projections and explicit limits.

nearest_to_many(query, vectors)

Selects independent searches for a batch of query vectors.

new(table, opts \\ [])

Constructs a scan. No database work occurs until execution.

new(table, source, opts)

Constructs a query from a table, explicit source, and keyword controls.

offset(query, offset)

Sets the result offset.

options(query, opts)

Merges options, validating them against the selected query kind.

order_by(query, ordering)

Sets explicit ordering, including per-column null placement.

query(table, opts \\ [])

Collects a scan immediately. Use new/2 for a reusable query.

row_ids(query, ids)

Selects direct row-ID retrieval.

row_offsets(query, offsets)

Selects direct physical-offset retrieval.

schema(query)

Returns an ArrowSchema describing the physical output. Convert explicitly with ArrowSchema.to_schema/1 before table creation.

search(table, vector, opts \\ [])

Runs a vector query immediately, returning up to 10 rows by default. Without :vector_column, selects the unique column compatible with the search mode and query dimension. Ambiguous matches require an explicit column; dimension mismatches return an error naming the query and expected dimensions. See the search controls for projection, filtering, distances, index tuning, and deadlines.

select(query, columns)

Sets projected column names.

select_as(query, expressions)

Sets SQL string or Expr projections.

stream(query, opts \\ [])

Builds a lazy row stream; each enumeration executes the query again. The only stream option is :batch_size (default 1024); query controls belong to the query value. Batches bound returned rows, not query memory. Ending or halting enumeration closes the cursor and releases its read admission slot.

stream_batches(query, opts \\ [])

Builds a lazy stream of native Arrow batches. Use Source.batches for schema-compatible ingestion.

take_offsets(table, offsets, opts \\ [])

Retrieves rows by non-negative uint64 physical offsets, with the same options and result-set semantics as take_row_ids/3. Updates, deletions, and compaction can change offsets; use the same table version for collection and retrieval.

take_row_ids(table, ids, opts \\ [])

Retrieves rows by internal ID. IDs are non-negative uint64 integers from _rowid, not application keys. Accepts :columns or :select, :with_row_id, and :timeout_ms; there is no default row limit. Missing IDs contribute no rows, duplicates do not repeat rows, and output order is unspecified. Collect and use IDs against the same table version.

text(query, text)

Selects full-text search with a string or structured FTS query.

timeout(query, milliseconds)

Sets a cooperative execution deadline: nil disables it, otherwise supply a positive uint32 millisecond count. For streams it covers the cursor lifetime, including consumer pauses; it does not interrupt the caller's Elixir code.

where(query, predicate)

Sets the SQL string or Expr predicate, replacing any previous predicate.