Struct TakeQuery 

pub struct TakeQuery { /* private fields */ }

A builder for LanceDB take queries.

See crate::Table::query for more details on queries

A TakeQuery is a query that is used to select a subset of rows from a table using dataset offsets or row ids.

See ExecutableQuery for methods that can be used to execute the query and retrieve results.

This query object can be reused to issue the same query multiple times.

Implementations

impl TakeQuery

pub fn from_offsets(parent: Arc<dyn BaseTable>, offsets: Vec<u64>) -> Self

Create a new TakeQuery that will return rows at the given offsets.

See crate::Table::take_offsets for more details.

pub fn from_row_ids(parent: Arc<dyn BaseTable>, row_ids: Vec<u64>) -> Self

Create a new TakeQuery that will return rows with the given row ids.

See crate::Table::take_row_ids for more details.

pub fn into_request(self) -> QueryRequest

Convert the TakeQuery into a QueryRequest.

pub fn current_request(&self) -> &QueryRequest

Return the current QueryRequest for the TakeQuery.

pub fn select(self, selection: Select) -> Self

Return only the specified columns.

By default a query will return all columns from the table. However, this can have a very significant impact on latency. LanceDb stores data in a columnar fashion. This means we can finely tune our I/O to select exactly the columns we need.

As a best practice you should always limit queries to the columns that you need.

You can also use this method to create new “dynamic” columns based on your existing columns. For example, you may not care about “a” or “b” but instead simply want “a + b”. This is often seen in the SELECT clause of an SQL query (e.g. SELECT a+b FROM my_table).

To create dynamic columns use Select::Dynamic (it might be easier to create this with the helper method Select::dynamic). A column will be returned for each tuple provided. The first value in that tuple provides the name of the column. The second value in the tuple is an SQL string used to specify how the column is calculated.

For example, an SQL query might state SELECT a + b AS combined, c. The equivalent input to Select::dynamic would be &[("combined", "a + b"), ("c", "c")].

Columns will always be returned in the order given, even if that order is different than the order used when adding the data.

pub fn with_row_id(self) -> Self

Return the _rowid meta column from the Table.

Trait Implementations

impl Clone for TakeQuery

fn clone(&self) -> TakeQuery

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TakeQuery

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl ExecutableQuery for TakeQuery

async fn create_plan( &self, options: QueryExecutionOptions, ) -> Result<Arc<dyn ExecutionPlan>>

Return the Datafusion ExecutionPlan.

async fn execute_with_options( &self, options: QueryExecutionOptions, ) -> Result<SendableRecordBatchStream>

Execute the query and return results

async fn explain_plan(&self, verbose: bool) -> Result<String>

async fn analyze_plan_with_options( &self, options: QueryExecutionOptions, ) -> Result<String>

fn execute( &self, ) -> impl Future<Output = Result<SendableRecordBatchStream>> + Send

Execute the query with default options and return results

fn analyze_plan(&self) -> impl Future<Output = Result<String>> + Send

impl HasQuery for TakeQuery

fn mut_query(&mut self) -> &mut QueryRequest