Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

fix(transfer): keep partitions when converting target table name case

t8y21170bcaa1cb4
diff --git a/crates/dbx-core/src/transfer.rs b/crates/dbx-core/src/transfer.rs
index c2eaf9a44f..27879cd0f3 100644
--- a/crates/dbx-core/src/transfer.rs
+++ b/crates/dbx-core/src/transfer.rs
@@ -4171,11 +4171,16 @@ fn can_reuse_source_table_ddl(
return false;
}
- preserves_target_table_name
- && !matches!(target_db_type, DatabaseType::ClickHouse)
- && (source_db_type == target_db_type
- || (is_mysql_family_target(source_db_type) && is_mysql_family_target(target_db_type))
- || (is_postgres_family_target(source_db_type) && is_postgres_family_target(target_db_type)))
+ let same_dialect_pair = source_db_type == target_db_type
+ || (is_mysql_family_target(source_db_type) && is_mysql_family_target(target_db_type))
+ || (is_postgres_family_target(source_db_type) && is_postgres_family_target(target_db_type));
+ // MySQL-family reuse rewrites the CREATE TABLE header to the target name, so a
+ // case-converted table no longer falls into the lossy generated-DDL path (which
+ // drops partitions, secondary indexes, and table options). Other dialects keep
+ // requiring an unchanged name because their reuse path has no name rewrite.
+ let name_compatible = preserves_target_table_name
+ || (is_mysql_family_target(source_db_type) && is_mysql_family_target(target_db_type));
+ name_compatible && !matches!(target_db_type, DatabaseType::ClickHouse) && same_dialect_pair
}
fn strip_dameng_storage_clauses(sql: &str) -> String {
@@ -4242,16 +4247,119 @@ fn rewrite_transfer_source_table_ddl(
target_schema: &str,
source_db_type: &DatabaseType,
target_db_type: &DatabaseType,
-) -> String {
+ table: &str,
+ target_table: &str,
+) -> Option<String> {
if is_postgres_family_target(source_db_type) && is_postgres_family_target(target_db_type) {
- rewrite_postgres_schema_qualified_references(sql, source_schema, target_schema)
+ Some(rewrite_postgres_schema_qualified_references(sql, source_schema, target_schema))
} else if matches!((source_db_type, target_db_type), (DatabaseType::Dameng, DatabaseType::Dameng)) {
- strip_dameng_storage_clauses(&rewrite_double_quoted_schema_qualifier(sql, source_schema, target_schema))
+ Some(strip_dameng_storage_clauses(&rewrite_double_quoted_schema_qualifier(sql, source_schema, target_schema)))
+ } else if is_mysql_family_target(source_db_type) && is_mysql_family_target(target_db_type) {
+ // The reused SHOW CREATE TABLE DDL carries the source table name; rewrite the
+ // CREATE TABLE header when the transfer renames the table (name case conversion).
+ // Unparseable heads return None so the caller falls back to generated DDL instead
+ // of creating a table under the wrong name.
+ if table == target_table {
+ Some(sql.to_string())
+ } else {
+ rewrite_mysql_create_table_name(sql, target_table)
+ }
} else {
- sql.to_string()
+ Some(sql.to_string())
}
}
+/// Rewrites the table identifier of the leading CREATE TABLE statement of a reused
+/// MySQL-family DDL. Only the last (table) segment of a qualified name is replaced.
+/// Returns None when the statement head does not look like `CREATE [TEMPORARY] TABLE
+/// [IF NOT EXISTS] <identifier> (` — callers then must not reuse this DDL.
+fn rewrite_mysql_create_table_name(sql: &str, target_table: &str) -> Option<String> {
+ fn skip_ws(b: &[u8], mut i: usize) -> usize {
+ while i < b.len() && b[i].is_ascii_whitespace() {
+ i += 1;
+ }
+ i
+ }
+ fn match_keyword(b: &[u8], i: usize, kw: &str) -> Option<usize> {
+ let i = skip_ws(b, i);
+ let end = i.checked_add(kw.len())?;
+ if end <= b.len()
+ && b[i..end].eq_ignore_ascii_case(kw.as_bytes())
+ && (end == b.len() || b[end].is_ascii_whitespace())
+ {
+ Some(end)
+ } else {
+ None
+ }
+ }
+
+ let b = sql.as_bytes();
+ let mut i = skip_ws(b, 0);
+ i = match_keyword(b, i, "CREATE")?;
+ if let Some(next) = match_keyword(b, i, "TEMPORARY") {
+ i = next;
+ }
+ i = match_keyword(b, i, "TABLE")?;
+ if let Some(next) = match_keyword(b, i, "IF") {
+ let next = match_keyword(b, next, "NOT")?;
+ i = match_keyword(b, next, "EXISTS")?;
+ }
+ i = skip_ws(b, i);
+
+ // Parse the identifier chain `a`.`b`.`c` (or bare), keeping the last segment's span.
+ let (segment_start, segment_end) = loop {
+ let current_start = i;
+ let current_end;
+ if i < b.len() && b[i] == b'`' {
+ i += 1;
+ let mut closed = false;
+ while i < b.len() {
+ if b[i] == b'`' {
+ if i + 1 < b.len() && b[i + 1] == b'`' {
+ i += 2;
+ continue;
+ }
+ i += 1;
+ closed = true;
+ break;
+ }
+ i += 1;
+ }
+ if !closed {
+ return None;
+ }
+ current_end = i;
+ } else {
+ while i < b.len() && !b[i].is_ascii_whitespace() && b[i] != b'.' && b[i] != b'(' {
+ i += 1;
+ }
+ current_end = i;
+ if current_start == current_end {
+ return None;
+ }
+ }
+ let after_segment = skip_ws(b, i);
+ if after_segment < b.len() && b[after_segment] == b'.' {
+ i = after_segment + 1;
+ continue;
+ }
+ break (current_start, current_end);
+ };
+
+ // A plain CREATE TABLE head is always followed by the column list.
+ let after = skip_ws(b, segment_end);
+ if after >= b.len() || b[after] != b'(' {
+ return None;
+ }
+
+ let quoted = format!("`{}`", target_table.replace('`', "``"));
+ let mut out = String::with_capacity(sql.len() + quoted.len());
+ out.push_str(&sql[..segment_start]);
+ out.push_str(&quoted);
+ out.push_str(&sql[segment_end..]);
+ Some(out)
+}
+
fn rewrite_postgres_serial_columns_for_transfer(
sql: &str,
sequences: &[PostgresOwnedSequence],
@@ -12852,6 +12960,95 @@ mod tests {
assert!(can_reuse_source_table_ddl(&DatabaseType::Postgres, &DatabaseType::Postgres, None, None, true,));
assert!(!can_reuse_source_table_ddl(&DatabaseType::Postgres, &DatabaseType::Postgres, None, None, false,));
assert!(can_reuse_source_table_ddl(&DatabaseType::Dameng, &DatabaseType::Dameng, None, None, true,));
+ // MySQL-family reuse renames the CREATE TABLE header, so a case-converted
+ // target name still reuses the source DDL (keeps partitions/indexes/options);
+ // dialects without a name rewrite keep requiring a preserved name.
+ assert!(can_reuse_source_table_ddl(&DatabaseType::Mysql, &DatabaseType::Mysql, None, None, false,));
+ assert!(can_reuse_source_table_ddl(&DatabaseType::Mysql, &DatabaseType::Doris, None, None, false,));
+ assert!(!can_reuse_source_table_ddl(&DatabaseType::Dameng, &DatabaseType::Dameng, None, None, false,));
+ assert!(!can_reuse_source_table_ddl(
+ &DatabaseType::Mysql,
+ &DatabaseType::Mysql,
+ Some("oceanbase"),
+ None,
+ false,
+ ));
+ }
+
+ #[test]
+ fn mysql_reused_ddl_renames_create_table_header_for_case_conversion() {
+ let ddl = "CREATE TABLE `orders_plain` (\n `id` int NOT NULL,\n PRIMARY KEY (`id`)\n) \
+ENGINE=InnoDB DEFAULT CHARSET=utf8mb4\nPARTITION BY RANGE (TO_DAYS(`created_day`))\n(\
+PARTITION p_old VALUES LESS THAN (TO_DAYS('2026-01-01')))";
+
+ let rewritten = rewrite_transfer_source_table_ddl(
+ ddl,
+ "dbx_src",
+ "dbx_dst",
+ &DatabaseType::Mysql,
+ &DatabaseType::Mysql,
+ "orders_plain",
+ "ORDERS_PLAIN",
+ )
+ .unwrap();
+
+ assert!(rewritten.starts_with("CREATE TABLE `ORDERS_PLAIN` ("));
+ assert!(rewritten.contains("PARTITION BY RANGE (TO_DAYS(`created_day`))"));
+ assert!(rewritten.contains("ENGINE=InnoDB"));
+ assert!(!rewritten.contains("`orders_plain`"));
+ }
+
+ #[test]
+ fn mysql_reused_ddl_keeps_identity_when_target_name_matches() {
+ let ddl = "CREATE TABLE `orders` (`id` int)";
+ assert_eq!(
+ rewrite_transfer_source_table_ddl(
+ ddl,
+ "s",
+ "t",
+ &DatabaseType::Mysql,
+ &DatabaseType::Mysql,
+ "orders",
+ "orders"
+ ),
+ Some(ddl.to_string())
+ );
+ }
+
+ #[test]
+ fn mysql_create_table_header_rename_handles_statement_shapes() {
+ let rewrite = |ddl: &str| rewrite_mysql_create_table_name(ddl, "TARGET");
+
+ // SHOW CREATE TABLE form with parenthesized column list.
+ assert_eq!(
+ rewrite("CREATE TABLE `src` (\n `id` int\n)"),
+ Some("CREATE TABLE `TARGET` (\n `id` int\n)".to_string())
+ );
+ // No space before the column list.
+ assert_eq!(rewrite("create table `src`(`id` int)"), Some("create table `TARGET`(`id` int)".to_string()));
+ // TEMPORARY + IF NOT EXISTS.
+ assert_eq!(
+ rewrite("CREATE TEMPORARY TABLE IF NOT EXISTS `src` (`id` int)"),
+ Some("CREATE TEMPORARY TABLE IF NOT EXISTS `TARGET` (`id` int)".to_string())
+ );
+ // Qualified name: only the table segment is replaced.
+ assert_eq!(
+ rewrite("CREATE TABLE `prod_db`.`src` (`id` int)"),
+ Some("CREATE TABLE `prod_db`.`TARGET` (`id` int)".to_string())
+ );
+ // Escaped backticks inside the source identifier.
+ assert_eq!(rewrite("CREATE TABLE `od``d` (`id` int)"), Some("CREATE TABLE `TARGET` (`id` int)".to_string()));
+ // Backtick inside the target identifier is escaped.
+ assert_eq!(
+ rewrite_mysql_create_table_name("CREATE TABLE `src` (`id` int)", "ta`rget"),
+ Some("CREATE TABLE `ta``rget` (`id` int)".to_string())
+ );
+ // Anything that is not a plain CREATE TABLE head is rejected.
+ assert_eq!(rewrite("ALTER TABLE `src` ADD COLUMN `x` int"), None);
+ assert_eq!(rewrite("CREATE TABLE `src` LIKE `other`"), None);
+ assert_eq!(rewrite("CREATE TABLE `src`"), None);
+ assert_eq!(rewrite("CREATE TABLE `unterminated (`id` int)"), None);
+ assert_eq!(rewrite(""), None);
}
#[test]
@@ -12968,8 +13165,16 @@ mod tests {
let ddl =
"CREATE TABLE \"src\".\"items\" (\"id\" integer);\nCOMMENT ON COLUMN \"src\".\"items\".\"id\" IS 'id';";
- let rewritten =
- rewrite_transfer_source_table_ddl(ddl, "src", "dst", &DatabaseType::Postgres, &DatabaseType::Postgres);
+ let rewritten = rewrite_transfer_source_table_ddl(
+ ddl,
+ "src",
+ "dst",
+ &DatabaseType::Postgres,
+ &DatabaseType::Postgres,
+ "items",
+ "items",
+ )
+ .unwrap();
assert!(rewritten.contains("CREATE TABLE \"dst\".\"items\""));
assert!(rewritten.contains("COMMENT ON COLUMN \"dst\".\"items\".\"id\""));
@@ -12990,8 +13195,16 @@ mod tests {
"ALTER TABLE \"SRC\".\"items\" ADD \"value\" INTEGER;",
);
- let rewritten =
- rewrite_transfer_source_table_ddl(ddl, "SRC", "DST", &DatabaseType::Dameng, &DatabaseType::Dameng);
+ let rewritten = rewrite_transfer_source_table_ddl(
+ ddl,
+ "SRC",
+ "DST",
+ &DatabaseType::Dameng,
+ &DatabaseType::Dameng,
+ "items",
+ "items",
+ )
+ .unwrap();
assert!(rewritten.contains("CREATE TABLE \"DST\".\"items\""));
assert!(rewritten.contains("COMMENT ON TABLE \"DST\".\"items\""));
@@ -13005,12 +13218,28 @@ mod tests {
assert!(rewritten.contains("/* keep STORAGE(ON block_comment_ts) and \"SRC\".block_comment */"));
let storage_portable_ddl = strip_dameng_storage_clauses(ddl);
assert_eq!(
- rewrite_transfer_source_table_ddl(ddl, "SRC", "SRC", &DatabaseType::Dameng, &DatabaseType::Dameng),
- storage_portable_ddl
+ rewrite_transfer_source_table_ddl(
+ ddl,
+ "SRC",
+ "SRC",
+ &DatabaseType::Dameng,
+ &DatabaseType::Dameng,
+ "items",
+ "items"
+ ),
+ Some(storage_portable_ddl.clone())
);
assert_eq!(
- rewrite_transfer_source_table_ddl(ddl, "", "DST", &DatabaseType::Dameng, &DatabaseType::Dameng),
- storage_portable_ddl
+ rewrite_transfer_source_table_ddl(
+ ddl,
+ "",
+ "DST",
+ &DatabaseType::Dameng,
+ &DatabaseType::Dameng,
+ "items",
+ "items"
+ ),
+ Some(storage_portable_ddl)
);
}
@@ -14327,7 +14556,10 @@ mod tests {
"archive",
&DatabaseType::Postgres,
&DatabaseType::Postgres,
- );
+ "it_quick_entry",
+ "it_quick_entry",
+ )
+ .unwrap();
let sequence = PostgresOwnedSequence {
name: "it_quick_entry_id_seq".to_string(),
owner_table: "it_quick_entry".to_string(),
diff --git a/crates/dbx-core/src/transfer/ddl_plan.rs b/crates/dbx-core/src/transfer/ddl_plan.rs
index e6584069f4..9d5c217647 100644
--- a/crates/dbx-core/src/transfer/ddl_plan.rs
+++ b/crates/dbx-core/src/transfer/ddl_plan.rs
@@ -180,14 +180,30 @@ pub(super) async fn prepare_table_ddl(
request.target_catalog.as_deref(),
request.quote_target_column_names,
)
- } else {
+ } else if let Some(rewritten) = rewrite_transfer_source_table_ddl(
+ &source_ddl,
+ &request.source_schema,
+ &request.target_schema,
+ source_db_type,
+ target_db_type,
+ table,
+ target_table,
+ ) {
reused_source_ddl = source_ddl_was_read;
- rewrite_transfer_source_table_ddl(
- &source_ddl,
+ rewritten
+ } else {
+ // The reused DDL's CREATE TABLE head could not be renamed safely; fall back
+ // to the generated DDL rather than creating the table under the wrong name.
+ generate_create_table_ddl_with_column_quoting(
+ columns,
+ target_table,
&request.source_schema,
&request.target_schema,
- source_db_type,
target_db_type,
+ source_db_type,
+ table_comment,
+ request.target_catalog.as_deref(),
+ request.quote_target_column_names,
)
}
} else {