qdrant-edge 0.7.0

A lightweight, in-process vector search engine designed for embedded devices, autonomous systems, and mobile agents.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

use std::sync::atomic::AtomicBool;

use crate::common::counter::hardware_counter::HardwareCounterCell;
use crate::common::types::DeferredBehavior;
use itertools::Itertools as _;
use crate::segment::common::operation_error::OperationResult;
use crate::segment::index::field_index::EstimationMerge;
use crate::shard::count::CountRequestInternal;

use super::EdgeShard;

impl EdgeShard {
    pub fn count(&self, request: CountRequestInternal) -> OperationResult<usize> {
        let CountRequestInternal { filter, exact } = request;

        let (non_appendable, appendable) = self.segments.read().split_segments();
        let segments = non_appendable.into_iter().chain(appendable);

        let points_count = if exact {
            segments
                .map(|segment| {
                    segment.get().read().read_filtered(
                        None,
                        None,
                        filter.as_ref(),
                        &AtomicBool::new(false),
                        &HardwareCounterCell::disposable(),
                        DeferredBehavior::Exclude,
                    )
                })
                .process_results(|iter| iter.flatten().count())?
        } else {
            let cardinality = segments
                .map(|segment| {
                    segment
                        .get()
                        .read() // blocking sync lock
                        .estimate_point_count(filter.as_ref(), &HardwareCounterCell::disposable())
                })
                .process_results(|iter| iter.merge_independent())?;

            cardinality.exp
        };

        Ok(points_count)
    }
}