use crate::advanced::{LockStrength, LockWait, RowLock};
use crate::error::{QueryError, QueryResult};
mod sealed {
pub trait Sealed {}
impl Sealed for super::Postgres {}
impl Sealed for super::Sqlite {}
impl Sealed for super::Mysql {}
impl Sealed for super::Mssql {}
impl Sealed for super::Cql {}
impl Sealed for super::NotSql {}
}
#[non_exhaustive]
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct RowLockSql {
pub table_hint: Option<String>,
pub suffix: Option<String>,
}
impl RowLockSql {
pub(crate) fn push_table_hint(&self, sql: &mut String) {
if let Some(hint) = &self.table_hint {
sql.push(' ');
sql.push_str(hint);
}
}
pub(crate) fn push_suffix(&self, sql: &mut String) {
if let Some(suffix) = &self.suffix {
sql.push(' ');
sql.push_str(suffix);
}
}
}
fn wait_suffix(wait: LockWait) -> &'static str {
match wait {
LockWait::Wait => "",
LockWait::NoWait => " NOWAIT",
LockWait::SkipLocked => " SKIP LOCKED",
}
}
pub trait SqlDialect: Send + Sync + sealed::Sealed {
fn placeholder(&self, i: usize) -> String;
fn returning_clause(&self, cols: &str) -> String;
fn quote_ident(&self, ident: &str) -> String;
fn row_lock_sql(&self, _lock: &RowLock) -> QueryResult<RowLockSql> {
Err(QueryError::unsupported(
"row locks are not supported by this dialect",
))
}
fn supports_distinct_on(&self) -> bool {
false
}
fn insert_has_returning(&self) -> bool {
true
}
fn upsert_clause(&self, conflict_cols: &[&str], update_set: &str) -> String;
fn supports_sql_emission(&self) -> bool {
true
}
fn supports_upsert(&self) -> bool {
true
}
fn upsert_do_nothing_clause(&self, _conflict_cols: &[&str]) -> String {
String::new()
}
fn like_escape_clause(&self) -> &'static str {
" ESCAPE '\\'"
}
fn begin_sql(&self) -> &'static str {
"BEGIN"
}
fn commit_sql(&self) -> &'static str {
"COMMIT"
}
fn rollback_sql(&self) -> &'static str {
"ROLLBACK"
}
fn write_limit_offset(
&self,
sql: &mut String,
take: Option<u64>,
skip: Option<u64>,
has_order_by: bool,
) {
let _ = has_order_by;
if let Some(take) = take {
sql.push_str(" LIMIT ");
sql.push_str(&take.to_string());
}
if let Some(skip) = skip {
sql.push_str(" OFFSET ");
sql.push_str(&skip.to_string());
}
}
}
pub struct Postgres;
pub struct Sqlite;
pub struct Mysql;
pub struct Mssql;
pub struct Cql;
pub struct NotSql;
impl SqlDialect for Postgres {
fn row_lock_sql(&self, lock: &RowLock) -> QueryResult<RowLockSql> {
let mut sql = String::from(match lock.strength {
LockStrength::Update => "FOR UPDATE",
LockStrength::NoKeyUpdate => "FOR NO KEY UPDATE",
LockStrength::Share => "FOR SHARE",
LockStrength::KeyShare => "FOR KEY SHARE",
});
if !lock.of_tables.is_empty() {
for table in &lock.of_tables {
if !crate::sql::is_valid_sql_identifier(table) {
return Err(QueryError::invalid_input(
"lock",
format!("invalid table name in OF clause: {table:?}"),
));
}
}
sql.push_str(" OF ");
sql.push_str(&lock.of_tables.join(", "));
}
sql.push_str(wait_suffix(lock.wait));
Ok(RowLockSql {
table_hint: None,
suffix: Some(sql),
})
}
fn placeholder(&self, i: usize) -> String {
format!("${}", i)
}
fn returning_clause(&self, cols: &str) -> String {
format!(" RETURNING {}", cols)
}
fn quote_ident(&self, i: &str) -> String {
format!("\"{}\"", i.replace('"', "\"\""))
}
fn supports_distinct_on(&self) -> bool {
true
}
fn upsert_clause(&self, c: &[&str], s: &str) -> String {
let quoted: Vec<String> = c.iter().map(|col| self.quote_ident(col)).collect();
format!(" ON CONFLICT ({}) DO UPDATE SET {}", quoted.join(", "), s)
}
fn upsert_do_nothing_clause(&self, c: &[&str]) -> String {
let quoted: Vec<String> = c.iter().map(|col| self.quote_ident(col)).collect();
format!(" ON CONFLICT ({}) DO NOTHING", quoted.join(", "))
}
}
impl SqlDialect for Sqlite {
fn placeholder(&self, i: usize) -> String {
format!("?{}", i)
}
fn returning_clause(&self, cols: &str) -> String {
format!(" RETURNING {}", cols)
}
fn quote_ident(&self, i: &str) -> String {
format!("\"{}\"", i.replace('"', "\"\""))
}
fn upsert_clause(&self, c: &[&str], s: &str) -> String {
let quoted: Vec<String> = c.iter().map(|col| self.quote_ident(col)).collect();
format!(" ON CONFLICT ({}) DO UPDATE SET {}", quoted.join(", "), s)
}
fn upsert_do_nothing_clause(&self, c: &[&str]) -> String {
let quoted: Vec<String> = c.iter().map(|col| self.quote_ident(col)).collect();
format!(" ON CONFLICT ({}) DO NOTHING", quoted.join(", "))
}
}
impl SqlDialect for Mysql {
fn row_lock_sql(&self, lock: &RowLock) -> QueryResult<RowLockSql> {
let mut sql = String::from(match lock.strength {
LockStrength::Update => "FOR UPDATE",
LockStrength::Share => "FOR SHARE",
LockStrength::NoKeyUpdate | LockStrength::KeyShare => {
return Err(QueryError::unsupported(
"MySQL row locks support only FOR UPDATE and FOR SHARE",
));
}
});
if !lock.of_tables.is_empty() {
return Err(QueryError::unsupported(
"MySQL row locks do not support OF <tables>",
));
}
sql.push_str(wait_suffix(lock.wait));
Ok(RowLockSql {
table_hint: None,
suffix: Some(sql),
})
}
fn placeholder(&self, _i: usize) -> String {
"?".into()
}
fn upsert_do_nothing_clause(&self, c: &[&str]) -> String {
let col = c.first().copied().unwrap_or("id");
format!(
" ON DUPLICATE KEY UPDATE {} = {}",
self.quote_ident(col),
self.quote_ident(col)
)
}
fn returning_clause(&self, _cols: &str) -> String {
String::new()
}
fn insert_has_returning(&self) -> bool {
false
}
fn quote_ident(&self, i: &str) -> String {
format!("`{}`", i.replace('`', "``"))
}
fn upsert_clause(&self, _c: &[&str], s: &str) -> String {
format!(" ON DUPLICATE KEY UPDATE {}", s)
}
fn like_escape_clause(&self) -> &'static str {
" ESCAPE '\\\\'"
}
}
impl SqlDialect for Mssql {
fn write_limit_offset(
&self,
sql: &mut String,
take: Option<u64>,
skip: Option<u64>,
has_order_by: bool,
) {
if take.is_none() && skip.is_none() {
return;
}
if !has_order_by {
sql.push_str(" ORDER BY (SELECT NULL)");
}
sql.push_str(" OFFSET ");
sql.push_str(&skip.unwrap_or(0).to_string());
sql.push_str(" ROWS");
if let Some(take) = take {
sql.push_str(" FETCH NEXT ");
sql.push_str(&take.to_string());
sql.push_str(" ROWS ONLY");
}
}
fn row_lock_sql(&self, lock: &RowLock) -> QueryResult<RowLockSql> {
if !lock.of_tables.is_empty() {
return Err(QueryError::unsupported(
"MSSQL row locks do not support OF <tables>",
));
}
let hint = match (lock.strength, lock.wait) {
(LockStrength::Update, LockWait::Wait) => "WITH (UPDLOCK, ROWLOCK)",
(LockStrength::Update, LockWait::SkipLocked) => "WITH (UPDLOCK, ROWLOCK, READPAST)",
(LockStrength::Update, LockWait::NoWait) => "WITH (UPDLOCK, ROWLOCK, NOWAIT)",
(LockStrength::Share, LockWait::Wait) => "WITH (HOLDLOCK, ROWLOCK)",
(LockStrength::Share, LockWait::NoWait) => "WITH (HOLDLOCK, ROWLOCK, NOWAIT)",
(LockStrength::Share, LockWait::SkipLocked) => {
return Err(QueryError::unsupported(
"MSSQL cannot combine a shared row lock with SKIP LOCKED",
));
}
(LockStrength::NoKeyUpdate | LockStrength::KeyShare, _) => {
return Err(QueryError::unsupported(
"MSSQL row locks support only FOR UPDATE and FOR SHARE",
));
}
};
Ok(RowLockSql {
table_hint: Some(hint.to_string()),
suffix: None,
})
}
fn placeholder(&self, i: usize) -> String {
format!("@P{}", i)
}
fn returning_clause(&self, cols: &str) -> String {
if cols == "*" {
return " OUTPUT INSERTED.*".into();
}
let prefixed: Vec<String> = cols
.split(',')
.map(|c| format!("INSERTED.{}", c.trim()))
.collect();
format!(" OUTPUT {}", prefixed.join(", "))
}
fn quote_ident(&self, i: &str) -> String {
format!("[{}]", i.replace(']', "]]"))
}
fn upsert_clause(&self, _c: &[&str], _s: &str) -> String {
String::new()
}
fn begin_sql(&self) -> &'static str {
"BEGIN TRANSACTION"
}
fn commit_sql(&self) -> &'static str {
"COMMIT TRANSACTION"
}
fn rollback_sql(&self) -> &'static str {
"ROLLBACK TRANSACTION"
}
}
impl SqlDialect for Cql {
fn placeholder(&self, _i: usize) -> String {
"?".into()
}
fn returning_clause(&self, _cols: &str) -> String {
String::new()
}
fn insert_has_returning(&self) -> bool {
false
}
fn quote_ident(&self, i: &str) -> String {
format!("\"{}\"", i.replace('"', "\"\""))
}
fn upsert_clause(&self, _c: &[&str], _s: &str) -> String {
String::new()
}
}
impl SqlDialect for NotSql {
fn placeholder(&self, _i: usize) -> String {
unimplemented!(
"NotSql dialect does not emit SQL; engines that return NotSql from \
QueryEngine::dialect() must not route requests through the SQL \
operation builders (FindManyOperation, CreateOperation, etc.). \
Use a SQL-capable dialect (Postgres/Mysql/Sqlite/Mssql) or build \
queries natively (e.g. BSON for MongoDB)."
)
}
fn returning_clause(&self, _cols: &str) -> String {
unimplemented!("NotSql::returning_clause — see NotSql::placeholder for details")
}
fn quote_ident(&self, _ident: &str) -> String {
unimplemented!("NotSql::quote_ident — see NotSql::placeholder for details")
}
fn upsert_clause(&self, _c: &[&str], _s: &str) -> String {
unimplemented!("NotSql::upsert_clause — see NotSql::placeholder for details")
}
fn supports_sql_emission(&self) -> bool {
false
}
fn supports_upsert(&self) -> bool {
false
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn placeholders_per_dialect() {
assert_eq!(Postgres.placeholder(3), "$3");
assert_eq!(Sqlite.placeholder(3), "?3");
assert_eq!(Mysql.placeholder(3), "?");
assert_eq!(Mssql.placeholder(3), "@P3");
}
#[test]
fn returning_mssql_is_output_inserted() {
assert_eq!(Mssql.returning_clause("*"), " OUTPUT INSERTED.*");
assert_eq!(Mssql.returning_clause("id"), " OUTPUT INSERTED.id");
assert_eq!(
Mssql.returning_clause("id, email"),
" OUTPUT INSERTED.id, INSERTED.email"
);
assert_eq!(
Mssql.returning_clause("id,email,name"),
" OUTPUT INSERTED.id, INSERTED.email, INSERTED.name"
);
}
#[test]
fn upsert_mysql_is_on_duplicate_key() {
assert_eq!(
Mysql.upsert_clause(&[], "x = 1"),
" ON DUPLICATE KEY UPDATE x = 1"
);
}
#[test]
fn upsert_postgres_is_on_conflict() {
assert_eq!(
Postgres.upsert_clause(&["email"], "name = EXCLUDED.name"),
" ON CONFLICT (\"email\") DO UPDATE SET name = EXCLUDED.name"
);
}
#[test]
fn quote_ident_backends_escape_the_embedded_quote() {
assert_eq!(
Postgres.quote_ident(r#"col"with"quote"#),
r#""col""with""quote""#
);
assert_eq!(
Sqlite.quote_ident(r#"col"with"quote"#),
r#""col""with""quote""#
);
assert_eq!(Mysql.quote_ident("co`l"), "`co``l`");
assert_eq!(Mssql.quote_ident("col]ident"), "[col]]ident]");
}
#[test]
#[should_panic(expected = "NotSql dialect does not emit SQL")]
fn not_sql_placeholder_panics() {
let _ = NotSql.placeholder(1);
}
#[test]
#[should_panic]
fn not_sql_quote_ident_panics() {
let _ = NotSql.quote_ident("col");
}
#[test]
#[should_panic]
fn not_sql_returning_clause_panics() {
let _ = NotSql.returning_clause("*");
}
#[test]
#[should_panic]
fn not_sql_upsert_clause_panics() {
let _ = NotSql.upsert_clause(&[], "x = 1");
}
#[test]
fn mssql_transaction_keywords_are_distinct() {
assert_eq!(Mssql.begin_sql(), "BEGIN TRANSACTION");
assert_eq!(Mssql.commit_sql(), "COMMIT TRANSACTION");
assert_eq!(Mssql.rollback_sql(), "ROLLBACK TRANSACTION");
}
#[test]
fn distinct_on_support() {
assert!(Postgres.supports_distinct_on());
assert!(!Sqlite.supports_distinct_on());
assert!(!Mysql.supports_distinct_on());
assert!(!Mssql.supports_distinct_on());
assert!(!NotSql.supports_distinct_on());
}
#[test]
fn like_escape_clause_per_dialect() {
assert_eq!(Postgres.like_escape_clause(), r" ESCAPE '\'");
assert_eq!(Sqlite.like_escape_clause(), r" ESCAPE '\'");
assert_eq!(Mssql.like_escape_clause(), r" ESCAPE '\'");
assert_eq!(Cql.like_escape_clause(), r" ESCAPE '\'");
assert_eq!(Mysql.like_escape_clause(), r" ESCAPE '\\'");
}
#[test]
fn sealed_pattern_prevents_external_impl() {
use crate::dialect::{Postgres, SqlDialect};
let _p: &dyn SqlDialect = &Postgres;
}
#[test]
fn limit_offset_default_is_limit_offset() {
use crate::dialect::{Postgres, SqlDialect};
let mut sql = String::from("SELECT 1");
Postgres.write_limit_offset(&mut sql, Some(20), Some(10), false);
assert_eq!(sql, "SELECT 1 LIMIT 20 OFFSET 10");
let mut sql = String::from("SELECT 1");
Postgres.write_limit_offset(&mut sql, None, None, false);
assert_eq!(sql, "SELECT 1");
}
#[test]
fn limit_offset_mssql_uses_offset_fetch() {
use crate::dialect::{Mssql, SqlDialect};
let mut sql = String::from("SELECT * FROM t ORDER BY id");
Mssql.write_limit_offset(&mut sql, Some(5), Some(10), true);
assert_eq!(
sql,
"SELECT * FROM t ORDER BY id OFFSET 10 ROWS FETCH NEXT 5 ROWS ONLY"
);
let mut sql = String::from("SELECT * FROM t");
Mssql.write_limit_offset(&mut sql, Some(1), None, false);
assert_eq!(
sql,
"SELECT * FROM t ORDER BY (SELECT NULL) OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY"
);
let mut sql = String::from("SELECT * FROM t ORDER BY id");
Mssql.write_limit_offset(&mut sql, None, Some(3), true);
assert_eq!(sql, "SELECT * FROM t ORDER BY id OFFSET 3 ROWS");
let mut sql = String::from("SELECT 1");
Mssql.write_limit_offset(&mut sql, None, None, false);
assert_eq!(sql, "SELECT 1");
}
}