#![cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
use core::marker::PhantomData;
use super::{Ordering, SortValues, ordered};
use crate::{
Carrier, ColumnName, ColumnShape, ComplexComparison, Cursor, CursorValue, FieldName,
Identifiable, OrderDirection, OrderTerm, Record, RecordAddress, TermName, Transformer, Walk,
comparison::{
At, Backend,
sql::{OrderSubjects, SqlKeyIn, SqlKeyset, SqlOrder, TermColumns},
},
query::sql::{
CrossingError, ELEMENT, EdgeCollection, EdgeShape, SqlDialect, SqlOrdering, SqlQuery,
distribute,
},
};
#[derive(Debug, Clone, PartialEq)]
struct Reel {
id: i64,
title: String,
tags: Vec<String>,
}
impl Identifiable for Reel {
type Id = i64;
fn id_ref(&self) -> &i64 {
&self.id
}
}
impl Transformer for Reel {
type Key = i64;
type Lineage = ();
type Record = Self;
type Graphql = ();
fn key(&self) -> i64 {
self.id
}
}
#[derive(Debug, Clone, PartialEq)]
struct ReelRow {
id: i64,
title: String,
tags: Vec<String>,
}
impl<'r, R> sqlx::FromRow<'r, R> for ReelRow
where
R: sqlx::Row,
i64: sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
String: sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
for<'a> &'a str: sqlx::ColumnIndex<R>,
{
fn from_row(row: &'r R) -> Result<Self, sqlx::Error> {
Ok(Self {
id: row.try_get("id")?,
title: row.try_get("title")?,
tags: Vec::new(),
})
}
}
fn reel_key<Db>(row: &ReelRow, _: usize, qb: &mut sqlx::QueryBuilder<Db>)
where
Db: sqlx::Database,
i64: Carrier<Db>,
{
row.id.push_bind(qb);
}
fn reel_tags<Db>(page: &mut [ReelRow], gathered: &[Db::Row]) -> Result<(), sqlx::Error>
where
Db: sqlx::Database,
for<'r> i64: sqlx::Decode<'r, Db> + sqlx::Type<Db>,
for<'r> String: sqlx::Decode<'r, Db> + sqlx::Type<Db>,
for<'a> &'a str: sqlx::ColumnIndex<Db::Row>,
{
use sqlx::Row as _;
let element: &str = ELEMENT;
distribute(
page,
gathered,
|row| row.id,
|row| row.try_get("id"),
|row| row.try_get::<String, _>(element),
|row| &mut row.tags,
)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ReelOrder {
Tags(OrderDirection),
Title(OrderDirection),
Id(OrderDirection),
}
#[derive(Debug, Clone, PartialEq)]
enum ReelValue {
Tags(Vec<u8>),
Title(String),
Id(i64),
}
impl CursorValue for ReelValue {
fn write_cursor(&self, out: &mut Vec<u8>) {
match self {
Self::Tags(value) => {
out.push(0);
value.write_cursor(out);
}
Self::Title(value) => {
out.push(1);
value.write_cursor(out);
}
Self::Id(value) => {
out.push(2);
value.write_cursor(out);
}
}
}
fn read_cursor(bytes: &[u8]) -> Option<Self> {
let (tag, rest) = bytes.split_first()?;
match tag {
0 => Vec::<u8>::read_cursor(rest).map(Self::Tags),
1 => String::read_cursor(rest).map(Self::Title),
2 => i64::read_cursor(rest).map(Self::Id),
_ => None,
}
}
}
impl<Db> Carrier<Db> for ReelValue
where
Db: sqlx::Database,
Vec<u8>: Carrier<Db>,
String: Carrier<Db>,
i64: Carrier<Db>,
{
fn push_bind(&self, qb: &mut sqlx::QueryBuilder<Db>) {
match self {
Self::Tags(value) => value.push_bind(qb),
Self::Title(value) => value.push_bind(qb),
Self::Id(value) => value.push_bind(qb),
}
}
}
struct ReelFilter<Db>(PhantomData<fn() -> Db>);
impl<Db: Backend> ComplexComparison<Db> for ReelFilter<Db> {
fn conjuncts(&self) -> usize {
0
}
fn apply<'q>(
&'q self,
_: At<'_>,
builder: <Db as Backend>::Builder<'q>,
) -> Result<<Db as Backend>::Builder<'q>, <Db as Backend>::Error> {
Ok(builder)
}
}
impl<Db: Backend> Record<Db> for Reel {
type Row = ReelRow;
type Comparison = ReelFilter<Db>;
type OrderBy = ReelOrder;
}
impl<Db> SqlQuery<Db> for ReelRow
where
Db: Backend + sqlx::Database,
SqlKeyIn<ReelValue, Db, 1>: ComplexComparison<Db>,
i64: Carrier<Db>,
for<'r> i64: sqlx::Decode<'r, Db> + sqlx::Type<Db>,
for<'r> String: sqlx::Decode<'r, Db> + sqlx::Type<Db>,
for<'a> &'a str: sqlx::ColumnIndex<Db::Row>,
{
type Record = Reel;
type Address = SqlKeyIn<ReelValue, Db, 1>;
const ADDRESS: RecordAddress =
RecordAddress::new(FieldName::new("reel"), &[FieldName::new("id")]);
const ALIASES: &'static [&'static str] = &[
"__ig_reel_0__",
"__ig_reel_1__",
"__ig_reel_2__",
"__ig_reel_3__",
"__ig_reel_4__",
"__ig_reel_5__",
"__ig_reel_6__",
"__ig_reel_7__",
];
const COLUMNS: &'static [ColumnShape] = &[
ColumnShape::Plain(ColumnName::new("id")),
ColumnShape::Plain(ColumnName::new("title")),
];
const COLLECTIONS: &'static [EdgeCollection<Self, Db>] = &[EdgeCollection::gather(
&[FieldName::new("tags")],
EdgeShape::Sequence,
reel_key::<Db>,
reel_tags::<Db>,
)];
fn addresses(ids: &[i64]) -> Result<Self::Address, CrossingError> {
Ok(SqlKeyIn::new(
["id"],
ids
.iter()
.map(|id| [ReelValue::Id(*id)])
.collect::<Vec<_>>(),
))
}
fn id(&self) -> Result<i64, CrossingError> {
Ok(self.id)
}
fn record(self) -> Result<Reel, CrossingError> {
Ok(Reel {
id: self.id,
title: self.title,
tags: self.tags,
})
}
}
impl<Db> SqlOrdering<Db> for ReelRow
where
Db: Backend + sqlx::Database,
SqlKeyIn<ReelValue, Db, 1>: ComplexComparison<Db>,
ReelValue: Carrier<Db>,
TermColumns: OrderSubjects<Db>,
i64: Carrier<Db>,
for<'r> i64: sqlx::Decode<'r, Db> + sqlx::Type<Db>,
for<'r> String: sqlx::Decode<'r, Db> + sqlx::Type<Db>,
for<'r> Vec<u8>: sqlx::Decode<'r, Db> + sqlx::Type<Db>,
for<'a> &'a str: sqlx::ColumnIndex<Db::Row>,
{
type Order = ReelOrder;
type Value = ReelValue;
type Subjects = TermColumns;
fn complete(written: &[ReelOrder]) -> Vec<ReelOrder> {
let mut order = written.to_vec();
if !written.iter().any(|term| matches!(term, ReelOrder::Id(_))) {
order.push(ReelOrder::Id(OrderDirection::Asc));
}
order
}
fn subjects(_: &[ReelOrder]) -> TermColumns {
TermColumns
}
fn term(order: ReelOrder) -> OrderTerm {
match order {
ReelOrder::Tags(direction) => OrderTerm::shadow(TermName::new("tags"), COMPANION, direction),
ReelOrder::Title(direction) => {
OrderTerm::new(TermName::new("title"), FieldName::new("title"), direction)
}
ReelOrder::Id(direction) => {
OrderTerm::new(TermName::new("id"), FieldName::new("id"), direction)
}
}
}
fn value(
&self,
order: ReelOrder,
_: usize,
raw: &Db::Row,
alias: &str,
) -> Result<Option<ReelValue>, sqlx::Error> {
match order {
ReelOrder::Tags(_) => {
sqlx::Row::try_get::<Vec<u8>, _>(raw, alias).map(|bytes| Some(ReelValue::Tags(bytes)))
}
ReelOrder::Title(_) => Ok(Some(ReelValue::Title(self.title.clone()))),
ReelOrder::Id(_) => Ok(Some(ReelValue::Id(self.id))),
}
}
}
const COMPANION: &FieldName = FieldName::new("__ig_tags_sort__");
fn terms<Db>(written: &[ReelOrder]) -> Vec<OrderTerm>
where
Db: SqlDialect,
ReelRow: SqlOrdering<Db, Order = ReelOrder>,
{
<ReelRow as SqlOrdering<Db>>::complete(written)
.iter()
.map(|term| <ReelRow as SqlOrdering<Db>>::term(*term))
.collect()
}
fn paged<Db>(written: &[ReelOrder], boundary: Option<&Cursor<ReelValue>>, walk: Walk) -> String
where
Db: SqlDialect,
ReelRow: SqlOrdering<Db, Order = ReelOrder, Value = ReelValue, Subjects = TermColumns>,
ReelValue: Carrier<Db>,
i64: sqlx::Type<Db> + for<'t> sqlx::Encode<'t, Db>,
{
let terms = terms::<Db>(written);
let order = SqlOrder::<Db>::new(&terms).expect("a companion column is a column");
let subjects = &TermColumns;
let keyset = boundary
.map(|cursor| SqlKeyset::resume_with(order, cursor, walk, subjects))
.transpose()
.expect("this cursor is this order's");
ordered::<ReelRow, Db>(
None,
None,
Ordering {
order,
subjects,
keyset: keyset.as_ref(),
values: SortValues::Projected,
},
walk,
Some(2),
None,
)
.expect("a renderable page")
.into_string()
}
#[cfg(feature = "sqlite")]
fn scanned<Db>(written: &[ReelOrder]) -> String
where
Db: SqlDialect,
ReelRow: SqlOrdering<Db, Order = ReelOrder, Value = ReelValue, Subjects = TermColumns>,
ReelValue: Carrier<Db>,
i64: sqlx::Type<Db> + for<'t> sqlx::Encode<'t, Db>,
{
let terms = terms::<Db>(written);
let order = SqlOrder::<Db>::new(&terms).expect("a companion column is a column");
ordered::<ReelRow, Db>(
None,
None,
Ordering {
order,
subjects: &TermColumns,
keyset: None,
values: SortValues::Unread,
},
Walk::Forward,
None,
None,
)
.expect("a renderable scan")
.into_string()
}
#[cfg(feature = "sqlite")]
fn boundary(tags: &[&str], id: i64, written: &[ReelOrder]) -> Cursor<ReelValue> {
let collection: Vec<String> = tags.iter().map(|tag| (*tag).to_owned()).collect();
Cursor::at(
&terms::<sqlx::Sqlite>(written),
[
Some(ReelValue::Tags(crate::collection_sort_key(&collection))),
Some(ReelValue::Id(id)),
],
)
}
const BY_TAGS: &[ReelOrder] = &[ReelOrder::Tags(OrderDirection::Asc)];
#[cfg(feature = "sqlite")]
#[test]
fn a_page_over_a_companion_projects_it_orders_by_it_and_resumes_at_it() {
let resumed = boundary(&["a"], 4, BY_TAGS);
assert_eq!(
paged::<sqlx::Sqlite>(BY_TAGS, Some(&resumed), Walk::Forward),
r#"SELECT "id", "title", "__ig_tags_sort__" AS "__ig_ord0__" FROM "reel" WHERE ("__ig_tags_sort__" > ? OR ("__ig_tags_sort__" = ? AND ("id" > ?))) ORDER BY "__ig_tags_sort__" ASC, "id" ASC LIMIT ?"#
);
}
#[cfg(feature = "sqlite")]
#[test]
fn the_backward_walk_inverts_the_companion_with_everything_else() {
let resumed = boundary(&["a"], 4, BY_TAGS);
assert_eq!(
paged::<sqlx::Sqlite>(BY_TAGS, Some(&resumed), Walk::Backward),
r#"SELECT "id", "title", "__ig_tags_sort__" AS "__ig_ord0__" FROM "reel" WHERE ("__ig_tags_sort__" < ? OR ("__ig_tags_sort__" = ? AND ("id" < ?))) ORDER BY "__ig_tags_sort__" DESC, "id" DESC LIMIT ?"#
);
}
#[cfg(feature = "postgres")]
#[test]
fn postgres_renders_the_companion_as_its_own_column() {
let terms = terms::<sqlx::Postgres>(BY_TAGS);
let resumed = Cursor::at(
&terms,
[
Some(ReelValue::Tags(crate::collection_sort_key(&[
"a".to_owned()
]))),
Some(ReelValue::Id(4)),
],
);
assert_eq!(
paged::<sqlx::Postgres>(BY_TAGS, Some(&resumed), Walk::Forward),
r#"SELECT "id", "title", "__ig_tags_sort__" AS "__ig_ord0__" FROM "reel" WHERE ("__ig_tags_sort__" > $1 OR ("__ig_tags_sort__" = $2 AND ("id" > $3))) ORDER BY "__ig_tags_sort__" ASC, "id" ASC LIMIT $4"#
);
}
#[cfg(feature = "mysql")]
#[test]
fn mysql_renders_the_companion_and_the_index_it_has_not_got_changes_nothing() {
let terms = terms::<sqlx::MySql>(BY_TAGS);
let resumed = Cursor::at(
&terms,
[
Some(ReelValue::Tags(crate::collection_sort_key(&[
"a".to_owned()
]))),
Some(ReelValue::Id(4)),
],
);
assert_eq!(
paged::<sqlx::MySql>(BY_TAGS, Some(&resumed), Walk::Forward),
r"SELECT `id`, `title`, `__ig_tags_sort__` AS `__ig_ord0__` FROM `reel` WHERE (`__ig_tags_sort__` > ? OR (`__ig_tags_sort__` = ? AND (`id` > ?))) ORDER BY `__ig_tags_sort__` ASC, `id` ASC LIMIT ?"
);
}
#[cfg(feature = "sqlite")]
#[test]
fn the_ordered_scan_carries_the_order_and_projects_no_boundary() {
let scan = scanned::<sqlx::Sqlite>(BY_TAGS);
assert_eq!(
scan,
r#"SELECT "id", "title" FROM "reel" ORDER BY "__ig_tags_sort__" ASC, "id" ASC"#
);
assert!(
!scan.contains("__ig_ord0__"),
"no cursor is minted, so no boundary is read"
);
}
#[cfg(feature = "sqlite")]
#[test]
fn the_first_page_of_a_walk_projects_the_boundary_as_every_page_does() {
assert!(
paged::<sqlx::Sqlite>(BY_TAGS, None, Walk::Forward)
.contains(r#""__ig_tags_sort__" AS "__ig_ord0__""#)
);
}
#[cfg(feature = "sqlite")]
#[test]
fn a_cursor_minted_under_another_order_is_refused() {
let by_title: &[ReelOrder] = &[ReelOrder::Title(OrderDirection::Asc)];
let elsewhere = Cursor::at(
&terms::<sqlx::Sqlite>(by_title),
[
Some(ReelValue::Title("a".to_owned())),
Some(ReelValue::Id(4)),
],
);
let terms = terms::<sqlx::Sqlite>(BY_TAGS);
let order = SqlOrder::<sqlx::Sqlite>::new(&terms).expect("a renderable order");
assert!(matches!(
SqlKeyset::resume_with(order, &elsewhere, Walk::Forward, &TermColumns),
Err(crate::CursorError::Order { .. })
));
}
#[cfg(feature = "sqlite")]
#[test]
fn a_malformed_boundary_is_refused_by_the_existing_family() {
let terms = terms::<sqlx::Sqlite>(BY_TAGS);
let absent = Cursor::at(&terms, [None, Some(ReelValue::Id(4))]);
let order = SqlOrder::<sqlx::Sqlite>::new(&terms).expect("a renderable order");
assert_eq!(
SqlKeyset::resume_with(order, &absent, Walk::Forward, &TermColumns).err(),
Some(crate::CursorError::Null(TermName::new("tags"))),
"a companion has no absence to mean, so the slot cannot be empty"
);
let minted = boundary(&["a"], 4, BY_TAGS).encode();
assert!(
Cursor::<ReelValue>::decode(&minted[..minted.len() - 3]).is_err(),
"and a frame a client shortened is refused rather than read as the nearest slot"
);
}
#[cfg(feature = "sqlite")]
mod live {
use sqlx::{Connection as _, Sqlite};
use super::{BY_TAGS, Reel, ReelOrder, ReelRow, ReelValue, boundary};
use crate::{
Cursor, OrderDirection, collection_sort_key,
query::{compare_collections, sql::Find},
};
fn corpus() -> Vec<(i64, Vec<String>, Vec<String>)> {
let owned =
|tags: &[&str]| -> Vec<String> { tags.iter().map(|tag| (*tag).to_owned()).collect() };
let reel = |id: i64, tags: &[&str]| (id, owned(tags), owned(tags));
vec![
reel(1, &["b"]),
reel(2, &[]),
reel(3, &["a", "b"]),
reel(4, &["a"]),
reel(5, &["a", "a", "a"]),
reel(6, &["10"]),
reel(7, &["2"]),
reel(8, &["ab"]),
(9, owned(&["a", "a"]), owned(&["z"])),
]
}
async fn written() -> sqlx::sqlite::SqliteConnection {
let mut db = sqlx::sqlite::SqliteConnection::connect("sqlite::memory:")
.await
.expect("an in-memory database");
for ddl in [
r#"CREATE TABLE "reel" ("id" INTEGER PRIMARY KEY, "title" TEXT NOT NULL,
"__ig_tags_sort__" BLOB NOT NULL)"#,
r#"CREATE TABLE "reel_tags" ("id" INTEGER NOT NULL, "tags_ordinal" INTEGER NOT NULL,
"tags" TEXT NOT NULL, PRIMARY KEY ("id", "tags_ordinal"))"#,
] {
sqlx::query(ddl).execute(&mut db).await.expect("a table");
}
for (id, ordered_as, elements) in corpus() {
sqlx::query(r#"INSERT INTO "reel" VALUES (?, ?, ?)"#)
.bind(id)
.bind(format!("reel {id}"))
.bind(collection_sort_key(&ordered_as))
.execute(&mut db)
.await
.expect("a reel");
for (ordinal, tag) in elements.iter().enumerate() {
sqlx::query(r#"INSERT INTO "reel_tags" VALUES (?, ?, ?)"#)
.bind(id)
.bind(i64::try_from(ordinal).expect("a small corpus"))
.bind(tag)
.execute(&mut db)
.await
.expect("a tag");
}
}
db
}
async fn scan(db: &mut sqlx::sqlite::SqliteConnection) -> Vec<i64> {
Find::<ReelRow, Sqlite, _>::new(&mut *db, false)
.order(BY_TAGS)
.fetch()
.await
.expect("the ordered scan")
.into_iter()
.map(|reel: Reel| reel.id)
.collect()
}
fn pinned() -> Vec<i64> {
let mut rows = corpus();
rows.sort_by(|(left_id, left, _), (right_id, right, _)| {
compare_collections(left, right).then(left_id.cmp(right_id))
});
rows.into_iter().map(|(id, _, _)| id).collect()
}
async fn forwards(db: &mut sqlx::sqlite::SqliteConnection, size: u32) -> Vec<i64> {
let mut ids = Vec::new();
let mut resume: Option<String> = None;
loop {
let page = match &resume {
None => Find::<ReelRow, Sqlite, _>::new(&mut *db, false)
.order(BY_TAGS)
.first(size)
.fetch()
.await
.expect("the first page"),
Some(encoded) => {
let cursor = Cursor::<ReelValue>::decode(encoded).expect("a cursor this engine minted");
Find::<ReelRow, Sqlite, _>::new(&mut *db, false)
.order(BY_TAGS)
.first(size)
.after(&cursor)
.fetch()
.await
.expect("the next page")
}
};
let more = page.has_next_page();
let last = page.edges().last().map(|edge| edge.cursor().encode());
ids.extend(
page
.into_edges()
.into_iter()
.map(|edge| edge.into_parts().0.id),
);
if !more {
break;
}
resume = last;
}
ids
}
async fn backwards(db: &mut sqlx::sqlite::SqliteConnection, size: u32) -> Vec<i64> {
let mut ids: Vec<i64> = Vec::new();
let mut resume: Option<String> = None;
loop {
let page = match &resume {
None => Find::<ReelRow, Sqlite, _>::new(&mut *db, false)
.order(BY_TAGS)
.last(size)
.fetch()
.await
.expect("the last page"),
Some(encoded) => {
let cursor = Cursor::<ReelValue>::decode(encoded).expect("a cursor this engine minted");
Find::<ReelRow, Sqlite, _>::new(&mut *db, false)
.order(BY_TAGS)
.last(size)
.before(&cursor)
.fetch()
.await
.expect("the page before it")
}
};
let more = page.has_previous_page();
let first = page.edges().first().map(|edge| edge.cursor().encode());
let mut head: Vec<i64> = page
.into_edges()
.into_iter()
.map(|edge| edge.into_parts().0.id)
.collect();
head.append(&mut ids);
ids = head;
if !more {
break;
}
resume = first;
}
ids
}
#[tokio::test]
async fn the_scan_is_the_pin() {
let mut db = written().await;
assert_eq!(scan(&mut db).await, pinned());
}
#[tokio::test]
async fn a_page_over_a_companion_walks_the_scan_exactly() {
let mut db = written().await;
let expected = scan(&mut db).await;
for size in 1..=4 {
assert_eq!(
forwards(&mut db, size).await,
expected,
"the forward walk at size {size}"
);
assert_eq!(
backwards(&mut db, size).await,
expected,
"the backward walk at size {size}"
);
}
}
#[tokio::test]
async fn the_boundary_is_the_companions_bytes_and_not_the_collections() {
let mut db = written().await;
let expected = scan(&mut db).await;
let at = expected
.iter()
.position(|id| *id == 9)
.expect("row 9 is in the scan");
let page = Find::<ReelRow, Sqlite, _>::new(&mut db, false)
.order(BY_TAGS)
.first(u32::try_from(at + 1).expect("a small corpus"))
.fetch()
.await
.expect("the page ending at row 9");
let edge = page.edges().last().expect("a non-empty page");
assert_eq!(edge.node().id, 9, "the page stops at row 9");
assert_eq!(
edge.node().tags,
["z"],
"and it is holding the collection its edge table gave it"
);
assert_eq!(
*edge.cursor().values(),
*boundary(&["a", "a"], 9, BY_TAGS).values(),
"while the boundary it hands back is the COMPANION's bytes"
);
let resumed = Cursor::<ReelValue>::decode(&edge.cursor().encode()).expect("its own cursor");
let after: Vec<i64> = Find::<ReelRow, Sqlite, _>::new(&mut db, false)
.order(BY_TAGS)
.first(16)
.after(&resumed)
.fetch()
.await
.expect("the page after row 9")
.into_edges()
.into_iter()
.map(|edge| edge.into_parts().0.id)
.collect();
assert_eq!(
after,
expected[at + 1..],
"every row after it, and no other — where a rebuilt boundary would have served none"
);
}
#[tokio::test]
async fn the_descending_order_is_the_exact_reverse() {
let mut db = written().await;
let ascending = scan(&mut db).await;
let descending: Vec<i64> = Find::<ReelRow, Sqlite, _>::new(&mut db, false)
.order(&[
ReelOrder::Tags(OrderDirection::Desc),
ReelOrder::Id(OrderDirection::Desc),
])
.fetch()
.await
.expect("the descending scan")
.into_iter()
.map(|reel: Reel| reel.id)
.collect();
let mut reversed = ascending;
reversed.reverse();
assert_eq!(descending, reversed);
}
}