#![cfg(feature = "sqlite")]
use super::{SqlDerivedComparison, SqlRefComparison};
use crate::{
At, FieldName, RecordAddress, ScalarFilter, TextFilter,
comparison::{
CollapsibleComparison, ComplexComparison, TryFromFilter,
sql::{
RelatedRow, RelationDepthError, RelationWidthError, SqlConjunction, SqlCountComparison,
SqlLoweringError, SqlScalarComparison, SqlTextComparison, tests::render_at,
},
},
};
const SHOT: RecordAddress = RecordAddress::new(FieldName::new("shot"), &[FieldName::new("id")]);
const KEYFRAME: RelatedRow = RelatedRow::new(
RecordAddress::new(FieldName::new("keyframe"), &[FieldName::new("id")]),
&[
"__ig_keyframe_0__",
"__ig_keyframe_1__",
"__ig_keyframe_2__",
],
);
const SPLICE: RelatedRow = RelatedRow::new(
RecordAddress::new(
FieldName::new("splice"),
&[FieldName::new("media_id"), FieldName::new("splice_id")],
),
&["__ig_splice_0__", "__ig_splice_1__"],
);
const SCENE: RelatedRow = RelatedRow::new(
RecordAddress::new(FieldName::new("scene"), &[FieldName::new("id")]),
&["__ig_scene_0__", "__ig_scene_1__", "__ig_scene_2__"],
);
const SHALLOW: RelatedRow = RelatedRow::new(
RecordAddress::new(FieldName::new("scene"), &[FieldName::new("id")]),
&["__ig_scene_0__"],
);
const DEEP: RelatedRow = RelatedRow::new(
RecordAddress::new(FieldName::new("deep"), &[FieldName::new("id")]),
&[
"__ig_deep_0__",
"__ig_deep_1__",
"__ig_deep_2__",
"__ig_deep_3__",
"__ig_deep_4__",
"__ig_deep_5__",
"__ig_deep_6__",
"__ig_deep_7__",
"__ig_deep_8__",
"__ig_deep_9__",
],
);
const DEFAULTED: RelatedRow = RelatedRow::new(
RecordAddress::new(FieldName::new("scene"), &[FieldName::new("id")]),
&[
"__ig_scene_0__",
"__ig_scene_1__",
"__ig_scene_2__",
"__ig_scene_3__",
"__ig_scene_4__",
"__ig_scene_5__",
"__ig_scene_6__",
"__ig_scene_7__",
],
);
const PARENT_ID: &FieldName = FieldName::new("parent_id");
const SHOT_ID: &FieldName = FieldName::new("shot_id");
const SCOPE: &str = "SELECT 1 FROM \"keyframe\" \"__ig_keyframe_1__\" \
WHERE \"__ig_keyframe_1__\".\"shot_id\" = \"shot\".\"id\"";
const CARDINALITY: &str = "(SELECT COUNT(*) FROM \"keyframe\" \"__ig_keyframe_1__\" \
WHERE \"__ig_keyframe_1__\".\"shot_id\" = \"shot\".\"id\")";
type Scalar = SqlScalarComparison<i64, sqlx::Sqlite>;
type Text = SqlTextComparison<String, sqlx::Sqlite>;
type Ref = SqlRefComparison<Keyframe, sqlx::Sqlite>;
type Derived = SqlDerivedComparison<Keyframe, sqlx::Sqlite>;
#[derive(Debug, Clone, PartialEq)]
struct Keyframe {
id: Scalar,
title: Text,
referential: bool,
}
impl Keyframe {
fn new() -> Self {
Self {
id: Scalar::new(),
title: Text::new(),
referential: true,
}
}
fn with_id(mut self, id: i64) -> Self {
self.id = Scalar::try_from_filter(ScalarFilter::<i64>::new().with_eq(id)).unwrap();
self
}
fn with_title(mut self, title: &str) -> Self {
self.title =
Text::try_from_filter(TextFilter::<String>::new().with_eq(title.to_owned())).unwrap();
self
}
const fn unreferential(mut self) -> Self {
self.referential = false;
self
}
}
impl ComplexComparison<sqlx::Sqlite> for Keyframe {
fn conjuncts(&self) -> usize {
self.id.conjuncts() + self.title.conjuncts()
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: SqlConjunction<'q, sqlx::Sqlite>,
) -> Result<SqlConjunction<'q, sqlx::Sqlite>, SqlLoweringError> {
let id = at.frame(FieldName::new("id"));
let builder = self.id.apply(id.at(), builder)?;
let title = at.frame(FieldName::new("title"));
self.title.apply(title.at(), builder)
}
}
impl CollapsibleComparison<sqlx::Sqlite> for Keyframe {
type Id = Scalar;
fn only_id(&self) -> Option<&Scalar> {
(self.referential && self.title.is_empty()).then_some(&self.id)
}
}
fn render(column: &str, comparison: &impl ComplexComparison<sqlx::Sqlite>) -> (String, usize) {
let frame = At::new(&SHOT).frame(FieldName::new(column));
render_at::<sqlx::Sqlite, _>(frame.at(), comparison)
}
fn lowered(
at: At<'_>,
comparison: &impl ComplexComparison<sqlx::Sqlite>,
) -> Result<String, SqlLoweringError> {
let mut qb = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
{
let out = SqlConjunction::with_lead(&mut qb, "");
comparison.apply(at, out)?;
}
Ok(qb.into_string())
}
#[test]
fn a_forward_reference_renders_a_semi_join_through_the_foreign_key() {
let cover = Ref::new(KEYFRAME, Keyframe::new().with_title("Autumn"));
assert_eq!(
render("cover_id", &cover),
(
"\"cover_id\" IN ( SELECT \"__ig_keyframe_1__\".\"id\" FROM \"keyframe\" \"__ig_keyframe_1__\" WHERE \"title\" = ? )".into(),
1
)
);
assert_eq!(ComplexComparison::conjuncts(&cover), 1);
}
#[test]
fn the_relation_subquery_carries_no_order_and_no_limit() {
use crate::comparison::sql::{QueryBuilder, SelectClause};
let cover = Ref::new(KEYFRAME, Keyframe::new().with_title("Autumn"));
let mut statement = QueryBuilder::<SelectClause, sqlx::Sqlite>::select()
.push_field("\"id\"")
.from("\"shot\"")
.begin_where();
{
let frame = At::new(&SHOT).frame(FieldName::new("cover_id"));
let accumulator = SqlConjunction::new(statement.inner_mut());
cover.apply(frame.at(), accumulator).unwrap();
}
let sql = statement
.order_by(FieldName::new("slate"), false)
.limit(10)
.finalize()
.into_string();
let (_, tail) = sql.split_once(" IN ( ").expect("a semi-join");
let (subquery, _) = tail.split_once(" )").expect("a closed subquery");
assert!(
!subquery.contains("ORDER BY") && !subquery.contains("LIMIT"),
"the relation subquery is bare: {subquery}"
);
assert!(sql.ends_with(" ORDER BY \"slate\" ASC LIMIT ?"), "{sql}");
}
#[test]
fn a_predicate_on_the_targets_id_alone_collapses_onto_the_foreign_key() {
let collapsing = Ref::new(KEYFRAME, Keyframe::new().with_id(10));
let (sql, binds) = render("cover_id", &collapsing);
assert_eq!((sql.as_str(), binds), ("\"cover_id\" = ?", 1));
assert!(!sql.contains("SELECT"), "the collapse renders no subquery");
assert_eq!(ComplexComparison::conjuncts(&collapsing), 1);
let declining = Ref::new(KEYFRAME, Keyframe::new().with_id(10).unreferential());
assert_eq!(
render("cover_id", &declining),
(
"\"cover_id\" IN ( SELECT \"__ig_keyframe_1__\".\"id\" FROM \"keyframe\" \"__ig_keyframe_1__\" WHERE \"id\" = ? )".into(),
1
)
);
let narrowed = Ref::new(KEYFRAME, Keyframe::new().with_id(10).with_title("Autumn"));
assert_eq!(
render("cover_id", &narrowed),
(
"\"cover_id\" IN ( SELECT \"__ig_keyframe_1__\".\"id\" FROM \"keyframe\" \"__ig_keyframe_1__\" WHERE \"id\" = ? AND \"title\" = ? )"
.into(),
2
)
);
}
#[test]
fn an_empty_nested_predicate_opens_no_conjunct() {
let empty = Ref::new(KEYFRAME, Keyframe::new());
assert_eq!(ComplexComparison::conjuncts(&empty), 0);
assert_eq!(render("cover_id", &empty), (String::new(), 0));
}
#[test]
fn a_relation_whose_address_is_wide_is_refused_and_writes_nothing() {
let frame = At::new(&SHOT).frame(FieldName::new("splice_id"));
let wide_target =
SqlRefComparison::<_, sqlx::Sqlite>::new(SPLICE, Keyframe::new().with_title("Autumn"));
assert_eq!(
lowered(frame.at(), &wide_target),
Err(SqlLoweringError::RelationWidth(RelationWidthError::new(
FieldName::new("splice"),
2
)))
);
let collapsing = SqlRefComparison::<_, sqlx::Sqlite>::new(SPLICE, Keyframe::new().with_id(10));
assert!(lowered(frame.at(), &collapsing).is_err());
let reverse = Derived::new(KEYFRAME, SHOT_ID).with_any(Keyframe::new());
assert_eq!(
lowered(At::new(SPLICE.address()), &reverse),
Err(SqlLoweringError::RelationWidth(RelationWidthError::new(
FieldName::new("splice"),
2
)))
);
}
#[test]
fn every_quantifier_opens_a_correlated_scope_of_its_own() {
let any = Derived::new(KEYFRAME, SHOT_ID).with_any(Keyframe::new().with_title("Autumn"));
assert_eq!(
render("covers", &any),
(format!("EXISTS ({SCOPE} AND \"title\" = ?)"), 1)
);
let none = Derived::new(KEYFRAME, SHOT_ID).with_none(Keyframe::new().with_title("Autumn"));
assert_eq!(
render("covers", &none),
(format!("NOT EXISTS ({SCOPE} AND \"title\" = ?)"), 1)
);
let all = Derived::new(KEYFRAME, SHOT_ID).with_all(Keyframe::new().with_title("Autumn"));
assert_eq!(
render("covers", &all),
(format!("NOT EXISTS ({SCOPE} AND NOT ( \"title\" = ? ))"), 1)
);
let count = Derived::new(KEYFRAME, SHOT_ID).with_count(
SqlCountComparison::try_from_filter(ScalarFilter::<usize>::new().with_gt(2)).unwrap(),
);
assert_eq!(render("covers", &count), (format!("{CARDINALITY} > ?"), 1));
let every = Derived::new(KEYFRAME, SHOT_ID)
.with_any(Keyframe::new())
.with_all(Keyframe::new().with_title("Autumn"))
.with_none(Keyframe::new())
.with_count(
SqlCountComparison::try_from_filter(ScalarFilter::<usize>::new().with_gt(2)).unwrap(),
);
assert_eq!(every.conjuncts(), 4);
assert_eq!(
render("covers", &every),
(
format!(
"EXISTS ({SCOPE}) AND NOT EXISTS ({SCOPE} AND NOT ( \"title\" = ? )) AND \
NOT EXISTS ({SCOPE}) AND {CARDINALITY} > ?"
),
2
)
);
}
#[test]
fn an_empty_predicate_is_vacuous_under_all_and_a_presence_test_under_the_others() {
let all = Derived::new(KEYFRAME, SHOT_ID).with_all(Keyframe::new());
assert_eq!(all.conjuncts(), 1);
assert_eq!(render("covers", &all), ("1 = 1".into(), 0));
let any = Derived::new(KEYFRAME, SHOT_ID).with_any(Keyframe::new());
assert_eq!(render("covers", &any), (format!("EXISTS ({SCOPE})"), 0));
let none = Derived::new(KEYFRAME, SHOT_ID).with_none(Keyframe::new());
assert_eq!(
render("covers", &none),
(format!("NOT EXISTS ({SCOPE})"), 0)
);
}
#[test]
fn the_correlation_qualifies_both_sides() {
let any = Derived::new(KEYFRAME, SHOT_ID).with_any(Keyframe::new());
let (sql, _) = render("covers", &any);
assert!(
sql.contains("\"__ig_keyframe_1__\".\"shot_id\" = \"shot\".\"id\""),
"both sides are qualified: {sql}"
);
}
#[test]
fn a_self_relation_aliases_the_inner_scope() {
let any = Derived::new(SCENE, PARENT_ID).with_any(Keyframe::new());
assert_eq!(
lowered(At::new(SCENE.address()), &any).unwrap(),
"EXISTS (SELECT 1 FROM \"scene\" \"__ig_scene_1__\" \
WHERE \"__ig_scene_1__\".\"parent_id\" = \"scene\".\"id\")"
);
}
#[test]
fn two_levels_of_one_table_take_two_aliases() {
let inner = Derived::new(SCENE, PARENT_ID).with_any(Keyframe::new());
let outer = SqlRefComparison::<_, sqlx::Sqlite>::new(SCENE, Nesting(inner));
let frame = At::new(SCENE.address()).frame(PARENT_ID);
assert_eq!(
lowered(frame.at(), &outer).unwrap(),
"\"parent_id\" IN ( SELECT \"__ig_scene_1__\".\"id\" FROM \"scene\" \"__ig_scene_1__\" \
WHERE EXISTS (SELECT 1 FROM \"scene\" \"__ig_scene_2__\" \
WHERE \"__ig_scene_2__\".\"parent_id\" = \"__ig_scene_1__\".\"id\") )"
);
}
#[test]
fn a_relation_deeper_than_its_aliases_is_refused() {
let any = Derived::new(SHALLOW, PARENT_ID).with_any(Keyframe::new());
assert_eq!(
lowered(At::new(SHALLOW.address()), &any),
Err(SqlLoweringError::RelationDepth(RelationDepthError::new(
FieldName::new("scene"),
1,
1
)))
);
let forward = SqlRefComparison::<_, sqlx::Sqlite>::new(SHALLOW, Keyframe::new().with_title("x"));
let frame = At::new(SHALLOW.address()).frame(PARENT_ID);
assert_eq!(
lowered(frame.at(), &forward),
Err(SqlLoweringError::RelationDepth(RelationDepthError::new(
FieldName::new("scene"),
1,
1
)))
);
}
#[test]
fn the_depth_a_row_refuses_at_is_its_own() {
let deep = hops(DEEP, 9);
let rendered = lowered(At::new(DEEP.address()).frame(PARENT_ID).at(), &deep)
.expect("ten names carry nine scopes");
assert!(
rendered.contains("\"deep\" \"__ig_deep_9__\""),
"{rendered}"
);
assert!(
rendered.contains("\"deep\" \"__ig_deep_1__\""),
"{rendered}"
);
let defaulted = hops(DEFAULTED, 9);
assert_eq!(
lowered(
At::new(DEFAULTED.address()).frame(PARENT_ID).at(),
&defaulted
),
Err(SqlLoweringError::RelationDepth(RelationDepthError::new(
FieldName::new("scene"),
8,
8
))),
"the default depth refuses at the default, by name",
);
}
fn hops(row: RelatedRow, hops: usize) -> Chain {
let mut built = Chain::Leaf(Box::new(Keyframe::new().with_title("x")));
for _ in 0..hops {
built = Chain::Hop(Box::new(SqlRefComparison::new(row, built)));
}
built
}
#[derive(Debug, Clone, PartialEq)]
enum Chain {
Leaf(Box<Keyframe>),
Hop(Box<SqlRefComparison<Chain, sqlx::Sqlite>>),
}
impl ComplexComparison<sqlx::Sqlite> for Chain {
fn conjuncts(&self) -> usize {
match self {
Self::Leaf(leaf) => ComplexComparison::conjuncts(leaf.as_ref()),
Self::Hop(hop) => ComplexComparison::conjuncts(hop.as_ref()),
}
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: SqlConjunction<'q, sqlx::Sqlite>,
) -> Result<SqlConjunction<'q, sqlx::Sqlite>, SqlLoweringError> {
match self {
Self::Leaf(leaf) => leaf.apply(at, builder),
Self::Hop(hop) => hop.apply(at, builder),
}
}
}
impl CollapsibleComparison<sqlx::Sqlite> for Chain {
type Id = Scalar;
fn only_id(&self) -> Option<&Scalar> {
None
}
}
#[derive(Debug, Clone, PartialEq)]
struct Nesting(Derived);
impl ComplexComparison<sqlx::Sqlite> for Nesting {
fn conjuncts(&self) -> usize {
ComplexComparison::conjuncts(&self.0)
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: SqlConjunction<'q, sqlx::Sqlite>,
) -> Result<SqlConjunction<'q, sqlx::Sqlite>, SqlLoweringError> {
self.0.apply(at, builder)
}
}
impl CollapsibleComparison<sqlx::Sqlite> for Nesting {
type Id = Scalar;
fn only_id(&self) -> Option<&Scalar> {
None
}
}
#[test]
fn a_derived_position_reads_the_row_and_leaves_the_path_unread() {
let any = Derived::new(KEYFRAME, SHOT_ID).with_any(Keyframe::new().with_title("Autumn"));
let outer = At::new(&SHOT).frame(FieldName::new("covers"));
let inner = outer.at().frame(FieldName::new("deeper"));
let top = lowered(At::new(&SHOT), &any).unwrap();
assert_eq!(top, render("covers", &any).0);
assert_eq!(top, lowered(inner.at(), &any).unwrap());
}
#[test]
fn the_nested_predicate_is_addressed_at_the_targets_own_top_level() {
let cover = Ref::new(KEYFRAME, Keyframe::new().with_id(10).unreferential());
let outer = At::new(&SHOT).frame(FieldName::new("cover"));
let inner = outer.at().frame(FieldName::new("id"));
assert_eq!(
render_at::<sqlx::Sqlite, _>(inner.at(), &cover),
(
"\"cover_id\" IN ( SELECT \"__ig_keyframe_1__\".\"id\" FROM \"keyframe\" \"__ig_keyframe_1__\" WHERE \"id\" = ? )".into(),
1
)
);
}
#[test]
fn the_quantifiers_bind_in_the_order_they_render() {
let bound = core::cell::RefCell::new(Vec::new());
let position = SqlDerivedComparison::<Probed<'_>, sqlx::Sqlite>::new(KEYFRAME, SHOT_ID)
.with_any(Probed {
value: 1,
bound: &bound,
})
.with_all(Probed {
value: 2,
bound: &bound,
})
.with_none(Probed {
value: 3,
bound: &bound,
});
lowered(At::new(&SHOT), &position).unwrap();
assert_eq!(*bound.borrow(), [1, 2, 3]);
}
struct Probed<'a> {
value: i64,
bound: &'a core::cell::RefCell<Vec<i64>>,
}
impl ComplexComparison<sqlx::Sqlite> for Probed<'_> {
fn conjuncts(&self) -> usize {
1
}
fn apply<'q>(
&'q self,
at: At<'_>,
mut builder: SqlConjunction<'q, sqlx::Sqlite>,
) -> Result<SqlConjunction<'q, sqlx::Sqlite>, SqlLoweringError> {
use crate::{Carrier, comparison::sql::tests::Probe};
let qb = builder.open();
crate::comparison::sql::push_column(qb, at);
qb.push(" = ");
Probe {
value: self.value,
bound: self.bound,
}
.push_bind(qb);
Ok(builder)
}
}
mod live {
use sqlx::{Connection as _, Executor as _, Row as _, sqlite::SqliteConnection};
use super::{
Derived, KEYFRAME, Keyframe, PARENT_ID, Ref, SCENE, SHOT, SHOT_ID, SqlRefComparison,
};
use crate::{
At, FieldName, ScalarFilter,
comparison::{
ComplexComparison, TryFromFilter,
sql::{QueryBuilder, SelectClause, SqlConjunction, SqlCountComparison, quote_ident},
},
};
async fn corpus() -> SqliteConnection {
let mut db = SqliteConnection::connect("sqlite::memory:")
.await
.expect("an in-memory database");
for ddl in [
r#"CREATE TABLE "shot" ("id" INTEGER PRIMARY KEY, "slate" TEXT NOT NULL,
"cover_id" INTEGER)"#,
r#"CREATE TABLE "keyframe" ("id" INTEGER PRIMARY KEY, "title" TEXT, "shot_id" INTEGER)"#,
] {
db.execute(ddl).await.expect("a table");
}
for (id, slate, cover) in [
(1i64, "alpha", Some(10i64)),
(2, "bravo", Some(11)),
(3, "delta", None),
(4, "echo", Some(12)),
(5, "foxtrot", None),
] {
sqlx::query(r#"INSERT INTO "shot" VALUES (?, ?, ?)"#)
.bind(id)
.bind(slate)
.bind(cover)
.execute(&mut db)
.await
.expect("a shot");
}
for (id, title, shot) in [
(10i64, Some("Autumn"), 1i64),
(11, Some("Meadow"), 1),
(12, Some("Zebra"), 2),
(13, Some("Autumn"), 4),
(14, Some("Autumn"), 5),
(15, None, 5),
] {
sqlx::query(r#"INSERT INTO "keyframe" VALUES (?, ?, ?)"#)
.bind(id)
.bind(title)
.bind(shot)
.execute(&mut db)
.await
.expect("a keyframe");
}
db
}
async fn shots(
db: &mut SqliteConnection,
at: At<'_>,
comparison: &impl ComplexComparison<sqlx::Sqlite>,
) -> Vec<i64> {
let mut statement = QueryBuilder::<SelectClause, sqlx::Sqlite>::select()
.push_field("\"id\"")
.from("\"shot\"")
.begin_where();
{
let accumulator = SqlConjunction::new(statement.inner_mut());
comparison
.apply(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 a_self_relation_correlates_to_the_outer_row() {
let mut db = scenes().await;
let children = Derived::new(SCENE, PARENT_ID).with_any(Keyframe::new().with_title("Autumn"));
assert_eq!(
rows(&mut db, At::new(SCENE.address()), &children).await,
[1, 3]
);
let none = Derived::new(SCENE, PARENT_ID).with_none(Keyframe::new().with_title("Autumn"));
assert_eq!(rows(&mut db, At::new(SCENE.address()), &none).await, [2, 4]);
let childless = Derived::new(SCENE, PARENT_ID).with_any(Keyframe::new());
assert_eq!(
rows(&mut db, At::new(SCENE.address()), &childless).await,
[1, 3]
);
}
#[tokio::test]
async fn two_levels_of_one_table_answer_through_two_aliases() {
let mut db = scenes().await;
let inner = Derived::new(SCENE, PARENT_ID).with_any(Keyframe::new().with_title("Autumn"));
let through = SqlRefComparison::<_, sqlx::Sqlite>::new(SCENE, super::Nesting(inner));
let frame = At::new(SCENE.address()).frame(PARENT_ID);
assert_eq!(rows(&mut db, frame.at(), &through).await, [2, 3, 4]);
let one_level = Derived::new(SCENE, PARENT_ID).with_any(Keyframe::new().with_title("Autumn"));
assert_eq!(
rows(&mut db, At::new(SCENE.address()), &one_level).await,
[1, 3]
);
}
async fn scenes() -> SqliteConnection {
let mut db = SqliteConnection::connect("sqlite::memory:")
.await
.expect("an in-memory database");
db.execute(
r#"CREATE TABLE "scene" ("id" INTEGER PRIMARY KEY, "title" TEXT, "parent_id" INTEGER)"#,
)
.await
.expect("a table");
for (id, title, parent) in [
(1i64, "root", None::<i64>),
(2, "Autumn", Some(1)),
(3, "other", Some(1)),
(4, "Autumn", Some(3)),
] {
sqlx::query(r#"INSERT INTO "scene" VALUES (?, ?, ?)"#)
.bind(id)
.bind(title)
.bind(parent)
.execute(&mut db)
.await
.expect("a scene");
}
db
}
async fn rows(
db: &mut SqliteConnection,
at: At<'_>,
comparison: &impl ComplexComparison<sqlx::Sqlite>,
) -> Vec<i64> {
let table = quote_ident::<sqlx::Sqlite>(at.record().table());
let mut statement = QueryBuilder::<SelectClause, sqlx::Sqlite>::select()
.push_field("\"id\"")
.from(table.as_str())
.begin_where();
{
let accumulator = SqlConjunction::new(statement.inner_mut());
comparison
.apply(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 the_semi_join_answers_about_the_referenced_row() {
let mut db = corpus().await;
let cover = Ref::new(KEYFRAME, Keyframe::new().with_title("Autumn"));
let frame = At::new(&SHOT).frame(FieldName::new("cover_id"));
assert_eq!(shots(&mut db, frame.at(), &cover).await, [1]);
let any = Derived::new(KEYFRAME, SHOT_ID).with_any(Keyframe::new().with_title("Autumn"));
assert_eq!(shots(&mut db, At::new(&SHOT), &any).await, [1, 4, 5]);
}
#[tokio::test]
async fn the_collapsed_form_answers_exactly_as_its_subquery_would() {
let mut db = corpus().await;
let frame = At::new(&SHOT).frame(FieldName::new("cover_id"));
let collapsing = Ref::new(KEYFRAME, Keyframe::new().with_id(11));
let declining = Ref::new(KEYFRAME, Keyframe::new().with_id(11).unreferential());
let collapsed = shots(&mut db, frame.at(), &collapsing).await;
assert_eq!(collapsed, [2]);
assert_eq!(collapsed, shots(&mut db, frame.at(), &declining).await);
}
#[tokio::test]
async fn every_quantifier_answers_its_own_question() {
let mut db = corpus().await;
let top = At::new(&SHOT);
let autumn = || Keyframe::new().with_title("Autumn");
let any = Derived::new(KEYFRAME, SHOT_ID).with_any(autumn());
let all = Derived::new(KEYFRAME, SHOT_ID).with_all(autumn());
let none = Derived::new(KEYFRAME, SHOT_ID).with_none(autumn());
let count = Derived::new(KEYFRAME, SHOT_ID).with_count(
SqlCountComparison::try_from_filter(ScalarFilter::<usize>::new().with_gt(1)).unwrap(),
);
assert_eq!(shots(&mut db, top, &any).await, [1, 4, 5]);
assert_eq!(shots(&mut db, top, &all).await, [3, 4, 5]);
assert_eq!(shots(&mut db, top, &none).await, [2, 3]);
assert_eq!(shots(&mut db, top, &count).await, [1, 5]);
}
#[tokio::test]
async fn all_over_a_row_with_no_children_is_vacuously_true() {
let mut db = corpus().await;
let top = At::new(&SHOT);
let all = Derived::new(KEYFRAME, SHOT_ID).with_all(Keyframe::new().with_title("Autumn"));
let any = Derived::new(KEYFRAME, SHOT_ID).with_any(Keyframe::new().with_title("Autumn"));
assert!(shots(&mut db, top, &all).await.contains(&3));
assert!(!shots(&mut db, top, &any).await.contains(&3));
let vacuous = Derived::new(KEYFRAME, SHOT_ID).with_all(Keyframe::new());
assert_eq!(shots(&mut db, top, &vacuous).await, [1, 2, 3, 4, 5]);
let has_one = Derived::new(KEYFRAME, SHOT_ID).with_any(Keyframe::new());
assert_eq!(shots(&mut db, top, &has_one).await, [1, 2, 4, 5]);
}
}