#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum BackendKind {
MySql,
PostgreSql,
Redis,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum PlaceholderStyle {
QuestionMark,
NumberedDollar,
NotApplicable,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum BackendCapability {
CheckedIdentifiers,
Select,
Aggregate,
Join,
Insert,
BatchInsert,
Update,
BatchUpdate,
Delete,
Upsert,
BatchUpsert,
Returning,
ExplicitConflictTarget,
TransactionCrud,
RedisPipeline,
RedisOptimisticTransaction,
RedisLua,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum SafetyConstraint {
ParameterizedValues,
CheckedIdentifiers,
ExplicitTrustedExpressions,
WriteRequiresWhere,
StructuredCommandArguments,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct BackendCapabilities {
pub backend: BackendKind,
pub relational: bool,
pub placeholder_style: PlaceholderStyle,
pub operations: &'static [BackendCapability],
pub transaction: &'static [BackendCapability],
pub safety: &'static [SafetyConstraint],
}
impl BackendCapabilities {
pub fn supports(&self, capability: BackendCapability) -> bool {
self.operations.contains(&capability) || self.transaction.contains(&capability)
}
pub fn enforces(&self, constraint: SafetyConstraint) -> bool {
self.safety.contains(&constraint)
}
}
const MYSQL_OPERATIONS: &[BackendCapability] = &[
BackendCapability::CheckedIdentifiers,
BackendCapability::Select,
BackendCapability::Aggregate,
BackendCapability::Join,
BackendCapability::Insert,
BackendCapability::BatchInsert,
BackendCapability::Update,
BackendCapability::BatchUpdate,
BackendCapability::Delete,
BackendCapability::Upsert,
BackendCapability::BatchUpsert,
];
const POSTGRES_OPERATIONS: &[BackendCapability] = &[
BackendCapability::CheckedIdentifiers,
BackendCapability::Select,
BackendCapability::Aggregate,
BackendCapability::Join,
BackendCapability::Insert,
BackendCapability::BatchInsert,
BackendCapability::Update,
BackendCapability::BatchUpdate,
BackendCapability::Delete,
BackendCapability::Upsert,
BackendCapability::Returning,
BackendCapability::ExplicitConflictTarget,
];
const SQL_SAFETY: &[SafetyConstraint] = &[
SafetyConstraint::ParameterizedValues,
SafetyConstraint::CheckedIdentifiers,
SafetyConstraint::ExplicitTrustedExpressions,
SafetyConstraint::WriteRequiresWhere,
];
pub const MYSQL_CAPABILITIES: BackendCapabilities = BackendCapabilities {
backend: BackendKind::MySql,
relational: true,
placeholder_style: PlaceholderStyle::QuestionMark,
operations: MYSQL_OPERATIONS,
transaction: &[BackendCapability::TransactionCrud],
safety: SQL_SAFETY,
};
pub const POSTGRES_CAPABILITIES: BackendCapabilities = BackendCapabilities {
backend: BackendKind::PostgreSql,
relational: true,
placeholder_style: PlaceholderStyle::NumberedDollar,
operations: POSTGRES_OPERATIONS,
transaction: &[
BackendCapability::TransactionCrud,
BackendCapability::Returning,
],
safety: SQL_SAFETY,
};
pub const REDIS_CAPABILITIES: BackendCapabilities = BackendCapabilities {
backend: BackendKind::Redis,
relational: false,
placeholder_style: PlaceholderStyle::NotApplicable,
operations: &[
BackendCapability::RedisPipeline,
BackendCapability::RedisLua,
],
transaction: &[BackendCapability::RedisOptimisticTransaction],
safety: &[SafetyConstraint::StructuredCommandArguments],
};
#[cfg(test)]
mod tests {
use super::*;
#[cfg(any(feature = "mysql", feature = "postgres", feature = "redis"))]
use std::future::Future;
#[cfg(any(feature = "mysql", feature = "postgres", feature = "redis"))]
fn assert_future<T>(_future: impl Future<Output = T>) {}
#[cfg(feature = "mysql")]
fn mysql_management_contract(db: &crate::mysql::Database) {
let _: &'static BackendCapabilities = crate::mysql::Database::capabilities();
let _: crate::PoolStatus = db.pool_status();
let _: bool = db.is_closed();
assert_future::<Result<bool, crate::DbError>>(db.health_check());
assert_future::<()>(db.close());
}
#[cfg(feature = "postgres")]
fn postgres_management_contract(db: &crate::postgres::Database) {
let _: &'static BackendCapabilities = crate::postgres::Database::capabilities();
let _: crate::PoolStatus = db.pool_status();
let _: bool = db.is_closed();
assert_future::<Result<bool, crate::DbError>>(db.health_check());
assert_future::<()>(db.close());
}
#[cfg(feature = "redis")]
fn redis_management_contract(client: &crate::redis::RedisClient) {
let _: &'static BackendCapabilities = crate::redis::RedisClient::capabilities();
let _: crate::PoolStatus = client.pool_status();
let _: bool = client.is_closed();
assert_future::<Result<bool, crate::DbError>>(client.health_check());
assert_future::<()>(client.close());
}
#[test]
fn management_contract_signatures_compile() {
#[cfg(feature = "mysql")]
let _ = mysql_management_contract;
#[cfg(feature = "postgres")]
let _ = postgres_management_contract;
#[cfg(feature = "redis")]
let _ = redis_management_contract;
}
#[test]
fn sql_backends_share_common_contract_and_expose_dialect_differences() {
for capability in [
BackendCapability::CheckedIdentifiers,
BackendCapability::Select,
BackendCapability::Aggregate,
BackendCapability::Join,
BackendCapability::Insert,
BackendCapability::BatchInsert,
BackendCapability::Update,
BackendCapability::BatchUpdate,
BackendCapability::Delete,
BackendCapability::Upsert,
BackendCapability::TransactionCrud,
] {
assert!(MYSQL_CAPABILITIES.supports(capability));
assert!(POSTGRES_CAPABILITIES.supports(capability));
}
assert!(!MYSQL_CAPABILITIES.supports(BackendCapability::Returning));
assert!(POSTGRES_CAPABILITIES.supports(BackendCapability::Returning));
assert!(!MYSQL_CAPABILITIES.supports(BackendCapability::ExplicitConflictTarget));
assert!(POSTGRES_CAPABILITIES.supports(BackendCapability::ExplicitConflictTarget));
}
#[test]
fn mysql_declares_batch_upsert_and_postgres_does_not() {
assert!(MYSQL_CAPABILITIES.supports(BackendCapability::BatchUpsert));
assert!(!POSTGRES_CAPABILITIES.supports(BackendCapability::BatchUpsert));
}
#[test]
fn redis_is_explicitly_non_relational() {
let redis = std::hint::black_box(REDIS_CAPABILITIES);
assert!(!redis.relational);
assert_eq!(redis.placeholder_style, PlaceholderStyle::NotApplicable);
assert!(!redis.supports(BackendCapability::Select));
assert!(redis.supports(BackendCapability::RedisPipeline));
assert!(redis.supports(BackendCapability::RedisOptimisticTransaction));
assert!(redis.supports(BackendCapability::RedisLua));
}
#[test]
fn sql_safety_contract_is_symmetric() {
for constraint in SQL_SAFETY {
assert!(MYSQL_CAPABILITIES.enforces(*constraint));
assert!(POSTGRES_CAPABILITIES.enforces(*constraint));
}
assert!(REDIS_CAPABILITIES.enforces(SafetyConstraint::StructuredCommandArguments));
assert!(!REDIS_CAPABILITIES.enforces(SafetyConstraint::WriteRequiresWhere));
}
}