#[cfg(feature = "sqlite")]
mod sqlite {
use core::convert::Infallible;
use crate::{
At, FieldName, ListFilter, QuantifiedFilter, RecordAddress, SetFilter, TextFilter,
comparison::{
TryFromFilter,
sql::{
SqlEdgeComparison, SqlEdgeSetComparison, SqlLoweringError, SqlScalarComparison,
SqlTextComparison,
tests::{ROW, render, render_at, threaded},
},
},
};
type Element<V> = SqlScalarComparison<V, sqlx::Sqlite>;
type Edge = SqlEdgeComparison<i64, Element<i64>, sqlx::Sqlite>;
type EdgeSet = SqlEdgeSetComparison<i64, Element<i64>, sqlx::Sqlite>;
type TextEdgeSet = SqlEdgeSetComparison<i64, SqlTextComparison<i64, sqlx::Sqlite>, sqlx::Sqlite>;
const SCOPE: &str = "SELECT 1 FROM \"p_tags\" WHERE \"p_tags\".\"id\" = \"p\".\"id\"";
fn length(tag: String) -> Result<i64, Infallible> {
Ok(tag.len() as i64)
}
#[test]
fn one_element_converter_serves_every_slot() {
let filter = SetFilter::<String>::new()
.with_encloses(["hdr".to_owned(), "sdr".to_owned()])
.with_has_element("stereo".to_owned());
let crossed = TextEdgeSet::try_from_filter_with(filter, length).unwrap();
assert_eq!(crossed.encloses(), Some(&[3i64, 3][..]));
assert_eq!(crossed.has_element(), Some(&6i64));
assert_eq!(crossed.conjuncts(), 2);
}
#[test]
fn the_one_converter_reaches_the_nested_element_filter() {
let filter = SetFilter::<String, TextFilter<String>>::new()
.with_has_element("stereo".to_owned())
.with_any(TextFilter::<String>::new().with_eq("hdr".to_owned()));
let crossed = TextEdgeSet::try_from_filter_with(filter, length).unwrap();
assert_eq!(crossed.has_element(), Some(&6i64));
assert_eq!(
crossed.any().expect("the element question").eq(),
Some(&3i64),
"the nested operand crossed through the same converter, one level down"
);
}
fn _a_pinned_collection_crosses_through_the_declaration_at_both_levels(
filter: ListFilter<u64, crate::ScalarFilter<u64>>,
) -> SqlEdgeComparison<crate::BeU64, SqlScalarComparison<crate::BeU64, sqlx::Sqlite>, sqlx::Sqlite>
{
fn store(mark: u64) -> Result<crate::BeU64, Infallible> {
Ok(crate::BeU64(mark))
}
SqlEdgeComparison::try_from_filter_with(filter, store).expect("an infallible crossing")
}
#[test]
fn the_correlation_names_the_parent_and_the_edge_table_apart() {
let crossed = Edge::try_from_filter(ListFilter::<i64>::new().with_has_element(6i64)).unwrap();
let (sql, _) = render::<sqlx::Sqlite, _>("tags", &crossed);
assert!(
sql.contains("\"p_tags\".\"id\" = \"p\".\"id\""),
"both sides are qualified: {sql}"
);
}
#[test]
fn a_compound_key_correlates_on_every_column() {
const SEGMENT: RecordAddress = RecordAddress::new(
FieldName::new("segment"),
&[FieldName::new("media_id"), FieldName::new("segment_id")],
);
let crossed = Edge::try_from_filter(ListFilter::<i64>::new().with_has_element(6i64)).unwrap();
assert_eq!(
render_at::<sqlx::Sqlite, _>(
At::new(&SEGMENT).frame(FieldName::new("speakers")).at(),
&crossed
)
.0,
"EXISTS (SELECT 1 FROM \"segment_speakers\" WHERE \
\"segment_speakers\".\"media_id\" = \"segment\".\"media_id\" AND \
\"segment_speakers\".\"segment_id\" = \"segment\".\"segment_id\" AND \
\"segment_speakers\".\"speakers\" = ?)"
);
}
#[test]
fn membership_is_containment_of_the_singleton_on_both_kinds() {
let member = EdgeSet::try_from_filter(SetFilter::<i64>::new().with_has_element(6i64)).unwrap();
let singleton =
EdgeSet::try_from_filter(SetFilter::<i64>::new().with_encloses([6i64])).unwrap();
let sequence = Edge::try_from_filter(ListFilter::<i64>::new().with_has_element(6i64)).unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>("tags", &member),
render::<sqlx::Sqlite, _>("tags", &singleton)
);
assert_eq!(
render::<sqlx::Sqlite, _>("tags", &sequence),
render::<sqlx::Sqlite, _>("tags", &member)
);
}
#[test]
fn an_element_question_opens_a_correlated_derived_table() {
let crossed = EdgeSet::try_from_filter(
SetFilter::<i64>::new().with_any(crate::ScalarFilter::new().with_gt(2)),
)
.unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>("tags", &crossed),
(
"EXISTS (SELECT 1 FROM ( SELECT \"p_tags\".\"tags\" AS \"value\" FROM \"p_tags\" WHERE \
\"p_tags\".\"id\" = \"p\".\"id\" ) AS \"__ig_element_0__\" WHERE \"value\" > ?)"
.to_owned(),
1
)
);
assert_eq!(crossed.conjuncts(), 1);
}
#[test]
fn a_cardinality_is_the_correlated_count() {
let set = EdgeSet::try_from_filter(
SetFilter::<i64>::new().with_count(crate::ScalarFilter::new().with_eq(0)),
)
.unwrap();
let sequence = Edge::try_from_filter(
ListFilter::<i64>::new().with_count(crate::ScalarFilter::new().with_eq(0)),
)
.unwrap();
let expected = (
"(SELECT COUNT(*) FROM \"p_tags\" WHERE \"p_tags\".\"id\" = \"p\".\"id\") = ?".to_owned(),
1,
);
assert_eq!(render::<sqlx::Sqlite, _>("tags", &set), expected);
assert_eq!(render::<sqlx::Sqlite, _>("tags", &sequence), expected);
}
#[test]
fn a_quantified_crossing_reaches_the_edge_table_through_the_wide_kinds_arms() {
let narrow = Edge::try_from_filter(
QuantifiedFilter::<i64>::new()
.with_any(crate::ScalarFilter::new().with_gt(2))
.with_count(crate::ScalarFilter::new().with_eq(0)),
)
.unwrap();
let wide = Edge::try_from_filter(
ListFilter::<i64>::new()
.with_any(crate::ScalarFilter::new().with_gt(2))
.with_count(crate::ScalarFilter::new().with_eq(0)),
)
.unwrap();
assert_eq!(narrow, wide);
assert_eq!(narrow.conjuncts(), wide.conjuncts());
assert_eq!(
render::<sqlx::Sqlite, _>("tags", &narrow),
render::<sqlx::Sqlite, _>("tags", &wide)
);
assert_eq!(
render::<sqlx::Sqlite, _>("tags", &narrow),
(
"EXISTS (SELECT 1 FROM ( SELECT \"p_tags\".\"tags\" AS \"value\" FROM \"p_tags\" WHERE \
\"p_tags\".\"id\" = \"p\".\"id\" ) AS \"__ig_element_0__\" WHERE \"value\" > ?) AND \
(SELECT COUNT(*) FROM \"p_tags\" WHERE \"p_tags\".\"id\" = \"p\".\"id\") = ?"
.to_owned(),
2
)
);
}
#[test]
fn an_empty_element_scope_is_a_predicate_and_an_empty_cardinality_is_not() {
let any =
EdgeSet::try_from_filter(SetFilter::<i64>::new().with_any(crate::ScalarFilter::new()))
.unwrap();
let count =
EdgeSet::try_from_filter(SetFilter::<i64>::new().with_count(crate::ScalarFilter::new()))
.unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>("tags", &any),
(
"EXISTS (SELECT 1 FROM ( SELECT \"p_tags\".\"tags\" AS \"value\" FROM \"p_tags\" WHERE \
\"p_tags\".\"id\" = \"p\".\"id\" ) AS \"__ig_element_0__\")"
.to_owned(),
0
)
);
assert!(!any.is_empty());
assert_eq!(
render::<sqlx::Sqlite, _>("tags", &count),
(String::new(), 0)
);
assert!(count.is_empty());
}
#[test]
fn every_sequence_operator_renders_its_own_conjunct() {
let filter = ListFilter::<i64>::new()
.with_eq([1i64])
.with_ne([2i64])
.with_gt([3i64])
.with_gte([4i64])
.with_lt([5i64])
.with_lte([6i64])
.with_has_element(7i64);
let crossed = Edge::try_from_filter(filter).unwrap();
assert_eq!(crossed.conjuncts(), 7);
let (sql, binds) = render::<sqlx::Sqlite, _>("tags", &crossed);
assert_eq!(binds, 19);
assert!(sql.contains("COALESCE("), "{sql}");
assert!(sql.contains("\"p_tags\".\"tags_ordinal\""), "{sql}");
assert!(sql.contains("NOT ( ( NOT EXISTS ("), "the `ne` wrap: {sql}");
}
#[test]
fn every_set_operator_renders_its_own_conjunct() {
let filter = SetFilter::<i64>::new()
.with_eq([1i64])
.with_ne([2i64])
.with_encloses([3i64])
.with_enclosed_by([4i64])
.with_overlaps([5i64])
.with_has_element(6i64);
let crossed = EdgeSet::try_from_filter(filter).unwrap();
assert_eq!(crossed.conjuncts(), 6);
let (sql, binds) = render::<sqlx::Sqlite, _>("tags", &crossed);
assert_eq!(binds, 8);
assert!(!sql.contains("ordinal"), "{sql}");
}
#[test]
fn the_set_operators_render_indexed_existence_tests() {
for (filter, expected) in [
(
SetFilter::<i64>::new().with_encloses([7i64]),
format!("EXISTS ({SCOPE} AND \"p_tags\".\"tags\" = ?)"),
),
(
SetFilter::<i64>::new().with_encloses([7i64, 8]),
format!(
"( EXISTS ({SCOPE} AND \"p_tags\".\"tags\" = ?) AND \
EXISTS ({SCOPE} AND \"p_tags\".\"tags\" = ?) )"
),
),
(
SetFilter::<i64>::new().with_enclosed_by([8i64]),
format!("NOT EXISTS ({SCOPE} AND \"p_tags\".\"tags\" NOT IN (?))"),
),
(
SetFilter::<i64>::new().with_overlaps([9i64, 10]),
format!("EXISTS ({SCOPE} AND \"p_tags\".\"tags\" IN (?, ?))"),
),
] {
let crossed = EdgeSet::try_from_filter(filter).unwrap();
assert_eq!(render::<sqlx::Sqlite, _>("tags", &crossed).0, expected);
}
}
#[test]
fn the_kind_splits_equality_and_only_the_sequence_reads_the_ordinal() {
let sequence = Edge::try_from_filter(ListFilter::<i64>::new().with_eq([1i64, 2])).unwrap();
let set = EdgeSet::try_from_filter(SetFilter::<i64>::new().with_eq([1i64, 2])).unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>("tags", &sequence).0,
format!(
"( NOT EXISTS ({SCOPE} AND (\"p_tags\".\"tags_ordinal\", \"p_tags\".\"tags\") \
NOT IN ((?, ?), (?, ?))) AND (SELECT COUNT(*) FROM \"p_tags\" WHERE \
\"p_tags\".\"id\" = \"p\".\"id\") = ? )"
)
);
assert_eq!(
render::<sqlx::Sqlite, _>("tags", &set).0,
format!(
"( ( EXISTS ({SCOPE} AND \"p_tags\".\"tags\" = ?) AND \
EXISTS ({SCOPE} AND \"p_tags\".\"tags\" = ?) ) AND \
NOT EXISTS ({SCOPE} AND \"p_tags\".\"tags\" NOT IN (?, ?)) )"
)
);
}
#[test]
fn no_set_rendering_names_the_ordinal_column() {
let filter = SetFilter::<i64>::new()
.with_eq([1i64])
.with_ne([2i64])
.with_encloses([3i64])
.with_enclosed_by([4i64])
.with_overlaps([5i64])
.with_has_element(6i64);
let crossed = EdgeSet::try_from_filter(filter).unwrap();
let (sql, _) = render::<sqlx::Sqlite, _>("tags", &crossed);
assert!(!sql.contains("ordinal"), "{sql}");
}
#[test]
fn an_ordering_reads_the_first_differing_ordinal_then_the_lengths() {
let crossed = Edge::try_from_filter(ListFilter::<i64>::new().with_gte([3i64, 4])).unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>("tags", &crossed).0,
"COALESCE((SELECT \"p_tags\".\"tags\" > \"__ig_operand_0__\".\"value\" FROM \"p_tags\" JOIN \
( SELECT ? AS \"ordinal\", ? AS \"value\" UNION ALL SELECT ?, ? ) AS \"__ig_operand_0__\" \
ON \"__ig_operand_0__\".\"ordinal\" = \"p_tags\".\"tags_ordinal\" \
WHERE \"p_tags\".\"id\" = \"p\".\"id\" AND \"p_tags\".\"tags\" <> \"__ig_operand_0__\".\"value\" \
ORDER BY \"p_tags\".\"tags_ordinal\" LIMIT 1), \
(SELECT COUNT(*) FROM \"p_tags\" WHERE \"p_tags\".\"id\" = \"p\".\"id\") >= ?)"
);
let strict = Edge::try_from_filter(ListFilter::<i64>::new().with_gt([3i64, 4])).unwrap();
let (strict, _) = render::<sqlx::Sqlite, _>("tags", &strict);
let (loose, _) = render::<sqlx::Sqlite, _>("tags", &crossed);
assert_eq!(strict.replace(") > ?)", ") >= ?)"), loose);
}
#[test]
fn an_empty_operand_degenerates_per_operator() {
for (filter, expected) in [
(
ListFilter::<i64>::new().with_eq([]),
format!("NOT EXISTS ({SCOPE})"),
),
(
ListFilter::<i64>::new().with_gt([]),
format!("EXISTS ({SCOPE})"),
),
(ListFilter::<i64>::new().with_gte([]), "1 = 1".to_owned()),
(ListFilter::<i64>::new().with_lt([]), "1 = 0".to_owned()),
(
ListFilter::<i64>::new().with_lte([]),
format!("NOT EXISTS ({SCOPE})"),
),
] {
let crossed = Edge::try_from_filter(filter).unwrap();
assert_eq!(render::<sqlx::Sqlite, _>("tags", &crossed).0, expected);
}
for (filter, expected) in [
(
SetFilter::<i64>::new().with_encloses([]),
"1 = 1".to_owned(),
),
(
SetFilter::<i64>::new().with_overlaps([]),
"1 = 0".to_owned(),
),
(
SetFilter::<i64>::new().with_enclosed_by([]),
format!("NOT EXISTS ({SCOPE})"),
),
(
SetFilter::<i64>::new().with_eq([]),
format!("NOT EXISTS ({SCOPE})"),
),
] {
let crossed = EdgeSet::try_from_filter(filter).unwrap();
assert_eq!(render::<sqlx::Sqlite, _>("tags", &crossed).0, expected);
}
}
#[test]
fn the_bind_count_follows_the_operand_length() {
for len in [0usize, 1, 3, 1000] {
let operand: Vec<i64> = (0..len as i64).collect();
let crossed =
EdgeSet::try_from_filter(SetFilter::<i64>::new().with_encloses(operand)).unwrap();
let (_, binds) = render::<sqlx::Sqlite, _>("tags", &crossed);
assert_eq!(binds, len, "a {len}-element operand");
}
}
#[test]
fn every_operand_is_bound_once_and_in_order() {
use core::cell::RefCell;
use crate::comparison::{
ComplexComparison,
sql::{SqlConjunction, tests::Probe},
};
let bound = RefCell::new(Vec::new());
let crossed = SqlEdgeSetComparison::<
Probe<'_>,
SqlScalarComparison<Probe<'_>, sqlx::Sqlite>,
sqlx::Sqlite,
>::try_from_filter_with_element(
SetFilter::<i64>::new()
.with_encloses([7i64, 8])
.with_overlaps([9i64])
.with_has_element(10i64),
|value| {
Ok::<_, Infallible>(Probe {
value,
bound: &bound,
})
},
|any: crate::ScalarFilter<i64>| {
SqlScalarComparison::try_from_filter(any.try_map(|value| {
Ok::<_, Infallible>(Probe {
value,
bound: &bound,
})
})?)
},
)
.unwrap();
let mut qb = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
{
let out = SqlConjunction::with_lead(&mut qb, "");
let frame = At::new(&ROW).frame(FieldName::new("tags"));
crossed.apply(frame.at(), out).unwrap();
}
assert_eq!(*bound.borrow(), [7, 8, 9, 10]);
}
#[test]
fn the_threaded_lowering_opens_one_clause() {
let crossed = EdgeSet::try_from_filter(
SetFilter::<i64>::new()
.with_encloses([3i64])
.with_overlaps([5i64]),
)
.unwrap();
assert_eq!(
threaded::<sqlx::Sqlite, _>("tags", &crossed),
format!(
"SELECT \"id\" FROM \"t\" WHERE EXISTS ({SCOPE} AND \"p_tags\".\"tags\" = ?) AND \
EXISTS ({SCOPE} AND \"p_tags\".\"tags\" IN (?))"
)
);
}
#[test]
fn a_filter_alone_crosses_into_an_edge_comparison() {
let crossed = <Edge as TryFromFilter<ListFilter<i64>>>::try_from_filter(
ListFilter::<i64>::new().with_has_element(6i64),
)
.unwrap();
assert_eq!(crossed.has_element(), Some(&6i64));
assert_eq!(
render::<sqlx::Sqlite, _>("tags", &crossed).0,
format!("EXISTS ({SCOPE} AND \"p_tags\".\"tags\" = ?)")
);
}
#[test]
fn one_comparison_is_applied_against_whatever_row_the_caller_names() {
const SEGMENT: RecordAddress =
RecordAddress::new(FieldName::new("segment"), &[FieldName::new("media_id")]);
let crossed = Edge::try_from_filter(ListFilter::<i64>::new().with_has_element(6i64)).unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>("tags", &crossed).0,
format!("EXISTS ({SCOPE} AND \"p_tags\".\"tags\" = ?)")
);
assert_eq!(
render_at::<sqlx::Sqlite, _>(
At::new(&SEGMENT).frame(FieldName::new("tags")).at(),
&crossed
)
.0,
"EXISTS (SELECT 1 FROM \"segment_tags\" WHERE \
\"segment_tags\".\"media_id\" = \"segment\".\"media_id\" AND \
\"segment_tags\".\"tags\" = ?)"
);
}
#[test]
fn the_edge_table_is_the_rows_table_extended_by_the_field() {
let crossed = Edge::try_from_filter(ListFilter::<i64>::new().with_eq([1i64])).unwrap();
let (tags, _) = render::<sqlx::Sqlite, _>("tags", &crossed);
let (speakers, _) = render::<sqlx::Sqlite, _>("speakers", &crossed);
assert!(tags.contains("FROM \"p_tags\""), "{tags}");
assert!(tags.contains("\"p_tags\".\"tags_ordinal\""), "{tags}");
assert!(speakers.contains("FROM \"p_speakers\""), "{speakers}");
assert!(
speakers.contains("\"p_speakers\".\"speakers_ordinal\""),
"{speakers}"
);
}
#[test]
fn an_edge_comparison_at_the_top_level_is_refused_rather_than_correlating_the_row_to_itself() {
use crate::comparison::{ComplexComparison, sql::SqlConjunction};
const SELF_CORRELATION: &str = "EXISTS (SELECT 1 FROM \"p\" WHERE \"p\".\"id\" = \"p\".\"id\")";
fn refuse_at_the_top_level<C: ComplexComparison<sqlx::Sqlite>>(comparison: &C) {
let mut qb = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
let refused = {
let out = SqlConjunction::with_lead(&mut qb, "");
comparison.apply(At::new(&ROW), out).err()
};
let sql = qb.sql();
let sql = sql.as_str();
assert!(
!sql.contains(SELF_CORRELATION),
"the top level rendered: {sql}"
);
assert_eq!(sql, "");
assert_eq!(
refused,
Some(SqlLoweringError::EdgeWithoutField(FieldName::new("p")))
);
}
for filter in [
ListFilter::<i64>::new().with_eq([]),
ListFilter::<i64>::new().with_ne([]),
ListFilter::<i64>::new().with_gt([]),
ListFilter::<i64>::new().with_lte([]),
] {
refuse_at_the_top_level(&Edge::try_from_filter(filter).unwrap());
}
for filter in [
SetFilter::<i64>::new().with_eq([]),
SetFilter::<i64>::new().with_ne([]),
SetFilter::<i64>::new().with_enclosed_by([]),
] {
refuse_at_the_top_level(&EdgeSet::try_from_filter(filter).unwrap());
}
refuse_at_the_top_level(&Edge::new());
refuse_at_the_top_level(&EdgeSet::new());
}
#[test]
fn an_edge_table_is_never_the_rows_own_table() {
use crate::comparison::sql::edge_table;
assert_eq!(
edge_table(At::new(&ROW)),
Err(SqlLoweringError::EdgeWithoutField(FieldName::new("p")))
);
assert_eq!(
edge_table(At::new(&ROW).frame(FieldName::new("tags")).at()).unwrap(),
"p_tags"
);
}
#[test]
fn the_refusal_names_the_row_it_was_applied_to() {
assert_eq!(
SqlLoweringError::EdgeWithoutField(FieldName::new("p")).to_string(),
"the top level of `p` names no field, so it has no edge table to correlate to"
);
}
#[test]
fn an_empty_comparison_renders_nothing() {
let crossed = Edge::new();
assert!(crossed.is_empty());
assert_eq!(crossed.conjuncts(), 0);
assert_eq!(crossed, Edge::default());
assert_eq!(
render::<sqlx::Sqlite, _>("tags", &crossed),
(String::new(), 0)
);
}
}
#[cfg(feature = "sqlite")]
mod live {
use core::num::TryFromIntError;
use sqlx::{Connection as _, Executor as _, Row as _, sqlite::SqliteConnection};
use crate::{
At, FieldName, ListFilter, RecordAddress, ScalarFilter,
comparison::{
ComplexComparison,
sql::{QueryBuilder, SelectClause, SqlConjunction, SqlEdgeComparison, SqlScalarComparison},
},
};
const CLIP: RecordAddress = RecordAddress::new(FieldName::new("clip"), &[FieldName::new("id")]);
fn tenths(seconds: u64) -> Result<i64, TryFromIntError> {
i64::try_from(seconds).map(|seconds| seconds * 10)
}
async fn corpus() -> SqliteConnection {
let mut db = SqliteConnection::connect("sqlite::memory:")
.await
.expect("an in-memory database");
for ddl in [
r#"CREATE TABLE "clip" ("id" INTEGER PRIMARY KEY, "slate" TEXT NOT NULL)"#,
r#"CREATE TABLE "clip_marks" ("id" INTEGER, "marks_ordinal" INTEGER, "marks" INTEGER,
PRIMARY KEY ("id", "marks_ordinal"))"#,
] {
db.execute(ddl).await.expect("a table");
}
for (id, slate) in [(1i64, "alpha"), (2, "bravo"), (3, "delta"), (4, "echo")] {
sqlx::query(r#"INSERT INTO "clip" VALUES (?, ?)"#)
.bind(id)
.bind(slate)
.execute(&mut db)
.await
.expect("a clip");
}
for (clip, ordinal, mark) in [
(1i64, 0i64, 10i64),
(1, 1, 90),
(2, 0, 10),
(2, 1, 20),
(4, 0, 400),
] {
sqlx::query(r#"INSERT INTO "clip_marks" VALUES (?, ?, ?)"#)
.bind(clip)
.bind(ordinal)
.bind(mark)
.execute(&mut db)
.await
.expect("a mark");
}
db
}
async fn clips(
db: &mut SqliteConnection,
comparison: &impl ComplexComparison<sqlx::Sqlite>,
) -> Vec<i64> {
let frame = At::new(&CLIP).frame(FieldName::new("marks"));
let mut statement = QueryBuilder::<SelectClause, sqlx::Sqlite>::select()
.push_field("\"id\"")
.from("\"clip\"")
.begin_where();
{
let accumulator = SqlConjunction::new(statement.inner_mut());
comparison
.apply(frame.at(), accumulator)
.expect("a rendered predicate");
}
let mut built = statement.order_by(FieldName::new("id"), false).finalize();
built
.build()
.fetch_all(db)
.await
.expect("the engine answers")
.iter()
.map(|row| row.get::<i64, _>(0))
.collect()
}
#[tokio::test]
async fn one_declared_converter_carries_both_levels_of_a_live_collection() {
let mut db = corpus().await;
let written = ListFilter::<u64, ScalarFilter<u64>>::new()
.with_has_element(1u64)
.with_any(ScalarFilter::new().with_gte(9u64));
let crossed =
SqlEdgeComparison::<i64, SqlScalarComparison<i64, sqlx::Sqlite>, sqlx::Sqlite>::try_from_filter_with(
written, tenths,
)
.expect("every mark fits the column's integer");
assert_eq!(
clips(&mut db, &crossed).await,
[1],
"the clip with a one-second mark AND a mark of nine seconds or more"
);
}
}
#[cfg(all(feature = "sqlite", feature = "postgres", feature = "mysql"))]
#[test]
fn the_map_chooses_a_strategy_per_dialect() {
use crate::{
ListFilter, SetFilter,
comparison::{
ToDatabaseComparison,
sql::{
SqlEdgeComparison, SqlEdgeSetComparison, SqlListComparison, SqlScalarComparison,
SqlSetComparison,
},
},
};
fn same<T>(_: core::marker::PhantomData<T>, _: core::marker::PhantomData<T>) {}
type Element<Db> = SqlScalarComparison<i64, Db>;
type Sequence<Db> = <ListFilter<i64> as ToDatabaseComparison<i64, Db>>::Comparison;
type Set<Db> = <SetFilter<i64> as ToDatabaseComparison<i64, Db>>::Comparison;
same(
core::marker::PhantomData::<Sequence<sqlx::Postgres>>,
core::marker::PhantomData::<SqlListComparison<i64, Element<sqlx::Postgres>, sqlx::Postgres>>,
);
same(
core::marker::PhantomData::<Set<sqlx::Postgres>>,
core::marker::PhantomData::<SqlSetComparison<i64, Element<sqlx::Postgres>, sqlx::Postgres>>,
);
same(
core::marker::PhantomData::<Sequence<sqlx::Sqlite>>,
core::marker::PhantomData::<SqlEdgeComparison<i64, Element<sqlx::Sqlite>, sqlx::Sqlite>>,
);
same(
core::marker::PhantomData::<Set<sqlx::Sqlite>>,
core::marker::PhantomData::<SqlEdgeSetComparison<i64, Element<sqlx::Sqlite>, sqlx::Sqlite>>,
);
same(
core::marker::PhantomData::<Sequence<sqlx::MySql>>,
core::marker::PhantomData::<SqlEdgeComparison<i64, Element<sqlx::MySql>, sqlx::MySql>>,
);
same(
core::marker::PhantomData::<Set<sqlx::MySql>>,
core::marker::PhantomData::<SqlEdgeSetComparison<i64, Element<sqlx::MySql>, sqlx::MySql>>,
);
}