Struct ScalarQuantizationStorage 

pub struct ScalarQuantizationStorage { /* private fields */ }

Implementations

impl ScalarQuantizationStorage

pub fn try_new( num_bits: u16, distance_type: DistanceType, bounds: Range<f64>, batches: impl IntoIterator<Item = RecordBatch>, frag_reuse_index: Option<Arc<FragReuseIndex>>, ) -> Result<Self>

pub async fn load( object_store: &ObjectStore, path: &Path, frag_reuse_index: Option<Arc<FragReuseIndex>>, ) -> Result<Self>

Trait Implementations

impl Clone for ScalarQuantizationStorage

fn clone(&self) -> ScalarQuantizationStorage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ScalarQuantizationStorage

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

Formats the value using the given formatter.

impl DeepSizeOf for ScalarQuantizationStorage

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 QuantizerStorage for ScalarQuantizationStorage

fn load_partition<'life0, 'life1, 'async_trait>( reader: &'life0 PreviousFileReader, range: Range<usize>, distance_type: DistanceType, metadata: &'life1 Self::Metadata, frag_reuse_index: Option<Arc<FragReuseIndex>>, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

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

Load a partition of SQ storage from disk.

Parameters

• *reader: file reader
• *range: row range of the partition
• *metric_type: metric type of the vectors
• *metadata: scalar quantization metadata

type Metadata = ScalarQuantizationMetadata

fn try_from_batch( batch: RecordBatch, metadata: &Self::Metadata, distance_type: DistanceType, frag_reuse_index: Option<Arc<FragReuseIndex>>, ) -> Result<Self>

where Self: Sized,

Create a QuantizerStorage from a RecordBatch. The batch should consist of row IDs and quantized vector.

fn metadata(&self) -> &Self::Metadata

fn remap(&self, mapping: &HashMap<u64, Option<u64>>) -> Result<Self>

impl VectorStore for ScalarQuantizationStorage

fn distance_type(&self) -> DistanceType

Return the DistanceType of the vectors.

fn dist_calculator( &self, query: ArrayRef, _dist_q_c: f32, ) -> Self::DistanceCalculator<'_>

Create a DistCalculator to compute the distance between the query.

Using dist calculator can be more efficient as it can pre-compute some values.

type DistanceCalculator<'a> = SQDistCalculator<'a>

fn to_batches(&self) -> Result<impl Iterator<Item = RecordBatch>>

fn append_batch(&self, batch: RecordBatch, vector_column: &str) -> Result<Self>

Append Raw RecordBatch into the Storage. The storage implement will perform quantization if necessary.

fn schema(&self) -> &SchemaRef

fn as_any(&self) -> &dyn Any

fn len(&self) -> usize

fn row_id(&self, id: u32) -> u64

Get the lance ROW ID from one vector.

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

fn dist_calculator_from_id(&self, id: u32) -> Self::DistanceCalculator<'_>

fn is_empty(&self) -> bool

Returns true if this graph is empty.

fn dist_between(&self, u: u32, v: u32) -> f32