Skip to main content

qdrant_client/qdrant_client/conversions/
query.rs

1use crate::qdrant::{
2    query, ContextInput, DiscoverInput, Formula, FormulaBuilder, Fusion, OrderBy, OrderByBuilder,
3    PointId, Query, RecommendInput, RelevanceFeedbackInput, TextQuery, TextQueryBuilder,
4    VectorInput,
5};
6
7impl From<VectorInput> for Query {
8    fn from(value: VectorInput) -> Self {
9        Self {
10            variant: Some(query::Variant::Nearest(value)),
11        }
12    }
13}
14
15impl From<RecommendInput> for Query {
16    fn from(value: RecommendInput) -> Self {
17        Self {
18            variant: Some(query::Variant::Recommend(value)),
19        }
20    }
21}
22
23impl From<DiscoverInput> for Query {
24    fn from(value: DiscoverInput) -> Self {
25        Self {
26            variant: Some(query::Variant::Discover(value)),
27        }
28    }
29}
30
31impl From<ContextInput> for Query {
32    fn from(value: ContextInput) -> Self {
33        Self {
34            variant: Some(query::Variant::Context(value)),
35        }
36    }
37}
38
39impl From<OrderBy> for Query {
40    fn from(value: OrderBy) -> Self {
41        Self {
42            variant: Some(query::Variant::OrderBy(value)),
43        }
44    }
45}
46
47impl From<Fusion> for Query {
48    fn from(value: Fusion) -> Self {
49        Self {
50            variant: Some(query::Variant::Fusion(value.into())),
51        }
52    }
53}
54
55impl From<RelevanceFeedbackInput> for Query {
56    fn from(value: RelevanceFeedbackInput) -> Self {
57        Self {
58            variant: Some(query::Variant::RelevanceFeedback(value)),
59        }
60    }
61}
62
63impl From<Formula> for Query {
64    fn from(value: Formula) -> Self {
65        Self {
66            variant: Some(query::Variant::Formula(value)),
67        }
68    }
69}
70
71impl From<FormulaBuilder> for Query {
72    fn from(value: FormulaBuilder) -> Self {
73        Self {
74            variant: Some(query::Variant::Formula(value.build())),
75        }
76    }
77}
78
79impl From<TextQuery> for Query {
80    fn from(value: TextQuery) -> Self {
81        Self {
82            variant: Some(query::Variant::Text(value)),
83        }
84    }
85}
86
87impl From<TextQueryBuilder> for Query {
88    fn from(value: TextQueryBuilder) -> Self {
89        Self {
90            variant: Some(query::Variant::Text(value.build())),
91        }
92    }
93}
94
95impl<T: Into<String>> From<T> for TextQuery {
96    fn from(value: T) -> Self {
97        TextQueryBuilder::new(value).build()
98    }
99}
100
101impl<T: Into<String>> From<T> for OrderBy {
102    fn from(value: T) -> Self {
103        OrderByBuilder::new(value).build()
104    }
105}
106
107impl From<Vec<f32>> for Query {
108    fn from(value: Vec<f32>) -> Self {
109        Query {
110            variant: Some(query::Variant::Nearest(VectorInput::new_dense(value))),
111        }
112    }
113}
114
115impl From<Vec<(u32, f32)>> for Query {
116    fn from(value: Vec<(u32, f32)>) -> Self {
117        let (indices, values): (Vec<_>, Vec<_>) = value.iter().copied().unzip();
118        Query {
119            variant: Some(query::Variant::Nearest(VectorInput::new_sparse(
120                indices, values,
121            ))),
122        }
123    }
124}
125
126impl From<Vec<Vec<f32>>> for Query {
127    fn from(value: Vec<Vec<f32>>) -> Self {
128        Query {
129            variant: Some(query::Variant::Nearest(VectorInput::new_multi(value))),
130        }
131    }
132}
133
134impl From<PointId> for Query {
135    fn from(value: PointId) -> Self {
136        Query {
137            variant: Some(query::Variant::Nearest(VectorInput::new_id(value))),
138        }
139    }
140}