use super::{
JsonElement, ListCrossingError, SqlListComparison, SqlSetComparison, cross_count, cross_element,
flatten_list, from_stored, ordering_operator, push_json_list_slots, push_json_set_slots,
};
use crate::{
ListFilter, TryMapFilter,
comparison::{
At, Backend, ComplexComparison, TryFromFilter,
sql::{
CollectionOp, SqlConjunction, SqlCountComparison, SqlLoweringError, not_wrapped,
push_count_slots, render_column,
},
},
};
impl<V, C> SqlListComparison<V, C, sqlx::MySql> {
pub fn try_from_filter_with<D, VF, E, F>(
filter: ListFilter<D, VF>,
f: F,
) -> Result<Self, ListCrossingError<E, <C as TryFromFilter<VF::Mapped>>::Error>>
where
F: Fn(D) -> Result<V, E>,
VF: TryMapFilter<D, V>,
C: TryFromFilter<VF::Mapped>,
{
Self::try_from_filter_with_element(filter, &f, |element| {
let stored = element
.try_map_filter(&f)
.map_err(ListCrossingError::Operand)?;
C::try_from_filter(stored).map_err(ListCrossingError::Element)
})
.map_err(flatten_list)
}
pub fn try_from_filter_with_element<D, VF, E, F, X, G>(
filter: ListFilter<D, VF>,
f: F,
g: G,
) -> Result<Self, ListCrossingError<E, X>>
where
F: FnMut(D) -> Result<V, E>,
G: FnOnce(VF) -> Result<C, X>,
{
if let Some(operator) = ordering_operator(&filter) {
return Err(ListCrossingError::JsonOrdering(operator));
}
let mut stored = filter.try_map(f).map_err(ListCrossingError::Operand)?;
let any = cross_element(stored.any.take(), g).map_err(ListCrossingError::Element)?;
let count = cross_count(stored.count.take()).map_err(ListCrossingError::Cardinality)?;
Ok(from_stored(stored, any, count))
}
}
impl<D, VF, V: TryFrom<D>, C: TryFromFilter<VF>> TryFromFilter<ListFilter<D, VF>>
for SqlListComparison<V, C, sqlx::MySql>
{
type Error = ListCrossingError<V::Error, C::Error>;
fn try_from_filter(filter: ListFilter<D, VF>) -> Result<Self, Self::Error> {
Self::try_from_filter_with_element(filter, V::try_from, C::try_from_filter)
}
}
impl<V: JsonElement, C: ComplexComparison<sqlx::MySql>> ComplexComparison<sqlx::MySql>
for SqlListComparison<V, C, sqlx::MySql>
{
#[inline]
fn conjuncts(&self) -> usize {
Self::conjuncts(self)
}
fn apply<'q>(
&'q self,
at: At<'_>,
mut builder: <sqlx::MySql as Backend>::Builder<'q>,
) -> Result<<sqlx::MySql as Backend>::Builder<'q>, <sqlx::MySql as Backend>::Error> {
refuse_element_scope(self.any.as_ref())?;
push_json_list_slots(self, at, &mut builder, push_collection_op);
push_json_count(self.count.as_ref(), at, &mut builder);
Ok(builder)
}
}
impl<V: JsonElement, C: ComplexComparison<sqlx::MySql>> ComplexComparison<sqlx::MySql>
for SqlSetComparison<V, C, sqlx::MySql>
{
#[inline]
fn conjuncts(&self) -> usize {
Self::conjuncts(self)
}
fn apply<'q>(
&'q self,
at: At<'_>,
mut builder: <sqlx::MySql as Backend>::Builder<'q>,
) -> Result<<sqlx::MySql as Backend>::Builder<'q>, <sqlx::MySql as Backend>::Error> {
refuse_element_scope(self.any.as_ref())?;
push_json_set_slots(self, at, &mut builder, push_collection_op);
push_json_count(self.count.as_ref(), at, &mut builder);
Ok(builder)
}
}
fn refuse_element_scope<C>(element: Option<&C>) -> Result<(), SqlLoweringError> {
match element {
Some(_) => Err(SqlLoweringError::JsonElementScope),
None => Ok(()),
}
}
fn push_json_count(
count: Option<&SqlCountComparison<i64, sqlx::MySql>>,
at: At<'_>,
out: &mut SqlConjunction<'_, sqlx::MySql>,
) {
let Some(count) = count else {
return;
};
let column = render_column::<sqlx::MySql>(at);
push_count_slots(count, out, |qb| {
qb.push("JSON_LENGTH(");
qb.push(&column);
qb.push(")");
});
}
fn push_collection_op(
qb: &mut sqlx::QueryBuilder<sqlx::MySql>,
at: At<'_>,
op: CollectionOp,
operand_json: &str,
negated: bool,
) {
let column = render_column::<sqlx::MySql>(at);
not_wrapped(qb, negated, |qb| match op {
CollectionOp::SequenceEq => {
qb.push(&column);
qb.push(" = ");
push_json(qb, operand_json);
}
CollectionOp::SetEq => {
qb.push("( JSON_CONTAINS(");
qb.push(&column);
qb.push(", ");
push_json(qb, operand_json);
qb.push(") AND JSON_CONTAINS(");
push_json(qb, operand_json);
qb.push(", ");
qb.push(&column);
qb.push(") )");
}
CollectionOp::Encloses => {
qb.push("JSON_CONTAINS(");
qb.push(&column);
qb.push(", ");
push_json(qb, operand_json);
qb.push(")");
}
CollectionOp::EnclosedBy => {
qb.push("JSON_CONTAINS(");
push_json(qb, operand_json);
qb.push(", ");
qb.push(&column);
qb.push(")");
}
CollectionOp::Overlaps => {
qb.push("JSON_OVERLAPS(");
qb.push(&column);
qb.push(", ");
push_json(qb, operand_json);
qb.push(")");
}
});
}
fn push_json(qb: &mut sqlx::QueryBuilder<sqlx::MySql>, json: &str) {
qb.push("CAST(");
qb.push_bind(json.to_owned());
qb.push(" AS JSON)");
}