use alloc::collections::BTreeMap;
use alloc::string::String;
use alloc::vec::Vec;
use serde::ser::{SerializeMap, SerializeSeq};
use serde::{Deserialize, Serialize, Serializer};
use crate::semantic::{
PlanPointId, PlanPointVectors, PlanQueryInput, PlanShardKey, PlanVectorStruct, PlanVectorValue,
};
impl core::fmt::Display for PlanPointId {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
PlanPointId::Number(n) => write!(f, "{n}"),
PlanPointId::String(s) => write!(f, "{s}"),
}
}
}
impl From<&qql_core::ast::PointId> for PlanPointId {
fn from(id: &qql_core::ast::PointId) -> Self {
match id {
qql_core::ast::PointId::Number(n) => PlanPointId::Number(*n),
qql_core::ast::PointId::String(s) => PlanPointId::String(s.clone()),
qql_core::ast::PointId::Param(name, _) => {
panic!("invariant violation: unbound parameter :{name} reached PlanPointId");
}
qql_core::ast::PointId::PositionalParam(idx, _) => {
panic!(
"invariant violation: unbound positional parameter ?{idx} reached PlanPointId"
);
}
}
}
}
impl Serialize for PlanPointId {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
PlanPointId::Number(n) => serializer.serialize_u64(*n),
PlanPointId::String(s) => serializer.serialize_str(s),
}
}
}
impl<'de> serde::Deserialize<'de> for PlanPointId {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[derive(serde::Deserialize)]
#[serde(untagged)]
enum Wire {
Number(u64),
String(String),
}
Ok(match Wire::deserialize(deserializer)? {
Wire::Number(n) => PlanPointId::Number(n),
Wire::String(s) => PlanPointId::String(s),
})
}
}
impl core::fmt::Display for PlanShardKey {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::Keyword(s) => write!(f, "{s}"),
Self::Number(n) => write!(f, "{n}"),
}
}
}
impl From<&qql_core::ast::ShardKey> for PlanShardKey {
fn from(key: &qql_core::ast::ShardKey) -> Self {
match key {
qql_core::ast::ShardKey::Keyword(s) => Self::Keyword(s.clone()),
qql_core::ast::ShardKey::Number(n) => Self::Number(*n),
qql_core::ast::ShardKey::Param(name, _) => {
panic!("invariant violation: unbound parameter :{name} reached PlanShardKey");
}
qql_core::ast::ShardKey::PositionalParam(idx, _) => {
panic!(
"invariant violation: unbound positional parameter ?{idx} reached PlanShardKey"
);
}
}
}
}
impl Serialize for PlanShardKey {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Number(n) => serializer.serialize_u64(*n),
Self::Keyword(s) => serializer.serialize_str(s),
}
}
}
impl<'de> serde::Deserialize<'de> for PlanShardKey {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[derive(serde::Deserialize)]
#[serde(untagged)]
enum Wire {
Number(u64),
String(String),
}
Ok(match Wire::deserialize(deserializer)? {
Wire::Number(n) => Self::Number(n),
Wire::String(s) => Self::Keyword(s),
})
}
}
impl From<&qql_core::ast::VectorValue> for PlanVectorValue {
fn from(v: &qql_core::ast::VectorValue) -> Self {
match v {
qql_core::ast::VectorValue::Dense(d) => PlanVectorValue::Dense(d.clone()),
qql_core::ast::VectorValue::Sparse { indices, values } => PlanVectorValue::Sparse {
indices: indices.clone(),
values: values.clone(),
},
qql_core::ast::VectorValue::MultiDense(rows) => {
PlanVectorValue::MultiDense(rows.clone())
}
qql_core::ast::VectorValue::Document {
text,
model,
options,
} => PlanVectorValue::Document {
text: text.clone(),
model: model.clone(),
options: plan_options(options),
},
qql_core::ast::VectorValue::Image {
source,
model,
options,
} => PlanVectorValue::Image {
image: source.clone(),
model: model.clone(),
options: plan_options(options),
},
qql_core::ast::VectorValue::Object {
object,
model,
options,
} => PlanVectorValue::Object {
object: object.clone(),
model: model.clone(),
options: plan_options(options),
},
qql_core::ast::VectorValue::Param(name, _) => PlanVectorValue::Param(name.clone()),
qql_core::ast::VectorValue::PositionalParam(idx, _) => {
PlanVectorValue::PositionalParam(*idx)
}
}
}
}
impl PlanVectorValue {
pub fn from_value(val: &qql_core::ast::Value) -> Option<Self> {
match val {
qql_core::ast::Value::F32Array(v) => Some(PlanVectorValue::Dense(v.clone())),
qql_core::ast::Value::List(items) => {
if items.is_empty() {
return Some(PlanVectorValue::Dense(Vec::new()));
}
if let qql_core::ast::Value::List(_) = &items[0] {
let mut rows = Vec::with_capacity(items.len());
for item in items {
if let qql_core::ast::Value::List(sub) = item {
let mut row = Vec::with_capacity(sub.len());
for f in sub {
match f {
qql_core::ast::Value::Float(x) => row.push(*x as f32),
qql_core::ast::Value::Int(i) => row.push(*i as f32),
_ => return None,
}
}
rows.push(row);
} else {
return None;
}
}
Some(PlanVectorValue::MultiDense(rows))
} else {
let mut dense = Vec::with_capacity(items.len());
for item in items {
match item {
qql_core::ast::Value::Float(x) => dense.push(*x as f32),
qql_core::ast::Value::Int(i) => dense.push(*i as f32),
_ => return None,
}
}
Some(PlanVectorValue::Dense(dense))
}
}
qql_core::ast::Value::Dict(entries) => {
let mut has_data = false;
let mut has_dim = false;
let mut has_indices = false;
let mut has_values = false;
for (k, _) in entries {
if k.eq_ignore_ascii_case("data") {
has_data = true;
} else if k.eq_ignore_ascii_case("dim") {
has_dim = true;
} else if k.eq_ignore_ascii_case("indices") {
has_indices = true;
} else if k.eq_ignore_ascii_case("values") {
has_values = true;
}
}
if has_data || has_dim {
if has_indices || has_values {
return None;
}
let mut flat: Option<Vec<f32>> = None;
let mut dim: Option<usize> = None;
for (k, v) in entries {
if k.eq_ignore_ascii_case("data") {
flat = match v {
qql_core::ast::Value::F32Array(items) => Some(items.clone()),
qql_core::ast::Value::List(items) => {
let mut out = Vec::with_capacity(items.len());
for item in items {
match item {
qql_core::ast::Value::Float(x) => out.push(*x as f32),
qql_core::ast::Value::Int(i) => out.push(*i as f32),
_ => return None,
}
}
Some(out)
}
_ => return None,
};
} else if k.eq_ignore_ascii_case("dim") {
match v {
qql_core::ast::Value::Int(n) if *n > 0 => {
dim = usize::try_from(*n).ok();
}
_ => return None,
}
} else {
return None;
}
}
let (flat, dim) = match (flat, dim) {
(Some(flat), Some(dim)) => (flat, dim),
_ => return None,
};
if flat.is_empty() || dim == 0 || flat.len() % dim != 0 {
return None;
}
return Some(PlanVectorValue::MultiDense(
flat.chunks_exact(dim).map(<[f32]>::to_vec).collect(),
));
}
let mut indices = None;
let mut values = None;
for (k, v) in entries {
if k == "indices"
&& let qql_core::ast::Value::List(idx_list) = v
{
let mut idxs = Vec::with_capacity(idx_list.len());
for idx in idx_list {
if let qql_core::ast::Value::Int(i) = idx {
idxs.push(*i as u32);
} else {
return None;
}
}
indices = Some(idxs);
} else if k == "values" {
match v {
qql_core::ast::Value::F32Array(items) => {
values = Some(items.clone());
}
qql_core::ast::Value::List(val_list) => {
let mut vals = Vec::with_capacity(val_list.len());
for val in val_list {
match val {
qql_core::ast::Value::Float(x) => vals.push(*x as f32),
qql_core::ast::Value::Int(i) => vals.push(*i as f32),
_ => return None,
}
}
values = Some(vals);
}
_ => return None,
}
}
}
if let (Some(indices), Some(values)) = (indices, values) {
Some(PlanVectorValue::Sparse { indices, values })
} else {
None
}
}
_ => None,
}
}
}
struct F64Elems<'a>(&'a [f32]);
impl Serialize for F64Elems<'_> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut seq = serializer.serialize_seq(Some(self.0.len()))?;
for v in self.0 {
seq.serialize_element(&(*v as f64))?;
}
seq.end()
}
}
impl Serialize for PlanVectorValue {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
PlanVectorValue::Dense(values) => F64Elems(values).serialize(serializer),
PlanVectorValue::Sparse { indices, values } => {
let mut map = serializer.serialize_map(Some(2))?;
map.serialize_entry("indices", indices)?;
map.serialize_entry("values", values)?;
map.end()
}
PlanVectorValue::MultiDense(rows) => {
let mut seq = serializer.serialize_seq(Some(rows.len()))?;
for row in rows {
seq.serialize_element(&F64Elems(row))?;
}
seq.end()
}
PlanVectorValue::Document {
text,
model,
options,
} => {
let mut map = serializer.serialize_map(Some(2 + usize::from(options.is_some())))?;
map.serialize_entry("text", text)?;
map.serialize_entry("model", &model.as_deref().unwrap_or(""))?;
if let Some(options) = options {
map.serialize_entry("options", &crate::value_serde::SerPairs(options))?;
}
map.end()
}
PlanVectorValue::Image {
image,
model,
options,
} => {
let mut map = serializer.serialize_map(Some(2 + usize::from(options.is_some())))?;
map.serialize_entry("image", image)?;
map.serialize_entry("model", &model.as_deref().unwrap_or(""))?;
if let Some(options) = options {
map.serialize_entry("options", &crate::value_serde::SerPairs(options))?;
}
map.end()
}
PlanVectorValue::Object {
object,
model,
options,
} => {
let mut map = serializer.serialize_map(Some(2 + usize::from(options.is_some())))?;
map.serialize_entry("object", &crate::value_serde::SerValueBox(object))?;
map.serialize_entry("model", &model.as_deref().unwrap_or(""))?;
if let Some(options) = options {
map.serialize_entry("options", &crate::value_serde::SerPairs(options))?;
}
map.end()
}
PlanVectorValue::Param(name) => serializer.serialize_str(&format!(":{name}")),
PlanVectorValue::PositionalParam(idx) => serializer.serialize_str(&format!("?{idx}")),
}
}
}
impl Serialize for PlanVectorStruct {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
PlanVectorStruct::Single(value) => value.serialize(serializer),
PlanVectorStruct::Named(vectors) => {
let mut map = serializer.serialize_map(Some(vectors.len()))?;
for (name, value) in vectors {
map.serialize_entry(name, value)?;
}
map.end()
}
}
}
}
impl<'de> Deserialize<'de> for PlanVectorStruct {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(untagged)]
enum ValueWire {
Dense(Vec<f32>),
MultiDense(Vec<Vec<f32>>),
Sparse { indices: Vec<u32>, values: Vec<f32> },
}
impl ValueWire {
fn into_value(self) -> PlanVectorValue {
match self {
ValueWire::Dense(values) => PlanVectorValue::Dense(values),
ValueWire::MultiDense(rows) => PlanVectorValue::MultiDense(rows),
ValueWire::Sparse { indices, values } => {
PlanVectorValue::Sparse { indices, values }
}
}
}
}
#[derive(Deserialize)]
#[serde(untagged)]
enum Wire {
Dense(Vec<f32>),
MultiDense(Vec<Vec<f32>>),
Sparse { indices: Vec<u32>, values: Vec<f32> },
Named(BTreeMap<String, ValueWire>),
}
Ok(match Wire::deserialize(deserializer)? {
Wire::Dense(values) => PlanVectorStruct::Single(PlanVectorValue::Dense(values)),
Wire::MultiDense(rows) => PlanVectorStruct::Single(PlanVectorValue::MultiDense(rows)),
Wire::Sparse { indices, values } => {
PlanVectorStruct::Single(PlanVectorValue::Sparse { indices, values })
}
Wire::Named(vectors) => PlanVectorStruct::Named(
vectors
.into_iter()
.map(|(name, value)| (name, value.into_value()))
.collect(),
),
})
}
}
impl From<&qql_core::ast::QueryInput> for PlanQueryInput {
fn from(input: &qql_core::ast::QueryInput) -> Self {
match input {
qql_core::ast::QueryInput::Point(id) => PlanQueryInput::Point(PlanPointId::from(id)),
qql_core::ast::QueryInput::Vector(v) => {
PlanQueryInput::Vector(PlanVectorValue::from(v))
}
qql_core::ast::QueryInput::Text {
text,
model,
options,
..
} => PlanQueryInput::Document {
text: text.clone(),
model: model.clone(),
options: plan_options(options),
},
qql_core::ast::QueryInput::Image {
source,
model,
options,
} => PlanQueryInput::Image {
image: source.clone(),
model: model.clone(),
options: plan_options(options),
},
qql_core::ast::QueryInput::Object {
object,
model,
options,
} => PlanQueryInput::Object {
object: object.clone(),
model: model.clone(),
options: plan_options(options),
},
qql_core::ast::QueryInput::Param(name, _) => {
PlanQueryInput::Vector(PlanVectorValue::Param(name.clone()))
}
qql_core::ast::QueryInput::PositionalParam(idx, _) => {
PlanQueryInput::Vector(PlanVectorValue::PositionalParam(*idx))
}
}
}
}
fn plan_options(
options: &[(alloc::string::String, qql_core::ast::Value)],
) -> Option<alloc::vec::Vec<(alloc::string::String, qql_core::ast::Value)>> {
if options.is_empty() {
return None;
}
Some(options.to_vec())
}
impl Serialize for PlanQueryInput {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
PlanQueryInput::Point(id) => id.serialize(serializer),
PlanQueryInput::Vector(v) => v.serialize(serializer),
PlanQueryInput::Document {
text,
model,
options,
} => {
let mut map = serializer.serialize_map(Some(2 + usize::from(options.is_some())))?;
map.serialize_entry("text", text)?;
map.serialize_entry("model", &model.as_deref().unwrap_or(""))?;
if let Some(options) = options {
map.serialize_entry("options", &crate::value_serde::SerPairs(options))?;
}
map.end()
}
PlanQueryInput::Image {
image,
model,
options,
} => {
let mut map = serializer.serialize_map(Some(2 + usize::from(options.is_some())))?;
map.serialize_entry("image", image)?;
map.serialize_entry("model", &model.as_deref().unwrap_or(""))?;
if let Some(options) = options {
map.serialize_entry("options", &crate::value_serde::SerPairs(options))?;
}
map.end()
}
PlanQueryInput::Object {
object,
model,
options,
} => {
let mut map = serializer.serialize_map(Some(2 + usize::from(options.is_some())))?;
map.serialize_entry("object", &crate::value_serde::SerValueBox(object))?;
map.serialize_entry("model", &model.as_deref().unwrap_or(""))?;
if let Some(options) = options {
map.serialize_entry("options", &crate::value_serde::SerPairs(options))?;
}
map.end()
}
}
}
}
impl From<&qql_core::ast::PointVectors> for PlanPointVectors {
fn from(v: &qql_core::ast::PointVectors) -> Self {
match v {
qql_core::ast::PointVectors::Unnamed(vv) => {
PlanPointVectors::Unnamed(PlanVectorValue::from(vv))
}
qql_core::ast::PointVectors::Named(entries) => PlanPointVectors::Named(
entries
.iter()
.map(|(n, vv)| (n.clone(), PlanVectorValue::from(vv)))
.collect(),
),
qql_core::ast::PointVectors::Param(name, _) => PlanPointVectors::Param(name.clone()),
qql_core::ast::PointVectors::PositionalParam(idx, _) => {
PlanPointVectors::PositionalParam(*idx)
}
}
}
}
impl Serialize for PlanPointVectors {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
PlanPointVectors::Unnamed(v) => v.serialize(serializer),
PlanPointVectors::Named(entries) => {
let mut map = serializer.serialize_map(Some(entries.len()))?;
for (name, value) in entries {
map.serialize_entry(name, value)?;
}
map.end()
}
PlanPointVectors::Param(name) => serializer.serialize_str(&format!(":{name}")),
PlanPointVectors::PositionalParam(idx) => serializer.serialize_str(&format!("?{idx}")),
}
}
}