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(sqlserver): preserve identity values during transfer

zipg83e1e293b0dc
diff --git a/crates/dbx-core/src/transfer.rs b/crates/dbx-core/src/transfer.rs
index 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_t
format!("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.rs
index 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() {