#![cfg(feature = "sqlite")]
use sqlx::QueryBuilder;
use crate::{
Carrier, ColumnName, ColumnShape, ComplexComparison, FieldName, Identifiable, Record,
RecordAddress, Transformer,
comparison::{Backend, sql::SqlKeyIn},
query::sql::{
CrossingError, ELEMENT, EdgeCollection, EdgeShape, EdgeWrite, SqlQuery, SqlWrite, distribute,
},
};
#[derive(Debug, Clone, PartialEq, Eq)]
struct Take {
id: i64,
frames: Vec<String>,
}
impl Identifiable for Take {
type Id = i64;
fn id_ref(&self) -> &i64 {
&self.id
}
}
impl Transformer for Take {
type Graphql = ();
type Key = i64;
type Lineage = i64;
type Record = Self;
fn key(&self) -> i64 {
self.id
}
}
impl<Db: Backend> Record<Db> for Take {
type Row = TakeRow;
type Comparison = SqlKeyIn<i64, Db, 1>;
type OrderBy = ();
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct TakeRow {
id: i64,
frames: Vec<String>,
}
impl<'r, R> sqlx::FromRow<'r, R> for TakeRow
where
R: sqlx::Row,
i64: 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")?,
frames: Vec::new(),
})
}
}
fn take_key<Db>(row: &TakeRow, _index: usize, qb: &mut QueryBuilder<Db>)
where
Db: sqlx::Database,
i64: Carrier<Db>,
{
row.id.push_bind(qb);
}
fn take_frames<Db>(page: &mut [TakeRow], 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.frames,
)
}
const TAKE: RecordAddress = RecordAddress::new(FieldName::new("take"), &[FieldName::new("id")]);
impl<Db> SqlQuery<Db> for TakeRow
where
Db: Backend + sqlx::Database,
SqlKeyIn<i64, 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 = Take;
type Address = SqlKeyIn<i64, Db, 1>;
const ADDRESS: RecordAddress = TAKE;
const ALIASES: &'static [&'static str] = &["__ig_take_0__", "__ig_take_1__"];
const COLLECTIONS: &'static [EdgeCollection<Self, Db>] = &[EdgeCollection::gather(
&[FieldName::new("frames")],
EdgeShape::Sequence,
take_key::<Db>,
take_frames::<Db>,
)];
const COLUMNS: &'static [ColumnShape] = &[ColumnShape::Plain(ColumnName::new("id"))];
fn addresses(ids: &[i64]) -> Result<Self::Address, CrossingError> {
Ok(SqlKeyIn::new(
["id"],
ids.iter().map(|id| [*id]).collect::<Vec<_>>(),
))
}
fn id(&self) -> Result<i64, CrossingError> {
Ok(self.id)
}
fn record(self) -> Result<Take, CrossingError> {
Ok(Take {
id: self.id,
frames: self.frames,
})
}
}
fn frames_len(row: &TakeRow) -> usize {
row.frames.len()
}
fn frames_element<Db>(row: &TakeRow, at: usize, qb: &mut QueryBuilder<Db>)
where
Db: sqlx::Database,
String: Carrier<Db>,
{
row.frames[at].push_bind(qb);
}
impl<Db> SqlWrite<Db> for TakeRow
where
Db: Backend + sqlx::Database,
SqlKeyIn<i64, Db, 1>: ComplexComparison<Db>,
i64: Carrier<Db>,
String: 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>,
{
const EDGES: &'static [EdgeWrite<Self, Db>] = &[EdgeWrite::new(
&[FieldName::new("frames")],
EdgeShape::Sequence,
frames_len,
frames_element::<Db>,
)];
fn row(record: Take) -> Result<Self, CrossingError> {
Ok(Self {
id: record.id,
frames: record.frames,
})
}
fn bind(&self, at: usize, qb: &mut QueryBuilder<Db>) {
debug_assert_eq!(at, 0, "this row has one column");
self.id.push_bind(qb);
}
fn bind_address(&self, _at: usize, qb: &mut QueryBuilder<Db>) {
self.id.push_bind(qb);
}
}
mod live {
use sqlx::{Connection as _, Executor as _, sqlite::SqliteConnection};
use super::{Take, TakeRow};
use crate::query::sql::{get, insert};
async fn empty() -> SqliteConnection {
let mut db = SqliteConnection::connect("sqlite::memory:")
.await
.expect("an in-memory database");
for ddl in [
r#"CREATE TABLE "take" ("id" INTEGER PRIMARY KEY)"#,
r#"CREATE TABLE "take_frames" ("id" INTEGER, "frames_ordinal" INTEGER, "frames" TEXT,
PRIMARY KEY ("id", "frames_ordinal"))"#,
] {
db.execute(ddl).await.expect("a table");
}
db
}
async fn ordinals(db: &mut SqliteConnection, id: i64) -> Vec<i64> {
sqlx::query_scalar(
r#"SELECT "frames_ordinal" FROM "take_frames" WHERE "id" = ? ORDER BY "frames_ordinal""#,
)
.bind(id)
.fetch_all(db)
.await
.expect("the engine answers")
}
async fn written(db: &mut SqliteConnection) -> Take {
let take = Take {
id: 1,
frames: ["a", "b", "c"].map(ToOwned::to_owned).to_vec(),
};
insert::<TakeRow, sqlx::Sqlite, _>(db, take.clone())
.await
.expect("the take is written");
take
}
#[tokio::test]
async fn the_write_lays_the_sequence_down_contiguously() {
let mut db = empty().await;
let take = written(&mut db).await;
assert_eq!(ordinals(&mut db, 1).await, [0, 1, 2]);
assert_eq!(
get::<TakeRow, sqlx::Sqlite, _>(&mut db, &1, false)
.await
.expect("the take is there"),
Some(take),
);
}
#[tokio::test]
async fn a_deleted_middle_ordinal_closes_up_in_the_answer() {
let mut db = empty().await;
written(&mut db).await;
sqlx::query(r#"DELETE FROM "take_frames" WHERE "id" = ? AND "frames_ordinal" = ?"#)
.bind(1i64)
.bind(1i64)
.execute(&mut db)
.await
.expect("the middle edge row is deleted");
assert_eq!(
ordinals(&mut db, 1).await,
[0, 2],
"the stored ordinals are no longer contiguous"
);
let got = get::<TakeRow, sqlx::Sqlite, _>(&mut db, &1, false)
.await
.expect("a hole is not an error");
assert_eq!(
got,
Some(Take {
id: 1,
frames: ["a", "c"].map(ToOwned::to_owned).to_vec(),
}),
"the surviving elements come back in ordinal order, and the gap closes up"
);
}
#[tokio::test]
async fn a_sequence_that_no_longer_starts_at_zero_still_reads_in_order() {
let mut db = empty().await;
written(&mut db).await;
sqlx::query(r#"DELETE FROM "take_frames" WHERE "id" = ? AND "frames_ordinal" = ?"#)
.bind(1i64)
.bind(0i64)
.execute(&mut db)
.await
.expect("the first edge row is deleted");
assert_eq!(
get::<TakeRow, sqlx::Sqlite, _>(&mut db, &1, false)
.await
.expect("a missing zeroth ordinal is not an error"),
Some(Take {
id: 1,
frames: ["b", "c"].map(ToOwned::to_owned).to_vec(),
}),
);
}
#[tokio::test]
async fn a_sequence_swept_empty_is_the_empty_collection() {
let mut db = empty().await;
written(&mut db).await;
sqlx::query(r#"DELETE FROM "take_frames" WHERE "id" = ?"#)
.bind(1i64)
.execute(&mut db)
.await
.expect("every edge row is deleted");
assert_eq!(
get::<TakeRow, sqlx::Sqlite, _>(&mut db, &1, false)
.await
.expect("an emptied collection is not an error"),
Some(Take {
id: 1,
frames: Vec::new(),
}),
);
}
}