use super::super::DatabaseInitializer;
use super::driver::SchemaConnection;
use super::driver::{OwnedSchemaConnection, SchemaDriver};
use super::plan::{plan_locked, report_tables};
use super::preflight::{format_violations, preflight_locked};
use super::{SchemaPreflightReport, SchemaSyncChangeKind, SchemaSyncReport};
use crate::error::BaseError;
#[cfg(feature = "mysql")]
use crate::table::SchemaColumn;
use crate::table::{SchemaValidationReport, TableDefinition};
impl DatabaseInitializer {
pub async fn validate_table_definition(
&self,
table: &TableDefinition,
) -> Result<SchemaValidationReport, BaseError> {
let driver = self.schema_driver()?;
match driver {
#[cfg(feature = "mysql")]
SchemaDriver::MySql => {
#[derive(sqlx::FromRow)]
struct ColumnRow {
column_name: String,
data_type: String,
column_type: String,
is_nullable: String,
character_maximum_length: Option<i64>,
column_default: Option<String>,
extra: String,
}
let database = self.db().as_mysql().ok_or_else(|| {
BaseError::DatabaseInitFailed(
"DatabaseInitializer 未持有 MySQL 后端".to_string(),
)
})?;
let rows: Vec<ColumnRow> = database
.query_with_params(
"SELECT CAST(COLUMN_NAME AS CHAR) AS column_name, CAST(DATA_TYPE AS CHAR) AS data_type, CAST(COLUMN_TYPE AS CHAR) AS column_type, CAST(IS_NULLABLE AS CHAR) AS is_nullable, CAST(CHARACTER_MAXIMUM_LENGTH AS SIGNED) AS character_maximum_length, CAST(COLUMN_DEFAULT AS CHAR) AS column_default, CAST(EXTRA AS CHAR) AS extra FROM information_schema.columns WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? ORDER BY ORDINAL_POSITION",
vec![serde_json::Value::String(table.name().to_string())],
)
.await
.map_err(BaseError::DatabaseQueryFailed)?;
let columns = rows
.into_iter()
.map(|row| {
SchemaColumn::new(
row.column_name,
row.data_type,
row.column_type,
row.is_nullable.eq_ignore_ascii_case("YES"),
row.character_maximum_length
.and_then(|length| u64::try_from(length).ok()),
row.column_default,
)
.with_auto_increment(
row.extra
.split_whitespace()
.any(|part| part.eq_ignore_ascii_case("auto_increment")),
)
})
.collect::<Vec<_>>();
Ok(table.validate_schema(&columns))
}
#[cfg(feature = "postgres")]
SchemaDriver::PostgreSql => {
let mut owned = self.acquire_schema_connection().await?;
let mut connection = owned.as_schema();
let existing = driver.introspect(&mut connection, table).await?;
let config = table.shared_config();
Ok(driver.dialect().validate_schema(config.as_ref(), &existing))
}
}
}
pub async fn plan_table_definitions(
&self,
definitions: &[&TableDefinition],
) -> Result<SchemaSyncReport, BaseError> {
let driver = self.schema_driver()?;
let definitions = driver.dialect().normalize_definitions(definitions)?;
if definitions.is_empty() {
return Ok(SchemaSyncReport::default());
}
let mut owned = self.acquire_schema_connection().await?;
let mut connection = owned.as_schema();
let plans = plan_locked(driver, &mut connection, &definitions).await?;
let (statements, deferred_statements) = plan_statements(&plans);
Ok(SchemaSyncReport {
tables: report_tables(&definitions),
changes: plans.into_iter().flat_map(|plan| plan.changes).collect(),
statements,
deferred_statements,
bindings: Vec::new(),
})
}
pub async fn preflight_table_definitions(
&self,
definitions: &[&TableDefinition],
) -> Result<SchemaPreflightReport, BaseError> {
let driver = self.schema_driver()?;
let definitions = driver.dialect().normalize_definitions(definitions)?;
if definitions.is_empty() {
return Ok(SchemaPreflightReport::default());
}
let mut owned = self.acquire_schema_connection().await?;
let mut connection = owned.as_schema();
let plans = plan_locked(driver, &mut connection, &definitions).await?;
let (statements, deferred_statements) = plan_statements(&plans);
let violations =
preflight_locked(driver.dialect(), &mut connection, &definitions, &plans).await?;
Ok(SchemaPreflightReport {
plan: SchemaSyncReport {
tables: report_tables(&definitions),
changes: plans
.iter()
.flat_map(|plan| plan.changes.iter().cloned())
.collect(),
statements,
deferred_statements,
bindings: Vec::new(),
},
violations,
})
}
pub async fn sync_table_definitions(
&self,
definitions: &[&TableDefinition],
) -> Result<SchemaSyncReport, BaseError> {
let driver = self.schema_driver()?;
let definitions = driver.dialect().normalize_definitions(definitions)?;
if definitions.is_empty() {
return Ok(SchemaSyncReport::default());
}
if let Some(definition) = definitions.iter().find(|definition| {
definition
.name()
.rsplit('.')
.next()
.is_some_and(|name| name == super::binding::BINDING_TABLE)
}) {
return Err(BaseError::ConfigError(format!(
"表 {} 是框架保留的系统表,不能由模块声明",
definition.name()
)));
}
let datasource = self.db().id().clone();
let mut owned = self.acquire_schema_connection().await?;
let mut connection = owned.as_schema();
let lock = driver.lock(&mut connection).await?;
let result = sync_locked(driver, &mut connection, &definitions, &datasource).await;
let reset_result = driver.reset_session(&mut connection).await;
let release_result = driver.unlock(&mut connection, &lock).await;
let result = match result {
Ok(report) => reset_result.map(|()| report),
Err(error) => {
if let Err(reset_error) = &reset_result {
tracing::warn!(
error = %reset_error,
"schema 同步失败后复位会话参数失败"
);
}
Err(error)
}
};
match (result, release_result) {
(Err(error), _) => Err(error),
(Ok(_), Err(error)) => Err(error),
(Ok(report), Ok(())) => Ok(report),
}
}
pub(crate) fn schema_driver(&self) -> Result<SchemaDriver, BaseError> {
SchemaDriver::for_backend(self.db().backend())
}
pub(crate) async fn acquire_schema_connection(
&self,
) -> Result<OwnedSchemaConnection, BaseError> {
#[cfg(feature = "mysql")]
if let Some(database) = self.db().as_mysql() {
let connection = database
.pool()
.acquire()
.await
.map_err(|error| BaseError::DatabaseConnectionDbError(error.into()))?;
return Ok(OwnedSchemaConnection::MySql(connection));
}
#[cfg(feature = "postgres")]
if let Some(database) = self.db().as_postgres() {
let connection = database
.pool()
.acquire()
.await
.map_err(|error| BaseError::DatabaseConnectionDbError(error.into()))?;
return Ok(OwnedSchemaConnection::PostgreSql(connection));
}
Err(BaseError::DatabaseInitFailed(
"DatabaseInitializer 未持有可用的数据库后端".to_string(),
))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum StepPhase {
Foundation,
Main,
Concurrent,
ForeignKeys,
PostForeignKeys,
AllNonForeignKey,
}
impl StepPhase {
fn runs_statements(self, step: &super::model::PlanStep) -> bool {
let is_foreign_key = matches!(
step.change.kind,
SchemaSyncChangeKind::AddedForeignKey | SchemaSyncChangeKind::ValidatedForeignKey
);
match self {
Self::Foundation => {
!step.concurrent
&& !is_foreign_key
&& matches!(
step.change.kind,
SchemaSyncChangeKind::CreatedTable
| SchemaSyncChangeKind::AddedColumn
| SchemaSyncChangeKind::CreatedEnumType
| SchemaSyncChangeKind::AddedEnumValue
)
}
Self::Main => {
!step.concurrent
&& !is_foreign_key
&& !matches!(
step.change.kind,
SchemaSyncChangeKind::CreatedTable
| SchemaSyncChangeKind::AddedColumn
| SchemaSyncChangeKind::CreatedEnumType
| SchemaSyncChangeKind::AddedEnumValue
)
}
Self::Concurrent => step.concurrent,
Self::ForeignKeys => !step.concurrent && is_foreign_key,
Self::PostForeignKeys => false,
Self::AllNonForeignKey => !step.concurrent && !is_foreign_key,
}
}
fn runs_deferred(self, step: &super::model::PlanStep) -> bool {
if step.deferred_statements.is_empty() {
return false;
}
let is_foreign_key = matches!(
step.change.kind,
SchemaSyncChangeKind::AddedForeignKey | SchemaSyncChangeKind::ValidatedForeignKey
);
match self {
Self::Concurrent => !is_foreign_key,
Self::PostForeignKeys => is_foreign_key,
_ => false,
}
}
}
async fn sync_locked(
driver: SchemaDriver,
connection: &mut SchemaConnection<'_>,
definitions: &[&TableDefinition],
datasource: &crate::datasource::DatasourceId,
) -> Result<SchemaSyncReport, BaseError> {
driver.configure_session(connection).await?;
let plans = plan_locked(driver, connection, definitions).await?;
super::binding::ensure_binding_table(driver, connection).await?;
let existing_bindings = super::binding::load_bindings(connection, datasource).await?;
let planned_changes = plans
.iter()
.flat_map(|plan| plan.changes.iter().cloned())
.collect::<Vec<_>>();
let binding_updates =
binding_updates(driver, definitions, &existing_bindings, &planned_changes)?;
super::binding::upsert_bindings(connection, datasource, &binding_updates).await?;
if driver.transactional_ddl() {
connection.begin().await?;
let transaction = async {
execute_steps(connection, &plans, StepPhase::Foundation).await?;
let violations = driver.preflight(connection, definitions, &plans).await?;
if !violations.is_empty() {
return Err(BaseError::DatabaseInitFailed(format_violations(
&violations,
)));
}
execute_steps(connection, &plans, StepPhase::Main).await
}
.await;
match transaction {
Ok(()) => connection.commit().await?,
Err(error) => {
let _ = connection.rollback().await;
return Err(error);
}
}
execute_steps(connection, &plans, StepPhase::Concurrent).await?;
if plans
.iter()
.flat_map(|plan| &plan.steps)
.any(|step| step.change.kind == SchemaSyncChangeKind::AddedForeignKey)
{
connection.begin().await?;
match execute_steps(connection, &plans, StepPhase::ForeignKeys).await {
Ok(()) => connection.commit().await?,
Err(error) => {
let _ = connection.rollback().await;
return Err(error);
}
}
}
execute_steps(connection, &plans, StepPhase::PostForeignKeys).await?;
} else {
let violations = driver.preflight(connection, definitions, &plans).await?;
if !violations.is_empty() {
return Err(BaseError::DatabaseInitFailed(format_violations(
&violations,
)));
}
execute_steps(connection, &plans, StepPhase::AllNonForeignKey).await?;
execute_steps(connection, &plans, StepPhase::ForeignKeys).await?;
}
let (statements, deferred_statements) = plan_statements(&plans);
Ok(SchemaSyncReport {
tables: report_tables(definitions),
changes: plans
.iter()
.flat_map(|plan| plan.steps.iter().map(|step| step.change.clone()))
.collect(),
statements,
deferred_statements,
bindings: binding_updates
.iter()
.map(|update| super::SchemaBindingChange {
datasource: datasource.clone(),
table: update.table.clone(),
mode: update.mode,
newly_bound: update.newly_bound,
})
.collect(),
})
}
fn plan_statements(plans: &[super::model::TableSyncPlan]) -> (Vec<String>, Vec<String>) {
let mut statements = Vec::new();
let mut deferred_statements = Vec::new();
for plan in plans {
for step in &plan.steps {
statements.extend(step.statements.iter().cloned());
deferred_statements.extend(step.deferred_statements.iter().cloned());
}
}
(statements, deferred_statements)
}
fn binding_updates(
driver: SchemaDriver,
definitions: &[&TableDefinition],
existing: &std::collections::BTreeMap<String, super::binding::BindingRecord>,
changes: &[super::SchemaSyncChange],
) -> Result<Vec<super::binding::BindingUpdate>, BaseError> {
let changed = changes
.iter()
.map(|change| change.table.as_str())
.collect::<std::collections::BTreeSet<_>>();
let now = super::binding::now_unix_seconds();
let mut updates = Vec::new();
for definition in definitions {
let table = definition.name().to_string();
let fingerprint = super::binding::table_fingerprint(driver, definition)?;
let record = existing.get(&table);
let (mode, newly_bound) = match record {
Some(record) => {
let mode = if record.mode == super::SchemaBindingMode::Adopted
&& changed.contains(table.as_str())
{
super::SchemaBindingMode::Managed
} else {
record.mode
};
(mode, false)
}
None if changed.contains(table.as_str()) => (super::SchemaBindingMode::Managed, true),
None => (super::SchemaBindingMode::Adopted, true),
};
let needs_write = record.map_or(true, |record| {
record.mode != mode || record.fingerprint != fingerprint
});
if needs_write {
updates.push(super::binding::BindingUpdate {
table,
mode,
fingerprint,
adopted_at: now,
newly_bound,
});
}
}
Ok(updates)
}
async fn execute_steps(
connection: &mut SchemaConnection<'_>,
plans: &[super::model::TableSyncPlan],
phase: StepPhase,
) -> Result<(), BaseError> {
for plan in plans {
for step in &plan.steps {
let run_statements = phase.runs_statements(step);
let run_deferred = phase.runs_deferred(step);
if !run_statements && !run_deferred {
continue;
}
if run_statements {
for statement in &step.statements {
connection.execute(statement).await?;
}
}
if run_deferred {
for statement in &step.deferred_statements {
connection.execute(statement).await?;
}
}
tracing::info!(
table = %step.change.table,
object = %step.change.object,
kind = ?step.change.kind,
phase = ?phase,
"数据库 schema 已同步"
);
}
}
Ok(())
}