Struct QdrantTableProvider 

pub struct QdrantTableProvider { /* private fields */ }

DataFusion TableProvider implementation for Qdrant vector database collections.

This is the main interface for integrating Qdrant collections with DataFusion SQL queries. It provides a complete SQL interface over vector data with support for all Qdrant vector types, schema projection optimization, and heterogeneous collection handling.

Features

• Complete Vector Support: Dense, multi-dense, and sparse vectors
• Schema Projection: Only fetches vector fields that are actually requested
• Heterogeneous Collections: Handles points with different vector field subsets
• High Performance: Single-pass processing with minimal allocations

Examples

Basic Usage

use qdrant_datafusion::prelude::*;
use qdrant_client::Qdrant;
use datafusion::prelude::*;
use std::sync::Arc;

// Connect to Qdrant
let client = Qdrant::from_url("http://localhost:6334").build()?;

// Create table provider for a collection
let table_provider = QdrantTableProvider::try_new(client, "my_vectors").await?;

// Register with DataFusion
let ctx = SessionContext::new();
ctx.register_table("vectors", Arc::new(table_provider))?;

// Query with SQL
let df = ctx.sql("SELECT id, embedding FROM vectors LIMIT 10").await?;
let results = df.collect().await?;

Advanced Projections

// Only fetch specific vector fields (optimized query to Qdrant)
let df = ctx.sql("
    SELECT
        text_embedding,
        keywords_indices,
        keywords_values
    FROM mixed_vectors
    WHERE id = 'doc123'
").await?;

Implementations

impl QdrantTableProvider

pub async fn try_new(client: Qdrant, collection: &str) -> Result<Self>

Create a new QdrantTableProvider for the specified Qdrant collection.

This constructor connects to the Qdrant collection, analyzes its schema, and creates a DataFusion-compatible table provider. The schema is built by examining the collection’s vector configuration and creating appropriate Arrow fields for all vector types.

Arguments

• client - Connected Qdrant client instance
• collection - Name of the Qdrant collection to provide access to

Returns

A configured QdrantTableProvider ready for SQL queries.

Errors

Returns an error if:

• The collection does not exist or is inaccessible
• The collection configuration cannot be retrieved
• The collection has an unsupported schema configuration

Examples

use qdrant_datafusion::prelude::*;
use qdrant_client::Qdrant;

let client = Qdrant::from_url("http://localhost:6334")
    .api_key("optional-api-key")
    .build()?;

let table_provider = QdrantTableProvider::try_new(client, "embeddings").await?;

Trait Implementations

impl Clone for QdrantTableProvider

fn clone(&self) -> QdrantTableProvider

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QdrantTableProvider

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

Formats the value using the given formatter.

impl TableProvider for QdrantTableProvider

fn as_any(&self) -> &dyn Any

Returns the table provider as Any so that it can be downcast to a specific implementation.

fn schema(&self) -> SchemaRef

Get a reference to the schema for this table

fn table_type(&self) -> TableType

Get the type of this table for metadata/catalog purposes.

fn scan<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _state: &'life1 dyn Session, projection: Option<&'life2 Vec<usize>>, filters: &'life3 [Expr], limit: Option<usize>, ) -> Pin<Box<dyn Future<Output = DataFusionResult<Arc<dyn ExecutionPlan>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Create an ExecutionPlan for scanning the table with optionally specified projection, filter and limit, described below.

fn insert_into<'life0, 'life1, 'async_trait>( &'life0 self, _state: &'life1 dyn Session, _input: Arc<dyn ExecutionPlan>, _insert_op: InsertOp, ) -> Pin<Box<dyn Future<Output = DataFusionResult<Arc<dyn ExecutionPlan>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Return an ExecutionPlan to insert data into this table, if supported.

fn constraints(&self) -> Option<&Constraints>

Get a reference to the constraints of the table. Returns:

fn get_table_definition(&self) -> Option<&str>

Get the create statement used to create this table, if available.

fn get_logical_plan(&self) -> Option<Cow<'_, LogicalPlan>>

Get the LogicalPlan of this table, if available.

fn get_column_default(&self, _column: &str) -> Option<&Expr>

Get the default value for a column, if available.

fn supports_filters_pushdown( &self, filters: &[&Expr], ) -> Result<Vec<TableProviderFilterPushDown>, DataFusionError>

Specify if DataFusion should provide filter expressions to the TableProvider to apply during the scan.

fn statistics(&self) -> Option<Statistics>

Get statistics for this table, if available Although not presently used in mainline DataFusion, this allows implementation specific behavior for downstream repositories, in conjunction with specialized optimizer rules to perform operations such as re-ordering of joins.