#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
use core::fmt::Display;
use super::SqlKeyIn;
#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
use crate::{
At, Backend, BindCeiling, Carrier, ComplexComparison, FieldName, QuoteIdent,
comparison::sql::{BindCeilingError, SqlConjunction, SqlLoweringError, tests::ROW},
};
#[cfg(feature = "sqlite")]
use crate::{
ScalarFilter,
comparison::sql::{SqlScalarComparison, tests::Probe},
};
#[test]
fn a_key_in_is_always_exactly_one_conjunct() {
let keyed = SqlKeyIn::<i64, (), 2>::new(["media", "segment"], [[1, 10], [2, 20]]);
let empty = SqlKeyIn::<i64, (), 2>::new(["media", "segment"], []);
assert_eq!(keyed.keys().len(), 2);
assert!(empty.keys().is_empty());
assert_eq!(keyed.parts(), &["media", "segment"]);
}
#[cfg(feature = "sqlite")]
fn rendered<C>(
field: &str,
comparison: &C,
bound: &core::cell::RefCell<Vec<i64>>,
) -> (String, Vec<i64>)
where
C: ComplexComparison<sqlx::Sqlite>,
{
let mut qb = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
{
let accumulator = SqlConjunction::with_lead(&mut qb, "");
let frame = At::new(&ROW).frame(FieldName::new(field));
comparison.apply(frame.at(), accumulator).unwrap();
}
(qb.sql().as_str().to_owned(), bound.take())
}
#[cfg(feature = "sqlite")]
fn probe(value: i64, bound: &core::cell::RefCell<Vec<i64>>) -> Probe<'_> {
Probe { value, bound }
}
#[cfg(feature = "sqlite")]
fn column_in<'a>(
values: [i64; 2],
bound: &'a core::cell::RefCell<Vec<i64>>,
) -> SqlScalarComparison<Probe<'a>, sqlx::Sqlite> {
SqlScalarComparison::try_from_filter_with(
ScalarFilter::<i64>::new().with_in_(values),
|value: i64| Ok::<_, core::convert::Infallible>(probe(value, bound)),
)
.unwrap()
}
#[cfg(feature = "sqlite")]
struct PerColumn<'a> {
media: SqlScalarComparison<Probe<'a>, sqlx::Sqlite>,
segment: SqlScalarComparison<Probe<'a>, sqlx::Sqlite>,
}
#[cfg(feature = "sqlite")]
impl ComplexComparison<sqlx::Sqlite> for PerColumn<'_> {
fn conjuncts(&self) -> usize {
self.media.conjuncts() + self.segment.conjuncts()
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: <sqlx::Sqlite as Backend>::Builder<'q>,
) -> Result<<sqlx::Sqlite as Backend>::Builder<'q>, SqlLoweringError> {
let media = at.frame(FieldName::new("media"));
let builder = self.media.apply(media.at(), builder)?;
let segment = at.frame(FieldName::new("segment"));
self.segment.apply(segment.at(), builder)
}
}
#[cfg(feature = "sqlite")]
const CANDIDATES: [(i64, i64); 4] = [(1, 10), (1, 20), (2, 10), (2, 20)];
#[cfg(feature = "sqlite")]
const COLUMNS: [&str; 2] = ["\"k_media\"", "\"k_segment\""];
#[cfg(feature = "sqlite")]
fn admits(sql: &str, bound: &[i64], row: (i64, i64)) -> bool {
let mut rest = bound;
let mut matched = true;
for conjunct in sql.split(" AND ") {
let (operands, remainder) = rest.split_at(conjunct.matches('?').count());
rest = remainder;
if conjunct == "1 = 0" {
matched = false;
continue;
}
let (head, _) = conjunct
.split_once(" IN (")
.expect("this evaluator reads a membership or the `1 = 0` an empty set renders");
matched &= if head.starts_with('(') {
operands
.as_chunks::<2>()
.0
.iter()
.any(|&[media, segment]| (media, segment) == row)
} else if head == COLUMNS[0] {
operands.contains(&row.0)
} else if head == COLUMNS[1] {
operands.contains(&row.1)
} else {
panic!("a membership over a column this evaluator does not know: {head}")
};
}
assert!(rest.is_empty(), "every bound operand belongs to a conjunct");
matched
}
#[cfg(feature = "sqlite")]
fn admitted(sql: &str, bound: &[i64]) -> Vec<(i64, i64)> {
CANDIDATES
.into_iter()
.filter(|row| admits(sql, bound, *row))
.collect()
}
#[cfg(feature = "sqlite")]
#[test]
fn a_compound_key_lowers_to_one_row_value_in() {
let bound = core::cell::RefCell::new(Vec::new());
let key_in = SqlKeyIn::<Probe<'_>, sqlx::Sqlite, 2>::new(
["media", "segment"],
[
[probe(1, &bound), probe(10, &bound)],
[probe(2, &bound), probe(20, &bound)],
],
);
assert_eq!(ComplexComparison::conjuncts(&key_in), 1);
assert_eq!(
rendered("k", &key_in, &bound),
(
"(\"k_media\", \"k_segment\") IN ((?, ?), (?, ?))".to_owned(),
vec![1, 10, 2, 20]
)
);
}
#[cfg(feature = "sqlite")]
#[test]
fn a_one_column_key_is_the_same_spelling_degenerating() {
let bound = core::cell::RefCell::new(Vec::new());
let key_in = SqlKeyIn::<Probe<'_>, sqlx::Sqlite, 1>::new(
["media"],
[[probe(1, &bound)], [probe(2, &bound)]],
);
assert_eq!(
rendered("k", &key_in, &bound),
("(\"k_media\") IN ((?), (?))".to_owned(), vec![1, 2])
);
}
#[cfg(feature = "sqlite")]
#[test]
fn a_row_value_in_and_a_per_column_conjunction_do_not_mean_the_same_thing() {
let bound = core::cell::RefCell::new(Vec::new());
let key_in = SqlKeyIn::<Probe<'_>, sqlx::Sqlite, 2>::new(
["media", "segment"],
[
[probe(1, &bound), probe(10, &bound)],
[probe(2, &bound), probe(20, &bound)],
],
);
let (key_sql, key_operands) = rendered("k", &key_in, &bound);
let per_column = PerColumn {
media: column_in([1, 2], &bound),
segment: column_in([10, 20], &bound),
};
let (column_sql, column_operands) = rendered("k", &per_column, &bound);
assert_eq!(key_operands.len(), column_operands.len());
let by_key = admitted(&key_sql, &key_operands);
let by_column = admitted(&column_sql, &column_operands);
assert_eq!(by_key, [(1, 10), (2, 20)]);
assert_eq!(by_column, [(1, 10), (1, 20), (2, 10), (2, 20)]);
assert_ne!(by_key, by_column);
}
#[cfg(feature = "sqlite")]
#[test]
fn an_empty_key_set_matches_no_rows_and_is_not_a_refusal() {
let bound = core::cell::RefCell::new(Vec::new());
let empty = SqlKeyIn::<Probe<'_>, sqlx::Sqlite, 2>::new(["media", "segment"], []);
assert_eq!(ComplexComparison::conjuncts(&empty), 1);
assert!(!empty.is_empty());
let (sql, operands) = rendered("k", &empty, &bound);
assert_eq!((sql.as_str(), operands.as_slice()), ("1 = 0", &[][..]));
assert_eq!(admitted(&sql, &operands), []);
}
#[cfg(feature = "sqlite")]
#[test]
fn a_key_column_extends_the_name_it_was_given_and_the_leaf_brackets_it() {
let bound = core::cell::RefCell::new(Vec::new());
let key_in = SqlKeyIn::<Probe<'_>, sqlx::Sqlite, 2>::new(
["media", "segment"],
[[probe(1, &bound), probe(10, &bound)]],
);
assert_eq!(
rendered("a\"b", &key_in, &bound).0,
"(\"a\"\"b_media\", \"a\"\"b_segment\") IN ((?, ?))"
);
}
#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
fn render_keys<Db>(keys: usize) -> Result<usize, SqlLoweringError>
where
Db: sqlx::Database
+ QuoteIdent
+ BindCeiling
+ for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Error = SqlLoweringError, Buffer: Display>,
i64: Carrier<Db>,
{
let key_in = SqlKeyIn::<i64, Db, 2>::new(["media", "segment"], vec![[1i64, 10i64]; keys]);
let mut qb = sqlx::QueryBuilder::<Db>::default();
let accumulator = SqlConjunction::with_lead(&mut qb, "");
let frame = At::new(&ROW).frame(FieldName::new("k"));
key_in
.apply(frame.at(), accumulator)
.map(|out| out.written())
}
#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
#[test]
fn a_key_set_is_refused_at_the_dialect_s_own_bind_ceiling() {
#[cfg(feature = "sqlite")]
{
assert_eq!(render_keys::<sqlx::Sqlite>(16383), Ok(1));
assert_eq!(
render_keys::<sqlx::Sqlite>(16384),
Err(SqlLoweringError::BindCeiling(BindCeilingError::new(
16384, 2, 32766
)))
);
}
#[cfg(feature = "postgres")]
{
assert_eq!(render_keys::<sqlx::Postgres>(32767), Ok(1));
assert_eq!(
render_keys::<sqlx::Postgres>(32768),
Err(SqlLoweringError::BindCeiling(BindCeilingError::new(
32768, 2, 65535
)))
);
}
#[cfg(feature = "mysql")]
{
assert_eq!(render_keys::<sqlx::MySql>(32767), Ok(1));
assert_eq!(
render_keys::<sqlx::MySql>(32768),
Err(SqlLoweringError::BindCeiling(BindCeilingError::new(
32768, 2, 65535
)))
);
}
}
#[cfg(feature = "sqlite")]
#[test]
fn a_refused_key_set_leaves_the_accumulator_untouched() {
let key_in =
SqlKeyIn::<i64, sqlx::Sqlite, 2>::new(["media", "segment"], vec![[1i64, 10i64]; 16384]);
let mut qb = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
{
let accumulator = SqlConjunction::new(&mut qb);
let frame = At::new(&ROW).frame(FieldName::new("k"));
assert!(key_in.apply(frame.at(), accumulator).is_err());
}
assert_eq!(qb.sql(), "");
}
#[cfg(feature = "sqlite")]
#[test]
fn the_refusal_names_what_a_caller_has_to_batch_by() {
let error = SqlLoweringError::BindCeiling(BindCeilingError::new(16384, 2, 32766));
assert_eq!(
error.to_string(),
"16384 keys of 2 columns need 32768 bound parameters and this dialect takes 32766"
);
}