#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
use core::fmt::Display;
#[cfg(feature = "sqlite")]
use super::Carrier;
#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
use super::{QueryBuilder, SelectClause, SqlConjunction};
#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
use crate::{
FieldName,
comparison::{At, Backend, ComplexComparison, RecordAddress},
};
#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
pub(crate) const ROW: RecordAddress =
RecordAddress::new(FieldName::new("p"), &[FieldName::new("id")]);
#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
pub(crate) fn render<Db, C>(column: &str, comparison: &C) -> (String, usize)
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
<Db as Backend>::Error: core::fmt::Debug,
C: ComplexComparison<Db>,
<Db as sqlx::Database>::Arguments: sqlx::IntoArguments<Db>,
{
let frame = At::new(&ROW).frame(FieldName::new(column));
render_at(frame.at(), comparison)
}
#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
pub(crate) fn render_at<Db, C>(at: At<'_>, comparison: &C) -> (String, usize)
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
<Db as Backend>::Error: core::fmt::Debug,
C: ComplexComparison<Db>,
<Db as sqlx::Database>::Arguments: sqlx::IntoArguments<Db>,
{
use sqlx::Execute;
let mut qb = sqlx::QueryBuilder::<Db>::default();
{
let out = SqlConjunction::with_lead(&mut qb, "");
if comparison.apply(at, out).unwrap().written() == 0 {
return (String::new(), 0);
}
}
let mut built = qb.build();
let binds = match built.take_arguments() {
Ok(Some(args)) => sqlx::Arguments::len(&args),
Ok(None) | Err(_) => 0,
};
(built.sql().as_str().to_owned(), binds)
}
#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
pub(super) fn threaded<Db, C>(field: &str, comparison: &C) -> String
where
Db: sqlx::Database + for<'q> Backend<Builder<'q> = SqlConjunction<'q, Db>, Buffer: Display>,
<Db as Backend>::Error: core::fmt::Debug,
C: ComplexComparison<Db>,
{
let mut builder = QueryBuilder::<SelectClause, Db>::select()
.push_field("\"id\"")
.from("\"t\"")
.begin_where();
{
let frame = At::new(&ROW).frame(FieldName::new(field));
let accumulator = SqlConjunction::new(builder.inner_mut());
comparison.apply(frame.at(), accumulator).unwrap();
}
builder.finalize().into_string()
}
#[cfg(feature = "sqlite")]
pub(super) struct Probe<'a> {
pub(super) value: i64,
pub(super) bound: &'a core::cell::RefCell<Vec<i64>>,
}
#[cfg(feature = "sqlite")]
impl Carrier<sqlx::Sqlite> for Probe<'_> {
fn push_bind(&self, qb: &mut sqlx::QueryBuilder<sqlx::Sqlite>) {
self.bound.borrow_mut().push(self.value);
qb.push_bind(self.value);
}
}
#[cfg(feature = "sqlite")]
impl crate::ColumnKind for Probe<'_> {}
#[cfg(feature = "sqlite")]
#[test]
fn the_accumulator_separates_only_between_conjuncts() {
use crate::{ScalarFilter, comparison::TryFromFilter};
const COLUMN: &str = "n";
let empty =
<super::SqlScalarComparison<i64, sqlx::Sqlite>>::try_from_filter(ScalarFilter::<i64>::new())
.unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>(COLUMN, &empty),
(String::new(), 0)
);
let one = <super::SqlScalarComparison<i64, sqlx::Sqlite>>::try_from_filter(
ScalarFilter::<i64>::new().with_eq(1i64),
)
.unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>(COLUMN, &one),
("\"n\" = ?".into(), 1)
);
let two = <super::SqlScalarComparison<i64, sqlx::Sqlite>>::try_from_filter(
ScalarFilter::<i64>::new().with_gt(0i64).with_eq(1i64),
)
.unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>(COLUMN, &two),
("\"n\" = ? AND \"n\" > ?".into(), 2)
);
}
#[cfg(feature = "sqlite")]
#[test]
fn the_lowering_brackets_the_column_and_escapes_a_bracket_inside_it() {
use crate::{
Nullable, ScalarFilter, TextFilter,
comparison::{
TryFromFilter,
sql::{SqlNullable, SqlScalarComparison, SqlTextComparison},
},
};
const INJECTED: &str = "n\" = 1 OR \"x";
let scalar = <SqlScalarComparison<i64, sqlx::Sqlite>>::try_from_filter(
ScalarFilter::<i64>::new().with_eq(1i64),
)
.unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>(INJECTED, &scalar),
("\"n\"\" = 1 OR \"\"x\" = ?".into(), 1)
);
let membership = <SqlScalarComparison<i64, sqlx::Sqlite>>::try_from_filter(
ScalarFilter::<i64>::new().with_in_([1i64]),
)
.unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>(INJECTED, &membership),
("\"n\"\" = 1 OR \"\"x\" IN (?)".into(), 1)
);
let nullable = <SqlNullable<SqlScalarComparison<i64, sqlx::Sqlite>, i64>>::try_from_filter(
Nullable::<ScalarFilter<i64>>::new(ScalarFilter::new()).with_null(true),
)
.unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>(INJECTED, &nullable),
("\"n\"\" = 1 OR \"\"x\" IS NULL".into(), 0)
);
let text = <SqlTextComparison<String, sqlx::Sqlite>>::try_from_filter(
TextFilter::<String>::new().with_contains("cam".to_owned()),
)
.unwrap();
assert_eq!(
render::<sqlx::Sqlite, _>(INJECTED, &text),
("instr(\"n\"\" = 1 OR \"\"x\", ?) > 0".into(), 1)
);
}
#[cfg(feature = "mysql")]
#[test]
fn the_bracket_a_column_gets_is_the_dialects_own() {
use crate::{
ScalarFilter,
comparison::{TryFromFilter, sql::SqlScalarComparison},
};
let crossed = <SqlScalarComparison<i64, sqlx::MySql>>::try_from_filter(
ScalarFilter::<i64>::new().with_eq(1i64),
)
.unwrap();
assert_eq!(
render::<sqlx::MySql, _>("n", &crossed),
("`n` = ?".into(), 1)
);
assert_eq!(
render::<sqlx::MySql, _>("a`b", &crossed),
("`a``b` = ?".into(), 1)
);
assert_eq!(
render::<sqlx::MySql, _>("a\"b", &crossed),
("`a\"b` = ?".into(), 1)
);
}
#[cfg(feature = "sqlite")]
#[test]
fn the_accumulator_counts_what_it_opened() {
let mut qb = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
{
let mut out = SqlConjunction::with_lead(&mut qb, "");
assert_eq!(out.written(), 0);
out.open().push("a");
out.open().push("b");
assert_eq!(out.written(), 2);
}
assert_eq!(qb.sql().as_str(), "a AND b");
}
#[cfg(feature = "sqlite")]
#[test]
fn the_lead_belongs_to_the_first_conjunct_and_an_unopened_accumulator_writes_none() {
let mut none = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
{
let unopened = SqlConjunction::new(&mut none);
assert_eq!(unopened.written(), 0);
}
assert_eq!(none.sql().as_str(), "");
let mut one = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
{
let mut out = SqlConjunction::new(&mut one);
out.open().push("a");
out.open().push("b");
}
assert_eq!(one.sql().as_str(), " WHERE a AND b");
let mut continued = sqlx::QueryBuilder::<sqlx::Sqlite>::default();
{
let mut out = SqlConjunction::with_lead(&mut continued, " AND ");
out.open().push("a");
out.open().push("b");
}
assert_eq!(continued.sql().as_str(), " AND a AND b");
}