#![cfg(feature = "sqlite")]
use sqlx::{Row as _, Sqlite};
use super::{InterfaceFind, SqlInterface, total_order, union};
use crate::{
Carrier, ComplexComparison, Cursor, CursorValue, FieldName, InterfaceArm, InterfaceColumn,
InterfaceKind, OrderDirection, OrderTerm, RecordAddress, ScalarFilter, TermName, TryFromFilter,
Walk,
comparison::{
At, Backend, Frame,
sql::{SqlKeyset, SqlLoweringError, SqlOrder, SqlScalarComparison},
},
query::Page,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum MediaKind {
Video,
Audio,
}
impl InterfaceKind for MediaKind {
const INTERFACE: &'static str = "Media";
const ALL: &'static [Self] = &[Self::Video, Self::Audio];
fn as_str(self) -> &'static str {
match self {
Self::Video => "video",
Self::Audio => "audio",
}
}
}
#[derive(Debug, Clone, PartialEq)]
enum MediaId {
Video(i64),
Audio(String),
}
impl MediaId {
const fn kind(&self) -> MediaKind {
match self {
Self::Video(_) => MediaKind::Video,
Self::Audio(_) => MediaKind::Audio,
}
}
}
#[derive(Debug, Clone, PartialEq)]
struct MediaSqliteRow {
kind: MediaKind,
id: MediaId,
title: String,
}
impl sqlx::FromRow<'_, sqlx::sqlite::SqliteRow> for MediaSqliteRow {
fn from_row(row: &sqlx::sqlite::SqliteRow) -> sqlx::Result<Self> {
let word: String = row.try_get("__ig_kind__")?;
let kind = MediaKind::parse(&word).map_err(|unknown| sqlx::Error::ColumnDecode {
index: "__ig_kind__".to_owned(),
source: Box::new(unknown),
})?;
let id = match kind {
MediaKind::Video => MediaId::Video(row.try_get("id")?),
MediaKind::Audio => MediaId::Audio(row.try_get("id")?),
};
Ok(Self {
kind,
id,
title: row.try_get("title")?,
})
}
}
enum Media {}
const VIDEO: &[InterfaceColumn] = &[InterfaceColumn::new(
FieldName::new("title"),
FieldName::new("title"),
)];
const AUDIO: &[InterfaceColumn] = &[InterfaceColumn::new(
FieldName::new("title"),
FieldName::new("label"),
)];
#[derive(Debug, Clone, Copy, PartialEq)]
enum MediaOrderBy {
Title(OrderDirection),
}
impl SqlInterface<Sqlite> for Media {
type Kind = MediaKind;
type Row = MediaSqliteRow;
type Comparison = TitleIs;
type Value = MediaValue;
type Order = MediaOrderBy;
const ARMS: &'static [InterfaceArm<MediaKind>] = &[
InterfaceArm::new(MediaKind::Video, VIDEO),
InterfaceArm::new(MediaKind::Audio, AUDIO),
];
fn address(kind: MediaKind) -> RecordAddress {
match kind {
MediaKind::Video => VIDEO_ADDRESS,
MediaKind::Audio => AUDIO_ADDRESS,
}
}
fn term(order: MediaOrderBy) -> OrderTerm {
match order {
MediaOrderBy::Title(direction) => {
OrderTerm::new(TermName::new("title"), FieldName::new("title"), direction)
}
}
}
fn value(row: &MediaSqliteRow, term: &OrderTerm) -> Option<MediaValue> {
match term.column().as_str() {
"title" => Some(MediaValue::Title(row.title.clone())),
"__ig_kind__" => Some(MediaValue::Kind(row.id.kind().as_str())),
"id" => Some(MediaValue::Address(row.id.clone())),
_ => None,
}
}
}
const VIDEO_ADDRESS: RecordAddress =
RecordAddress::new(FieldName::new("video"), &[FieldName::new("id")]);
const AUDIO_ADDRESS: RecordAddress =
RecordAddress::new(FieldName::new("audio"), &[FieldName::new("audio_id")]);
#[test]
fn each_member_reaches_its_own_arm() {
for kind in MediaKind::ALL.iter().copied() {
let arm = <Media as SqlInterface<Sqlite>>::arm(kind).expect("every member has an arm");
assert_eq!(arm.kind(), kind);
}
}
#[test]
fn an_arm_carries_what_its_member_calls_the_shared_column() {
let video = <Media as SqlInterface<Sqlite>>::arm(MediaKind::Video).expect("an arm");
let audio = <Media as SqlInterface<Sqlite>>::arm(MediaKind::Audio).expect("an arm");
assert_eq!(video.columns()[0].field().as_str(), "title");
assert_eq!(video.columns()[0].column().as_str(), "title");
assert_eq!(audio.columns()[0].field().as_str(), "title");
assert_eq!(audio.columns()[0].column().as_str(), "label");
}
#[test]
fn every_arm_projects_the_interfaces_own_columns_in_one_order() {
let promised: Vec<&str> = <Media as SqlInterface<Sqlite>>::ARMS[0]
.columns()
.iter()
.map(|column| column.field().as_str())
.collect();
for arm in <Media as SqlInterface<Sqlite>>::ARMS {
let names: Vec<&str> = arm
.columns()
.iter()
.map(|column| column.field().as_str())
.collect();
assert_eq!(
names,
promised,
"`{}` promises something else",
arm.kind().as_str()
);
}
}
#[test]
fn the_table_is_the_members_address_and_not_a_second_copy() {
assert_eq!(
<Media as SqlInterface<Sqlite>>::table(MediaKind::Audio).as_str(),
"audio"
);
assert_eq!(
<Media as SqlInterface<Sqlite>>::address(MediaKind::Audio)
.keys()
.first()
.expect("a row is addressed by at least one column")
.as_str(),
"audio_id",
"the address column is the member's too, and the members need not agree about its name"
);
}
fn _the_parameter_is_the_database<Db: Backend + sqlx::Database, I: SqlInterface<Db>>() {}
fn _media_is_about_sqlite() {
_the_parameter_is_the_database::<Sqlite, Media>();
}
#[derive(Debug, Clone, PartialEq)]
enum MediaValue {
Title(String),
Kind(&'static str),
Address(MediaId),
}
impl CursorValue for MediaValue {
fn write_cursor(&self, out: &mut Vec<u8>) {
match self {
Self::Title(value) => {
out.push(0);
value.write_cursor(out);
}
Self::Kind(value) => {
out.push(1);
(*value).to_owned().write_cursor(out);
}
Self::Address(MediaId::Video(value)) => {
out.push(2);
value.write_cursor(out);
}
Self::Address(MediaId::Audio(value)) => {
out.push(3);
value.write_cursor(out);
}
}
}
fn read_cursor(bytes: &[u8]) -> Option<Self> {
let (tag, rest) = <[u8]>::split_first(bytes)?;
match *tag {
0 => String::read_cursor(rest).map(Self::Title),
1 => String::read_cursor(rest).and_then(|word| {
MediaKind::parse(&word)
.ok()
.map(|kind| Self::Kind(kind.as_str()))
}),
2 => i64::read_cursor(rest).map(|id| Self::Address(MediaId::Video(id))),
3 => String::read_cursor(rest).map(|id| Self::Address(MediaId::Audio(id))),
_ => None,
}
}
}
impl Carrier<Sqlite> for MediaValue {
fn push_bind(&self, qb: &mut sqlx::QueryBuilder<Sqlite>) {
match self {
Self::Title(value) => Carrier::<Sqlite>::push_bind(value, qb),
Self::Kind(value) => Carrier::<Sqlite>::push_bind(&(*value).to_owned(), qb),
Self::Address(MediaId::Video(value)) => Carrier::<Sqlite>::push_bind(value, qb),
Self::Address(MediaId::Audio(value)) => Carrier::<Sqlite>::push_bind(value, qb),
}
}
}
struct TitleIs(SqlScalarComparison<String, Sqlite>);
impl ComplexComparison<Sqlite> for TitleIs {
fn conjuncts(&self) -> usize {
ComplexComparison::<Sqlite>::conjuncts(&self.0)
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: <Sqlite as Backend>::Builder<'q>,
) -> Result<<Sqlite as Backend>::Builder<'q>, SqlLoweringError> {
let frame = At::frame(at, FieldName::new("title"));
ComplexComparison::<Sqlite>::apply(&self.0, Frame::at(&frame), builder)
}
}
fn titled() -> TitleIs {
TitleIs(
SqlScalarComparison::try_from_filter(
ScalarFilter::<std::string::String>::new().with_eq("a".to_owned()),
)
.expect("a text equality crosses into SQLite"),
)
}
fn rendered(filter: Option<&TitleIs>, written: &[OrderTerm], limit: Option<u32>) -> String {
let order = total_order::<Media, sqlx::Sqlite>(written);
let order = SqlOrder::<Sqlite>::new(&order).expect("SQLite places NULL either way");
let statement = union::<Media, Sqlite>(filter, &order, None, Walk::Forward, limit)
.expect("the binding renders");
::core::convert::AsRef::<str>::as_ref(&statement.sql()).to_owned()
}
#[test]
fn the_union_projects_every_member_under_the_interfaces_own_names() {
assert_eq!(
rendered(None, &[], None),
r#"SELECT * FROM ( SELECT "title" AS "title", 'video' AS "__ig_kind__", "id" AS "id" FROM "video" UNION ALL SELECT "label" AS "title", 'audio' AS "__ig_kind__", "audio_id" AS "id" FROM "audio" ) AS "__ig_union__" ORDER BY "__ig_kind__" ASC, "id" ASC"#
);
}
#[test]
fn the_shared_predicate_speaks_the_interfaces_vocabulary_once() {
let filter = titled();
let statement = rendered(Some(&filter), &[], None);
assert!(
statement
.ends_with(r#") AS "__ig_union__" WHERE "title" = ? ORDER BY "__ig_kind__" ASC, "id" ASC"#),
"{statement}"
);
assert_eq!(statement.matches('?').count(), 1, "{statement}");
}
#[test]
fn the_tail_is_the_discriminant_and_then_the_address() {
let written = [OrderTerm::new(
TermName::new("title"),
FieldName::new("title"),
OrderDirection::Desc,
)];
let statement = rendered(None, &written, Some(3));
assert!(
statement.ends_with(r#"ORDER BY "title" DESC, "__ig_kind__" ASC, "id" ASC LIMIT ?"#),
"{statement}"
);
}
#[test]
fn a_moved_prefix_moves_the_words_the_union_invents() {
let order = total_order::<Legacy, sqlx::Sqlite>(&[]);
let order = SqlOrder::<Sqlite>::new(&order).expect("SQLite places NULL either way");
let statement =
union::<Legacy, Sqlite>(None, &order, None, Walk::Forward, None).expect("the binding renders");
assert_eq!(
::core::convert::AsRef::<str>::as_ref(&statement.sql()),
r#"SELECT * FROM ( SELECT "title" AS "title", 'video' AS "__mine_kind__", "id" AS "id" FROM "video" UNION ALL SELECT "label" AS "title", 'audio' AS "__mine_kind__", "audio_id" AS "id" FROM "audio" ) AS "__mine_union__" ORDER BY "__mine_kind__" ASC, "id" ASC"#
);
}
#[test]
fn a_moved_prefix_leaves_the_terms_identity_alone() {
let defaulted = <Media as SqlInterface<Sqlite>>::KIND_TERM;
let moved = <Legacy as SqlInterface<Sqlite>>::KIND_TERM;
assert_eq!(
defaulted.identity(),
moved.identity(),
"a cursor freezes this"
);
assert_eq!(defaulted.identity(), TermName::new("__ig_kind__"));
assert_ne!(defaulted.column(), moved.column(), "and renders that");
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct Legacy;
impl SqlInterface<Sqlite> for Legacy {
type Kind = MediaKind;
type Row = MediaSqliteRow;
type Comparison = TitleIs;
type Value = MediaValue;
type Order = MediaOrderBy;
const ARMS: &'static [InterfaceArm<MediaKind>] = <Media as SqlInterface<Sqlite>>::ARMS;
const KIND: &'static FieldName = FieldName::new("__mine_kind__");
const SOURCE: &'static FieldName = FieldName::new("__mine_union__");
fn address(kind: MediaKind) -> RecordAddress {
<Media as SqlInterface<Sqlite>>::address(kind)
}
fn term(order: MediaOrderBy) -> OrderTerm {
<Media as SqlInterface<Sqlite>>::term(order)
}
fn value(row: &MediaSqliteRow, term: &OrderTerm) -> Option<MediaValue> {
<Media as SqlInterface<Sqlite>>::value(row, term)
}
}
#[test]
fn a_written_term_over_the_tail_moves_it() {
let written = [OrderTerm::new(
TermName::new("id"),
FieldName::new("id"),
OrderDirection::Desc,
)];
let completed = total_order::<Media, sqlx::Sqlite>(&written);
assert_eq!(completed.len(), 2, "{completed:?}");
assert_eq!(completed[0].column(), FieldName::new("__ig_kind__"));
assert_eq!(completed[1].column(), FieldName::new("id"));
assert_eq!(
completed[1].direction(),
OrderDirection::Asc,
"the tail is the framework's, so a client cannot invert half of it and keep the other half"
);
}
fn resumed(written: &[OrderTerm], title: &str, id: MediaId) -> Cursor<MediaValue> {
let order = total_order::<Media, sqlx::Sqlite>(written);
let mut values: Vec<Option<MediaValue>> = written
.iter()
.map(|_| Some(MediaValue::Title(title.to_owned())))
.collect();
values.push(Some(MediaValue::Kind(id.kind().as_str())));
values.push(Some(MediaValue::Address(id)));
Cursor::at(&order, values)
}
#[test]
fn a_resumed_page_renders_the_general_keyset_over_the_tail() {
let written = [OrderTerm::new(
TermName::new("title"),
FieldName::new("title"),
OrderDirection::Asc,
)];
let cursor = resumed(&written, "a", MediaId::Audio("a-7".to_owned()));
let order = total_order::<Media, sqlx::Sqlite>(&written);
let order = SqlOrder::<Sqlite>::new(&order).expect("SQLite places NULL either way");
let keyset =
SqlKeyset::resume(order, &cursor, Walk::Forward).expect("the cursor is this order's");
let statement = union::<Media, Sqlite>(None, &order, Some(&keyset), Walk::Forward, Some(2))
.expect("the binding renders");
assert!(
::core::convert::AsRef::<str>::as_ref(&statement.sql()).ends_with(
r#") AS "__ig_union__" WHERE ("title" > ? OR ("title" = ? AND ("__ig_kind__" > ? OR ("__ig_kind__" = ? AND ("id" > ?))))) ORDER BY "title" ASC, "__ig_kind__" ASC, "id" ASC LIMIT ?"#
),
"{}",
::core::convert::AsRef::<str>::as_ref(&statement.sql())
);
}
#[test]
fn a_filtered_page_joins_both_conjuncts() {
let cursor = resumed(&[], "a", MediaId::Audio("a-7".to_owned()));
let order = total_order::<Media, sqlx::Sqlite>(&[]);
let order = SqlOrder::<Sqlite>::new(&order).expect("SQLite places NULL either way");
let keyset =
SqlKeyset::resume(order, &cursor, Walk::Forward).expect("the cursor is this order's");
let filter = titled();
let statement = union::<Media, Sqlite>(Some(&filter), &order, Some(&keyset), Walk::Forward, None)
.expect("the binding renders");
let sql = ::core::convert::AsRef::<str>::as_ref(&statement.sql()).to_owned();
assert!(
sql.contains(r#"WHERE "title" = ? AND ("__ig_kind__" > ?"#),
"{sql}"
);
}
async fn corpus() -> sqlx::sqlite::SqliteConnection {
use sqlx::Connection as _;
let mut db = sqlx::sqlite::SqliteConnection::connect("sqlite::memory:")
.await
.expect("an in-memory database");
for statement in [
r#"CREATE TABLE "video" ("id" INTEGER PRIMARY KEY, "title" TEXT NOT NULL)"#,
r#"CREATE TABLE "audio" ("audio_id" TEXT PRIMARY KEY, "label" TEXT NOT NULL)"#,
r#"INSERT INTO "video" VALUES (1, 'a'), (2, 'b'), (3, 'c')"#,
r#"INSERT INTO "audio" VALUES ('a-1', 'a'), ('a-2', 'b')"#,
] {
sqlx::query(statement)
.execute(&mut db)
.await
.expect("the fixture's own DDL");
}
db
}
fn by_title() -> [MediaOrderBy; 1] {
[MediaOrderBy::Title(OrderDirection::Asc)]
}
fn rows(page: &Page<MediaSqliteRow, MediaValue>) -> Vec<(String, MediaId)> {
page
.edges()
.iter()
.map(|edge| (edge.node().title.clone(), edge.node().id.clone()))
.collect()
}
#[tokio::test]
async fn a_page_walks_both_members_in_one_order_and_resumes_across_the_tie() {
let mut db = corpus().await;
let written = by_title();
let first = InterfaceFind::<Media, Sqlite, _>::new(&mut db)
.order(&written)
.first(3)
.fetch()
.await
.expect("the first page");
assert_eq!(
rows(&first),
[
("a".to_owned(), MediaId::Audio("a-1".to_owned())),
("a".to_owned(), MediaId::Video(1)),
("b".to_owned(), MediaId::Audio("a-2".to_owned())),
],
"the tie on `a` is broken by the DISCRIMINANT first — `audio` sorts before `video` — and only \
then by an id"
);
assert!(first.has_next_page(), "two rows are still behind it");
assert!(!first.has_previous_page());
let boundary = first.end_cursor().expect("a non-empty page ends somewhere");
let second = InterfaceFind::<Media, Sqlite, _>::new(&mut db)
.order(&written)
.after(boundary)
.fetch()
.await
.expect("the second page");
assert_eq!(
rows(&second),
[
("b".to_owned(), MediaId::Video(2)),
("c".to_owned(), MediaId::Video(3)),
]
);
assert!(!second.has_next_page(), "the walk is exhausted");
assert!(second.has_previous_page(), "a position was given");
}
#[tokio::test]
async fn a_pages_cursor_round_trips_through_the_string_a_client_holds() {
let mut db = corpus().await;
let written = by_title();
let first = InterfaceFind::<Media, Sqlite, _>::new(&mut db)
.order(&written)
.first(1)
.fetch()
.await
.expect("the first page");
let text = first
.end_cursor()
.expect("a non-empty page ends somewhere")
.encode();
let decoded = Cursor::<MediaValue>::decode(&text).expect("the framework's own encoding");
let second = InterfaceFind::<Media, Sqlite, _>::new(&mut db)
.order(&written)
.after(&decoded)
.fetch()
.await
.expect("the second page");
assert_eq!(
rows(&second)[0],
("a".to_owned(), MediaId::Video(1)),
"the page after the first `a` is the OTHER `a`, which only the tail can say"
);
}
#[tokio::test]
async fn a_filtered_page_reads_both_members_through_their_own_column_names() {
let mut db = corpus().await;
let filter = titled();
let page = InterfaceFind::<Media, Sqlite, _>::new(&mut db)
.filter(&filter)
.order(&by_title())
.first(10)
.fetch()
.await
.expect("the page");
assert_eq!(
rows(&page),
[
("a".to_owned(), MediaId::Audio("a-1".to_owned())),
("a".to_owned(), MediaId::Video(1)),
],
"one predicate, written once, reaching `video.title` and `audio.label` through the aliases"
);
}
#[tokio::test]
async fn the_backward_walk_comes_back_in_display_order() {
let mut db = corpus().await;
let page = InterfaceFind::<Media, Sqlite, _>::new(&mut db)
.order(&by_title())
.last(2)
.fetch()
.await
.expect("the page");
assert_eq!(
rows(&page),
[
("b".to_owned(), MediaId::Video(2)),
("c".to_owned(), MediaId::Video(3)),
]
);
assert!(page.has_previous_page(), "three rows are still ahead of it");
}
#[tokio::test]
async fn the_decoded_rows_discriminant_and_address_are_one_answer() {
let mut db = corpus().await;
let page = InterfaceFind::<Media, Sqlite, _>::new(&mut db)
.order(&by_title())
.first(10)
.fetch()
.await
.expect("the page");
for edge in page.edges() {
assert_eq!(edge.node().kind, edge.node().id.kind(), "{:?}", edge.node());
}
}
#[test]
fn the_surface_is_what_says_whether_a_read_is_already_open() {
const {
assert!(!<&mut sqlx::sqlite::SqliteConnection as super::BeginRead>::IN_TRANSACTION);
assert!(<&mut sqlx::Transaction<'_, Sqlite> as super::BeginRead>::IN_TRANSACTION);
}
}
#[tokio::test]
async fn a_page_inside_a_callers_read_passes_through_and_leaves_it_open() {
let mut db = corpus().await;
let mut read = sqlx::Connection::begin(&mut db)
.await
.expect("the caller's own transaction");
let page = InterfaceFind::<Media, Sqlite, _>::new(&mut read)
.order(&by_title())
.first(2)
.fetch()
.await
.expect("a page inside a transaction");
assert_eq!(rows(&page).len(), 2);
let held: i64 = sqlx::query_scalar(r#"SELECT COUNT(*) FROM "video""#)
.fetch_one(&mut *read)
.await
.expect("the transaction is still open");
assert_eq!(held, 3);
read.commit().await.expect("the caller closes their own");
}