From 729bae3e39aab8130d914359239251d732d49b3c Mon Sep 17 00:00:00 2001 From: t8y2 <1156263951@qq.com> Date: Sat, 1 Aug 2026 17:16:21 +0800 Subject: [PATCH] fix(schema-diff): create sequences before dependent tables --- crates/dbx-core/src/schema_diff.rs | 272 +++++++++++++++++++++-------- 1 file changed, 201 insertions(+), 71 deletions(-) diff --git a/crates/dbx-core/src/schema_diff.rs b/crates/dbx-core/src/schema_diff.rs index 5f2f2f2b3d..a47a349858 100644 --- a/crates/dbx-core/src/schema_diff.rs +++ b/crates/dbx-core/src/schema_diff.rs @@ -3248,6 +3248,87 @@ fn generate_create_table_sql( (lines.join("\n"), missing) } +fn append_sequence_diff_sql( + lines: &mut Vec, + 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 {