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(sqlserver): preserve identity values during transfer
zipg83e1e293b0dc
diff --git a/crates/dbx-core/src/transfer.rs b/crates/dbx-core/src/transfer.rsindex ba58ffab8c..ea17574073 100644--- a/crates/dbx-core/src/transfer.rs+++ b/crates/dbx-core/src/transfer.rs@@ -1738,6 +1738,22 @@ pub(crate) fn wrap_dameng_identity_insert_sql_for_table(insert_sql: &str, full_tformat!("SET IDENTITY_INSERT {full_table} ON;\n{trimmed};\nSET IDENTITY_INSERT {full_table} OFF;")}+async fn execute_sqlserver_identity_batch(+ client: &mut db::sqlserver::SqlServerClient,+ sql: &str,+ timeout: Option<std::time::Duration>,+) -> Result<(), String> {+ let future = db::sqlserver::execute_simple_batch_with_max_rows(client, sql, None);+ let result: Vec<db::QueryResult> = match timeout {+ Some(timeout) => tokio::time::timeout(timeout, future)+ .await+ .map_err(|_| format!("Query timed out after {} seconds", timeout.as_secs().max(1)))??,+ None => future.await?,+ };+ drop(result);+ Ok(())+}+async fn execute_transfer_write_statement(state: &AppState,target_pool_key: &str,@@ -1754,6 +1770,52 @@ async fn execute_transfer_write_statement(let enable_sql = identity_insert_statement(table, schema, target_db_type, true);let disable_sql = identity_insert_statement(table, schema, target_db_type, false);++ if *target_db_type == DatabaseType::SqlServer {+ // SQL Server scopes IDENTITY_INSERT to the current session. The generic+ // pool helper may check out a different physical connection for each+ // statement, so keep all three statements on the same locked client.+ crate::query::check_read_only_for_connection(state, target_pool_key, sql).await?;+ let (_, _, _, query_timeout_secs) = transfer_pool_context(state, target_pool_key).await;+ let query_timeout = query_timeout_duration(query_timeout_secs);+ let pool_handle = state.pool_handle(target_pool_key).await;+ let client = match pool_handle.as_ref() {+ Some(PoolKind::SqlServer(client)) => client.clone(),+ _ => return Err("SQL Server connection not found".to_string()),+ };+ let mut client = client.lock().await;++ let enable_result = execute_sqlserver_identity_batch(&mut client, &enable_sql, query_timeout).await;+ if let Err(error) = enable_result {+ drop(client);+ if is_transfer_query_timeout(&error) {+ state.remove_pool_by_key(target_pool_key).await;+ }+ return Err(format!("Failed to enable IDENTITY_INSERT for {table}: {error}"));+ }++ let write_result = execute_sqlserver_identity_batch(&mut client, sql, query_timeout).await;+ let disable_result = execute_sqlserver_identity_batch(&mut client, &disable_sql, query_timeout).await;+ drop(client);++ if write_result.as_ref().is_err_and(|error| is_transfer_query_timeout(error))+ || disable_result.as_ref().is_err_and(|error| is_transfer_query_timeout(error))+ {+ state.remove_pool_by_key(target_pool_key).await;+ }++ return match (write_result, disable_result) {+ (Ok(_), Ok(_)) => Ok(()),+ (Err(write_error), Ok(_)) => Err(write_error),+ (Ok(_), Err(disable_error)) => {+ Err(format!("Failed to disable IDENTITY_INSERT for {table}: {disable_error}"))+ }+ (Err(write_error), Err(disable_error)) => {+ Err(format!("{write_error}; also failed to disable IDENTITY_INSERT for {table}: {disable_error}"))+ }+ };+ }+execute_on_pool(state, target_pool_key, &enable_sql).await.map_err(|e| format!("Failed to enable IDENTITY_INSERT for {table}: {e}"))?;diff --git a/crates/dbx-core/tests/live_sqlserver_transfer.rs b/crates/dbx-core/tests/live_sqlserver_transfer.rsindex 9c63da32ff..c64a236c26 100644--- a/crates/dbx-core/tests/live_sqlserver_transfer.rs+++ b/crates/dbx-core/tests/live_sqlserver_transfer.rs@@ -284,6 +284,111 @@ async fn live_sqlserver_transfer_rebuild_releases_constraint_and_index_names() {test_result.unwrap();}+#[tokio::test]+#[ignore = "requires DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at SQL Server"]+async fn live_sqlserver_transfer_overwrite_handles_existing_identity_target() {+ let database = std::env::var("DBX_LIVE_SQLSERVER_DATABASE").unwrap_or_else(|_| "dbx_sqlserver_demo".to_string());+ let suffix = uuid::Uuid::new_v4().simple().to_string();+ let connection_id = format!("live-sqlserver-8690-{suffix}");+ let source_schema = format!("dbx_8690_src_{}", &suffix[..12]);+ let target_schema = format!("dbx_8690_dst_{}", &suffix[..12]);+ let table = "identity_rows";++ let mut client = sqlserver_connect(&database).await;+ for statement in [+ format!("CREATE SCHEMA [{source_schema}]"),+ format!("CREATE SCHEMA [{target_schema}]"),+ format!(+ "CREATE TABLE [{source_schema}].[{table}] (id INT IDENTITY(100,1) NOT NULL CONSTRAINT [PK_8690_src_{suffix}] PRIMARY KEY, name NVARCHAR(64) NOT NULL)"+ ),+ format!(+ "CREATE TABLE [{target_schema}].[{table}] (id INT IDENTITY(1,1) NOT NULL CONSTRAINT [PK_8690_dst_{suffix}] PRIMARY KEY, name NVARCHAR(64) NOT NULL)"+ ),+ format!("INSERT INTO [{source_schema}].[{table}] (name) VALUES (N'first'), (N'second')"),+ format!("INSERT INTO [{target_schema}].[{table}] (name) VALUES (N'stale')"),+ ] {+ dbx_core::db::sqlserver::execute_batch(&mut client, &statement)+ .await+ .expect("create issue #8690 fixtures");+ }++ let dir = std::env::temp_dir().join(format!("dbx-live-sqlserver-8690-{suffix}"));+ std::fs::create_dir_all(&dir).expect("create issue #8690 directory");+ let storage = Storage::open(&dir.join("storage.db")).await.expect("open issue #8690 storage");+ let state = Arc::new(AppState::new(storage));+ state.configs.write().await.insert(connection_id.clone(), live_sqlserver_config(&connection_id, &database));+ let pool_key = state.get_or_create_pool(&connection_id, Some(&database)).await.expect("create SQL Server pool");+ let request = TransferRequest {+ transfer_id: format!("live-sqlserver-8690-transfer-{suffix}"),+ source_connection_id: connection_id.clone(),+ source_database: database.clone(),+ source_schema: source_schema.clone(),+ source_catalog: None,+ target_connection_id: connection_id.clone(),+ target_database: database.clone(),+ target_schema: target_schema.clone(),+ target_catalog: None,+ tables: vec![table.to_string()],+ create_table: true,+ drop_target_before_create: false,+ drop_target_confirmed: false,+ content: TransferContent::default(),+ objects: Vec::new(),+ mode: TransferMode::Overwrite,+ target_table_name_case: TransferTableNameCase::Preserve,+ quote_target_column_names: true,+ ownership_policy: TransferOwnershipPolicy::Preserve,+ batch_size: 1,+ };++ let test_result = async {+ let transferred = transfer_table(+ &state,+ &request,+ table,+ 0,+ &DatabaseType::SqlServer,+ &DatabaseType::SqlServer,+ &pool_key,+ &pool_key,+ &HashMap::new(),+ &mut Vec::new(),+ None,+ |_| {},+ )+ .await?;+ assert_eq!(transferred, 2);++ let rows = dbx_core::db::sqlserver::execute_query(+ &mut client,+ &format!("SELECT id, name FROM [{target_schema}].[{table}] ORDER BY id"),+ )+ .await+ .map_err(|error| format!("read transferred rows: {error}"))?;+ assert_eq!(rows.rows.len(), 2);+ assert_eq!(rows.rows[0][0].as_i64(), Some(100));+ assert_eq!(rows.rows[1][0].as_i64(), Some(101));+ assert_eq!(rows.rows[0][1].as_str(), Some("first"));+ assert_eq!(rows.rows[1][1].as_str(), Some("second"));+ Ok::<_, String>(())+ }+ .await;++ let cleanup = dbx_core::db::sqlserver::execute_batch(+ &mut client,+ &format!(+ "IF OBJECT_ID(N'[{target_schema}].[{table}]', N'U') IS NOT NULL DROP TABLE [{target_schema}].[{table}]; \+ IF OBJECT_ID(N'[{source_schema}].[{table}]', N'U') IS NOT NULL DROP TABLE [{source_schema}].[{table}]; \+ IF SCHEMA_ID(N'{target_schema}') IS NOT NULL DROP SCHEMA [{target_schema}]; \+ IF SCHEMA_ID(N'{source_schema}') IS NOT NULL DROP SCHEMA [{source_schema}];"+ ),+ )+ .await;+ let _ = std::fs::remove_dir_all(dir);+ cleanup.expect("cleanup issue #8690 fixtures");+ test_result.expect("SQL Server overwrite transfer should preserve explicit identity values");+}+#[tokio::test]#[ignore = "requires DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at SQL Server"]async fn live_sqlserver_keyset_pagination_copies_every_row() {