use alloc::collections::BTreeMap;
use alloc::string::String;
use alloc::vec::Vec;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum PlanPointId {
Number(u64),
String(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum PlanShardKey {
Keyword(String),
Number(u64),
}
impl PlanShardKey {
pub fn as_keyword(&self) -> Option<&str> {
match self {
Self::Keyword(s) => Some(s.as_str()),
Self::Number(_) => None,
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum PlanVectorValue {
Dense(Vec<f32>),
Sparse {
indices: Vec<u32>,
values: Vec<f32>,
},
MultiDense(Vec<Vec<f32>>),
Document {
text: String,
model: Option<String>,
options: Option<Vec<(String, qql_core::ast::Value)>>,
},
Image {
image: String,
model: Option<String>,
options: Option<Vec<(String, qql_core::ast::Value)>>,
},
Object {
object: alloc::boxed::Box<qql_core::ast::Value>,
model: Option<String>,
options: Option<Vec<(String, qql_core::ast::Value)>>,
},
Param(String),
PositionalParam(usize),
}
#[derive(Debug, Clone, PartialEq)]
pub enum PlanVectorStruct {
Single(PlanVectorValue),
Named(BTreeMap<String, PlanVectorValue>),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PlanFacetValue {
Keyword(String),
Integer(i64),
Bool(bool),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PlanGroupId {
Keyword(String),
Unsigned(u64),
Signed(i64),
}
#[derive(Debug, Clone, PartialEq)]
pub enum PlanQueryInput {
Point(PlanPointId),
Vector(PlanVectorValue),
Document {
text: String,
model: Option<String>,
options: Option<Vec<(String, qql_core::ast::Value)>>,
},
Image {
image: String,
model: Option<String>,
options: Option<Vec<(String, qql_core::ast::Value)>>,
},
Object {
object: alloc::boxed::Box<qql_core::ast::Value>,
model: Option<String>,
options: Option<Vec<(String, qql_core::ast::Value)>>,
},
}
#[derive(Debug, Clone, PartialEq)]
pub enum PlanPointVectors {
Unnamed(PlanVectorValue),
Named(Vec<(String, PlanVectorValue)>),
Param(String),
PositionalParam(usize),
}
#[cfg(test)]
mod tests {
use super::*;
use qql_core::ast::Value;
fn dict(pairs: Vec<(&str, Value)>) -> Value {
Value::Dict(pairs.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
}
#[test]
fn from_value_dense_float_list_and_f32array_lower_identically() {
let floats: Vec<Value> = (0..384).map(|i| Value::Float(i as f64 * 0.001)).collect();
let packed: Vec<f32> = (0..384).map(|i| (i as f64 * 0.001) as f32).collect();
assert_eq!(
PlanVectorValue::from_value(&Value::List(floats)),
PlanVectorValue::from_value(&Value::F32Array(packed.clone()))
);
assert_eq!(
PlanVectorValue::from_value(&Value::F32Array(packed.clone())),
Some(PlanVectorValue::Dense(packed))
);
}
#[test]
fn from_value_flat_multivector_chunks() {
let v = dict(vec![
(
"data",
Value::List(vec![
Value::Float(0.1),
Value::Float(0.2),
Value::Float(0.3),
Value::Float(0.4),
]),
),
("dim", Value::Int(2)),
]);
assert_eq!(
PlanVectorValue::from_value(&v),
Some(PlanVectorValue::MultiDense(vec![
vec![0.1, 0.2],
vec![0.3, 0.4]
]))
);
let v = dict(vec![
("data", Value::F32Array(vec![0.1, 0.2])),
("dim", Value::Int(2)),
]);
assert_eq!(
PlanVectorValue::from_value(&v),
Some(PlanVectorValue::MultiDense(vec![vec![0.1, 0.2]]))
);
let nested = Value::List(vec![
Value::List(vec![Value::Float(0.1), Value::Float(0.2)]),
Value::List(vec![Value::Float(0.3), Value::Float(0.4)]),
]);
let flat2 = dict(vec![
(
"data",
Value::List(vec![
Value::Float(0.1),
Value::Float(0.2),
Value::Float(0.3),
Value::Float(0.4),
]),
),
("dim", Value::Int(2)),
]);
assert_eq!(
PlanVectorValue::from_value(&nested),
PlanVectorValue::from_value(&flat2)
);
}
#[test]
fn from_value_flat_multivector_rejects_bad_shapes() {
assert_eq!(
PlanVectorValue::from_value(&dict(vec![("data", Value::List(vec![]))])),
None
);
assert_eq!(
PlanVectorValue::from_value(&dict(vec![
("data", Value::List(vec![Value::Float(0.1)])),
("dim", Value::Int(2)),
])),
None
);
assert_eq!(
PlanVectorValue::from_value(&dict(vec![
("data", Value::List(vec![Value::Float(0.1)])),
("dim", Value::Int(0)),
])),
None
);
assert_eq!(
PlanVectorValue::from_value(&dict(vec![
("data", Value::List(vec![Value::Float(0.1)])),
("dim", Value::Int(1)),
("indices", Value::List(vec![Value::Int(0)])),
])),
None
);
}
#[test]
fn from_value_sparse_accepts_f32array_values() {
let v = dict(vec![
("indices", Value::List(vec![Value::Int(1), Value::Int(5)])),
("values", Value::F32Array(vec![0.5, 0.8])),
]);
assert_eq!(
PlanVectorValue::from_value(&v),
Some(PlanVectorValue::Sparse {
indices: vec![1, 5],
values: vec![0.5, 0.8]
})
);
}
#[test]
fn vector_struct_round_trips_every_output_shape() {
for (json, typed) in [
(
serde_json::json!([0.5, 0.25]),
PlanVectorStruct::Single(PlanVectorValue::Dense(vec![0.5, 0.25])),
),
(
serde_json::json!([[0.5, 0.25], [0.125, 0.0]]),
PlanVectorStruct::Single(PlanVectorValue::MultiDense(vec![
vec![0.5, 0.25],
vec![0.125, 0.0],
])),
),
(
serde_json::json!({"indices": [1, 5], "values": [0.5, 0.75]}),
PlanVectorStruct::Single(PlanVectorValue::Sparse {
indices: vec![1, 5],
values: vec![0.5, 0.75],
}),
),
(
serde_json::json!({
"dense": [0.5, 0.25],
"sparse": {"indices": [2], "values": [0.5]},
}),
PlanVectorStruct::Named(BTreeMap::from([
("dense".to_string(), PlanVectorValue::Dense(vec![0.5, 0.25])),
(
"sparse".to_string(),
PlanVectorValue::Sparse {
indices: vec![2],
values: vec![0.5],
},
),
])),
),
] {
let parsed: PlanVectorStruct = serde_json::from_value(json.clone()).unwrap();
assert_eq!(parsed, typed, "parse {json}");
assert_eq!(serde_json::to_value(&typed).unwrap(), json, "serialize");
}
}
#[test]
fn vector_struct_rejects_unmodelled_shapes() {
assert!(
serde_json::from_value::<PlanVectorStruct>(
serde_json::json!({"text": "hello", "model": "m"})
)
.is_err()
);
assert!(serde_json::from_value::<PlanVectorStruct>(serde_json::json!(null)).is_err());
assert!(serde_json::from_value::<PlanVectorStruct>(serde_json::json!("dense")).is_err());
}
#[test]
fn facet_and_group_values_serialize_untagged() {
assert_eq!(
serde_json::to_value(PlanFacetValue::Keyword("books".into())).unwrap(),
serde_json::json!("books")
);
assert_eq!(
serde_json::to_value(PlanFacetValue::Integer(-3)).unwrap(),
serde_json::json!(-3)
);
assert_eq!(
serde_json::to_value(PlanFacetValue::Bool(true)).unwrap(),
serde_json::json!(true)
);
assert_eq!(
serde_json::from_value::<PlanFacetValue>(serde_json::json!(7)).unwrap(),
PlanFacetValue::Integer(7)
);
for (json, typed) in [
(serde_json::json!("a"), PlanGroupId::Keyword("a".into())),
(serde_json::json!(7), PlanGroupId::Unsigned(7)),
(serde_json::json!(-3), PlanGroupId::Signed(-3)),
] {
let parsed: PlanGroupId = serde_json::from_value(json.clone()).unwrap();
assert_eq!(parsed, typed);
assert_eq!(serde_json::to_value(&typed).unwrap(), json);
}
}
}