Struct IVFIndex 

pub struct IVFIndex {
    pub ivf: IvfModel,
    pub metric_type: MetricType,
    /* private fields */
}

IVF Index. WARNING: Internal API with no stability guarantees.

Fields

ivf: IvfModel

Ivf model

metric_type: MetricType

Implementations

impl IVFIndex

pub async fn load_partition( &self, partition_id: usize, write_cache: bool, metrics: &dyn MetricsCollector, ) -> Result<Arc<dyn VectorIndex>>

Load one partition of the IVF sub-index.

Internal API with no stability guarantees.

Parameters

• partition_id: partition ID.

pub fn preprocess_query( &self, partition_id: usize, query: &Query, ) -> Result<Query>

preprocess the query vector given the partition id.

Internal API with no stability guarantees.

Trait Implementations

impl Debug for IVFIndex

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

Formats the value using the given formatter.

impl DeepSizeOf for IVFIndex

fn deep_size_of_children(&self, context: &mut Context) -> usize

Returns an estimation of the heap-managed storage of this object. This does not include the size of the object itself.

fn deep_size_of(&self) -> usize

Returns an estimation of a total size of memory owned by the object, including heap-managed storage.

impl Index for IVFIndex

fn as_any(&self) -> &dyn Any

Cast to Any.

fn as_index(self: Arc<Self>) -> Arc<dyn Index>

Cast to Index

fn as_vector_index(self: Arc<Self>) -> Result<Arc<dyn VectorIndex>>

Cast to vector::VectorIndex

fn index_type(&self) -> IndexType

Get the type of the index

fn prewarm<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Prewarm the index.

fn statistics(&self) -> Result<Value>

Retrieve index statistics as a JSON Value

fn calculate_included_frags<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<RoaringBitmap>> + Send + 'async_trait>>

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

Read through the index and determine which fragment ids are covered by the index

impl VectorIndex for IVFIndex

fn find_partitions(&self, query: &Query) -> Result<(UInt32Array, Float32Array)>

find the IVF partitions ids given the query vector.

Internal API with no stability guarantees.

Assumes the query vector is normalized if the metric type is cosine.

fn sub_index_type(&self) -> (SubIndexType, QuantizationType)

the index type of this vector index.

fn search<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _query: &'life1 Query, _pre_filter: Arc<dyn PreFilter>, _metrics: &'life2 dyn MetricsCollector, ) -> Pin<Box<dyn Future<Output = Result<RecordBatch>> + Send + 'async_trait>>

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

Search entire index for k nearest neighbors.

fn search_in_partition<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, partition_id: usize, query: &'life1 Query, pre_filter: Arc<dyn PreFilter>, metrics: &'life2 dyn MetricsCollector, ) -> Pin<Box<dyn Future<Output = Result<RecordBatch>> + Send + 'async_trait>>

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

Search a single partition for nearest neighbors.

fn total_partitions(&self) -> usize

Get the total number of partitions in the index.

fn is_loadable(&self) -> bool

If the index is loadable by IVF, so it can be a sub-index that is loaded on demand by IVF.

fn use_residual(&self) -> bool

Use residual vector to search.

fn load<'life0, 'async_trait>( &'life0 self, _reader: Arc<dyn Reader>, _offset: usize, _length: usize, ) -> Pin<Box<dyn Future<Output = Result<Box<dyn VectorIndex>>> + Send + 'async_trait>>

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

Load the index from the reader on-demand.

fn partition_reader<'life0, 'life1, 'async_trait>( &'life0 self, partition_id: usize, with_vector: bool, metrics: &'life1 dyn MetricsCollector, ) -> Pin<Box<dyn Future<Output = Result<SendableRecordBatchStream>> + Send + 'async_trait>>

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

fn to_batch_stream<'life0, 'async_trait>( &'life0 self, _with_vector: bool, ) -> Pin<Box<dyn Future<Output = Result<SendableRecordBatchStream>> + Send + 'async_trait>>

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

fn num_rows(&self) -> u64

fn row_ids(&self) -> Box<dyn Iterator<Item = &u64>>

Return the IDs of rows in the index.

fn remap<'life0, 'life1, 'async_trait>( &'life0 mut self, _mapping: &'life1 HashMap<u64, Option<u64>>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Remap the index according to mapping

fn ivf_model(&self) -> &IvfModel

fn quantizer(&self) -> Quantizer

fn partition_size(&self, part_id: usize) -> usize

fn metric_type(&self) -> MetricType

The metric type of this vector index.

fn load_partition<'life0, 'async_trait>( &'life0 self, reader: Arc<dyn Reader>, offset: usize, length: usize, _partition_id: usize, ) -> Pin<Box<dyn Future<Output = Result<Box<dyn VectorIndex>, Error>> + Send + 'async_trait>>

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

Load the partition from the reader on-demand.