use serde::{
Deserialize,
Deserializer,
Serialize,
Serializer,
de,
};
use serde_json::{
Map,
Value,
};
use crate::{
data::catalog::{
document::EntryKind,
error::{
CatalogErrorExt,
CatalogRule,
catalog_error,
},
select::{
run::CompiledQuery,
state::SelectEnv,
},
},
errors::{
BunsenError,
BunsenResult,
},
};
pub(crate) fn query_error(message: impl Into<String>) -> BunsenError {
catalog_error(CatalogRule::Selection, message)
}
pub const DEFAULT_FLOOR: f64 = 1e-9;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SelectQuery {
pub kind: EntryKind,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub floor: Option<f64>,
#[serde(default)]
pub run: Vec<LabeledStage>,
}
impl SelectQuery {
pub fn new(
kind: EntryKind,
run: Vec<Stage>,
) -> Self {
Self {
kind,
floor: None,
run: run.into_iter().map(LabeledStage::from).collect(),
}
}
pub fn from_value(value: &Value) -> BunsenResult<Self> {
let query: Self = serde_json::from_value(value.clone())
.map_err(|e| query_error(format!("a query: {e}")))?;
if let Some(floor) = query.floor
&& !(floor.is_finite() && floor >= 0.0)
{
return Err(query_error(format!(
"`floor` is a weight, 0 or more, not {floor}"
)));
}
Ok(query)
}
pub fn from_yaml(yaml: &str) -> BunsenResult<Self> {
let value: Value = serde_saphyr::from_str(yaml)
.map_err(|e| query_error(format!("a query is YAML: {e}")))?;
Self::from_value(&value)
}
pub fn floor(&self) -> f64 {
self.floor.unwrap_or(DEFAULT_FLOOR)
}
pub fn compile(
&self,
env: &SelectEnv<'_>,
) -> BunsenResult<CompiledQuery> {
CompiledQuery::compile(self, env)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case", deny_unknown_fields)]
pub enum Stage {
From(NameList),
Keep(Predicate),
Drop(Predicate),
Weigh(WeighBlock),
Order(SortKeys),
Limit(usize),
Per(PerStage),
Use(String),
Unset(String),
}
impl Stage {
pub fn op(&self) -> &'static str {
match self {
Self::From(_) => "from",
Self::Keep(_) => "keep",
Self::Drop(_) => "drop",
Self::Weigh(_) => "weigh",
Self::Order(_) => "order",
Self::Limit(_) => "limit",
Self::Per(_) => "per",
Self::Use(_) => "use",
Self::Unset(_) => "unset",
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct LabeledStage {
pub stage: Stage,
pub label: Option<String>,
}
impl From<Stage> for LabeledStage {
fn from(stage: Stage) -> Self {
Self { stage, label: None }
}
}
impl Serialize for LabeledStage {
fn serialize<S: Serializer>(
&self,
serializer: S,
) -> Result<S::Ok, S::Error> {
let mut value = serde_json::to_value(&self.stage).map_err(serde::ser::Error::custom)?;
if let (Some(label), Value::Object(map)) = (&self.label, &mut value) {
map.insert("as".to_string(), Value::String(label.clone()));
}
value.serialize(serializer)
}
}
impl<'de> Deserialize<'de> for LabeledStage {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let mut value = Value::deserialize(deserializer)?;
let label = match &mut value {
Value::Object(map) => match map.remove("as") {
None => None,
Some(Value::String(label)) => Some(label),
Some(other) => {
return Err(de::Error::custom(format!(
"a stage's label `as` is a string, not {other}"
)));
}
},
_ => None,
};
let stage = serde_json::from_value(value).map_err(de::Error::custom)?;
Ok(Self { stage, label })
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PerStage {
pub group: PerGroup,
#[serde(default)]
pub run: Vec<LabeledStage>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PerGroup {
Facet(String),
Names(Vec<String>),
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct WeighBlock {
#[serde(default)]
pub by: Vec<WeighEntry>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub floor: Option<f64>,
}
#[derive(Clone, Debug, PartialEq)]
pub enum WeighEntry {
When {
when: Predicate,
then: f64,
otherwise: f64,
},
Match {
tag: String,
language: String,
truncated: f64,
otherwise: f64,
},
Release {
step: f64,
min: f64,
},
Mul(f64),
Add(f64),
Clip(f64, f64),
}
pub const RELEASE_STEP: f64 = 0.05;
impl WeighEntry {
pub fn multiplies(&self) -> bool {
!matches!(self, Self::Add(_) | Self::Clip(..))
}
fn from_value(value: &Value) -> BunsenResult<Self> {
let Value::Object(fields) = value else {
return Err(query_error(format!("a `by` entry is a map, not {value}")));
};
let number = |key: &str, default: f64| -> BunsenResult<f64> {
match fields.get(key) {
None => Ok(default),
Some(v) => v
.as_f64()
.filter(|n| n.is_finite())
.ok_or_else(|| query_error(format!("`{key}` is a number, not {v}"))),
}
};
let only = |allowed: &[&str]| -> BunsenResult<()> {
match fields.keys().find(|k| !allowed.contains(&k.as_str())) {
Some(k) => Err(query_error(format!(
"this `by` entry takes {allowed:?}, not `{k}`"
))),
None => Ok(()),
}
};
if let Some(when) = fields.get("when") {
only(&["when", "then", "else"])?;
return Ok(Self::When {
when: Predicate::from_value(when)?,
then: number("then", 1.0)?,
otherwise: number("else", 0.0)?,
});
}
if let Some(matched) = fields.get("match") {
only(&["match", "truncated", "else"])?;
let (tag, language) = match matched {
Value::Object(m) if m.len() == 1 => {
let (tag, language) = m.iter().next().expect("one");
let language = language.as_str().ok_or_else(|| {
query_error(format!("`match.{tag}` is a language, not {language}"))
})?;
(tag.clone(), language.to_string())
}
other => {
return Err(query_error(format!(
"`match` is `{{TAG: LANGUAGE}}`, not {other}"
)));
}
};
return Ok(Self::Match {
tag,
language,
truncated: number("truncated", 1.0)?,
otherwise: number("else", 0.0)?,
});
}
if let Some(release) = fields.get("release") {
only(&["release", "step", "min"])?;
if release.as_str() != Some("latest") {
return Err(query_error(format!("`release` is `latest`, not {release}")));
}
let step = number("step", RELEASE_STEP)?;
let min = number("min", 0.0)?;
if step < 0.0 || min < 0.0 {
return Err(query_error("`release`'s `step` and `min` are 0 or more"));
}
return Ok(Self::Release { step, min });
}
if fields.contains_key("mul") {
only(&["mul"])?;
return Ok(Self::Mul(number("mul", 1.0)?));
}
if fields.contains_key("add") {
only(&["add"])?;
return Ok(Self::Add(number("add", 0.0)?));
}
if let Some(clip) = fields.get("clip") {
only(&["clip"])?;
let bounds: Option<Vec<f64>> = clip
.as_array()
.map(|items| items.iter().filter_map(Value::as_f64).collect());
return match bounds.as_deref() {
Some([a, b]) if a <= b && a.is_finite() && b.is_finite() => Ok(Self::Clip(*a, *b)),
_ => Err(query_error(format!(
"`clip` is `[a, b]`, with `a` at most `b`, not {clip}"
))),
};
}
Err(query_error(format!(
"a `by` entry is `when`, `match`, `release`, `mul`, `add` or `clip`, not {}",
flow(value)
)))
}
fn to_value(&self) -> Value {
let mut map = Map::new();
let mut put = |k: &str, v: Value| {
map.insert(k.to_string(), v);
};
match self {
Self::When {
when,
then,
otherwise,
} => {
put("when", when.to_value());
put("then", (*then).into());
put("else", (*otherwise).into());
}
Self::Match {
tag,
language,
truncated,
otherwise,
} => {
put("match", single(tag, Value::String(language.clone())));
put("truncated", (*truncated).into());
put("else", (*otherwise).into());
}
Self::Release { step, min } => {
put("release", "latest".into());
put("step", (*step).into());
put("min", (*min).into());
}
Self::Mul(k) => put("mul", (*k).into()),
Self::Add(k) => put("add", (*k).into()),
Self::Clip(a, b) => put("clip", vec![*a, *b].into()),
}
Value::Object(map)
}
}
impl Serialize for WeighEntry {
fn serialize<S: Serializer>(
&self,
serializer: S,
) -> Result<S::Ok, S::Error> {
self.to_value().serialize(serializer)
}
}
impl<'de> Deserialize<'de> for WeighEntry {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = Value::deserialize(deserializer)?;
Self::from_value(&value).map_err(|e| de::Error::custom(e.problem_message()))
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct NameList(pub Vec<String>);
impl Serialize for NameList {
fn serialize<S: Serializer>(
&self,
serializer: S,
) -> Result<S::Ok, S::Error> {
match self.0.as_slice() {
[one] => serializer.serialize_str(one),
many => many.serialize(serializer),
}
}
}
impl<'de> Deserialize<'de> for NameList {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
#[derive(Deserialize)]
#[serde(untagged)]
enum OneOrMany {
One(String),
Many(Vec<String>),
}
Ok(match OneOrMany::deserialize(deserializer)? {
OneOrMany::One(one) => NameList(vec![one]),
OneOrMany::Many(many) => NameList(many),
})
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum Predicate {
Name(String),
All(Vec<Predicate>),
Any(Vec<Predicate>),
Not(Box<Predicate>),
Test {
key: String,
value: Value,
},
}
impl Predicate {
pub fn from_value(value: &Value) -> BunsenResult<Self> {
match value {
Value::String(name) => Ok(Self::Name(name.clone())),
Value::Array(items) => Ok(Self::All(
items
.iter()
.map(Self::from_value)
.collect::<BunsenResult<_>>()?,
)),
Value::Object(entries) => {
let mut all = entries
.iter()
.map(|(key, value)| Self::entry(key, value))
.collect::<BunsenResult<Vec<_>>>()?;
match all.len() {
0 => Err(query_error("an empty map is not a predicate")),
1 => Ok(all.pop().expect("one")),
_ => Ok(Self::All(all)),
}
}
other => Err(query_error(format!(
"a predicate is a name, a list or a map, not {other}"
))),
}
}
fn entry(
key: &str,
value: &Value,
) -> BunsenResult<Self> {
let operands = |op: &str| -> BunsenResult<Vec<Predicate>> {
let Value::Array(items) = value else {
return Err(query_error(format!("`{op}` takes a list, not {value}")));
};
items.iter().map(Self::from_value).collect()
};
Ok(match key {
"$any" => Self::Any(operands("$any")?),
"$all" => Self::All(operands("$all")?),
"$not" => Self::Not(Box::new(Self::from_value(value)?)),
_ => Self::Test {
key: key.to_string(),
value: value.clone(),
},
})
}
pub fn to_value(&self) -> Value {
match self {
Self::Name(name) => Value::String(name.clone()),
Self::All(items) => Value::Array(items.iter().map(Self::to_value).collect()),
Self::Any(items) => single(
"$any",
Value::Array(items.iter().map(Self::to_value).collect()),
),
Self::Not(inner) => single("$not", inner.to_value()),
Self::Test { key, value } => single(key, value.clone()),
}
}
}
fn single(
key: &str,
value: Value,
) -> Value {
let mut map = Map::new();
map.insert(key.to_string(), value);
Value::Object(map)
}
impl Serialize for Predicate {
fn serialize<S: Serializer>(
&self,
serializer: S,
) -> Result<S::Ok, S::Error> {
self.to_value().serialize(serializer)
}
}
impl<'de> Deserialize<'de> for Predicate {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = Value::deserialize(deserializer)?;
Self::from_value(&value).map_err(|e| de::Error::custom(e.problem_message()))
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SortKey {
pub key: String,
pub descending: bool,
pub missing_first: bool,
}
impl SortKey {
pub fn asc(key: impl Into<String>) -> Self {
Self {
key: key.into(),
descending: false,
missing_first: false,
}
}
pub fn desc(key: impl Into<String>) -> Self {
Self {
key: key.into(),
descending: true,
missing_first: false,
}
}
fn from_value(value: &Value) -> BunsenResult<Self> {
match value {
Value::String(key) => Ok(Self::asc(key.clone())),
Value::Object(fields) => {
let mut key = None;
let mut descending = false;
let mut missing_first = false;
for (k, v) in fields {
match (k.as_str(), v) {
("asc" | "desc", Value::String(s)) if key.is_none() => {
key = Some(s.clone());
descending = k == "desc";
}
("missing", Value::String(m)) if m == "first" || m == "last" => {
missing_first = m == "first";
}
_ => {
return Err(query_error(format!(
"a sort key is `K`, `{{asc: K}}` or `{{desc: K}}`, with an \
optional `missing: first | last`; not `{k}: {v}`"
)));
}
}
}
let key = key.ok_or_else(|| {
query_error("a sort key map names its key with `asc` or `desc`")
})?;
Ok(Self {
key,
descending,
missing_first,
})
}
other => Err(query_error(format!(
"a sort key is a key or a map, not {other}"
))),
}
}
fn to_value(&self) -> Value {
if !self.descending && !self.missing_first {
return Value::String(self.key.clone());
}
let mut map = Map::new();
let direction = if self.descending { "desc" } else { "asc" };
map.insert(direction.to_string(), Value::String(self.key.clone()));
if self.missing_first {
map.insert("missing".to_string(), Value::String("first".to_string()));
}
Value::Object(map)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SortKeys(pub Vec<SortKey>);
impl Serialize for SortKeys {
fn serialize<S: Serializer>(
&self,
serializer: S,
) -> Result<S::Ok, S::Error> {
match self.0.as_slice() {
[one] => one.to_value().serialize(serializer),
many => {
Value::Array(many.iter().map(SortKey::to_value).collect()).serialize(serializer)
}
}
}
}
impl<'de> Deserialize<'de> for SortKeys {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = Value::deserialize(deserializer)?;
let keys = match &value {
Value::Array(items) => items
.iter()
.map(SortKey::from_value)
.collect::<BunsenResult<Vec<_>>>(),
one => SortKey::from_value(one).map(|k| vec![k]),
};
keys.map(SortKeys)
.map_err(|e| de::Error::custom(e.problem_message()))
}
}
pub fn flow(value: &Value) -> String {
match value {
Value::String(s) => {
let plain = s
.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '_' | '-' | '.' | '/' | '$'))
&& !s.is_empty();
if plain {
s.clone()
} else {
Value::String(s.clone()).to_string()
}
}
Value::Array(items) => format!(
"[{}]",
items.iter().map(flow).collect::<Vec<_>>().join(", ")
),
Value::Object(fields) => format!(
"{{{}}}",
fields
.iter()
.map(|(k, v)| format!("{}: {}", flow(&Value::String(k.clone())), flow(v)))
.collect::<Vec<_>>()
.join(", ")
),
other => other.to_string(),
}
}