feat(schema-diff): preserve dialect-specific DDL semantics
This commit is contained in:
1 parent
820b8cd26f
commit
002a2c85c0
146 files changed
+36532
-1375
No files matched your search
@@ -0,0 +1,659 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::data_compare::{DataCompareFromTablesPreparation, DataCompareResult};
|
||||
use crate::schema_diff::SchemaDiffPreparation;
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum CorrectionStepType {
|
||||
SchemaCreate,
|
||||
SchemaAlter,
|
||||
SchemaDrop,
|
||||
DataInsert,
|
||||
DataUpdate,
|
||||
DataDelete,
|
||||
SchemaPostSync,
|
||||
Checkpoint,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct CorrectionStep {
|
||||
pub step_type: CorrectionStepType,
|
||||
pub table_name: Option<String>,
|
||||
pub sql: String,
|
||||
pub rollback_sql: Option<String>,
|
||||
pub description: String,
|
||||
pub risk_level: CorrectionRiskLevel,
|
||||
#[serde(default)]
|
||||
pub depends_on: Vec<usize>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum CorrectionRiskLevel {
|
||||
Safe,
|
||||
#[default]
|
||||
Caution,
|
||||
Dangerous,
|
||||
Blocked,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum CorrectionStrategy {
|
||||
StructureFirst,
|
||||
DataFirst,
|
||||
Interleaved,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct JointCorrectionPlan {
|
||||
pub strategy: CorrectionStrategy,
|
||||
pub steps: Vec<CorrectionStep>,
|
||||
pub schema_diff_count: usize,
|
||||
pub data_diff_count: usize,
|
||||
pub total_estimated_duration_secs: Option<u64>,
|
||||
#[serde(default)]
|
||||
pub rollback_steps: Vec<CorrectionStep>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct JointCorrectionOptions {
|
||||
pub strategy: CorrectionStrategy,
|
||||
#[serde(default)]
|
||||
pub include_checkpoints: bool,
|
||||
#[serde(default)]
|
||||
pub include_rollback: bool,
|
||||
}
|
||||
|
||||
impl Default for JointCorrectionOptions {
|
||||
fn default() -> Self {
|
||||
Self { strategy: CorrectionStrategy::StructureFirst, include_checkpoints: true, include_rollback: true }
|
||||
}
|
||||
}
|
||||
|
||||
/// Build a joint correction plan from schema diff and data compare results.
|
||||
///
|
||||
/// Orchestrates schema + data changes according to `CorrectionStrategy`:
|
||||
/// - `StructureFirst`: schema → data → post-sync checks
|
||||
/// - `DataFirst`: data → schema
|
||||
/// - `Interleaved`: per-table schema + data interleaved
|
||||
///
|
||||
/// # Limitations
|
||||
/// - `Interleaved` uses placeholder SQL rather than actual per-table DDL slices.
|
||||
/// - Table name matching uses substring checks (`line.contains(&name)`), which can
|
||||
/// produce false positives when one table name is a prefix of another.
|
||||
pub fn build_joint_correction_plan(
|
||||
schema_diff: Option<&SchemaDiffPreparation>,
|
||||
data_compare: Option<&DataCompareFromTablesPreparation>,
|
||||
options: JointCorrectionOptions,
|
||||
) -> JointCorrectionPlan {
|
||||
let mut steps = Vec::new();
|
||||
let mut rollback_steps = Vec::new();
|
||||
let mut step_index = 0usize;
|
||||
|
||||
match options.strategy {
|
||||
CorrectionStrategy::StructureFirst => {
|
||||
step_index = append_schema_steps(schema_diff, &mut steps, &mut rollback_steps, &options, step_index);
|
||||
let _ = append_data_steps(data_compare, &mut steps, &mut rollback_steps, &options, step_index);
|
||||
}
|
||||
CorrectionStrategy::DataFirst => {
|
||||
step_index = append_data_steps(data_compare, &mut steps, &mut rollback_steps, &options, step_index);
|
||||
let _ = append_schema_steps(schema_diff, &mut steps, &mut rollback_steps, &options, step_index);
|
||||
}
|
||||
CorrectionStrategy::Interleaved => {
|
||||
if let Some(schema) = schema_diff {
|
||||
let table_diffs: Vec<_> = schema.diffs.iter().filter(|d| d.diff_type != "unchanged").collect();
|
||||
|
||||
for table_diff in &table_diffs {
|
||||
let tbl_name = &table_diff.name;
|
||||
|
||||
if let Some(dc) = data_compare {
|
||||
if contains_table(&dc.sync_sql, tbl_name) {
|
||||
step_index = append_table_data_step(
|
||||
&dc.result,
|
||||
tbl_name,
|
||||
&mut steps,
|
||||
&mut rollback_steps,
|
||||
&options,
|
||||
step_index,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
step_index = append_table_schema_step(
|
||||
table_diff,
|
||||
tbl_name,
|
||||
&mut steps,
|
||||
&mut rollback_steps,
|
||||
&options,
|
||||
step_index,
|
||||
);
|
||||
}
|
||||
} else if let Some(dc) = data_compare {
|
||||
let _ = append_data_steps(Some(dc), &mut steps, &mut rollback_steps, &options, step_index);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let schema_diff_count = steps
|
||||
.iter()
|
||||
.filter(|s| {
|
||||
matches!(
|
||||
s.step_type,
|
||||
CorrectionStepType::SchemaCreate
|
||||
| CorrectionStepType::SchemaAlter
|
||||
| CorrectionStepType::SchemaDrop
|
||||
| CorrectionStepType::SchemaPostSync
|
||||
)
|
||||
})
|
||||
.count();
|
||||
let data_diff_count = steps
|
||||
.iter()
|
||||
.filter(|s| {
|
||||
matches!(
|
||||
s.step_type,
|
||||
CorrectionStepType::DataInsert | CorrectionStepType::DataUpdate | CorrectionStepType::DataDelete
|
||||
)
|
||||
})
|
||||
.count();
|
||||
|
||||
JointCorrectionPlan {
|
||||
strategy: options.strategy,
|
||||
steps,
|
||||
schema_diff_count,
|
||||
data_diff_count,
|
||||
total_estimated_duration_secs: None,
|
||||
rollback_steps,
|
||||
}
|
||||
}
|
||||
|
||||
fn append_schema_steps(
|
||||
schema_diff: Option<&SchemaDiffPreparation>,
|
||||
steps: &mut Vec<CorrectionStep>,
|
||||
_rollback_steps: &mut Vec<CorrectionStep>,
|
||||
options: &JointCorrectionOptions,
|
||||
mut step_index: usize,
|
||||
) -> usize {
|
||||
let Some(schema) = schema_diff else {
|
||||
return step_index;
|
||||
};
|
||||
|
||||
if schema.sync_sql.is_empty() {
|
||||
return step_index;
|
||||
}
|
||||
|
||||
if options.include_checkpoints {
|
||||
steps.push(CorrectionStep {
|
||||
step_type: CorrectionStepType::Checkpoint,
|
||||
table_name: None,
|
||||
sql: String::new(),
|
||||
rollback_sql: None,
|
||||
description: "Schema correction checkpoint".to_string(),
|
||||
risk_level: CorrectionRiskLevel::Safe,
|
||||
depends_on: Vec::new(),
|
||||
});
|
||||
step_index += 1;
|
||||
}
|
||||
|
||||
let table_diffs: Vec<_> = schema.diffs.iter().filter(|d| d.diff_type != "unchanged").collect();
|
||||
|
||||
for table_diff in &table_diffs {
|
||||
let tbl_name = &table_diff.name;
|
||||
step_index = append_table_schema_step(table_diff, tbl_name, steps, _rollback_steps, options, step_index);
|
||||
}
|
||||
|
||||
step_index
|
||||
}
|
||||
|
||||
fn append_table_schema_step(
|
||||
table_diff: &crate::schema_diff::TableDiff,
|
||||
tbl_name: &str,
|
||||
steps: &mut Vec<CorrectionStep>,
|
||||
rollback_steps: &mut Vec<CorrectionStep>,
|
||||
options: &JointCorrectionOptions,
|
||||
mut step_index: usize,
|
||||
) -> usize {
|
||||
let step_type = match table_diff.diff_type.as_str() {
|
||||
"added" => CorrectionStepType::SchemaCreate,
|
||||
"removed" => CorrectionStepType::SchemaDrop,
|
||||
_ => CorrectionStepType::SchemaAlter,
|
||||
};
|
||||
|
||||
let risk_level = match table_diff.diff_type.as_str() {
|
||||
"removed" => CorrectionRiskLevel::Dangerous,
|
||||
"modified" => CorrectionRiskLevel::Caution,
|
||||
_ => CorrectionRiskLevel::Safe,
|
||||
};
|
||||
|
||||
let has_incomplete_triggers = table_diff
|
||||
.triggers
|
||||
.as_ref()
|
||||
.is_some_and(|triggers| triggers.iter().any(|t| t.source.as_ref().is_some_and(|s| s.statement.is_none())));
|
||||
|
||||
let rollback_sql = if options.include_rollback {
|
||||
match table_diff.diff_type.as_str() {
|
||||
"added" => Some(format!("DROP TABLE IF EXISTS {};", tbl_name)),
|
||||
"removed" => {
|
||||
table_diff.target_ddl.as_ref().map(|ddl| {
|
||||
if has_incomplete_triggers {
|
||||
format!(
|
||||
"-- WARNING: Rollback DDL is INCOMPLETE — trigger bodies could not be reconstructed.\n-- Manual review required. Original DDL:\n{}",
|
||||
ddl
|
||||
)
|
||||
} else {
|
||||
ddl.clone()
|
||||
}
|
||||
}).or_else(|| {
|
||||
if has_incomplete_triggers {
|
||||
Some(format!(
|
||||
"-- WARNING: Rollback is INCOMPLETE — table '{}' had triggers that cannot be reconstructed.\n-- Manual intervention required before executing.",
|
||||
tbl_name
|
||||
))
|
||||
} else {
|
||||
Some(format!(
|
||||
"-- Manual rollback required: recreate table {} with original DDL",
|
||||
tbl_name
|
||||
))
|
||||
}
|
||||
})
|
||||
}
|
||||
"modified" => table_diff.sync_sql.as_ref().map(|s| format!("-- Rollback: {}", s)),
|
||||
_ => None,
|
||||
}
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let rollback_risk = if has_incomplete_triggers { CorrectionRiskLevel::Blocked } else { risk_level.clone() };
|
||||
|
||||
let rollback_desc = if has_incomplete_triggers {
|
||||
format!(
|
||||
"INCOMPLETE Rollback for schema {} on table: {tbl_name} — trigger bodies cannot be reconstructed",
|
||||
table_diff.diff_type
|
||||
)
|
||||
} else {
|
||||
format!("Rollback for schema {} on table: {tbl_name}", table_diff.diff_type)
|
||||
};
|
||||
|
||||
let sql = table_diff.sync_sql.clone().unwrap_or_else(|| format!("-- Schema change for table: {tbl_name}"));
|
||||
|
||||
steps.push(CorrectionStep {
|
||||
step_type,
|
||||
table_name: Some(tbl_name.to_string()),
|
||||
sql,
|
||||
rollback_sql: rollback_sql.clone(),
|
||||
description: format!("Schema {} for table: {tbl_name}", table_diff.diff_type),
|
||||
risk_level,
|
||||
depends_on: Vec::new(),
|
||||
});
|
||||
|
||||
if let Some(rollback) = rollback_sql {
|
||||
rollback_steps.push(CorrectionStep {
|
||||
step_type: match table_diff.diff_type.as_str() {
|
||||
"added" => CorrectionStepType::SchemaDrop,
|
||||
"removed" => CorrectionStepType::SchemaCreate,
|
||||
_ => CorrectionStepType::SchemaAlter,
|
||||
},
|
||||
table_name: Some(tbl_name.to_string()),
|
||||
sql: rollback,
|
||||
rollback_sql: None,
|
||||
description: rollback_desc,
|
||||
risk_level: rollback_risk,
|
||||
depends_on: Vec::new(),
|
||||
});
|
||||
}
|
||||
|
||||
step_index += 1;
|
||||
|
||||
step_index
|
||||
}
|
||||
|
||||
fn append_data_steps(
|
||||
data_compare: Option<&DataCompareFromTablesPreparation>,
|
||||
steps: &mut Vec<CorrectionStep>,
|
||||
_rollback_steps: &mut Vec<CorrectionStep>,
|
||||
options: &JointCorrectionOptions,
|
||||
mut step_index: usize,
|
||||
) -> usize {
|
||||
let Some(dc) = data_compare else {
|
||||
return step_index;
|
||||
};
|
||||
|
||||
if dc.result.added.is_empty() && dc.result.removed.is_empty() && dc.result.modified.is_empty() {
|
||||
return step_index;
|
||||
}
|
||||
|
||||
if options.include_checkpoints {
|
||||
steps.push(CorrectionStep {
|
||||
step_type: CorrectionStepType::Checkpoint,
|
||||
table_name: None,
|
||||
sql: String::new(),
|
||||
rollback_sql: None,
|
||||
description: "Data correction checkpoint".to_string(),
|
||||
risk_level: CorrectionRiskLevel::Safe,
|
||||
depends_on: Vec::new(),
|
||||
});
|
||||
step_index += 1;
|
||||
}
|
||||
|
||||
for statement in &dc.sync_statements {
|
||||
let (step_type, description) = if statement.to_uppercase().starts_with("INSERT") {
|
||||
(CorrectionStepType::DataInsert, format!("Insert data: {}", summary(statement, 80)))
|
||||
} else if statement.to_uppercase().starts_with("UPDATE") {
|
||||
(CorrectionStepType::DataUpdate, format!("Update data: {}", summary(statement, 80)))
|
||||
} else if statement.to_uppercase().starts_with("DELETE") {
|
||||
(CorrectionStepType::DataDelete, format!("Delete data: {}", summary(statement, 80)))
|
||||
} else {
|
||||
(CorrectionStepType::SchemaPostSync, format!("Pre-sync: {}", summary(statement, 80)))
|
||||
};
|
||||
|
||||
let rollback_sql = if options.include_rollback {
|
||||
if statement.to_uppercase().starts_with("INSERT") {
|
||||
Some(format!("-- Rollback: DELETE matching rows; manual review needed: {}", summary(statement, 60)))
|
||||
} else if statement.to_uppercase().starts_with("DELETE") {
|
||||
Some(format!("-- Rollback: INSERT deleted rows; manual review needed: {}", summary(statement, 60)))
|
||||
} else if statement.to_uppercase().starts_with("UPDATE") {
|
||||
Some(format!("-- Rollback: reverse UPDATE; manual review needed: {}", summary(statement, 60)))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
steps.push(CorrectionStep {
|
||||
step_type,
|
||||
table_name: None,
|
||||
sql: statement.clone(),
|
||||
rollback_sql,
|
||||
description,
|
||||
risk_level: CorrectionRiskLevel::Caution,
|
||||
depends_on: Vec::new(),
|
||||
});
|
||||
step_index += 1;
|
||||
}
|
||||
|
||||
step_index
|
||||
}
|
||||
|
||||
fn append_table_data_step(
|
||||
data_prep: &DataCompareResult,
|
||||
tbl_name: &str,
|
||||
steps: &mut Vec<CorrectionStep>,
|
||||
_rollback_steps: &mut Vec<CorrectionStep>,
|
||||
_options: &JointCorrectionOptions,
|
||||
mut step_index: usize,
|
||||
) -> usize {
|
||||
let total = data_prep.added.len() + data_prep.modified.len() + data_prep.removed.len();
|
||||
if total == 0 {
|
||||
return step_index;
|
||||
}
|
||||
|
||||
steps.push(CorrectionStep {
|
||||
step_type: CorrectionStepType::DataInsert,
|
||||
table_name: Some(tbl_name.to_string()),
|
||||
sql: format!(
|
||||
"-- Data sync for table: {tbl_name} ({} added, {} modified, {} removed)",
|
||||
data_prep.added.len(),
|
||||
data_prep.modified.len(),
|
||||
data_prep.removed.len()
|
||||
),
|
||||
rollback_sql: None,
|
||||
description: format!(
|
||||
"Data sync for table: {tbl_name} ({} added, {} modified, {} removed)",
|
||||
data_prep.added.len(),
|
||||
data_prep.modified.len(),
|
||||
data_prep.removed.len()
|
||||
),
|
||||
risk_level: CorrectionRiskLevel::Caution,
|
||||
depends_on: Vec::new(),
|
||||
});
|
||||
step_index += 1;
|
||||
|
||||
step_index
|
||||
}
|
||||
|
||||
fn contains_table(sync_sql: &str, table_name: &str) -> bool {
|
||||
sync_sql.contains(table_name)
|
||||
}
|
||||
|
||||
fn summary(text: &str, max_len: usize) -> String {
|
||||
let cleaned = text.replace('\n', " ");
|
||||
if cleaned.len() <= max_len {
|
||||
cleaned
|
||||
} else {
|
||||
format!("{}...", &cleaned[..max_len.min(cleaned.len())])
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::data_compare::{
|
||||
DataCompareChangedCell, DataCompareFromTablesPreparation, DataCompareModifiedRow, DataCompareResult,
|
||||
DataCompareRow,
|
||||
};
|
||||
use crate::schema_diff::{SchemaDiffPreparation, TableDiff};
|
||||
use serde_json::json;
|
||||
use std::collections::HashMap;
|
||||
|
||||
fn sample_table_diff(diff_type: &str, name: &str) -> TableDiff {
|
||||
TableDiff {
|
||||
diff_type: diff_type.to_string(),
|
||||
object_type: Some("table".to_string()),
|
||||
name: name.to_string(),
|
||||
columns: None,
|
||||
indexes: None,
|
||||
foreign_keys: None,
|
||||
triggers: None,
|
||||
ddl: None,
|
||||
target_ddl: None,
|
||||
source_table_comment: None,
|
||||
target_table_comment: None,
|
||||
sync_sql: Some(format!("-- SQL for {name}")),
|
||||
}
|
||||
}
|
||||
|
||||
fn sample_schema_preparation() -> SchemaDiffPreparation {
|
||||
SchemaDiffPreparation {
|
||||
diffs: vec![sample_table_diff("added", "users"), sample_table_diff("modified", "orders")],
|
||||
sync_sql: "-- Schema sync SQL for users\n-- Schema sync SQL for orders".to_string(),
|
||||
function_diffs: Vec::new(),
|
||||
sequence_diffs: Vec::new(),
|
||||
rule_diffs: Vec::new(),
|
||||
owner_diffs: Vec::new(),
|
||||
rollback_sync_sql: Some("-- Rollback SQL".to_string()),
|
||||
rollback_completeness: crate::schema_diff::RollbackCompleteness::Complete,
|
||||
missing_rollback_objects: Vec::new(),
|
||||
rename_candidates: Vec::new(),
|
||||
rollback_graph: None,
|
||||
compatibility_warnings: Vec::new(),
|
||||
permission_diffs: Vec::new(),
|
||||
permission_sync_sql: None,
|
||||
dependency_graph: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn sample_data_preparation() -> DataCompareFromTablesPreparation {
|
||||
DataCompareFromTablesPreparation {
|
||||
result: DataCompareResult {
|
||||
added: vec![DataCompareRow {
|
||||
key: "1".to_string(),
|
||||
key_values: HashMap::from([("id".to_string(), json!(1))]),
|
||||
values: HashMap::from([("id".to_string(), json!(1)), ("name".to_string(), json!("Ada"))]),
|
||||
}],
|
||||
removed: vec![],
|
||||
modified: vec![DataCompareModifiedRow {
|
||||
key: "2".to_string(),
|
||||
key_values: HashMap::from([("id".to_string(), json!(2))]),
|
||||
source_values: HashMap::new(),
|
||||
target_values: HashMap::new(),
|
||||
changes: vec![DataCompareChangedCell {
|
||||
column: "name".to_string(),
|
||||
source: json!("Bob"),
|
||||
target: json!("Bobby"),
|
||||
}],
|
||||
}],
|
||||
},
|
||||
sync_statements: vec![
|
||||
"INSERT INTO \"public\".\"users\" (\"id\", \"name\") VALUES (1, 'Ada');".to_string(),
|
||||
"UPDATE \"public\".\"users\" SET \"name\" = 'Bob' WHERE \"id\" = 2;".to_string(),
|
||||
],
|
||||
sync_sql: "INSERT INTO \"public\".\"users\" (\"id\", \"name\") VALUES (1, 'Ada');\n\
|
||||
UPDATE \"public\".\"users\" SET \"name\" = 'Bob' WHERE \"id\" = 2;"
|
||||
.to_string(),
|
||||
pre_sync_statements: vec![],
|
||||
source_row_count: 2,
|
||||
target_row_count: 2,
|
||||
source_truncated: false,
|
||||
target_truncated: false,
|
||||
degradation_level: Some("full".to_string()),
|
||||
sampling_rate: Some(1.0),
|
||||
confidence_score: Some(1.0),
|
||||
verification_method: Some("full_compare".to_string()),
|
||||
source_checksums: None,
|
||||
target_checksums: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn builds_structure_first_correction_plan() {
|
||||
let schema = sample_schema_preparation();
|
||||
let data = sample_data_preparation();
|
||||
let plan = build_joint_correction_plan(
|
||||
Some(&schema),
|
||||
Some(&data),
|
||||
JointCorrectionOptions {
|
||||
strategy: CorrectionStrategy::StructureFirst,
|
||||
include_checkpoints: true,
|
||||
include_rollback: true,
|
||||
},
|
||||
);
|
||||
|
||||
assert_eq!(plan.strategy, CorrectionStrategy::StructureFirst);
|
||||
assert!(plan.schema_diff_count > 0);
|
||||
assert!(plan.data_diff_count > 0);
|
||||
|
||||
let first_data_idx = plan.steps.iter().position(|s| {
|
||||
matches!(
|
||||
s.step_type,
|
||||
CorrectionStepType::DataInsert | CorrectionStepType::DataUpdate | CorrectionStepType::DataDelete
|
||||
)
|
||||
});
|
||||
|
||||
let last_schema_idx = plan.steps.iter().rposition(|s| {
|
||||
matches!(
|
||||
s.step_type,
|
||||
CorrectionStepType::SchemaCreate | CorrectionStepType::SchemaAlter | CorrectionStepType::SchemaDrop
|
||||
)
|
||||
});
|
||||
|
||||
if let (Some(si), Some(di)) = (last_schema_idx, first_data_idx) {
|
||||
assert!(si < di, "Schema steps should come before data steps in StructureFirst strategy");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn builds_data_first_correction_plan() {
|
||||
let schema = sample_schema_preparation();
|
||||
let data = sample_data_preparation();
|
||||
let plan = build_joint_correction_plan(
|
||||
Some(&schema),
|
||||
Some(&data),
|
||||
JointCorrectionOptions {
|
||||
strategy: CorrectionStrategy::DataFirst,
|
||||
include_checkpoints: true,
|
||||
include_rollback: true,
|
||||
},
|
||||
);
|
||||
|
||||
assert_eq!(plan.strategy, CorrectionStrategy::DataFirst);
|
||||
assert!(plan
|
||||
.steps
|
||||
.iter()
|
||||
.any(|s| matches!(s.step_type, CorrectionStepType::DataInsert | CorrectionStepType::DataUpdate)));
|
||||
assert!(plan
|
||||
.steps
|
||||
.iter()
|
||||
.any(|s| matches!(s.step_type, CorrectionStepType::SchemaCreate | CorrectionStepType::SchemaAlter)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn builds_interleaved_correction_plan() {
|
||||
let schema = sample_schema_preparation();
|
||||
let data = sample_data_preparation();
|
||||
let plan = build_joint_correction_plan(
|
||||
Some(&schema),
|
||||
Some(&data),
|
||||
JointCorrectionOptions {
|
||||
strategy: CorrectionStrategy::Interleaved,
|
||||
include_checkpoints: true,
|
||||
include_rollback: true,
|
||||
},
|
||||
);
|
||||
|
||||
assert_eq!(plan.strategy, CorrectionStrategy::Interleaved);
|
||||
assert!(!plan.steps.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn handles_missing_schema_diff() {
|
||||
let data = sample_data_preparation();
|
||||
let plan = build_joint_correction_plan(None, Some(&data), JointCorrectionOptions::default());
|
||||
|
||||
assert_eq!(plan.schema_diff_count, 0);
|
||||
assert!(plan.data_diff_count > 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn handles_missing_data_compare() {
|
||||
let schema = sample_schema_preparation();
|
||||
let plan = build_joint_correction_plan(Some(&schema), None, JointCorrectionOptions::default());
|
||||
|
||||
assert!(plan.schema_diff_count > 0);
|
||||
assert_eq!(plan.data_diff_count, 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn handles_empty_input() {
|
||||
let plan = build_joint_correction_plan(None, None, JointCorrectionOptions::default());
|
||||
|
||||
assert_eq!(plan.steps.len(), 0);
|
||||
assert_eq!(plan.schema_diff_count, 0);
|
||||
assert_eq!(plan.data_diff_count, 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn correction_step_serialization() {
|
||||
let step = CorrectionStep {
|
||||
step_type: CorrectionStepType::SchemaCreate,
|
||||
table_name: Some("public.users".to_string()),
|
||||
sql: "CREATE TABLE ...".to_string(),
|
||||
rollback_sql: Some("DROP TABLE ...".to_string()),
|
||||
description: "Create users table".to_string(),
|
||||
risk_level: CorrectionRiskLevel::Safe,
|
||||
depends_on: vec![0],
|
||||
};
|
||||
|
||||
let json = serde_json::to_string(&step).expect("serialization should succeed");
|
||||
let deserialized: CorrectionStep = serde_json::from_str(&json).expect("deserialization should succeed");
|
||||
|
||||
assert_eq!(deserialized.step_type, CorrectionStepType::SchemaCreate);
|
||||
assert_eq!(deserialized.table_name, Some("public.users".to_string()));
|
||||
assert_eq!(deserialized.risk_level, CorrectionRiskLevel::Safe);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn joint_correction_plan_serialization() {
|
||||
let schema = sample_schema_preparation();
|
||||
let data = sample_data_preparation();
|
||||
let plan = build_joint_correction_plan(Some(&schema), Some(&data), JointCorrectionOptions::default());
|
||||
|
||||
let json = serde_json::to_string(&plan).expect("serialization should succeed");
|
||||
assert!(json.contains("structureFirst") || json.contains("StructureFirst"));
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user