use sqlx::QueryBuilder;
use super::insert_statement;
#[cfg(any(feature = "postgres", feature = "mysql"))]
use super::upsert_statement;
use crate::{
Assemble, Carrier, ColumnKind, ColumnName, ColumnShape, ComplexComparison, FieldName,
Identifiable, Record, RecordAddress, Transformer, assembled, assembled_flattened,
comparison::{Backend, sql::SqlKeyIn},
query::sql::{CrossingError, SqlQuery, SqlWrite},
};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Timebase {
num: i64,
den: i64,
}
impl ColumnKind for Timebase {
const SEGMENTS: &'static [ColumnShape] = &[
ColumnShape::Plain(ColumnName::new("num")),
ColumnShape::Plain(ColumnName::new("den")),
];
}
#[cfg(feature = "sqlite")]
impl Carrier<sqlx::Sqlite> for Timebase {
fn push_bind(&self, qb: &mut QueryBuilder<sqlx::Sqlite>) {
qb.push_bind(self.num);
qb.push(", ");
qb.push_bind(self.den);
}
}
#[cfg(feature = "postgres")]
impl Carrier<sqlx::Postgres> for Timebase {
fn push_bind(&self, qb: &mut QueryBuilder<sqlx::Postgres>) {
qb.push_bind(self.num);
qb.push(", ");
qb.push_bind(self.den);
}
}
#[cfg(feature = "mysql")]
impl Carrier<sqlx::MySql> for Timebase {
fn push_bind(&self, qb: &mut QueryBuilder<sqlx::MySql>) {
qb.push_bind(self.num);
qb.push(", ");
qb.push_bind(self.den);
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct Take {
id: i64,
tb: Timebase,
}
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,
tb: Timebase,
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct FlattenedRow {
id: i64,
tb: Timebase,
}
const TAKE: RecordAddress = RecordAddress::new(FieldName::new("take"), &[FieldName::new("id")]);
const FLATTEN: RecordAddress =
RecordAddress::new(FieldName::new("flattened"), &[FieldName::new("id")]);
const ALIASES: &[&str] = &["__ig_take_0__", "__ig_take_1__"];
macro_rules! row {
($row:ty, $address:expr, $columns:expr) => {
impl<Db> SqlQuery<Db> for $row
where
Db: Backend + sqlx::Database,
SqlKeyIn<i64, Db, 1>: ComplexComparison<Db>,
i64: Carrier<Db>,
Timebase: ColumnKind,
for<'r> i64: 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 = $address;
const ALIASES: &'static [&'static str] = ALIASES;
const COLUMNS: &'static [ColumnShape] = $columns;
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,
tb: self.tb,
})
}
}
impl<Db> SqlWrite<Db> for $row
where
Db: Backend + sqlx::Database,
SqlKeyIn<i64, Db, 1>: ComplexComparison<Db>,
i64: Carrier<Db>,
Timebase: Carrier<Db> + ColumnKind,
for<'r> i64: sqlx::Decode<'r, Db> + sqlx::Type<Db>,
for<'a> &'a str: sqlx::ColumnIndex<Db::Row>,
{
fn row(record: Take) -> Result<Self, CrossingError> {
Ok(Self {
id: record.id,
tb: record.tb,
})
}
fn bind(&self, at: usize, qb: &mut QueryBuilder<Db>) {
match at {
0 => self.id.push_bind(qb),
_ => self.tb.push_bind(qb),
}
}
fn bind_address(&self, _at: usize, qb: &mut QueryBuilder<Db>) {
self.id.push_bind(qb);
}
}
};
}
row!(
TakeRow,
TAKE,
&[
ColumnShape::Plain(ColumnName::new("id")),
crate::shape::<Timebase>(ColumnName::new("tb")),
]
);
row!(
FlattenedRow,
FLATTEN,
&[
ColumnShape::Plain(ColumnName::new("id")),
crate::flattened::<Timebase>(),
]
);
#[cfg(feature = "sqlite")]
impl crate::Describe<sqlx::Sqlite> for Take {
const BLUEPRINT: crate::Table = crate::Table::new(
TAKE,
&[
crate::Column::new(FieldName::new("id"), "INTEGER", false),
crate::Column::new(FieldName::new("tb_num"), "INTEGER", false),
crate::Column::new(FieldName::new("tb_den"), "INTEGER", false),
],
);
}
#[cfg(feature = "sqlite")]
const _: () = assert!(crate::describes(
&<Take as crate::Describe<sqlx::Sqlite>>::BLUEPRINT,
<TakeRow as SqlQuery<sqlx::Sqlite>>::COLUMNS
));
#[cfg(feature = "sqlite")]
#[test]
fn the_list_counts_fields_and_the_width_counts_columns() {
let columns = <TakeRow as SqlQuery<sqlx::Sqlite>>::COLUMNS;
assert_eq!(columns.len(), 2, "an id and a composite");
assert_eq!(crate::width(columns), 3, "which is three columns");
assert_eq!(
columns[1].segments().len(),
2,
"and the second entry carries what its type answered"
);
}
fn insert_text<Row, Db>(row: &Row) -> (String, usize)
where
Row: SqlWrite<Db>,
Db: crate::query::sql::SqlDialect,
<Db as sqlx::Database>::Arguments: sqlx::IntoArguments<Db>,
{
use sqlx::Execute as _;
let mut statement = insert_statement::<Row, Db>(row);
let mut built = statement.build();
let binds = match built.take_arguments() {
Ok(Some(arguments)) => sqlx::Arguments::len(&arguments),
Ok(None) | Err(_) => 0,
};
(built.sql().as_str().to_owned(), binds)
}
fn select_text<Row, Db>() -> String
where
Row: SqlQuery<Db>,
Db: crate::query::sql::SqlDialect,
i64: sqlx::Type<Db>,
for<'t> i64: sqlx::Encode<'t, Db>,
<Db as sqlx::Database>::Arguments: sqlx::IntoArguments<Db>,
{
use sqlx::Execute as _;
let mut statement =
crate::query::sql::find::scan::<Row, Db>(None, None, None).expect("no predicate to lower");
statement.build().sql().as_str().to_owned()
}
fn take() -> Take {
Take {
id: 7,
tb: Timebase {
num: 24_000,
den: 1_001,
},
}
}
#[cfg(feature = "sqlite")]
#[test]
fn the_prefixed_columns_are_what_sqlite_is_sent() {
let row = <TakeRow as SqlWrite<sqlx::Sqlite>>::row(take()).expect("nothing converts");
assert_eq!(
insert_text::<TakeRow, sqlx::Sqlite>(&row),
(
r#"INSERT INTO "take" ("id", "tb_num", "tb_den") VALUES (?, ?, ?)"#.to_owned(),
3
)
);
assert_eq!(
select_text::<TakeRow, sqlx::Sqlite>(),
r#"SELECT "id", "tb_num", "tb_den" FROM "take""#
);
}
#[cfg(feature = "sqlite")]
#[test]
fn the_flatten_word_drops_the_prefix_and_nothing_else() {
let row = <FlattenedRow as SqlWrite<sqlx::Sqlite>>::row(take()).expect("nothing converts");
assert_eq!(
insert_text::<FlattenedRow, sqlx::Sqlite>(&row),
(
r#"INSERT INTO "flattened" ("id", "num", "den") VALUES (?, ?, ?)"#.to_owned(),
3
)
);
assert_eq!(
select_text::<FlattenedRow, sqlx::Sqlite>(),
r#"SELECT "id", "num", "den" FROM "flattened""#
);
assert_eq!(
crate::width(<FlattenedRow as SqlQuery<sqlx::Sqlite>>::COLUMNS),
3,
"dropping a name drops no column"
);
}
#[cfg(feature = "postgres")]
#[test]
fn postgres_renders_the_flattened_columns() {
let row = <TakeRow as SqlWrite<sqlx::Postgres>>::row(take()).expect("nothing converts");
assert_eq!(
insert_text::<TakeRow, sqlx::Postgres>(&row),
(
r#"INSERT INTO "take" ("id", "tb_num", "tb_den") VALUES ($1, $2, $3)"#.to_owned(),
3
)
);
assert_eq!(
select_text::<TakeRow, sqlx::Postgres>(),
r#"SELECT "id", "tb_num", "tb_den" FROM "take""#
);
use sqlx::Execute as _;
let mut statement = upsert_statement::<TakeRow, sqlx::Postgres>(&row);
let replace = statement.build().sql().as_str().to_owned();
assert_eq!(
replace,
concat!(
r#"INSERT INTO "take" ("id", "tb_num", "tb_den") VALUES ($1, $2, $3)"#,
r#" ON CONFLICT ("id") DO UPDATE SET "id" = "excluded"."id","#,
r#" "tb_num" = "excluded"."tb_num", "tb_den" = "excluded"."tb_den""#
),
"the assignment list is every COLUMN, so a composite contributes its segments here too"
);
}
#[cfg(feature = "mysql")]
#[test]
fn mysql_renders_the_flattened_columns() {
let row = <TakeRow as SqlWrite<sqlx::MySql>>::row(take()).expect("nothing converts");
assert_eq!(
insert_text::<TakeRow, sqlx::MySql>(&row),
(
"INSERT INTO `take` (`id`, `tb_num`, `tb_den`) VALUES (?, ?, ?)".to_owned(),
3
)
);
assert_eq!(
select_text::<TakeRow, sqlx::MySql>(),
"SELECT `id`, `tb_num`, `tb_den` FROM `take`"
);
use sqlx::Execute as _;
let mut statement = upsert_statement::<TakeRow, sqlx::MySql>(&row);
let replace = statement.build().sql().as_str().to_owned();
assert_eq!(
replace,
concat!(
"INSERT INTO `take` (`id`, `tb_num`, `tb_den`) VALUES (?, ?, ?)",
" ON DUPLICATE KEY UPDATE `id` = VALUES(`id`),",
" `tb_num` = VALUES(`tb_num`), `tb_den` = VALUES(`tb_den`)"
)
);
}
impl<'a, R: sqlx::Row> Assemble<'a, R> for Timebase
where
i64: Assemble<'a, R>,
{
fn assemble(row: &'a R, under: Option<&crate::Path<'_>>) -> sqlx::Result<Self> {
Ok(Self {
num: assembled(row, FieldName::new("num"), under)?,
den: assembled(row, FieldName::new("den"), under)?,
})
}
}
macro_rules! decode {
($row:ty, $tb:expr) => {
impl<'a, R: sqlx::Row> sqlx::FromRow<'a, R> for $row
where
i64: Assemble<'a, R>,
Timebase: Assemble<'a, R>,
{
fn from_row(__row: &'a R) -> sqlx::Result<Self> {
let id: i64 = assembled(__row, FieldName::new("id"), None)?;
let tb: Timebase = $tb(__row)?;
Ok(Self { id, tb })
}
}
};
}
decode!(TakeRow, |row| assembled(row, FieldName::new("tb"), None));
decode!(FlattenedRow, |row| assembled_flattened(row, None));
#[cfg(feature = "sqlite")]
#[tokio::test]
async fn the_flattened_composite_makes_the_whole_round_trip() {
use sqlx::Connection as _;
use crate::{
TypeVisitor as _,
query::sql::{Create, get, insert},
};
let mut db = sqlx::sqlite::SqliteConnection::connect("sqlite::memory:")
.await
.expect("an in-memory database");
let mut create = Create::<sqlx::Sqlite>::new();
create
.next_type::<Take>()
.expect("this descriptor renders for SQLite");
create.run(&mut db).await.expect("and the engine takes it");
insert::<TakeRow, sqlx::Sqlite, _>(&mut db, take())
.await
.expect("three values for two fields");
assert_eq!(
get::<TakeRow, sqlx::Sqlite, _>(&mut db, &7, false)
.await
.expect("the record is there"),
Some(take()),
"two columns back into one field"
);
let (num, den): (i64, i64) =
sqlx::query_as(r#"SELECT "tb_num", "tb_den" FROM "take" WHERE "id" = 7"#)
.fetch_one(&mut db)
.await
.expect("the flattened columns are what the schema holds");
assert_eq!((num, den), (24_000, 1_001));
}
#[cfg(feature = "sqlite")]
#[tokio::test]
async fn the_emitted_spelling_reads_what_a_hand_written_decode_reads() {
use sqlx::{Connection as _, FromRow as _, Row as _};
let mut db = sqlx::sqlite::SqliteConnection::connect("sqlite::memory:")
.await
.expect("an in-memory database");
for statement in [
r#"CREATE TABLE "take" ("id" INTEGER, "tb_num" INTEGER, "tb_den" INTEGER)"#,
r#"INSERT INTO "take" VALUES (7, 24000, 1001)"#,
] {
sqlx::query(statement)
.execute(&mut db)
.await
.expect("the fixture's own DDL");
}
let row = sqlx::query(r#"SELECT "tb_den", "id", "tb_num" FROM "take""#)
.fetch_one(&mut db)
.await
.expect("one row");
let by_hand = TakeRow {
id: row.try_get("id").expect("the id column"),
tb: Timebase {
num: row.try_get("tb_num").expect("the first flattened column"),
den: row.try_get("tb_den").expect("the second"),
},
};
assert_eq!(
TakeRow::from_row(&row).expect("the seam decodes"),
by_hand,
"the walk joined `tb_num` and `tb_den`, in that order"
);
}
#[cfg(feature = "sqlite")]
#[tokio::test]
async fn the_flattened_decode_asks_for_the_bare_columns() {
use sqlx::{Connection as _, FromRow as _};
let mut db = sqlx::sqlite::SqliteConnection::connect("sqlite::memory:")
.await
.expect("an in-memory database");
for statement in [
r#"CREATE TABLE "flattened" ("id" INTEGER, "num" INTEGER, "den" INTEGER)"#,
r#"INSERT INTO "flattened" VALUES (7, 24000, 1001)"#,
] {
sqlx::query(statement)
.execute(&mut db)
.await
.expect("the fixture's own DDL");
}
let row = sqlx::query(r#"SELECT * FROM "flattened""#)
.fetch_one(&mut db)
.await
.expect("one row");
let flattened = FlattenedRow::from_row(&row).expect("the flattened seam decodes");
assert_eq!(
(flattened.id, flattened.tb),
(
7,
Timebase {
num: 24_000,
den: 1_001
}
)
);
assert!(
TakeRow::from_row(&row).is_err(),
"and the prefixed spelling finds nothing in this table"
);
}