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, not_wrapped, push_count_slots,
push_element_scope, render_column,
},
},
};
impl<V, C> SqlListComparison<V, C, sqlx::Sqlite> {
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::Sqlite>
{
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::Sqlite>> ComplexComparison<sqlx::Sqlite>
for SqlListComparison<V, C, sqlx::Sqlite>
{
#[inline]
fn conjuncts(&self) -> usize {
Self::conjuncts(self)
}
fn apply<'q>(
&'q self,
at: At<'_>,
mut builder: <sqlx::Sqlite as Backend>::Builder<'q>,
) -> Result<<sqlx::Sqlite as Backend>::Builder<'q>, <sqlx::Sqlite as Backend>::Error> {
push_json_list_slots(self, at, &mut builder, push_collection_op);
push_json_any(self.any.as_ref(), at, &mut builder)?;
push_json_count(self.count.as_ref(), at, &mut builder);
Ok(builder)
}
}
impl<V: JsonElement, C: ComplexComparison<sqlx::Sqlite>> ComplexComparison<sqlx::Sqlite>
for SqlSetComparison<V, C, sqlx::Sqlite>
{
#[inline]
fn conjuncts(&self) -> usize {
Self::conjuncts(self)
}
fn apply<'q>(
&'q self,
at: At<'_>,
mut builder: <sqlx::Sqlite as Backend>::Builder<'q>,
) -> Result<<sqlx::Sqlite as Backend>::Builder<'q>, <sqlx::Sqlite as Backend>::Error> {
push_json_set_slots(self, at, &mut builder, push_collection_op);
push_json_any(self.any.as_ref(), at, &mut builder)?;
push_json_count(self.count.as_ref(), at, &mut builder);
Ok(builder)
}
}
fn push_json_any<C>(
element: Option<&C>,
at: At<'_>,
out: &mut SqlConjunction<'_, sqlx::Sqlite>,
) -> Result<(), <sqlx::Sqlite as Backend>::Error>
where
C: ComplexComparison<sqlx::Sqlite>,
{
let Some(element) = element else {
return Ok(());
};
let column = render_column::<sqlx::Sqlite>(at);
push_element_scope(out.open(), element, at, |qb| {
qb.push("json_each(");
qb.push(&column);
qb.push(")");
})
}
fn push_json_count(
count: Option<&SqlCountComparison<i64, sqlx::Sqlite>>,
at: At<'_>,
out: &mut SqlConjunction<'_, sqlx::Sqlite>,
) {
let Some(count) = count else {
return;
};
let column = render_column::<sqlx::Sqlite>(at);
push_count_slots(count, out, |qb| {
qb.push("json_array_length(");
qb.push(&column);
qb.push(")");
});
}
fn push_collection_op(
qb: &mut sqlx::QueryBuilder<sqlx::Sqlite>,
at: At<'_>,
op: CollectionOp,
operand_json: &str,
negated: bool,
) {
let column = render_column::<sqlx::Sqlite>(at);
not_wrapped(qb, negated, |qb| match op {
CollectionOp::SequenceEq => {
qb.push(&column);
qb.push(" = ");
qb.push_bind(operand_json.to_owned());
}
CollectionOp::SetEq => {
let stored = Each::Column(&column);
let operand = Each::Operand(operand_json);
qb.push("( ");
push_contained(qb, &operand, &stored);
qb.push(" AND ");
push_contained(qb, &stored, &operand);
qb.push(" )");
}
CollectionOp::Encloses => {
push_contained(qb, &Each::Operand(operand_json), &Each::Column(&column))
}
CollectionOp::EnclosedBy => {
push_contained(qb, &Each::Column(&column), &Each::Operand(operand_json))
}
CollectionOp::Overlaps => {
push_overlapping(qb, &Each::Column(&column), &Each::Operand(operand_json))
}
});
}
enum Each<'a> {
Column(&'a str),
Operand(&'a str),
}
fn push_each(qb: &mut sqlx::QueryBuilder<sqlx::Sqlite>, arg: &Each<'_>) {
qb.push("json_each(");
match arg {
Each::Column(quoted) => {
qb.push(*quoted);
}
Each::Operand(json) => {
qb.push_bind((*json).to_owned());
}
}
qb.push(")");
}
fn push_contained(qb: &mut sqlx::QueryBuilder<sqlx::Sqlite>, sub: &Each<'_>, sup: &Each<'_>) {
qb.push("NOT EXISTS (SELECT 1 FROM ");
push_each(qb, sub);
qb.push(" WHERE value NOT IN (SELECT value FROM ");
push_each(qb, sup);
qb.push("))");
}
fn push_overlapping(qb: &mut sqlx::QueryBuilder<sqlx::Sqlite>, a: &Each<'_>, b: &Each<'_>) {
qb.push("EXISTS (SELECT 1 FROM ");
push_each(qb, a);
qb.push(" WHERE value IN (SELECT value FROM ");
push_each(qb, b);
qb.push("))");
}