use qql_core::error::QqlError;
use qql_plan::types::{
FilterExpression, OrderByQuery, PayloadSelectorReq, VectorSelectorReq, WithLookupValue,
};
use qql_plan::{PlanPointId, PlanPointVectors, PlanQueryInput, PlanVectorValue};
use crate::qdrant_grpc::qdrant;
use super::common::{shard_key_selector, to_point_id};
use super::filter::{to_filter, to_filter_opt};
use super::formula::{formula_default_to_grpc, plan_formula_to_grpc};
pub(crate) fn to_query_points(
req: &qql_plan::types::QueryRequest,
collection: &str,
) -> Result<qdrant::QueryPoints, QqlError> {
Ok(qdrant::QueryPoints {
collection_name: collection.into(),
prefetch: req
.prefetch
.iter()
.map(to_prefetch)
.collect::<Result<Vec<_>, _>>()?,
query: Some(to_query_variant(&req.query)?),
using: req.using.clone(),
filter: to_filter_opt(req.filter.as_ref())?,
params: req.params.as_ref().map(to_search_params),
score_threshold: req.score_threshold.map(|s| s as f32),
limit: req.limit,
offset: req.offset,
with_payload: req.with_payload.as_ref().map(to_payload_selector),
with_vectors: req.with_vector.as_ref().map(to_vectors_selector),
shard_key_selector: shard_key_selector(&req.shard_key),
timeout: req.timeout,
read_consistency: req.consistency.as_ref().map(to_read_consistency),
..Default::default()
})
}
pub(crate) fn to_query_groups(
req: &qql_plan::types::QueryGroupsRequest,
collection: &str,
) -> Result<qdrant::QueryPointGroups, QqlError> {
Ok(qdrant::QueryPointGroups {
collection_name: collection.into(),
prefetch: req
.prefetch
.iter()
.map(to_prefetch)
.collect::<Result<Vec<_>, _>>()?,
query: Some(to_query_variant(&req.query)?),
using: req.using.clone(),
filter: to_filter_opt(req.filter.as_ref())?,
params: req.params.as_ref().map(to_search_params),
score_threshold: req.score_threshold.map(|s| s as f32),
with_payload: req.with_payload.as_ref().map(to_payload_selector),
with_vectors: req.with_vector.as_ref().map(to_vectors_selector),
group_by: req.group_by.clone(),
group_size: Some(req.group_size),
limit: Some(req.limit),
with_lookup: req.with_lookup.as_ref().map(|wv| match wv {
WithLookupValue::Collection(c) => qdrant::WithLookup {
collection: c.clone(),
..Default::default()
},
WithLookupValue::Full(wl) => qdrant::WithLookup {
collection: wl.collection.clone(),
with_payload: wl.with_payload.as_ref().map(to_payload_selector),
with_vectors: wl.with_vectors.as_ref().map(to_vectors_selector),
},
}),
shard_key_selector: shard_key_selector(&req.shard_key),
timeout: req.timeout,
read_consistency: req.consistency.as_ref().map(to_read_consistency),
..Default::default()
})
}
pub(crate) fn to_order_by(order_by: &OrderByQuery) -> Result<qdrant::OrderBy, QqlError> {
let direction = match order_by.direction.as_deref() {
None => None,
Some("asc") => Some(qdrant::Direction::Asc as i32),
Some("desc") => Some(qdrant::Direction::Desc as i32),
Some(other) => {
return Err(QqlError::validation(
"QQL-GRPC-DIRECTION",
format!(
"unsupported order_by direction '{other}' on the gRPC path; use 'asc' or 'desc'"
),
None,
));
}
};
Ok(qdrant::OrderBy {
key: order_by.key.clone(),
direction,
start_from: order_by
.start_from
.as_ref()
.map(to_start_from)
.transpose()?,
})
}
fn to_start_from(value: &qql_core::ast::Value) -> Result<qdrant::StartFrom, QqlError> {
use qdrant::start_from::Value as Sf;
use qql_core::ast::Value;
let start = match value {
Value::Int(n) => Sf::Integer(*n),
Value::UInt(n) => Sf::Integer(i64::try_from(*n).map_err(|_| {
QqlError::validation(
"QQL-GRPC-START-FROM",
format!(
"order_by START FROM integer {n} cannot be represented on the gRPC path: the bundled Qdrant proto stores it as int64 (max {})",
i64::MAX
),
None,
)
})?),
Value::Float(f) => Sf::Float(*f),
Value::Str(text) if qql_core::ast::looks_like_iso_datetime(text) => {
Sf::Datetime(text.clone())
}
other => {
return Err(QqlError::validation(
"QQL-GRPC-START-FROM",
format!(
"order_by START FROM {} cannot be represented on the gRPC path; use an integer, float, or ISO-8601 datetime",
qql_plan::value_error_text(other)
),
None,
));
}
};
Ok(qdrant::StartFrom { value: Some(start) })
}
pub(crate) fn to_read_consistency(
c: &qql_plan::types::ReadConsistencyParam,
) -> qdrant::ReadConsistency {
use qdrant::read_consistency::Value as RcValue;
use qql_plan::types::ReadConsistencyParam;
let value = match c {
ReadConsistencyParam::Factor(n) => RcValue::Factor(*n),
ReadConsistencyParam::Majority => {
RcValue::Type(qdrant::ReadConsistencyType::Majority as i32)
}
ReadConsistencyParam::Quorum => RcValue::Type(qdrant::ReadConsistencyType::Quorum as i32),
ReadConsistencyParam::All => RcValue::Type(qdrant::ReadConsistencyType::All as i32),
};
qdrant::ReadConsistency { value: Some(value) }
}
pub(crate) fn to_prefetch(
pf: &qql_plan::types::PrefetchRequest,
) -> Result<qdrant::PrefetchQuery, QqlError> {
Ok(qdrant::PrefetchQuery {
prefetch: match pf.prefetch.as_ref() {
Some(pfs) => pfs
.iter()
.map(to_prefetch)
.collect::<Result<Vec<_>, QqlError>>()?,
None => Vec::new(),
},
query: pf.query.as_ref().map(to_query_variant).transpose()?,
using: pf.using.clone(),
filter: to_filter_opt(pf.filter.as_ref())?,
params: pf.params.as_ref().map(to_search_params),
score_threshold: pf.score_threshold.map(|s| s as f32),
limit: pf.limit,
lookup_from: pf.lookup_from.as_ref().map(|l| qdrant::LookupLocation {
collection_name: l.collection.clone(),
vector_name: l.vector.clone(),
..Default::default()
}),
})
}
pub(crate) fn to_grpc_rrf(rrf: &qql_plan::types::RrfQuery) -> Result<qdrant::Rrf, QqlError> {
let k = match rrf.rrf.k {
Some(k) => {
let k32 = u32::try_from(k).map_err(|_| {
QqlError::validation(
"QQL-GRPC-RRF-K",
format!(
"rrf_k = {k} cannot be represented on the gRPC path: the bundled Qdrant proto stores k as uint32 (max {})",
u32::MAX
),
None,
)
})?;
Some(k32)
}
None => None,
};
let weights = match rrf.rrf.weights.as_ref() {
Some(weights) => {
let mut out = Vec::with_capacity(weights.len());
for w in weights {
let w32 = *w as f32;
if (w32 as f64) != *w {
return Err(QqlError::validation(
"QQL-GRPC-RRF-WEIGHT",
format!(
"rrf_weights value {w} cannot be represented exactly on the gRPC path: the bundled Qdrant proto stores weights as f32"
),
None,
));
}
out.push(w32);
}
out
}
None => Vec::new(),
};
Ok(qdrant::Rrf { k, weights })
}
pub(crate) fn to_query_variant(
qv: &qql_plan::types::QueryVariant,
) -> Result<qdrant::Query, QqlError> {
use qdrant::query::Variant;
use qql_plan::types::QueryVariant;
let variant = match qv {
QueryVariant::Nearest(nq) => Variant::Nearest(to_vector_input(&nq.nearest)?),
QueryVariant::Recommend { recommend } => Variant::Recommend(qdrant::RecommendInput {
positive: recommend
.positive
.iter()
.map(to_vector_input)
.collect::<Result<Vec<_>, _>>()?,
negative: recommend
.negative
.iter()
.map(to_vector_input)
.collect::<Result<Vec<_>, _>>()?,
strategy: recommend
.strategy
.as_deref()
.map(|s| match s {
"average_vector" => Ok(qdrant::RecommendStrategy::AverageVector as i32),
"best_score" => Ok(qdrant::RecommendStrategy::BestScore as i32),
"sum_scores" => Ok(qdrant::RecommendStrategy::SumScores as i32),
other => Err(QqlError::validation(
"QQL-GRPC-STRATEGY",
format!(
"unsupported recommend strategy '{other}' on the gRPC path; use average_vector, best_score, or sum_scores"
),
None,
)),
})
.transpose()?,
}),
QueryVariant::Context { context } => Variant::Context(qdrant::ContextInput {
pairs: context
.iter()
.map(|p| {
Ok(qdrant::ContextInputPair {
positive: Some(to_vector_input(&p.positive)?),
negative: Some(to_vector_input(&p.negative)?),
})
})
.collect::<Result<Vec<_>, QqlError>>()?,
}),
QueryVariant::Discover { discover } => Variant::Discover(qdrant::DiscoverInput {
target: Some(to_vector_input(&discover.target)?),
context: Some(qdrant::ContextInput {
pairs: discover
.context
.iter()
.map(|p| {
Ok(qdrant::ContextInputPair {
positive: Some(to_vector_input(&p.positive)?),
negative: Some(to_vector_input(&p.negative)?),
})
})
.collect::<Result<Vec<_>, QqlError>>()?,
}),
}),
QueryVariant::OrderBy { order_by } => Variant::OrderBy(to_order_by(order_by)?),
QueryVariant::Sample { .. } => Variant::Sample(0),
QueryVariant::Fusion { fusion } => {
let val = match fusion.as_str() {
"rrf" => qdrant::Fusion::Rrf as i32,
"dbsf" => qdrant::Fusion::Dbsf as i32,
other => {
return Err(QqlError::validation(
"QQL-GRPC-FUSION",
format!("unsupported fusion method '{other}' on the gRPC path"),
None,
));
}
};
Variant::Fusion(val)
}
QueryVariant::Rrf(rrf) => Variant::Rrf(to_grpc_rrf(rrf)?),
QueryVariant::Formula(fq) => Variant::Formula(qdrant::Formula {
expression: Some(plan_formula_to_grpc(&fq.formula)?),
defaults: fq
.defaults
.as_ref()
.map(|defaults| {
defaults
.iter()
.map(|(key, value)| (key.clone(), formula_default_to_grpc(value)))
.collect()
})
.unwrap_or_default(),
}),
QueryVariant::RelevanceFeedback { relevance_feedback } => {
let feedback = relevance_feedback
.feedback
.iter()
.map(|item| {
Ok(qdrant::FeedbackItem {
example: Some(to_vector_input(&item.example)?),
score: item.score as f32,
})
})
.collect::<Result<Vec<_>, QqlError>>()?;
let strategy = Some(qdrant::FeedbackStrategy {
variant: Some(qdrant::feedback_strategy::Variant::Naive(
qdrant::NaiveFeedbackStrategy {
a: relevance_feedback.strategy.naive.a as f32,
b: relevance_feedback.strategy.naive.b as f32,
c: relevance_feedback.strategy.naive.c as f32,
},
)),
});
Variant::RelevanceFeedback(qdrant::RelevanceFeedbackInput {
target: Some(to_vector_input(&relevance_feedback.target)?),
feedback,
strategy,
})
}
};
Ok(qdrant::Query {
variant: Some(variant),
})
}
pub(crate) fn to_vector_input(input: &PlanQueryInput) -> Result<qdrant::VectorInput, QqlError> {
use qdrant::vector_input::Variant;
let variant = match input {
PlanQueryInput::Point(id) => Variant::Id(to_point_id(id)),
PlanQueryInput::Vector(PlanVectorValue::Dense(data)) => {
Variant::Dense(qdrant::DenseVector { data: data.clone() })
}
PlanQueryInput::Vector(PlanVectorValue::Sparse { indices, values }) => {
Variant::Sparse(qdrant::SparseVector {
indices: indices.clone(),
values: values.clone(),
})
}
PlanQueryInput::Vector(PlanVectorValue::MultiDense(rows)) => {
Variant::MultiDense(qdrant::MultiDenseVector {
vectors: rows
.iter()
.map(|row| qdrant::DenseVector { data: row.clone() })
.collect(),
})
}
PlanQueryInput::Document {
text,
model,
options,
} => Variant::Document(qdrant::Document {
text: text.clone(),
model: model.clone().unwrap_or_default(),
options: grpc_options(options),
}),
PlanQueryInput::Image {
image,
model,
options,
} => Variant::Image(qdrant::Image {
image: Some(qdrant::Value {
kind: Some(qdrant::value::Kind::StringValue(image.clone())),
}),
model: model.clone().unwrap_or_default(),
options: grpc_options(options),
}),
PlanQueryInput::Object {
object,
model,
options,
} => Variant::Object(qdrant::InferenceObject {
object: Some(super::values::to_qdrant_value(object.as_ref())),
model: model.clone().unwrap_or_default(),
options: grpc_options(options),
}),
PlanQueryInput::Vector(PlanVectorValue::Param(name)) => {
return Err(QqlError::validation(
"QQL-BIND-UNBOUND-PARAM",
format!(
"unbound named parameter ':{name}' reached gRPC to_vector_input (bind parameters before dispatch)"
),
None,
));
}
PlanQueryInput::Vector(PlanVectorValue::PositionalParam(idx)) => {
return Err(QqlError::validation(
"QQL-BIND-MISSING-POSITIONAL",
format!(
"missing positional parameter '?{}' reached gRPC to_vector_input (bind parameters before dispatch)",
idx + 1
),
None,
));
}
PlanQueryInput::Vector(PlanVectorValue::Document {
text,
model,
options,
}) => Variant::Document(qdrant::Document {
text: text.clone(),
model: model.clone().unwrap_or_default(),
options: grpc_options(options),
}),
PlanQueryInput::Vector(PlanVectorValue::Image {
image,
model,
options,
}) => Variant::Image(qdrant::Image {
image: Some(qdrant::Value {
kind: Some(qdrant::value::Kind::StringValue(image.clone())),
}),
model: model.clone().unwrap_or_default(),
options: grpc_options(options),
}),
PlanQueryInput::Vector(PlanVectorValue::Object {
object,
model,
options,
}) => Variant::Object(qdrant::InferenceObject {
object: Some(super::values::to_qdrant_value(object.as_ref())),
model: model.clone().unwrap_or_default(),
options: grpc_options(options),
}),
};
Ok(qdrant::VectorInput {
variant: Some(variant),
})
}
fn grpc_options(
options: &Option<Vec<(String, qql_core::ast::Value)>>,
) -> std::collections::HashMap<String, qdrant::Value> {
options
.as_ref()
.map(|pairs| {
pairs
.iter()
.map(|(k, v)| (k.clone(), super::values::to_qdrant_value(v)))
.collect()
})
.unwrap_or_default()
}
pub(crate) fn to_payload_selector(ps: &PayloadSelectorReq) -> qdrant::WithPayloadSelector {
match ps {
PayloadSelectorReq::All(b) => qdrant::WithPayloadSelector {
selector_options: Some(qdrant::with_payload_selector::SelectorOptions::Enable(*b)),
},
PayloadSelectorReq::Include { include } => qdrant::WithPayloadSelector {
selector_options: Some(qdrant::with_payload_selector::SelectorOptions::Include(
qdrant::PayloadIncludeSelector {
fields: include.clone(),
},
)),
},
PayloadSelectorReq::Exclude { exclude } => qdrant::WithPayloadSelector {
selector_options: Some(qdrant::with_payload_selector::SelectorOptions::Exclude(
qdrant::PayloadExcludeSelector {
fields: exclude.clone(),
},
)),
},
}
}
pub(crate) fn to_vectors_selector(vs: &VectorSelectorReq) -> qdrant::WithVectorsSelector {
match vs {
VectorSelectorReq::All(b) => qdrant::WithVectorsSelector {
selector_options: Some(qdrant::with_vectors_selector::SelectorOptions::Enable(*b)),
},
VectorSelectorReq::Names(names) => qdrant::WithVectorsSelector {
selector_options: Some(qdrant::with_vectors_selector::SelectorOptions::Include(
qdrant::VectorsSelector {
names: names.clone(),
},
)),
},
}
}
pub(crate) fn to_search_params(
params: &qql_plan::types::SearchParamsRequest,
) -> qdrant::SearchParams {
use qql_plan::types::IdfSearchParams;
qdrant::SearchParams {
hnsw_ef: params.hnsw_ef,
exact: params.exact,
indexed_only: params.indexed_only,
quantization: params
.quantization
.as_ref()
.map(|q| qdrant::QuantizationSearchParams {
ignore: q.ignore,
rescore: q.rescore,
oversampling: q.oversampling,
}),
acorn: params.acorn.as_ref().map(|a| qdrant::AcornSearchParams {
enable: Some(a.enable),
max_selectivity: a.max_selectivity,
}),
idf: params.idf.as_ref().map(|idf| match idf {
IdfSearchParams::Global => qdrant::IdfParams { corpus: None },
IdfSearchParams::Corpus { corpus } => qdrant::IdfParams {
corpus: to_filter(corpus).ok(),
},
}),
}
}
pub(crate) fn plan_vector_to_proto(v: &PlanVectorValue) -> Result<qdrant::Vector, QqlError> {
use qdrant::vector::Vector as ProtoVector;
let vector = match v {
PlanVectorValue::Dense(data) => {
ProtoVector::Dense(qdrant::DenseVector { data: data.clone() })
}
PlanVectorValue::Sparse { indices, values } => ProtoVector::Sparse(qdrant::SparseVector {
indices: indices.clone(),
values: values.clone(),
}),
PlanVectorValue::MultiDense(rows) => ProtoVector::MultiDense(qdrant::MultiDenseVector {
vectors: rows
.iter()
.map(|row| qdrant::DenseVector { data: row.clone() })
.collect(),
}),
PlanVectorValue::Document {
text,
model,
options,
} => ProtoVector::Document(qdrant::Document {
text: text.clone(),
model: model.clone().unwrap_or_default(),
options: grpc_options(options),
}),
PlanVectorValue::Image {
image,
model,
options,
} => ProtoVector::Image(qdrant::Image {
image: Some(qdrant::Value {
kind: Some(qdrant::value::Kind::StringValue(image.clone())),
}),
model: model.clone().unwrap_or_default(),
options: grpc_options(options),
}),
PlanVectorValue::Object {
object,
model,
options,
} => ProtoVector::Object(qdrant::InferenceObject {
object: Some(super::values::to_qdrant_value(object.as_ref())),
model: model.clone().unwrap_or_default(),
options: grpc_options(options),
}),
PlanVectorValue::Param(name) => {
return Err(QqlError::validation(
"QQL-BIND-UNBOUND-PARAM",
format!(
"unbound named parameter ':{name}' reached gRPC plan_vector_to_proto (bind parameters before dispatch)"
),
None,
));
}
PlanVectorValue::PositionalParam(idx) => {
return Err(QqlError::validation(
"QQL-BIND-MISSING-POSITIONAL",
format!(
"missing positional parameter '?{}' reached gRPC plan_vector_to_proto (bind parameters before dispatch)",
idx + 1
),
None,
));
}
};
Ok(qdrant::Vector {
vector: Some(vector),
..Default::default()
})
}
pub(crate) fn to_vectors(vectors: &PlanPointVectors) -> Result<Option<qdrant::Vectors>, QqlError> {
match vectors {
PlanPointVectors::Unnamed(v) => Ok(Some(qdrant::Vectors {
vectors_options: Some(qdrant::vectors::VectorsOptions::Vector(
plan_vector_to_proto(v)?,
)),
})),
PlanPointVectors::Named(entries) => {
let mut map = std::collections::HashMap::with_capacity(entries.len());
for (name, v) in entries {
map.insert(name.clone(), plan_vector_to_proto(v)?);
}
Ok(Some(qdrant::Vectors {
vectors_options: Some(qdrant::vectors::VectorsOptions::Vectors(
qdrant::NamedVectors { vectors: map },
)),
}))
}
PlanPointVectors::Param(name) => Err(QqlError::validation(
"QQL-BIND-UNBOUND-PARAM",
format!(
"unbound named parameter ':{name}' reached gRPC to_vectors (bind parameters before dispatch)"
),
None,
)),
PlanPointVectors::PositionalParam(idx) => Err(QqlError::validation(
"QQL-BIND-MISSING-POSITIONAL",
format!(
"missing positional parameter '?{}' reached gRPC to_vectors (bind parameters before dispatch)",
idx + 1
),
None,
)),
}
}
pub(crate) fn points_and_filter_selector(
points: Option<&Vec<PlanPointId>>,
filter: Option<&FilterExpression>,
) -> Result<Option<qdrant::PointsSelector>, QqlError> {
if let Some(points) = points {
Ok(Some(qdrant::PointsSelector {
points_selector_one_of: Some(qdrant::points_selector::PointsSelectorOneOf::Points(
qdrant::PointsIdsList {
ids: points.iter().map(to_point_id).collect(),
},
)),
}))
} else if let Some(f) = filter {
Ok(Some(qdrant::PointsSelector {
points_selector_one_of: Some(qdrant::points_selector::PointsSelectorOneOf::Filter(
to_filter(f)?,
)),
}))
} else {
Ok(None)
}
}
pub(crate) fn to_get_points(
request: &qql_plan::types::PointsRequest,
collection: &str,
) -> qdrant::GetPoints {
qdrant::GetPoints {
collection_name: collection.to_owned(),
ids: request.ids.iter().map(to_point_id).collect(),
with_payload: request.with_payload.as_ref().map(to_payload_selector),
with_vectors: request.with_vector.as_ref().map(to_vectors_selector),
shard_key_selector: shard_key_selector(&request.shard_key),
..Default::default()
}
}
pub(crate) fn to_count_points(
request: &qql_plan::types::CountRequest,
collection: &str,
) -> Result<qdrant::CountPoints, QqlError> {
Ok(qdrant::CountPoints {
collection_name: collection.to_owned(),
filter: to_filter_opt(request.filter.as_ref())?,
exact: request.exact.or(Some(true)),
shard_key_selector: shard_key_selector(&request.shard_key),
..Default::default()
})
}
pub(crate) fn to_scroll_points(
request: &qql_plan::types::ScrollRequest,
collection: &str,
) -> Result<qdrant::ScrollPoints, QqlError> {
let limit = request
.limit
.map(|l| {
u32::try_from(l).map_err(|_| {
QqlError::validation(
"QQL-GRPC-SCROLL-LIMIT",
format!(
"scroll limit {l} cannot be represented on the gRPC path: the bundled Qdrant proto stores scroll limit as uint32 (max {})",
u32::MAX
),
None,
)
})
})
.transpose()?;
Ok(qdrant::ScrollPoints {
collection_name: collection.to_owned(),
filter: to_filter_opt(request.filter.as_ref())?,
offset: request.offset.as_ref().map(to_point_id),
limit,
with_payload: request.with_payload.as_ref().map(to_payload_selector),
with_vectors: request.with_vector.as_ref().map(to_vectors_selector),
shard_key_selector: shard_key_selector(&request.shard_key),
order_by: request.order_by.as_ref().map(to_order_by).transpose()?,
..Default::default()
})
}
pub(crate) fn to_facet_counts(
request: &qql_plan::types::FacetRequest,
collection: &str,
) -> Result<qdrant::FacetCounts, QqlError> {
Ok(qdrant::FacetCounts {
collection_name: collection.to_owned(),
key: request.key.clone(),
filter: to_filter_opt(request.filter.as_ref())?,
limit: request.limit,
exact: request.exact,
shard_key_selector: shard_key_selector(&request.shard_key),
..Default::default()
})
}