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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(table-editor): clear stale auto-increment flag on PK change
Melody Ruchcd8300c3f5f5
diff --git a/crates/dbx-core/src/table_structure_sql/columns.rs b/crates/dbx-core/src/table_structure_sql/columns.rsindex 87866ed188..2eeab03c66 100644--- a/crates/dbx-core/src/table_structure_sql/columns.rs+++ b/crates/dbx-core/src/table_structure_sql/columns.rs@@ -12,6 +12,7 @@ use super::column_format::{};use super::comments::build_sqlserver_column_comment_sql;use super::dialect::{capabilities_for, database_label, is_oracle_like, StructureDialect};+use super::indexes::has_existing_index_change;use super::types::{EditableStructureColumn, TableStructureSqlOptions};use super::util::{clean, is_protected_manticore_id_column, normalize_default, original_comment, original_default, qualified_table,@@ -176,7 +177,18 @@ pub(super) fn build_column_sql(options: &TableStructureSqlOptions, warnings: &mucontinue;}- if !has_existing_column_attribute_change(column) && !has_column_extra_change(column) && !has_position_change {+ // A column handing its primary key membership over to another column keeps its+ // AUTO_INCREMENT flag in the submitted draft, which MySQL rejects (ERROR 1075) once+ // the column is no longer keyed. Rewrite it inside the same coalesced ALTER even+ // though the draft reports no change on the column itself.+ let clears_orphaned_auto_increment = mysql_coalesced_primary_key_change+ .is_some_and(|change| mysql_orphans_auto_increment_column(options, column, change));++ if !has_existing_column_attribute_change(column)+ && !has_column_extra_change(column)+ && !has_position_change+ && !clears_orphaned_auto_increment+ {continue;}let original = column.original.as_ref().unwrap();@@ -221,14 +233,23 @@ pub(super) fn build_column_sql(options: &TableStructureSqlOptions, warnings: &mu));continue;}- if !has_rename && !has_attribute_change && !has_position_change {+ if !has_rename && !has_attribute_change && !has_position_change && !clears_orphaned_auto_increment {continue;}match dialect {StructureDialect::Mysql => {- let clause =- build_mysql_existing_column_clause(column, if has_position_change { &position_clause } else { "" });+ let rewritten;+ let effective_column = if clears_orphaned_auto_increment {+ rewritten = without_auto_increment(column);+ &rewritten+ } else {+ column+ };+ let clause = build_mysql_existing_column_clause(+ effective_column,+ if has_position_change { &position_clause } else { "" },+ );if mysql_coalesced_primary_key_change.is_some_and(|change| mysql_auto_increment_touches_primary_key(column, change)){@@ -377,6 +398,54 @@ fn mysql_auto_increment_touches_primary_key(column: &EditableStructureColumn, ch&& (change.old_ids.contains(column.id.as_str()) || change.new_ids.contains(column.id.as_str()))}+/// MySQL allows AUTO_INCREMENT only on a column that leads some key, so a column handing the+/// primary key over to another column must lose the flag in the same statement — unless an+/// already existing index that survives this change still keys it.+fn mysql_orphans_auto_increment_column(+ options: &TableStructureSqlOptions,+ column: &EditableStructureColumn,+ change: &PrimaryKeyChange<'_>,+) -> bool {+ column.original.is_some()+ && column.extra.as_ref().is_some_and(|extra| extra.auto_increment.unwrap_or(false))+ && change.old_ids.contains(column.id.as_str())+ && !change.new_ids.contains(column.id.as_str())+ && !mysql_column_leads_kept_index(options, column)+}++/// Whether a persisted, non-primary index keys this column for the whole change.+///+/// Only an index the draft leaves completely untouched counts. One created by this draft is+/// added after the column DDL, and an edited one is rebuilt as DROP + CREATE after it, so+/// neither covers the column while the coalesced ALTER runs — and the DROP would hit the very+/// same ERROR 1075. Matching is against the persisted names on both sides, so a draft that+/// swaps two column names cannot credit one column's index to the other.+///+/// This applies the InnoDB rule that the auto column must *lead* an index. MyISAM also accepts+/// it in a later position of a multi-column index; DBX has no engine information here, so such+/// a table loses AUTO_INCREMENT rather than every InnoDB table keeping an invalid one.+fn mysql_column_leads_kept_index(options: &TableStructureSqlOptions, column: &EditableStructureColumn) -> bool {+ let Some(original_name) = column.original.as_ref().map(|original| original.name.as_str()) else {+ return false;+ };+ options.indexes.iter().any(|index| {+ !index.marked_for_drop+ && !has_existing_index_change(index)+ && index.original.as_ref().is_some_and(|original| {+ !original.is_primary+ && original.columns.first().is_some_and(|first| clean(first).eq_ignore_ascii_case(original_name))+ })+ })+}++fn without_auto_increment(column: &EditableStructureColumn) -> EditableStructureColumn {+ let mut cleared = column.clone();+ if let Some(extra) = cleared.extra.as_mut() {+ extra.auto_increment = Some(false);+ }+ cleared+}+pub(super) fn build_primary_key_sql(options: &TableStructureSqlOptions,dialect: StructureDialect,diff --git a/crates/dbx-core/src/table_structure_sql/tests.rs b/crates/dbx-core/src/table_structure_sql/tests.rsindex 0950fec996..4b2f37b30d 100644--- a/crates/dbx-core/src/table_structure_sql/tests.rs+++ b/crates/dbx-core/src/table_structure_sql/tests.rs@@ -4242,10 +4242,141 @@ fn mysql_coalesces_migration_away_from_existing_auto_increment_primary_key() {vec![old_pk, new_pk],));+ assert_eq!(result.warnings, Vec::<String>::new());+ // The old key column keeps its AUTO_INCREMENT checkbox in the draft, but MySQL refuses an+ // auto column that no longer leads a key, so the flag is cleared in the same statement.+ assert_eq!(+ result.statements,+ vec![+ "ALTER TABLE `users` DROP PRIMARY KEY, MODIFY COLUMN `id` bigint NOT NULL, ADD PRIMARY KEY (`external_id`);"+ ]+ );+}++/// Regression for #7973: swapping the primary key onto another column left the previous+/// AUTO_INCREMENT key column untouched, so the coalesced ALTER failed with+/// `ERROR 1075 Incorrect table definition; there can be only one auto column ...`.+#[test]+fn mysql_clears_auto_increment_on_column_replaced_by_new_auto_increment_primary_key() {+ let mut old_pk = existing_pk_column("ID", "bigint unsigned", true, false);+ old_pk.id = "old_id".to_string();+ old_pk.comment = "自增ID".to_string();+ old_pk.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });+ let old_original = old_pk.original.as_mut().unwrap();+ old_original.extra = Some("auto_increment".to_string());+ old_original.comment = Some("自增ID".to_string());++ let mut new_pk = existing_pk_column("ProjectID", "bigint", false, true);+ new_pk.id = "project_id".to_string();+ new_pk.comment = "对应project表的主键ID".to_string();+ new_pk.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });+ new_pk.original.as_mut().unwrap().comment = Some("对应project表的主键ID".to_string());++ let result = build_table_structure_change_sql(structure_change_options(+ DatabaseType::Mysql,+ None,+ "issue7973_repro",+ vec![old_pk, new_pk],+ ));++ assert_eq!(result.warnings, Vec::<String>::new());+ assert_eq!(+ result.statements,+ vec![+ "ALTER TABLE `issue7973_repro` DROP PRIMARY KEY, MODIFY COLUMN `ID` bigint unsigned NOT NULL COMMENT '自增ID', MODIFY COLUMN `ProjectID` bigint NOT NULL AUTO_INCREMENT COMMENT '对应project表的主键ID', ADD PRIMARY KEY (`ProjectID`);"+ ]+ );+}++/// A surviving secondary index still keys the column, so AUTO_INCREMENT stays legal there+/// and must not be stripped just because the primary key moved elsewhere.+#[test]+fn mysql_keeps_auto_increment_when_a_kept_index_still_leads_with_the_column() {+ let mut old_pk = existing_pk_column("id", "bigint", true, false);+ old_pk.id = "old_id".to_string();+ old_pk.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });+ old_pk.original.as_mut().unwrap().extra = Some("auto_increment".to_string());++ let mut new_pk = existing_pk_column("external_id", "varchar(64)", false, true);+ new_pk.id = "new_external_id".to_string();++ let mut options = structure_change_options(DatabaseType::Mysql, None, "users", vec![old_pk, new_pk]);+ options.indexes = vec![existing_index("idx_users_id", &["id"], false)];++ let result = build_table_structure_change_sql(options);+assert_eq!(result.warnings, Vec::<String>::new());assert_eq!(result.statements, vec!["ALTER TABLE `users` DROP PRIMARY KEY, ADD PRIMARY KEY (`external_id`);"]);}+/// An index the same draft edits is rebuilt as DROP + CREATE *after* the column DDL, so it+/// cannot excuse the AUTO_INCREMENT flag: the DROP INDEX would hit ERROR 1075 itself.+#[test]+fn mysql_clears_auto_increment_when_the_only_covering_index_is_rebuilt_by_the_same_draft() {+ let mut old_pk = existing_pk_column("id", "bigint", true, false);+ old_pk.id = "old_id".to_string();+ old_pk.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });+ old_pk.original.as_mut().unwrap().extra = Some("auto_increment".to_string());++ let mut new_pk = existing_pk_column("external_id", "varchar(64)", false, true);+ new_pk.id = "new_external_id".to_string();++ let mut rebuilt_index = existing_index("idx_users_id", &["id"], false);+ rebuilt_index.is_unique = true;++ let mut options = structure_change_options(DatabaseType::Mysql, None, "users", vec![old_pk, new_pk]);+ options.indexes = vec![rebuilt_index];++ let result = build_table_structure_change_sql(options);++ assert_eq!(result.warnings, Vec::<String>::new());+ assert_eq!(+ result.statements,+ vec![+ "ALTER TABLE `users` DROP PRIMARY KEY, MODIFY COLUMN `id` bigint NOT NULL, ADD PRIMARY KEY (`external_id`);",+ "DROP INDEX `idx_users_id` ON `users`;",+ "CREATE UNIQUE INDEX `idx_users_id` ON `users` (`id`);",+ ]+ );+}++/// The covering index is matched by persisted names on both sides, so a draft that swaps two+/// column names cannot credit one column's index to the other.+#[test]+fn mysql_index_cover_does_not_follow_a_column_name_swap() {+ let mut old_pk = existing_pk_column("id", "bigint", true, false);+ old_pk.id = "old_id".to_string();+ old_pk.name = "legacy_id".to_string();+ old_pk.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });+ old_pk.original.as_mut().unwrap().extra = Some("auto_increment".to_string());++ // Takes over the name the surviving index was built on, but not the index itself.+ let mut renamed = existing_pk_column("tenant_id", "bigint", false, false);+ renamed.id = "tenant".to_string();+ renamed.name = "id".to_string();++ let mut new_pk = existing_pk_column("external_id", "varchar(64)", false, true);+ new_pk.id = "new_external_id".to_string();++ let mut options = structure_change_options(DatabaseType::Mysql, None, "users", vec![old_pk, renamed, new_pk]);+ options.indexes = vec![existing_index("idx_users_tenant_id", &["tenant_id"], false)];++ let result = build_table_structure_change_sql(options);++ assert_eq!(result.warnings, Vec::<String>::new());+ // Only the second statement is what this test is about: the auto column lost AUTO_INCREMENT+ // even though `idx_users_tenant_id` leads with a column *named* `id` in the draft. The+ // separate rename statement, and the order the two renames run in, are pre-existing+ // name-swap behavior unrelated to this fix.+ assert_eq!(+ result.statements,+ vec![+ "ALTER TABLE `users` CHANGE COLUMN `tenant_id` `id` bigint NOT NULL;",+ "ALTER TABLE `users` DROP PRIMARY KEY, CHANGE COLUMN `id` `legacy_id` bigint NOT NULL, ADD PRIMARY KEY (`external_id`);",+ ]+ );+}+#[test]fn mysql_coalesces_renamed_auto_increment_primary_key_column() {let mut old_pk = existing_pk_column("campaign_rel_id", "bigint", true, false);