use sqlx::{Connection as _, Sqlite};
use crate::{
Carrier, ColumnName, ColumnReader, ColumnShape, ColumnWriter, ComplexComparison, Field,
FieldName, Identifiable, Record, RecordAddress, ScalarFilter, Transformer,
comparison::{
At, Backend, Frame, TryFromFilter,
sql::{SqlKeyIn, SqlLoweringError, SqlScalarComparison},
},
query::sql::{CrossingError, SqlQuery},
};
#[derive(Debug, Clone, PartialEq)]
pub(super) struct Segment {
pub(super) media: String,
pub(super) id: i64,
pub(super) transcript: String,
pub(super) duration: i64,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub(super) struct SegmentKey {
pub(super) media: String,
pub(super) id: i64,
}
impl Field for SegmentKey {
fn write(&self, w: &mut impl ColumnWriter) {
self.media.write(w);
self.id.write(w);
}
fn read<R: ColumnReader>(r: &mut R) -> Result<Self, R::Error> {
Ok(Self {
media: String::read(r)?,
id: i64::read(r)?,
})
}
}
impl Identifiable for Segment {
type Id = i64;
fn id_ref(&self) -> &i64 {
&self.id
}
}
impl Identifiable for SegmentKey {
type Id = i64;
fn id_ref(&self) -> &i64 {
&self.id
}
}
impl Transformer for Segment {
type Key = SegmentKey;
type Lineage = String;
type Record = Self;
type Graphql = ();
fn key(&self) -> SegmentKey {
SegmentKey {
media: self.media.clone(),
id: self.id,
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub(super) struct SegmentRow {
media: String,
id: i64,
transcript: String,
duration: i64,
}
impl<'r, R> sqlx::FromRow<'r, R> for SegmentRow
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 {
media: row.try_get("media_id")?,
id: row.try_get("id")?,
transcript: row.try_get("transcript")?,
duration: row.try_get("duration")?,
})
}
}
pub(super) struct SegmentFilter<Db> {
duration: SqlScalarComparison<i64, Db>,
}
impl<Db> ComplexComparison<Db> for SegmentFilter<Db>
where
Db: Backend<Error = SqlLoweringError>,
SqlScalarComparison<i64, Db>: ComplexComparison<Db>,
{
fn conjuncts(&self) -> usize {
ComplexComparison::<Db>::conjuncts(&self.duration)
}
fn apply<'q>(
&'q self,
at: At<'_>,
builder: <Db as Backend>::Builder<'q>,
) -> Result<<Db as Backend>::Builder<'q>, <Db as Backend>::Error> {
let frame = At::frame(at, FieldName::new("duration"));
ComplexComparison::<Db>::apply(&self.duration, Frame::at(&frame), builder)
}
}
pub(super) fn shorter_than(seconds: i64) -> SegmentFilter<Sqlite> {
SegmentFilter {
duration: SqlScalarComparison::try_from_filter(ScalarFilter::<i64>::new().with_lte(seconds))
.expect("an integer bound crosses into SQLite"),
}
}
impl<Db> Record<Db> for Segment
where
Db: Backend,
SegmentFilter<Db>: ComplexComparison<Db>,
{
type Row = SegmentRow;
type Comparison = SegmentFilter<Db>;
type OrderBy = ();
}
impl<Db> SqlQuery<Db> for SegmentRow
where
Db: Backend + sqlx::Database,
SegmentFilter<Db>: ComplexComparison<Db>,
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 = Segment;
type Address = SqlKeyIn<i64, Db, 1>;
const ADDRESS: RecordAddress = RecordAddress::new(
FieldName::new("segment"),
&[FieldName::new("media_id"), FieldName::new("id")],
);
const ALIASES: &'static [&'static str] = &[
"__ig_segment_0__",
"__ig_segment_1__",
"__ig_segment_2__",
"__ig_segment_3__",
"__ig_segment_4__",
"__ig_segment_5__",
"__ig_segment_6__",
"__ig_segment_7__",
];
const COLUMNS: &'static [ColumnShape] = &[
ColumnShape::Plain(ColumnName::new("media_id")),
ColumnShape::Plain(ColumnName::new("id")),
ColumnShape::Plain(ColumnName::new("transcript")),
ColumnShape::Plain(ColumnName::new("duration")),
];
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<Segment, CrossingError> {
Ok(Segment {
media: self.media,
id: self.id,
transcript: self.transcript,
duration: self.duration,
})
}
}
pub(super) const SEEDED: &[(&str, i64, &str, i64)] = &[
("m1", 1, "a long sunset over the harbour", 30),
("m1", 2, "Der Sonnenuntergang, ein sunset am Meer", 12),
("m2", 3, "le coucher de soleil — a sunset in Nice", 45),
("m2", 4, "sunset again, and again, sunset", 8),
("m3", 5, "a heron over still water", 20),
("m3", 6, "sunset light on the sunset ridge", 60),
];
pub(super) async fn store() -> sqlx::sqlite::SqliteConnection {
let mut db = sqlx::sqlite::SqliteConnection::connect("sqlite::memory:")
.await
.expect("an in-memory database");
sqlx::query(
r#"CREATE TABLE "segment" ("media_id" TEXT NOT NULL, "id" INTEGER PRIMARY KEY,
"transcript" TEXT NOT NULL, "duration" INTEGER NOT NULL)"#,
)
.execute(&mut db)
.await
.expect("the table");
for (media, id, transcript, duration) in SEEDED {
sqlx::query(r#"INSERT INTO "segment" VALUES (?, ?, ?, ?)"#)
.bind(media)
.bind(id)
.bind(transcript)
.bind(duration)
.execute(&mut db)
.await
.expect("a segment");
}
db
}
pub(super) async fn forget(db: &mut sqlx::sqlite::SqliteConnection, id: i64) {
sqlx::query(r#"DELETE FROM "segment" WHERE "id" = ?"#)
.bind(id)
.execute(db)
.await
.expect("the row goes");
}