Trait IndexBackendPlugin 

pub trait IndexBackendPlugin: Send + Sync {
    // Required methods
    fn create_element_index<'life0, 'life1, 'async_trait>(
        &'life0 self,
        query_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn ElementIndex>, IndexError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn create_archive_index<'life0, 'life1, 'async_trait>(
        &'life0 self,
        query_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn ElementArchiveIndex>, IndexError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn create_result_index<'life0, 'life1, 'async_trait>(
        &'life0 self,
        query_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn ResultIndex>, IndexError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn create_future_queue<'life0, 'life1, 'async_trait>(
        &'life0 self,
        query_id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn FutureQueue>, IndexError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn is_volatile(&self) -> bool;
}

Index backend plugin trait for implementing storage backends Plugin trait for external index storage backends.

Each storage backend (RocksDB, Garnet, etc.) implements this trait to provide the four index types needed for query evaluation.

Thread Safety

Implementations must be Send + Sync to allow use across async tasks.

Example

use drasi_core::interface::IndexBackendPlugin;

pub struct MyIndexProvider {
    // configuration fields
}

#[async_trait]
impl IndexBackendPlugin for MyIndexProvider {
    async fn create_element_index(&self, query_id: &str) -> Result<Arc<dyn ElementIndex>, IndexError> {
        // Create and return your element index implementation
    }
    // ... other methods
}

Required Methods

fn create_element_index<'life0, 'life1, 'async_trait>( &'life0 self, query_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn ElementIndex>, IndexError>> + Send + 'async_trait>>

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

Create an ElementIndex instance for the given query.

The element index manages the current graph elements (nodes and relationships) for a specific query. Each query gets its own isolated index instance.

fn create_archive_index<'life0, 'life1, 'async_trait>( &'life0 self, query_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn ElementArchiveIndex>, IndexError>> + Send + 'async_trait>>

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

Create an ElementArchiveIndex instance for the given query.

The archive index supports point-in-time queries and version history, enabling the past() function in Cypher queries.

fn create_result_index<'life0, 'life1, 'async_trait>( &'life0 self, query_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn ResultIndex>, IndexError>> + Send + 'async_trait>>

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

Create a ResultIndex instance for the given query.

The result index stores accumulated query results and aggregations, supporting efficient incremental computation.

fn create_future_queue<'life0, 'life1, 'async_trait>( &'life0 self, query_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn FutureQueue>, IndexError>> + Send + 'async_trait>>

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

Create a FutureQueue instance for the given query.

The future queue manages temporal queries and scheduled operations, enabling time-based query features.

fn is_volatile(&self) -> bool

Returns true if this backend is volatile (data lost on restart).

Volatile backends (like in-memory) require re-bootstrapping after restart, while persistent backends (like RocksDB) retain data.

Implementors