fix(schema-diff): create sequences before dependent tables

This commit is contained in:
t8y2 committed 2026-08-01 17:16:21 +08:00
1 parent fbac66572a
commit 729bae3e39
1 file changed
+201 -71
+201 -71
View File
@@ -3248,6 +3248,87 @@ fn generate_create_table_sql(
(lines.join("\n"), missing)
}
fn append_sequence_diff_sql(
lines: &mut Vec<String>,
sequence_diffs: &[SequenceDiff],
profile: DdlDialectProfile,
db_type: DatabaseType,
schema: Option<&str>,
cascade: &str,
should_render: impl Fn(&str) -> bool,
) {
let mut matching = sequence_diffs.iter().filter(|diff| should_render(&diff.diff_type)).peekable();
if matching.peek().is_none() {
return;
}
lines.push(String::new());
lines.push("-- Sequences".to_string());
for diff in matching {
match diff.diff_type.as_str() {
"added" => {
if let Some(source) = &diff.source {
if let Some(template) = profile.sequence_create_template {
lines.push(format!("-- Create sequence: {}", diff.name));
let name = qualified_name(&diff.name, db_type, schema);
let cycle = if source.cycle { "CYCLE" } else { "NO CYCLE" };
lines.push(DdlDialectProfile::render_template(
template,
&[
("name", &name),
("data_type", &source.data_type),
("start_value", &source.start_value),
("increment", &source.increment),
("min_value", &source.min_value),
("max_value", &source.max_value),
("cycle", cycle),
],
));
} else {
lines.push(format!(
"-- Skip sequence {}: target database does not support sequence DDL generation",
diff.name
));
}
}
}
"removed" => {
if let Some(template) = profile.sequence_drop_template {
lines.push(format!("-- Drop sequence: {}", diff.name));
let name = qualified_name(&diff.name, db_type, schema);
lines.push(DdlDialectProfile::render_template(template, &[("name", &name), ("cascade", cascade)]));
} else {
lines.push(format!("-- Skip drop sequence {}: unsupported on target", diff.name));
}
}
"modified" => {
if let Some(source) = &diff.source {
if let Some(template) = profile.sequence_alter_template {
lines.push(format!("-- Alter sequence: {}", diff.name));
let name = qualified_name(&diff.name, db_type, schema);
let cycle = if source.cycle { "CYCLE" } else { "NO CYCLE" };
lines.push(DdlDialectProfile::render_template(
template,
&[
("name", &name),
("data_type", &source.data_type),
("start_value", &source.start_value),
("increment", &source.increment),
("min_value", &source.min_value),
("max_value", &source.max_value),
("cycle", cycle),
],
));
} else {
lines.push(format!("-- Skip alter sequence {}: unsupported on target", diff.name));
}
}
}
_ => {}
}
}
}
#[allow(clippy::too_many_arguments)]
pub fn generate_schema_sync_sql(
diffs: &[TableDiff],
@@ -3301,6 +3382,10 @@ fn generate_schema_sync_sql_inner(
rewrite_column_type(source_type, db_type, source_dialect)
};
append_sequence_diff_sql(&mut lines, sequence_diffs, profile, db_type, schema, cascade, |diff_type| {
diff_type == "added"
});
for diff in diffs {
let table = qualified_name(&diff.name, db_type, schema);
@@ -3676,77 +3761,9 @@ fn generate_schema_sync_sql_inner(
}
}
// Sequence diffs
if !sequence_diffs.is_empty() {
lines.push(String::new());
lines.push("-- Sequences".to_string());
for diff in sequence_diffs {
match diff.diff_type.as_str() {
"added" => {
if let Some(source) = &diff.source {
if let Some(template) = profile.sequence_create_template {
lines.push(format!("-- Create sequence: {}", diff.name));
let name = qualified_name(&diff.name, db_type, schema);
let cycle = if source.cycle { "CYCLE" } else { "NO CYCLE" };
lines.push(DdlDialectProfile::render_template(
template,
&[
("name", &name),
("data_type", &source.data_type),
("start_value", &source.start_value),
("increment", &source.increment),
("min_value", &source.min_value),
("max_value", &source.max_value),
("cycle", cycle),
],
));
} else {
lines.push(format!(
"-- Skip sequence {}: target database does not support sequence DDL generation",
diff.name
));
}
}
}
"removed" => {
if let Some(template) = profile.sequence_drop_template {
lines.push(format!("-- Drop sequence: {}", diff.name));
let name = qualified_name(&diff.name, db_type, schema);
lines.push(DdlDialectProfile::render_template(
template,
&[("name", &name), ("cascade", cascade)],
));
} else {
lines.push(format!("-- Skip drop sequence {}: unsupported on target", diff.name));
}
}
"modified" => {
if let Some(source) = &diff.source {
if let Some(template) = profile.sequence_alter_template {
lines.push(format!("-- Alter sequence: {}", diff.name));
let name = qualified_name(&diff.name, db_type, schema);
let cycle = if source.cycle { "CYCLE" } else { "NO CYCLE" };
lines.push(DdlDialectProfile::render_template(
template,
&[
("name", &name),
("data_type", &source.data_type),
("start_value", &source.start_value),
("increment", &source.increment),
("min_value", &source.min_value),
("max_value", &source.max_value),
("cycle", cycle),
],
));
} else {
lines.push(format!("-- Skip alter sequence {}: unsupported on target", diff.name));
}
}
}
_ => {}
}
}
}
append_sequence_diff_sql(&mut lines, sequence_diffs, profile, db_type, schema, cascade, |diff_type| {
matches!(diff_type, "removed" | "modified")
});
// Rule diffs (PostgreSQL RULE)
if !rule_diffs.is_empty() {
@@ -8413,6 +8430,119 @@ mod tests {
);
}
#[test]
fn postgres_creates_sequences_before_tables_that_reference_them() {
let table_diff = TableDiff {
diff_type: "added".into(),
object_type: Some("table".into()),
name: "events".into(),
ddl: Some(
"CREATE TABLE public.events (id bigint NOT NULL DEFAULT nextval('public.events_id_seq'::regclass))"
.into(),
),
..TableDiff::default()
};
let sequence_diff = SequenceDiff {
diff_type: "added".into(),
name: "events_id_seq".into(),
source: Some(SequenceInfo {
name: "events_id_seq".into(),
data_type: "bigint".into(),
start_value: "1".into(),
min_value: "1".into(),
max_value: "9223372036854775807".into(),
increment: "1".into(),
cycle: false,
last_value: None,
}),
target: None,
changes: vec![],
};
let sql = generate_schema_sync_sql(
&[table_diff],
&[],
&[sequence_diff],
&[],
&[],
DatabaseType::Postgres,
Some("public"),
false,
Some(DialectKind::Postgres),
&[],
);
let sequence_position = sql.find("CREATE SEQUENCE").expect("sequence DDL");
let table_position = sql.find("CREATE TABLE public.events").expect("table DDL");
assert!(sequence_position < table_position, "{sql}");
}
#[test]
fn postgres_drops_sequences_after_dependent_tables() {
let table_diff = TableDiff {
diff_type: "removed".into(),
object_type: Some("table".into()),
name: "events".into(),
..TableDiff::default()
};
let sequence_diff = SequenceDiff {
diff_type: "removed".into(),
name: "events_id_seq".into(),
source: None,
target: None,
changes: vec![],
};
let sql = generate_schema_sync_sql(
&[table_diff],
&[],
&[sequence_diff],
&[],
&[],
DatabaseType::Postgres,
Some("public"),
false,
Some(DialectKind::Postgres),
&[],
);
let table_position = sql.find("DROP TABLE").expect("table DDL");
let sequence_position = sql.find("DROP SEQUENCE").expect("sequence DDL");
assert!(table_position < sequence_position, "{sql}");
}
#[test]
fn postgres_sync_sql_preserves_zero_timestamp_precision() {
let table_diff = TableDiff {
diff_type: "modified".into(),
object_type: Some("table".into()),
name: "events".into(),
columns: Some(vec![ColumnDiff {
diff_type: "modified".into(),
name: "created_at".into(),
source: Some(column("created_at", "timestamp(0) without time zone", None)),
target: Some(column("created_at", "timestamp without time zone", None)),
changes: vec!["type: timestamp without time zone → timestamp(0) without time zone".into()],
}]),
..TableDiff::default()
};
let sql = generate_schema_sync_sql(
&[table_diff],
&[],
&[],
&[],
&[],
DatabaseType::Postgres,
Some("public"),
false,
Some(DialectKind::Postgres),
&[],
);
assert!(sql.contains("ALTER COLUMN \"created_at\" TYPE timestamp(0)"), "{sql}");
}
#[test]
fn postgres_function_sequence_rule_owner_use_profile_templates() {
let fn_diff = FunctionDiff {