qdrant_edge/shard/query/
mod.rs

1#[cfg(feature = "api")]
2mod conversions;
3pub mod formula;
4pub mod mmr;
5pub mod planned_query;
6pub mod query_enum;
7pub mod scroll;
8mod validation;
9
10pub mod query_context;
11#[cfg(test)]
12mod tests;
13
14use crate::common::types::ScoreType;
15use ordered_float::OrderedFloat;
16use crate::segment::data_types::order_by::OrderBy;
17use crate::segment::data_types::vectors::VectorInternal;
18use crate::segment::index::query_optimization::rescore_formula::parsed_formula::ParsedFormula;
19use crate::segment::types::*;
20use serde::Serialize;
21
22use self::query_enum::*;
23use crate::shard::search::CoreSearchRequest;
24
25/// Internal response type for a universal query request.
26///
27/// Capable of returning multiple intermediate results if needed, like the case of RRF (Reciprocal Rank Fusion)
28pub type ShardQueryResponse = Vec<Vec<ScoredPoint>>;
29
30/// Internal representation of a universal query request.
31///
32/// Direct translation of the user-facing request, but with all point ids substituted with their corresponding vectors.
33///
34/// For the case of formula queries, it collects conditions and variables too.
35#[derive(Clone, Debug, Hash, Serialize)]
36pub struct ShardQueryRequest {
37    pub prefetches: Vec<ShardPrefetch>,
38    #[serde(skip_serializing_if = "Option::is_none")]
39    pub query: Option<ScoringQuery>,
40    #[serde(skip_serializing_if = "Option::is_none")]
41    pub filter: Option<Filter>,
42    #[serde(skip_serializing_if = "Option::is_none")]
43    pub score_threshold: Option<OrderedFloat<ScoreType>>,
44    pub limit: usize,
45    pub offset: usize,
46    /// Search params for when there is no prefetch
47    #[serde(skip_serializing_if = "Option::is_none")]
48    pub params: Option<SearchParams>,
49    pub with_vector: WithVector,
50    pub with_payload: WithPayloadInterface,
51}
52
53impl ShardQueryRequest {
54    pub fn prefetches_depth(&self) -> usize {
55        self.prefetches
56            .iter()
57            .map(ShardPrefetch::depth)
58            .max()
59            .unwrap_or(0)
60    }
61
62    pub fn filter_refs(&self) -> Vec<Option<&Filter>> {
63        let mut filters = vec![];
64        filters.push(self.filter.as_ref());
65
66        for prefetch in &self.prefetches {
67            filters.extend(prefetch.filter_refs())
68        }
69
70        filters
71    }
72}
73
74#[derive(Clone, Debug, Hash, Serialize)]
75pub struct ShardPrefetch {
76    pub prefetches: Vec<ShardPrefetch>,
77    #[serde(skip_serializing_if = "Option::is_none")]
78    pub query: Option<ScoringQuery>,
79    pub limit: usize,
80    #[serde(skip_serializing_if = "Option::is_none")]
81    pub params: Option<SearchParams>,
82    #[serde(skip_serializing_if = "Option::is_none")]
83    pub filter: Option<Filter>,
84    #[serde(skip_serializing_if = "Option::is_none")]
85    pub score_threshold: Option<OrderedFloat<ScoreType>>,
86}
87
88impl ShardPrefetch {
89    pub fn depth(&self) -> usize {
90        let mut depth = 1;
91        for prefetch in &self.prefetches {
92            depth = depth.max(prefetch.depth() + 1);
93        }
94        depth
95    }
96
97    fn filter_refs(&self) -> Vec<Option<&Filter>> {
98        let mut filters = vec![];
99
100        filters.push(self.filter.as_ref());
101
102        for prefetch in &self.prefetches {
103            filters.extend(prefetch.filter_refs())
104        }
105
106        filters
107    }
108}
109
110/// Same as `Query`, but with the resolved vector references.
111#[derive(Clone, Debug, PartialEq, Hash, Serialize)]
112pub enum ScoringQuery {
113    /// Score points against some vector(s)
114    Vector(QueryEnum),
115
116    /// Reciprocal rank fusion
117    Fusion(FusionInternal),
118
119    /// Order by a payload field
120    OrderBy(OrderBy),
121
122    /// Score boosting via an arbitrary formula
123    Formula(ParsedFormula),
124
125    /// Sample points
126    Sample(SampleInternal),
127
128    /// Maximal Marginal Relevance
129    ///
130    /// This one behaves a little differently than the other scorings, since it is two parts.
131    /// It will create one nearest neighbor search in segment space and then try to resolve MMR algorithm higher up.
132    ///
133    /// E.g. If it is the root query of a request:
134    ///   1. Performs search all the way down to segments.
135    ///   2. MMR gets calculated once results reach collection level.
136    Mmr(MmrInternal),
137}
138
139impl ScoringQuery {
140    /// Get the vector name if it is scored against a vector
141    pub fn get_vector_name(&self) -> Option<&VectorName> {
142        match self {
143            ScoringQuery::Vector(query) => Some(query.get_vector_name()),
144            ScoringQuery::Mmr(mmr) => Some(&mmr.using),
145            ScoringQuery::Fusion(_)
146            | ScoringQuery::OrderBy(_)
147            | ScoringQuery::Formula(_)
148            | ScoringQuery::Sample(_) => None,
149        }
150    }
151}
152
153#[derive(Clone, Debug, PartialEq, Hash, Serialize)]
154pub enum FusionInternal {
155    /// Reciprocal Rank Fusion with optional weights per prefetch
156    Rrf {
157        k: usize,
158        /// Weights for each prefetch source. Higher weight = more influence on final ranking.
159        /// If None, all sources are weighted equally.
160        weights: Option<Vec<ordered_float::OrderedFloat<f32>>>,
161    },
162    /// Distribution-based score fusion
163    Dbsf,
164}
165
166#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Serialize)]
167pub enum SampleInternal {
168    Random,
169}
170
171/// Maximal Marginal Relevance configuration
172#[derive(Clone, Debug, PartialEq, Hash, Serialize)]
173pub struct MmrInternal {
174    /// Query vector, used to get the relevance of each point.
175    pub vector: VectorInternal,
176    /// Vector name to use for similarity computation, defaults to empty string (default vector)
177    pub using: VectorNameBuf,
178    /// Lambda parameter controlling diversity vs relevance trade-off (0.0 = full diversity, 1.0 = full relevance)
179    pub lambda: OrderedFloat<f32>,
180    /// Maximum number of candidates to preselect using nearest neighbors.
181    pub candidates_limit: usize,
182}
183
184impl From<CoreSearchRequest> for ShardQueryRequest {
185    fn from(value: CoreSearchRequest) -> Self {
186        let CoreSearchRequest {
187            query,
188            filter,
189            score_threshold,
190            limit,
191            offset,
192            params,
193            with_vector,
194            with_payload,
195        } = value;
196
197        Self {
198            prefetches: vec![],
199            query: Some(ScoringQuery::Vector(query)),
200            filter,
201            score_threshold: score_threshold.map(OrderedFloat),
202            limit,
203            offset,
204            params,
205            with_vector: with_vector.unwrap_or_default(),
206            with_payload: with_payload.unwrap_or_default(),
207        }
208    }
209}
qdrant_edge/shard/query/mod.rs

qdrant_edge/shard/query/
mod.rs
