Struct HNSWIndex

pub struct HNSWIndex<Q: Quantization> { /* private fields */ }

Implementations

impl<Q: Quantization> HNSWIndex<Q>

pub async fn try_new( reader: Arc<dyn Reader>, aux_reader: Arc<dyn Reader>, options: HNSWIndexOptions, ) -> Result<Self>

pub fn quantizer(&self) -> &Quantizer

pub fn metadata(&self) -> HnswMetadata

Trait Implementations

impl<Q: Clone + Quantization> Clone for HNSWIndex<Q>

where Q::Storage: Clone,

fn clone(&self) -> HNSWIndex<Q>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Q: Quantization> Debug for HNSWIndex<Q>

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

Formats the value using the given formatter.

impl<Q: Quantization + DeepSizeOf> DeepSizeOf for HNSWIndex<Q>

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<Q: Quantization + Send + Sync + 'static> Index for HNSWIndex<Q>

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 VectorIndex

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

Retrieve index statistics as a JSON Value

fn index_type(&self) -> IndexType

Get the type of the index

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

This is a kind of slow operation. It’s better to use the fragment_bitmap. This only exists for cases where the fragment_bitmap has become corrupted or missing.

impl<Q: Quantization + Send + Sync + 'static> VectorIndex for HNSWIndex<Q>

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

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

Search the vector for nearest neighbors.

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

fn search_in_partition<'life0, 'life1, 'async_trait>( &'life0 self, __arg1: usize, _: &'life1 Query, __arg3: Arc<dyn PreFilter>, ) -> Pin<Box<dyn Future<Output = Result<RecordBatch>> + Send + 'async_trait>>

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

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 check_can_remap(&self) -> Result<()>

If the index can be remapped return Ok. Else return an error explaining why not

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 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>>> + Send + 'async_trait>>

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

Load the partition from the reader on-demand.

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 sub_index_type(&self) -> (SubIndexType, QuantizationType)

the index type of this vector index.

fn metric_type(&self) -> DistanceType

The metric type of this vector index.

fn remap_to<'life0, 'async_trait>( self: Arc<Self>, _store: ObjectStore, _mapping: &'life0 HashMap<u64, Option<u64>>, _column: String, _index_dir: Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Remap the index according to mapping