use qql_core::error::QqlError;
use qql_plan::types::{FilterExpression, FormulaDefault, PlanDecayKind, PlanFormula};
use crate::qdrant_grpc::qdrant;
use super::filter::{compound_to_filter, to_condition};
pub(crate) fn plan_formula_to_grpc(expr: &PlanFormula) -> Result<qdrant::Expression, QqlError> {
use qdrant::expression::Variant;
let variant = match expr {
PlanFormula::Constant(value) => Variant::Constant(*value as f32),
PlanFormula::Variable(name) => Variant::Variable(name.clone()),
PlanFormula::Sum { left, right } => Variant::Sum(qdrant::SumExpression {
sum: vec![plan_formula_to_grpc(left)?, plan_formula_to_grpc(right)?],
}),
PlanFormula::Sub { left, right } => Variant::Sum(qdrant::SumExpression {
sum: vec![
plan_formula_to_grpc(left)?,
qdrant::Expression {
variant: Some(Variant::Neg(Box::new(plan_formula_to_grpc(right)?))),
},
],
}),
PlanFormula::Mul { left, right } => Variant::Mult(qdrant::MultExpression {
mult: vec![plan_formula_to_grpc(left)?, plan_formula_to_grpc(right)?],
}),
PlanFormula::Div {
left,
right,
by_zero_default,
} => Variant::Div(Box::new(qdrant::DivExpression {
left: Some(Box::new(plan_formula_to_grpc(left)?)),
right: Some(Box::new(plan_formula_to_grpc(right)?)),
by_zero_default: by_zero_default.map(|value| value as f32),
})),
PlanFormula::Neg(operand) => Variant::Neg(Box::new(plan_formula_to_grpc(operand)?)),
PlanFormula::Abs(x) => Variant::Abs(Box::new(plan_formula_to_grpc(x)?)),
PlanFormula::Sqrt(x) => Variant::Sqrt(Box::new(plan_formula_to_grpc(x)?)),
PlanFormula::Log10(x) => Variant::Log10(Box::new(plan_formula_to_grpc(x)?)),
PlanFormula::Ln(x) => Variant::Ln(Box::new(plan_formula_to_grpc(x)?)),
PlanFormula::Exp(x) => Variant::Exp(Box::new(plan_formula_to_grpc(x)?)),
PlanFormula::Acosh(x) => Variant::Acosh(Box::new(plan_formula_to_grpc(x)?)),
PlanFormula::Max(args) => Variant::Max(qdrant::MaxExpression {
max: args
.iter()
.map(plan_formula_to_grpc)
.collect::<Result<Vec<_>, _>>()?,
}),
PlanFormula::Min(args) => Variant::Min(qdrant::MinExpression {
min: args
.iter()
.map(plan_formula_to_grpc)
.collect::<Result<Vec<_>, _>>()?,
}),
PlanFormula::Pow { base, exponent } => Variant::Pow(Box::new(qdrant::PowExpression {
base: Some(Box::new(plan_formula_to_grpc(base)?)),
exponent: Some(Box::new(plan_formula_to_grpc(exponent)?)),
})),
PlanFormula::GeoDistance { lat, lon, field } => Variant::GeoDistance(qdrant::GeoDistance {
origin: Some(qdrant::GeoPoint {
lat: *lat,
lon: *lon,
}),
to: field.clone(),
}),
PlanFormula::Decay {
kind,
x,
target,
scale,
midpoint,
} => {
let decay = Box::new(qdrant::DecayParamsExpression {
x: Some(Box::new(plan_formula_to_grpc(x)?)),
target: target
.as_ref()
.map(|target| plan_formula_to_grpc(target).map(Box::new))
.transpose()?,
scale: scale.map(|value| value as f32),
midpoint: midpoint.map(|value| value as f32),
});
match kind {
PlanDecayKind::Exp => Variant::ExpDecay(decay),
PlanDecayKind::Lin => Variant::LinDecay(decay),
PlanDecayKind::Gauss => Variant::GaussDecay(decay),
}
}
PlanFormula::Condition(filter) => Variant::Condition(condition_to_grpc(filter)?),
PlanFormula::Case { cond, then_, else_ } => {
let condition = plan_formula_to_grpc(cond)?;
let one_minus = qdrant::Expression {
variant: Some(Variant::Sum(qdrant::SumExpression {
sum: vec![
qdrant::Expression {
variant: Some(Variant::Constant(1.0)),
},
qdrant::Expression {
variant: Some(Variant::Neg(Box::new(condition.clone()))),
},
],
})),
};
Variant::Sum(qdrant::SumExpression {
sum: vec![
qdrant::Expression {
variant: Some(Variant::Mult(qdrant::MultExpression {
mult: vec![condition, plan_formula_to_grpc(then_)?],
})),
},
qdrant::Expression {
variant: Some(Variant::Mult(qdrant::MultExpression {
mult: vec![one_minus, plan_formula_to_grpc(else_)?],
})),
},
],
})
}
PlanFormula::Datetime(value) => Variant::Datetime(value.clone()),
PlanFormula::DatetimeKey(key) => Variant::DatetimeKey(key.clone()),
};
Ok(qdrant::Expression {
variant: Some(variant),
})
}
fn condition_to_grpc(filter: &FilterExpression) -> Result<qdrant::Condition, QqlError> {
match filter {
FilterExpression::Single(clause) => to_condition(clause),
FilterExpression::Compound(compound) => Ok(qdrant::Condition {
condition_one_of: Some(qdrant::condition::ConditionOneOf::Filter(
compound_to_filter(compound)?,
)),
}),
}
}
pub(crate) fn formula_default_to_grpc(value: &FormulaDefault) -> qdrant::Value {
use qdrant::value::Kind;
let kind = match value {
FormulaDefault::Null => None,
FormulaDefault::Bool(value) => Some(Kind::BoolValue(*value)),
FormulaDefault::Int(value) => Some(Kind::IntegerValue(*value)),
FormulaDefault::Float(value) => Some(Kind::DoubleValue(*value)),
FormulaDefault::String(value) => Some(Kind::StringValue(value.clone())),
FormulaDefault::List(values) => Some(Kind::ListValue(qdrant::ListValue {
values: values.iter().map(formula_default_to_grpc).collect(),
})),
FormulaDefault::Object(entries) => Some(Kind::StructValue(qdrant::Struct {
fields: entries
.iter()
.map(|(key, value)| (key.clone(), formula_default_to_grpc(value)))
.collect(),
})),
};
qdrant::Value { kind }
}