use super::dialect::SchemaDialect;
use super::model::{ExistingTableSchema, TableSyncPlan};
use super::preflight::preflight_locked;
use super::SchemaDataViolation;
use crate::error::BaseError;
use crate::table::TableDefinition;
use yang_db::BackendKind;
const LOCK_TIMEOUT_SECONDS: u64 = 30;
#[cfg(feature = "postgres")]
const DDL_LOCK_TIMEOUT_SECONDS: u64 = 30;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum SchemaDriver {
#[cfg(feature = "mysql")]
MySql,
#[cfg(feature = "postgres")]
PostgreSql,
}
pub(crate) enum SchemaConnection<'a> {
#[cfg(feature = "mysql")]
MySql(&'a mut sqlx::MySqlConnection),
#[cfg(feature = "postgres")]
PostgreSql(&'a mut sqlx::PgConnection),
}
pub(crate) enum OwnedSchemaConnection {
#[cfg(feature = "mysql")]
MySql(sqlx::pool::PoolConnection<sqlx::MySql>),
#[cfg(feature = "postgres")]
PostgreSql(sqlx::pool::PoolConnection<sqlx::Postgres>),
}
impl OwnedSchemaConnection {
pub(crate) fn as_schema(&mut self) -> SchemaConnection<'_> {
match self {
#[cfg(feature = "mysql")]
Self::MySql(connection) => SchemaConnection::MySql(connection),
#[cfg(feature = "postgres")]
Self::PostgreSql(connection) => SchemaConnection::PostgreSql(connection),
}
}
}
#[derive(Debug)]
pub(crate) enum SchemaLock {
#[cfg(feature = "mysql")]
MySql(String),
#[cfg(feature = "postgres")]
PostgreSql(i64),
}
impl SchemaConnection<'_> {
pub(crate) async fn execute(&mut self, statement: &str) -> Result<(), BaseError> {
match self {
#[cfg(feature = "mysql")]
Self::MySql(connection) => sqlx::query(statement)
.execute(&mut **connection)
.await
.map(|_| ())
.map_err(|error| BaseError::DatabaseExecuteFailed(error.into())),
#[cfg(feature = "postgres")]
Self::PostgreSql(connection) => sqlx::query(statement)
.execute(&mut **connection)
.await
.map(|_| ())
.map_err(|error| BaseError::DatabaseExecuteFailed(error.into())),
}
}
pub(crate) async fn fetch_text_column(
&mut self,
statement: &str,
) -> Result<Vec<String>, BaseError> {
match self {
#[cfg(feature = "mysql")]
Self::MySql(connection) => sqlx::query_scalar::<_, String>(statement)
.fetch_all(&mut **connection)
.await
.map_err(|error| BaseError::DatabaseQueryFailed(error.into())),
#[cfg(feature = "postgres")]
Self::PostgreSql(connection) => sqlx::query_scalar::<_, String>(statement)
.fetch_all(&mut **connection)
.await
.map_err(|error| BaseError::DatabaseQueryFailed(error.into())),
}
}
pub(crate) async fn begin(&mut self) -> Result<(), BaseError> {
self.execute("BEGIN").await
}
pub(crate) async fn commit(&mut self) -> Result<(), BaseError> {
self.execute("COMMIT").await
}
pub(crate) async fn rollback(&mut self) -> Result<(), BaseError> {
self.execute("ROLLBACK").await
}
}
impl SchemaDriver {
pub(crate) fn for_backend(backend: BackendKind) -> Result<Self, BaseError> {
match backend {
#[cfg(feature = "mysql")]
BackendKind::MySql => Ok(Self::MySql),
#[cfg(feature = "postgres")]
BackendKind::PostgreSql => Ok(Self::PostgreSql),
#[allow(unreachable_patterns)]
_ => Err(BaseError::DatabaseInitFailed(format!(
"schema 同步不支持数据库后端: {backend:?}"
))),
}
}
pub(crate) fn dialect(self) -> SchemaDialect {
match self {
#[cfg(feature = "mysql")]
Self::MySql => SchemaDialect::MySql,
#[cfg(feature = "postgres")]
Self::PostgreSql => SchemaDialect::PostgreSql,
}
}
pub(crate) fn transactional_ddl(self) -> bool {
match self {
#[cfg(feature = "mysql")]
Self::MySql => false,
#[cfg(feature = "postgres")]
Self::PostgreSql => true,
}
}
pub(crate) async fn configure_session(
self,
connection: &mut SchemaConnection<'_>,
) -> Result<(), BaseError> {
match self {
#[cfg(feature = "mysql")]
Self::MySql => {
let _ = connection;
Ok(())
}
#[cfg(feature = "postgres")]
Self::PostgreSql => {
connection
.execute(&format!("SET lock_timeout = '{DDL_LOCK_TIMEOUT_SECONDS}s'"))
.await
}
}
}
pub(crate) async fn reset_session(
self,
connection: &mut SchemaConnection<'_>,
) -> Result<(), BaseError> {
match self {
#[cfg(feature = "mysql")]
Self::MySql => {
let _ = connection;
Ok(())
}
#[cfg(feature = "postgres")]
Self::PostgreSql => connection.execute("RESET lock_timeout").await,
}
}
pub(crate) async fn introspect(
self,
connection: &mut SchemaConnection<'_>,
definition: &TableDefinition,
) -> Result<ExistingTableSchema, BaseError> {
match (self, connection) {
#[cfg(feature = "mysql")]
(Self::MySql, SchemaConnection::MySql(connection)) => {
super::inspect::load_existing_schema(connection, definition).await
}
#[cfg(feature = "postgres")]
(Self::PostgreSql, SchemaConnection::PostgreSql(connection)) => {
super::pg::load_existing_schema(connection, definition).await
}
#[allow(unreachable_patterns)]
_ => Err(BaseError::DatabaseInitFailed(
"schema driver 与数据库连接后端不一致".to_string(),
)),
}
}
#[allow(dead_code)]
pub(crate) fn render_create_table(
self,
table: &crate::table::TableConfig,
include_foreign_keys: bool,
) -> Result<String, BaseError> {
self.dialect()
.render_create_table(table, include_foreign_keys)
}
pub(crate) fn plan_changes(
self,
definition: &TableDefinition,
existing: &ExistingTableSchema,
) -> Result<TableSyncPlan, BaseError> {
super::plan::plan_table_sync_with(self.dialect(), definition, existing)
}
pub(crate) async fn preflight(
self,
connection: &mut SchemaConnection<'_>,
definitions: &[&TableDefinition],
plans: &[TableSyncPlan],
) -> Result<Vec<SchemaDataViolation>, BaseError> {
preflight_locked(self.dialect(), connection, definitions, plans).await
}
pub(crate) async fn lock(
self,
connection: &mut SchemaConnection<'_>,
) -> Result<SchemaLock, BaseError> {
match (self, connection) {
#[cfg(feature = "mysql")]
(Self::MySql, SchemaConnection::MySql(connection)) => {
let database_name: Option<String> = sqlx::query_scalar("SELECT DATABASE()")
.fetch_one(&mut **connection)
.await
.map_err(|error| BaseError::DatabaseQueryFailed(error.into()))?;
let database_name = database_name.ok_or_else(|| {
BaseError::DatabaseInitFailed("当前 MySQL 连接没有选定数据库".to_string())
})?;
let lock_name = mysql_lock_name(&database_name);
let acquired: Option<i64> = sqlx::query_scalar("SELECT GET_LOCK(?, ?)")
.bind(&lock_name)
.bind(LOCK_TIMEOUT_SECONDS as i64)
.fetch_one(&mut **connection)
.await
.map_err(|error| BaseError::DatabaseQueryFailed(error.into()))?;
if acquired != Some(1) {
return Err(BaseError::DatabaseInitFailed(format!(
"等待 schema 同步锁超时: {lock_name}"
)));
}
Ok(SchemaLock::MySql(lock_name))
}
#[cfg(feature = "postgres")]
(Self::PostgreSql, SchemaConnection::PostgreSql(connection)) => {
let database_name: String = sqlx::query_scalar("SELECT current_database()")
.fetch_one(&mut **connection)
.await
.map_err(|error| BaseError::DatabaseQueryFailed(error.into()))?;
let key = postgres_lock_key(&database_name);
let deadline = std::time::Instant::now()
+ std::time::Duration::from_secs(LOCK_TIMEOUT_SECONDS);
loop {
let acquired: bool = sqlx::query_scalar("SELECT pg_try_advisory_lock($1)")
.bind(key)
.fetch_one(&mut **connection)
.await
.map_err(|error| BaseError::DatabaseQueryFailed(error.into()))?;
if acquired {
return Ok(SchemaLock::PostgreSql(key));
}
if std::time::Instant::now() >= deadline {
return Err(BaseError::DatabaseInitFailed(format!(
"等待 schema 同步锁超时: pg_advisory_lock({key})"
)));
}
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
}
}
#[allow(unreachable_patterns)]
_ => Err(BaseError::DatabaseInitFailed(
"schema driver 与数据库连接后端不一致".to_string(),
)),
}
}
pub(crate) async fn unlock(
self,
connection: &mut SchemaConnection<'_>,
lock: &SchemaLock,
) -> Result<(), BaseError> {
match (self, connection, lock) {
#[cfg(feature = "mysql")]
(Self::MySql, SchemaConnection::MySql(connection), SchemaLock::MySql(lock_name)) => {
let released: Option<i64> = sqlx::query_scalar("SELECT RELEASE_LOCK(?)")
.bind(lock_name)
.fetch_one(&mut **connection)
.await
.map_err(|error| BaseError::DatabaseQueryFailed(error.into()))?;
if released != Some(1) {
return Err(BaseError::DatabaseInitFailed(format!(
"schema 同步锁释放失败: {lock_name}"
)));
}
Ok(())
}
#[cfg(feature = "postgres")]
(
Self::PostgreSql,
SchemaConnection::PostgreSql(connection),
SchemaLock::PostgreSql(key),
) => {
let released: bool = sqlx::query_scalar("SELECT pg_advisory_unlock($1)")
.bind(key)
.fetch_one(&mut **connection)
.await
.map_err(|error| BaseError::DatabaseQueryFailed(error.into()))?;
if !released {
return Err(BaseError::DatabaseInitFailed(format!(
"schema 同步锁释放失败: pg_advisory_lock({key})"
)));
}
Ok(())
}
#[allow(unreachable_patterns)]
_ => Err(BaseError::DatabaseInitFailed(
"schema driver 与数据库连接后端不一致".to_string(),
)),
}
}
}
#[cfg(feature = "mysql")]
fn mysql_lock_name(database_name: &str) -> String {
format!(
"yang_base_schema_{:016x}",
fnv1a_64(database_name.as_bytes())
)
}
#[cfg(feature = "postgres")]
fn postgres_lock_key(database_name: &str) -> i64 {
fnv1a_64(database_name.as_bytes()) as i64
}
#[cfg(any(feature = "mysql", feature = "postgres"))]
fn fnv1a_64(bytes: &[u8]) -> u64 {
let mut hash: u64 = 0xcbf29ce484222325;
for byte in bytes {
hash ^= u64::from(*byte);
hash = hash.wrapping_mul(0x100000001b3);
}
hash
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn driver_dispatch_follows_backend_and_ddl_transactionality() {
#[cfg(feature = "mysql")]
{
let driver = SchemaDriver::for_backend(BackendKind::MySql).expect("MySQL 驱动应可用");
assert_eq!(driver.dialect(), SchemaDialect::MySql);
assert!(!driver.transactional_ddl());
assert_eq!(mysql_lock_name("test"), mysql_lock_name("test"));
}
#[cfg(feature = "postgres")]
{
let driver =
SchemaDriver::for_backend(BackendKind::PostgreSql).expect("PostgreSQL 驱动应可用");
assert_eq!(driver.dialect(), SchemaDialect::PostgreSql);
assert!(driver.transactional_ddl());
assert_eq!(postgres_lock_key("test"), postgres_lock_key("test"));
}
assert!(SchemaDriver::for_backend(BackendKind::Redis).is_err());
}
}