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。

51.6 KB
Raw Blame
use dbx_core::connection::AppState;
use dbx_core::models::connection::{ConnectionConfig, DatabaseType};
use dbx_core::transfer::{
    clear_foreign_key_linked_overwrite_targets, drop_backup_tables, rename_tables_to_backup,
    sort_tables_by_fk_dependency_with_foreign_keys, transfer_table, transfer_table_with_result, TransferColumnNameCase,
    TransferContent, TransferMode, TransferOwnershipPolicy, TransferRequest, TransferTableNameCase,
};
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;

fn live_sqlserver_config(id: &str, database: &str) -> ConnectionConfig {
    ConnectionConfig {
        oracle_oci_nls_lang: None,
        oracle_oci_tns_admin: None,
        docs_notes_path: None,
        id: id.to_string(),
        name: id.to_string(),
        note: String::new(),
        db_type: DatabaseType::SqlServer,
        driver_profile: None,
        driver_label: None,
        url_params: None,
        agent_java_options: Vec::new(),
        host: std::env::var("DBX_LIVE_SQLSERVER_HOST").unwrap_or_else(|_| "127.0.0.1".to_string()),
        port: std::env::var("DBX_LIVE_SQLSERVER_PORT").ok().and_then(|value| value.parse().ok()).unwrap_or(1433),
        username: std::env::var("DBX_LIVE_SQLSERVER_USER").unwrap_or_else(|_| "sa".to_string()),
        password: std::env::var("DBX_LIVE_SQLSERVER_PASSWORD").expect("DBX_LIVE_SQLSERVER_PASSWORD"),
        database: Some(database.to_string()),
        default_schema: None,
        visible_databases: None,
        visible_database_patterns: None,
        visible_schemas: None,
        attached_databases: Vec::new(),
        init_script: None,
        color: None,
        transport_layers: Vec::new(),
        connect_timeout_secs: 15,
        query_timeout_secs: 30,
        idle_timeout_secs: 60,
        manual_transaction_timeout_secs: 300,
        idle_disconnect_secs: 0,
        keepalive_interval_secs: 0,
        ssl: false,
        ca_cert_path: String::new(),
        client_cert_path: String::new(),
        client_key_path: String::new(),
        sysdba: false,
        oracle_connection_type: None,
        connection_string: None,
        redis_connection_mode: None,
        redis_sentinel_master: String::new(),
        redis_sentinel_nodes: String::new(),
        redis_sentinel_username: String::new(),
        redis_sentinel_password: String::new(),
        redis_sentinel_tls: false,
        redis_cluster_nodes: String::new(),
        redis_key_separator: dbx_core::models::connection::default_redis_key_separator(),
        redis_scan_page_size: None,
        redis_database_aliases: Default::default(),
        redis_key_templates: Vec::new(),
        redis_key_filter: None,
        redis_key_grouping: None,
        etcd_endpoints: String::new(),
        gbase_server: String::new(),
        informix_server: String::new(),
        external_config: None,
        plugin_id: None,
        plugin_connection_provider: None,
        plugin_connection_type: None,
        connection_secrets: Default::default(),
        jdbc_driver_class: None,
        jdbc_driver_paths: Vec::new(),
        one_time: false,
        save_password: true,
        read_only: false,
        is_production: false,
        production_databases: vec![],
        production_badge_scope: None,
        show_system_schemas: false,
        sidebar_auto_load_all_tables: false,
        show_database_links: None,
        show_native_jobs: None,
        show_user_admin: None,
        database_info: None,
    }
}

async fn sqlserver_env() -> (String, u16, String, String) {
    let host = std::env::var("DBX_LIVE_SQLSERVER_HOST").unwrap_or_else(|_| "127.0.0.1".to_string());
    let port = std::env::var("DBX_LIVE_SQLSERVER_PORT").ok().and_then(|value| value.parse().ok()).unwrap_or(1433);
    let user = std::env::var("DBX_LIVE_SQLSERVER_USER").unwrap_or_else(|_| "sa".to_string());
    let password = std::env::var("DBX_LIVE_SQLSERVER_PASSWORD").expect("DBX_LIVE_SQLSERVER_PASSWORD");
    (host, port, user, password)
}

async fn sqlserver_connect(database: &str) -> dbx_core::db::sqlserver::SqlServerClient {
    let (host, port, user, password) = sqlserver_env().await;
    dbx_core::db::sqlserver::connect(&host, port, &user, &password, Some(database), None, Duration::from_secs(20))
        .await
        .expect("connect SQL Server")
}

/// Whether a schema-scoped object with `name` still exists on `table`.
async fn sqlserver_object_on_table_exists(
    client: &mut dbx_core::db::sqlserver::SqlServerClient,
    table: &str,
    name: &str,
) -> bool {
    let sql = format!(
        "SELECT CASE WHEN EXISTS ( \
            SELECT 1 FROM sys.objects o WHERE o.name = N'{name}' AND o.parent_object_id = OBJECT_ID(N'dbo.{table}') \
            UNION ALL \
            SELECT 1 FROM sys.indexes i WHERE i.name = N'{name}' AND i.object_id = OBJECT_ID(N'dbo.{table}') \
         ) THEN 1 ELSE 0 END",
        name = name.replace('\'', "''"),
        table = table.replace('\'', "''"),
    );
    let result = dbx_core::db::sqlserver::execute_query(client, &sql).await.expect("query object existence");
    result.rows.first().and_then(|row| row.first()).and_then(|v| v.as_i64()).map(|n| n == 1).unwrap_or(false)
}

#[tokio::test]
#[ignore = "requires DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at SQL Server"]
async fn live_sqlserver_transfer_rebuild_releases_constraint_and_index_names() {
    let suffix = uuid::Uuid::new_v4().simple().to_string();
    let source_db = format!("dbx_rebuild_src_{}", &suffix[..12]);
    let target_db = format!("dbx_rebuild_dst_{}", &suffix[..12]);
    let connection_id = format!("live-sqlserver-rebuild-{suffix}");

    // Create both databases and populate source + target with same-named constraints.
    let mut master = sqlserver_connect("master").await;
    dbx_core::db::sqlserver::execute_batch(
        &mut master,
        &format!("CREATE DATABASE [{source_db}]; CREATE DATABASE [{target_db}];"),
    )
    .await
    .expect("create rebuild databases");

    let mut source_client = sqlserver_connect(&source_db).await;
    dbx_core::db::sqlserver::execute_batch(
        &mut source_client,
        "CREATE TABLE dbo.departments (id INT NOT NULL CONSTRAINT PK_departments PRIMARY KEY, name NVARCHAR(32)); \
         CREATE TABLE dbo.employees (id INT NOT NULL CONSTRAINT PK_employees PRIMARY KEY, dept_id INT NULL, \
             CONSTRAINT FK_emp_dept FOREIGN KEY (dept_id) REFERENCES dbo.departments(id)); \
         CREATE INDEX IX_emp_dept ON dbo.employees(dept_id); \
         INSERT INTO dbo.departments VALUES (10, N'Engineering'), (20, N'Sales'); \
         INSERT INTO dbo.employees VALUES (1, 10), (2, 20);",
    )
    .await
    .expect("create source tables");

    let mut target_client = sqlserver_connect(&target_db).await;
    dbx_core::db::sqlserver::execute_batch(
        &mut target_client,
        "CREATE TABLE dbo.departments (id INT NOT NULL CONSTRAINT PK_departments PRIMARY KEY, name NVARCHAR(32)); \
         CREATE TABLE dbo.employees (id INT NOT NULL CONSTRAINT PK_employees PRIMARY KEY, dept_id INT NULL, \
             CONSTRAINT FK_emp_dept FOREIGN KEY (dept_id) REFERENCES dbo.departments(id)); \
         CREATE INDEX IX_emp_dept ON dbo.employees(dept_id); \
         INSERT INTO dbo.departments VALUES (99, N'Stale'); \
         INSERT INTO dbo.employees VALUES (98, 99);",
    )
    .await
    .expect("create target tables");

    let dir = std::env::temp_dir().join(format!("dbx-live-sqlserver-rebuild-{suffix}"));
    std::fs::create_dir_all(&dir).expect("create rebuild directory");
    let storage =
        dbx_core::persistence::test_storage::open(&dir.join("storage.db")).await.expect("open rebuild storage");
    let state = Arc::new(AppState::new(storage));
    let config = live_sqlserver_config(&connection_id, &source_db);
    state.configs.write().await.insert(connection_id.clone(), config);
    let source_pool_key = state.get_or_create_pool(&connection_id, Some(&source_db)).await.expect("source pool");
    let target_pool_key = state.get_or_create_pool(&connection_id, Some(&target_db)).await.expect("target pool");

    let request = TransferRequest {
        table_filters: std::collections::HashMap::new(),
        transfer_id: format!("live-sqlserver-rebuild-{suffix}"),
        source_connection_id: connection_id.clone(),
        source_database: source_db.clone(),
        source_schema: "dbo".to_string(),
        source_catalog: None,
        target_connection_id: connection_id.clone(),
        target_database: target_db.clone(),
        target_schema: "dbo".to_string(),
        target_catalog: None,
        tables: vec!["departments".to_string(), "employees".to_string()],
        create_table: true,
        drop_target_before_create: true,
        drop_target_confirmed: true,
        oracle_packages: None,
        content: TransferContent::default(),
        objects: Some(Vec::new()),
        mode: TransferMode::Append,
        target_table_name_case: TransferTableNameCase::Preserve,
        target_column_name_case: TransferColumnNameCase::Preserve,
        quote_target_column_names: true,
        ownership_policy: TransferOwnershipPolicy::Preserve,
        batch_size: 10,
    };

    let test_result = async {
        let backup_names = rename_tables_to_backup(
            &state,
            &request,
            &request.tables,
            DatabaseType::SqlServer,
            &target_pool_key,
            |_| {},
        )
        .await?;
        assert_eq!(backup_names.len(), 2, "both preexisting targets must be backed up");

        // The pre-pass must have released every schema-unique constraint and index name
        // so the rebuilt tables can reuse the source DDL's names without colliding.
        for (table, name) in [
            ("departments", "PK_departments"),
            ("employees", "PK_employees"),
            ("employees", "FK_emp_dept"),
            ("employees", "IX_emp_dept"),
        ] {
            assert!(
                !sqlserver_object_on_table_exists(&mut target_client, table, name).await,
                "{name} on {table} must have been released before rebuild"
            );
        }

        let mut pending_fk_alters: Vec<(String, String)> = Vec::new();
        for (i, table) in request.tables.iter().enumerate() {
            transfer_table(
                &state,
                &request,
                table,
                i,
                &DatabaseType::SqlServer,
                &DatabaseType::SqlServer,
                &source_pool_key,
                &target_pool_key,
                &HashMap::new(),
                &mut pending_fk_alters,
                Some(&backup_names),
                |_| {},
            )
            .await?;
        }

        // The rebuilt tables must have reclaimed the FK and index names — the names that
        // would otherwise collide with the backups. Primary keys are regenerated inline by
        // the source DDL (SQL Server auto-names them), so only their presence matters.
        for (table, name) in [("employees", "FK_emp_dept"), ("employees", "IX_emp_dept")] {
            assert!(
                sqlserver_object_on_table_exists(&mut target_client, table, name).await,
                "{name} on {table} must be rebuilt"
            );
        }
        for table in ["departments", "employees"] {
            let pk = dbx_core::db::sqlserver::execute_query(
                &mut target_client,
                &format!(
                    "SELECT COUNT(*) FROM sys.key_constraints WHERE parent_object_id = OBJECT_ID('dbo.{table}') AND type = 'PK'"
                ),
            )
            .await
            .expect("count primary key");
            assert_eq!(
                pk.rows.first().and_then(|r| r.first()).and_then(|v| v.as_i64()),
                Some(1),
                "{table} must have a primary key"
            );
        }

        // Stale target rows replaced by source data.
        let count = dbx_core::db::sqlserver::execute_query(
            &mut target_client,
            "SELECT CAST(COUNT(*) AS INT) FROM dbo.departments WHERE id IN (10,20)",
        )
        .await
        .expect("count rebuilt departments");
        assert_eq!(count.rows.first().and_then(|r| r.first()).and_then(|v| v.as_i64()), Some(2));

        // The rebuilt foreign key must still reject an orphan reference.
        let orphan = dbx_core::db::sqlserver::execute_query(&mut target_client, "INSERT INTO dbo.employees VALUES (7, 999)").await;
        assert!(orphan.is_err(), "rebuilt FK must reject a missing referenced department");

        drop_backup_tables(&state, &request, DatabaseType::SqlServer, &target_pool_key, &backup_names, &request.tables).await?;
        Ok::<_, String>(())
    }
    .await;

    // SQL Server refuses to drop a database with active connections (code 3702); the
    // state pools and setup clients still hold some. Force them all off first.
    let cleanup = dbx_core::db::sqlserver::execute_batch(
        &mut master,
        &format!(
            "ALTER DATABASE [{source_db}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE [{source_db}]; \
             ALTER DATABASE [{target_db}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE [{target_db}];"
        ),
    )
    .await;
    let _ = std::fs::remove_dir_all(dir);
    cleanup.expect("drop rebuild databases");
    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 =
        dbx_core::persistence::test_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 {
        table_filters: std::collections::HashMap::new(),
        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,
        oracle_packages: None,
        content: TransferContent::default(),
        objects: Some(Vec::new()),
        mode: TransferMode::Overwrite,
        target_table_name_case: TransferTableNameCase::Preserve,
        target_column_name_case: TransferColumnNameCase::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() {
    let suffix = uuid::Uuid::new_v4().simple().to_string();
    let source_db = format!("dbx_keyset_src_{}", &suffix[..12]);
    let target_db = format!("dbx_keyset_dst_{}", &suffix[..12]);
    let source_connection_id = format!("live-sqlserver-keyset-src-{suffix}");
    let target_connection_id = format!("live-sqlserver-keyset-dst-{suffix}");

    let mut master = sqlserver_connect("master").await;
    dbx_core::db::sqlserver::execute_batch(
        &mut master,
        &format!("CREATE DATABASE [{source_db}]; CREATE DATABASE [{target_db}];"),
    )
    .await
    .expect("create keyset databases");

    let mut source_client = sqlserver_connect(&source_db).await;
    dbx_core::db::sqlserver::execute_batch(
        &mut source_client,
        "CREATE TABLE dbo.big (id INT NOT NULL CONSTRAINT PK_big PRIMARY KEY, name NVARCHAR(64) NOT NULL); \
         ;WITH seq AS (SELECT 1 n UNION ALL SELECT n + 1 FROM seq WHERE n < 25) \
         INSERT INTO dbo.big (id, name) \
         SELECT n, CONCAT('row-', n) FROM seq OPTION (MAXRECURSION 0);",
    )
    .await
    .expect("create source table");

    let dir = std::env::temp_dir().join(format!("dbx-live-sqlserver-keyset-{suffix}"));
    std::fs::create_dir_all(&dir).expect("create keyset directory");
    let storage =
        dbx_core::persistence::test_storage::open(&dir.join("storage.db")).await.expect("open keyset storage");
    let state = Arc::new(AppState::new(storage));
    state
        .configs
        .write()
        .await
        .insert(source_connection_id.clone(), live_sqlserver_config(&source_connection_id, &source_db));
    state
        .configs
        .write()
        .await
        .insert(target_connection_id.clone(), live_sqlserver_config(&target_connection_id, &target_db));
    let source_pool_key = state.get_or_create_pool(&source_connection_id, Some(&source_db)).await.expect("source pool");
    let target_pool_key = state.get_or_create_pool(&target_connection_id, Some(&target_db)).await.expect("target pool");

    let request = TransferRequest {
        table_filters: std::collections::HashMap::new(),
        transfer_id: format!("live-sqlserver-keyset-{suffix}"),
        source_connection_id: source_connection_id.clone(),
        source_database: source_db.clone(),
        source_schema: "dbo".to_string(),
        source_catalog: None,
        target_connection_id: target_connection_id.clone(),
        target_database: target_db.clone(),
        target_schema: "dbo".to_string(),
        target_catalog: None,
        tables: vec!["big".to_string()],
        create_table: true,
        drop_target_before_create: false,
        drop_target_confirmed: false,
        oracle_packages: None,
        content: TransferContent::default(),
        objects: Some(Vec::new()),
        mode: TransferMode::Append,
        target_table_name_case: TransferTableNameCase::Preserve,
        target_column_name_case: TransferColumnNameCase::Preserve,
        quote_target_column_names: true,
        ownership_policy: TransferOwnershipPolicy::Preserve,
        batch_size: 3,
    };

    let test_result = async {
        let transferred = transfer_table(
            &state,
            &request,
            "big",
            0,
            &DatabaseType::SqlServer,
            &DatabaseType::SqlServer,
            &source_pool_key,
            &target_pool_key,
            &HashMap::new(),
            &mut Vec::new(),
            None,
            |_| {},
        )
        .await?;
        assert_eq!(transferred, 25, "keyset pagination must copy every row");

        let mut target_client = sqlserver_connect(&target_db).await;
        let rows = dbx_core::db::sqlserver::execute_query(&mut target_client, "SELECT id FROM dbo.big ORDER BY id")
            .await
            .expect("read target ids");
        let collected: Vec<i64> = rows.rows.iter().map(|row| row[0].as_i64().unwrap()).collect();
        assert_eq!(collected, (1..=25).collect::<Vec<i64>>(), "keyset pagination must not drop or duplicate rows");
        Ok::<_, String>(())
    }
    .await;

    let cleanup = dbx_core::db::sqlserver::execute_batch(
        &mut master,
        &format!(
            "ALTER DATABASE [{source_db}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE [{source_db}]; \
             ALTER DATABASE [{target_db}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE [{target_db}];"
        ),
    )
    .await;
    let _ = std::fs::remove_dir_all(dir);
    cleanup.expect("drop keyset databases");
    test_result.unwrap();
}

#[tokio::test]
#[ignore = "requires DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at SQL Server"]
async fn live_sqlserver_progress_read_survives_total_duration_beyond_timeout() {
    let suffix = uuid::Uuid::new_v4().simple().to_string();
    let source_db = format!("dbx_progress_src_{}", &suffix[..12]);
    let target_db = format!("dbx_progress_dst_{}", &suffix[..12]);
    let source_connection_id = format!("live-sqlserver-progress-src-{suffix}");
    let target_connection_id = format!("live-sqlserver-progress-dst-{suffix}");

    let mut master = sqlserver_connect("master").await;
    dbx_core::db::sqlserver::execute_batch(
        &mut master,
        &format!("CREATE DATABASE [{source_db}]; CREATE DATABASE [{target_db}];"),
    )
    .await
    .expect("create progress databases");

    // The transfer spans several pages whose total duration far exceeds the 1s
    // budget. With the timeout treated as an inactivity window, a steady stream must
    // never be cancelled just for taking longer than the timeout in total. Generate
    // the rows with a non-recursive cross join so the fixture itself stays fast.
    let mut source_client = sqlserver_connect(&source_db).await;
    dbx_core::db::sqlserver::execute_batch(
        &mut source_client,
        "CREATE TABLE dbo.big (id INT NOT NULL CONSTRAINT PK_big PRIMARY KEY, name NVARCHAR(64) NOT NULL); \
         INSERT INTO dbo.big (id, name) \
         SELECT t.n, REPLICATE('x', 64) \
         FROM ( \
             SELECT a.n + b.n * 10 + c.n * 100 + d.n * 1000 + e.n * 10000 + 1 AS n \
             FROM (VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) a(n) \
             CROSS JOIN (VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) b(n) \
             CROSS JOIN (VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) c(n) \
             CROSS JOIN (VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) d(n) \
             CROSS JOIN (VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) e(n) \
         ) t WHERE t.n <= 20000;",
    )
    .await
    .expect("create source table");

    let dir = std::env::temp_dir().join(format!("dbx-live-sqlserver-progress-{suffix}"));
    std::fs::create_dir_all(&dir).expect("create progress directory");
    let storage =
        dbx_core::persistence::test_storage::open(&dir.join("storage.db")).await.expect("open progress storage");
    let state = Arc::new(AppState::new(storage));
    // The read runs under the source's query timeout; keep it at 1s so the test only
    // passes when the transfer treats it as an inactivity budget, not a wall clock.
    let mut source_config = live_sqlserver_config(&source_connection_id, &source_db);
    source_config.query_timeout_secs = 1;
    state.configs.write().await.insert(source_connection_id.clone(), source_config);
    state
        .configs
        .write()
        .await
        .insert(target_connection_id.clone(), live_sqlserver_config(&target_connection_id, &target_db));
    let source_pool_key = state.get_or_create_pool(&source_connection_id, Some(&source_db)).await.expect("source pool");
    let target_pool_key = state.get_or_create_pool(&target_connection_id, Some(&target_db)).await.expect("target pool");

    let request = TransferRequest {
        table_filters: std::collections::HashMap::new(),
        transfer_id: format!("live-sqlserver-progress-{suffix}"),
        source_connection_id: source_connection_id.clone(),
        source_database: source_db.clone(),
        source_schema: "dbo".to_string(),
        source_catalog: None,
        target_connection_id: target_connection_id.clone(),
        target_database: target_db.clone(),
        target_schema: "dbo".to_string(),
        target_catalog: None,
        tables: vec!["big".to_string()],
        create_table: true,
        drop_target_before_create: false,
        drop_target_confirmed: false,
        oracle_packages: None,
        content: TransferContent::default(),
        objects: Some(Vec::new()),
        mode: TransferMode::Append,
        target_table_name_case: TransferTableNameCase::Preserve,
        target_column_name_case: TransferColumnNameCase::Preserve,
        quote_target_column_names: true,
        ownership_policy: TransferOwnershipPolicy::Preserve,
        batch_size: 10000,
    };

    let test_result = async {
        let transferred = transfer_table(
            &state,
            &request,
            "big",
            0,
            &DatabaseType::SqlServer,
            &DatabaseType::SqlServer,
            &source_pool_key,
            &target_pool_key,
            &HashMap::new(),
            &mut Vec::new(),
            None,
            |_| {},
        )
        .await?;
        assert_eq!(transferred, 20000, "the whole table must be transferred across multiple pages without timing out");

        let mut target_client = sqlserver_connect(&target_db).await;
        let count = dbx_core::db::sqlserver::execute_query(&mut target_client, "SELECT COUNT(*) FROM dbo.big")
            .await
            .expect("count target rows");
        assert_eq!(count.rows[0][0].as_i64(), Some(20000), "no row may be dropped or duplicated");
        Ok::<_, String>(())
    }
    .await;

    let cleanup = dbx_core::db::sqlserver::execute_batch(
        &mut master,
        &format!(
            "ALTER DATABASE [{source_db}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE [{source_db}]; \
             ALTER DATABASE [{target_db}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE [{target_db}];"
        ),
    )
    .await;
    let _ = std::fs::remove_dir_all(dir);
    cleanup.expect("drop progress databases");
    test_result.unwrap();
}

#[tokio::test]
#[ignore = "requires DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at SQL Server"]
async fn live_sqlserver_keyset_uniqueidentifier_datetime2_composite_key() {
    let suffix = uuid::Uuid::new_v4().simple().to_string();
    let source_db = format!("dbx_typed_src_{}", &suffix[..12]);
    let target_db = format!("dbx_typed_dst_{}", &suffix[..12]);
    let source_connection_id = format!("live-sqlserver-typed-src-{suffix}");
    let target_connection_id = format!("live-sqlserver-typed-dst-{suffix}");

    let mut master = sqlserver_connect("master").await;
    dbx_core::db::sqlserver::execute_batch(
        &mut master,
        &format!("CREATE DATABASE [{source_db}]; CREATE DATABASE [{target_db}];"),
    )
    .await
    .expect("create typed databases");

    let mut source_client = sqlserver_connect(&source_db).await;
    dbx_core::db::sqlserver::execute_batch(
        &mut source_client,
        "CREATE TABLE dbo.typed_key ( \
             uid UNIQUEIDENTIFIER NOT NULL, \
             ts DATETIME2(3) NOT NULL, \
             name NVARCHAR(32) NOT NULL, \
             CONSTRAINT PK_typed_key PRIMARY KEY (uid, ts) \
         ); \
         INSERT INTO dbo.typed_key (uid, ts, name) VALUES \
             ('00000000-0000-0000-0000-000000000001', '2024-01-01 00:00:00.000', N'a'), \
             ('00000000-0000-0000-0000-000000000002', '2024-01-02 00:00:00.000', N'b'), \
             ('00000000-0000-0000-0000-000000000003', '2024-01-03 00:00:00.000', N'c'), \
             ('00000000-0000-0000-0000-000000000004', '2024-01-04 00:00:00.000', N'd'), \
             ('00000000-0000-0000-0000-000000000005', '2024-01-05 00:00:00.000', N'e'), \
             ('00000000-0000-0000-0000-000000000006', '2024-01-06 00:00:00.000', N'f'), \
             ('00000000-0000-0000-0000-000000000007', '2024-01-07 00:00:00.000', N'g'), \
             ('00000000-0000-0000-0000-000000000008', '2024-01-08 00:00:00.000', N'h');",
    )
    .await
    .expect("create source typed table");

    let dir = std::env::temp_dir().join(format!("dbx-live-sqlserver-typed-{suffix}"));
    std::fs::create_dir_all(&dir).expect("create typed directory");
    let storage = dbx_core::persistence::test_storage::open(&dir.join("storage.db")).await.expect("open typed storage");
    let state = Arc::new(AppState::new(storage));
    state
        .configs
        .write()
        .await
        .insert(source_connection_id.clone(), live_sqlserver_config(&source_connection_id, &source_db));
    state
        .configs
        .write()
        .await
        .insert(target_connection_id.clone(), live_sqlserver_config(&target_connection_id, &target_db));
    let source_pool_key = state.get_or_create_pool(&source_connection_id, Some(&source_db)).await.expect("source pool");
    let target_pool_key = state.get_or_create_pool(&target_connection_id, Some(&target_db)).await.expect("target pool");

    let request = TransferRequest {
        table_filters: std::collections::HashMap::new(),
        transfer_id: format!("live-sqlserver-typed-{suffix}"),
        source_connection_id: source_connection_id.clone(),
        source_database: source_db.clone(),
        source_schema: "dbo".to_string(),
        source_catalog: None,
        target_connection_id: target_connection_id.clone(),
        target_database: target_db.clone(),
        target_schema: "dbo".to_string(),
        target_catalog: None,
        tables: vec!["typed_key".to_string()],
        create_table: true,
        drop_target_before_create: false,
        drop_target_confirmed: false,
        oracle_packages: None,
        content: TransferContent::default(),
        objects: Some(Vec::new()),
        mode: TransferMode::Append,
        target_table_name_case: TransferTableNameCase::Preserve,
        target_column_name_case: TransferColumnNameCase::Preserve,
        quote_target_column_names: true,
        ownership_policy: TransferOwnershipPolicy::Preserve,
        batch_size: 3,
    };

    let test_result = async {
        let transferred = transfer_table(
            &state,
            &request,
            "typed_key",
            0,
            &DatabaseType::SqlServer,
            &DatabaseType::SqlServer,
            &source_pool_key,
            &target_pool_key,
            &HashMap::new(),
            &mut Vec::new(),
            None,
            |_| {},
        )
        .await?;
        assert_eq!(transferred, 8, "keyset pagination must copy every typed row");

        let mut target_client = sqlserver_connect(&target_db).await;
        let rows = dbx_core::db::sqlserver::execute_query(
            &mut target_client,
            "SELECT LOWER(CAST(uid AS VARCHAR(36))) FROM dbo.typed_key ORDER BY uid",
        )
        .await
        .expect("read target uids");
        let collected: Vec<String> = rows.rows.iter().map(|row| row[0].as_str().unwrap().to_string()).collect();
        let expected: Vec<String> = (1..=8).map(|i| format!("00000000-0000-0000-0000-{i:012}")).collect();
        assert_eq!(collected, expected, "uniqueidentifier + datetime2 keyset cursor must round-trip every row");
        Ok::<_, String>(())
    }
    .await;

    let cleanup = dbx_core::db::sqlserver::execute_batch(
        &mut master,
        &format!(
            "ALTER DATABASE [{source_db}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE [{source_db}]; \
             ALTER DATABASE [{target_db}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE [{target_db}];"
        ),
    )
    .await;
    let _ = std::fs::remove_dir_all(dir);
    cleanup.expect("drop typed databases");
    test_result.unwrap();
}

/// User report (SQL Server 数据同步 / issue #9734 family): transferring a SQL Server
/// table into a **new** target database reuses the source `CREATE TABLE` DDL, so the
/// created target keeps its `IDENTITY` column. The batched INSERT then writes explicit
/// identity values and SQL Server rejects the batch with 544 unless the write is wrapped
/// in `SET IDENTITY_INSERT`.
#[tokio::test]
#[ignore = "requires DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at SQL Server"]
async fn live_sqlserver_transfer_new_identity_target_keeps_explicit_identity_values() {
    let suffix = uuid::Uuid::new_v4().simple().to_string();
    let source_db = format!("dbx_identity_src_{}", &suffix[..12]);
    let target_db = format!("dbx_identity_dst_{}", &suffix[..12]);
    let connection_id = format!("live-sqlserver-identity-{suffix}");
    let table = "daq_electest";

    let mut master = sqlserver_connect("master").await;
    dbx_core::db::sqlserver::execute_batch(
        &mut master,
        &format!("CREATE DATABASE [{source_db}]; CREATE DATABASE [{target_db}];"),
    )
    .await
    .expect("create identity databases");

    let mut source_client = sqlserver_connect(&source_db).await;
    dbx_core::db::sqlserver::execute_batch(
        &mut source_client,
        &format!(
            "CREATE TABLE dbo.[{table}] ( \
                id INT IDENTITY(1,1) NOT NULL CONSTRAINT [PK_daq_electest] PRIMARY KEY, \
                name NVARCHAR(64) NOT NULL); \
             INSERT INTO dbo.[{table}] (name) VALUES (N'first'), (N'second');"
        ),
    )
    .await
    .expect("create identity source table");

    let dir = std::env::temp_dir().join(format!("dbx-live-sqlserver-identity-{suffix}"));
    std::fs::create_dir_all(&dir).expect("create identity directory");
    let storage =
        dbx_core::persistence::test_storage::open(&dir.join("storage.db")).await.expect("open identity storage");
    let state = Arc::new(AppState::new(storage));
    state.configs.write().await.insert(connection_id.clone(), live_sqlserver_config(&connection_id, &source_db));
    let source_pool_key = state.get_or_create_pool(&connection_id, Some(&source_db)).await.expect("source pool");
    let target_pool_key = state.get_or_create_pool(&connection_id, Some(&target_db)).await.expect("target pool");

    let request = TransferRequest {
        table_filters: std::collections::HashMap::new(),
        transfer_id: format!("live-sqlserver-identity-{suffix}"),
        source_connection_id: connection_id.clone(),
        source_database: source_db.clone(),
        source_schema: "dbo".to_string(),
        source_catalog: None,
        target_connection_id: connection_id.clone(),
        target_database: target_db.clone(),
        target_schema: "dbo".to_string(),
        target_catalog: None,
        tables: vec![table.to_string()],
        create_table: true,
        drop_target_before_create: false,
        drop_target_confirmed: false,
        oracle_packages: None,
        content: TransferContent::default(),
        objects: Some(Vec::new()),
        mode: TransferMode::Append,
        target_table_name_case: TransferTableNameCase::Preserve,
        target_column_name_case: TransferColumnNameCase::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,
            &source_pool_key,
            &target_pool_key,
            &HashMap::new(),
            &mut Vec::new(),
            None,
            |_| {},
        )
        .await?;
        assert_eq!(transferred, 2);

        let mut target_client = sqlserver_connect(&target_db).await;
        let rows = dbx_core::db::sqlserver::execute_query(
            &mut target_client,
            &format!("SELECT id, name FROM dbo.[{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(1));
        assert_eq!(rows.rows[1][0].as_i64(), Some(2));
        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 master,
        &format!(
            "ALTER DATABASE [{source_db}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE [{source_db}]; \
             ALTER DATABASE [{target_db}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE [{target_db}];"
        ),
    )
    .await;
    let _ = std::fs::remove_dir_all(dir);
    cleanup.expect("drop identity databases");
    test_result.expect("transfer into a freshly created identity target must keep the source identity values");
}

/// User report (issue #9729): DBX's **database export** emitted one `CONSTRAINT` line per
/// column of a composite foreign key, all sharing the source constraint name. SQL Server
/// requires constraint names to be unique in the schema, so replaying the exported script
/// failed with 8168 (`名称不允许重复`) — the user hit it while importing `test1.sql`.
///
/// This drives the real export path against a real SQL Server and replays the produced
/// script into a fresh database, which is exactly what the user did by hand.
#[tokio::test]
#[ignore = "requires DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at SQL Server"]
async fn live_sqlserver_database_export_replays_composite_foreign_keys() {
    use dbx_core::data::database_export::{export_database_sql_core, DatabaseExportRequest};

    let suffix = uuid::Uuid::new_v4().simple().to_string();
    let source_db = format!("dbx_export_src_{}", &suffix[..12]);
    let target_db = format!("dbx_export_dst_{}", &suffix[..12]);
    let connection_id = format!("live-sqlserver-export-{suffix}");

    let mut master = sqlserver_connect("master").await;
    dbx_core::db::sqlserver::execute_batch(
        &mut master,
        &format!("CREATE DATABASE [{source_db}]; CREATE DATABASE [{target_db}];"),
    )
    .await
    .expect("create export databases");

    let mut source_client = sqlserver_connect(&source_db).await;
    dbx_core::db::sqlserver::execute_batch(
        &mut source_client,
        "CREATE TABLE dbo.QRTZ_JOB_DETAILS ( \
             sched_name NVARCHAR(100) NOT NULL, \
             job_name NVARCHAR(170) NOT NULL, \
             job_group NVARCHAR(170) NOT NULL, \
             description NVARCHAR(250) NULL, \
             CONSTRAINT PK_QRTZ_JOB_DETAILS PRIMARY KEY (sched_name, job_name, job_group)); \
         CREATE TABLE dbo.QRTZ_TRIGGERS ( \
             sched_name NVARCHAR(100) NOT NULL, \
             trigger_name NVARCHAR(170) NOT NULL, \
             trigger_group NVARCHAR(170) NOT NULL, \
             job_name NVARCHAR(170) NOT NULL, \
             job_group NVARCHAR(170) NOT NULL, \
             description NVARCHAR(250) NULL, \
             next_fire_time BIGINT NULL, \
             PRIMARY KEY (sched_name, trigger_name, trigger_group), \
             CONSTRAINT [FK_QRTRZ_TRIGGERS_JOB_DETAILS] FOREIGN KEY (sched_name, job_name, job_group) \
                 REFERENCES dbo.QRTZ_JOB_DETAILS (sched_name, job_name, job_group)); \
         INSERT INTO dbo.QRTZ_JOB_DETAILS (sched_name, job_name, job_group, description) \
             VALUES (N'sched', N'job', N'group', N'quartz job'); \
         INSERT INTO dbo.QRTZ_TRIGGERS (sched_name, trigger_name, trigger_group, job_name, job_group, next_fire_time) \
             VALUES (N'sched', N'trigger', N'group', N'job', N'group', 1700000000000);",
    )
    .await
    .expect("create QRTZ fixtures");

    let dir = std::env::temp_dir().join(format!("dbx-live-sqlserver-export-{suffix}"));
    std::fs::create_dir_all(&dir).expect("create export directory");
    let storage =
        dbx_core::persistence::test_storage::open(&dir.join("storage.db")).await.expect("open export storage");
    let state = Arc::new(AppState::new(storage));
    state.configs.write().await.insert(connection_id.clone(), live_sqlserver_config(&connection_id, &source_db));
    let _ = state.get_or_create_pool(&connection_id, Some(&source_db)).await.expect("export source pool");

    let export_path = dir.join("test1.sql");
    let request = DatabaseExportRequest {
        export_id: format!("live-sqlserver-export-{suffix}"),
        connection_id: connection_id.clone(),
        database: source_db.clone(),
        schema: "dbo".to_string(),
        file_path: export_path.to_string_lossy().into_owned(),
        selected_tables: vec!["QRTZ_JOB_DETAILS".to_string(), "QRTZ_TRIGGERS".to_string()],
        excluded_tables: Vec::new(),
        include_structure: true,
        include_data: true,
        include_objects: false,
        include_create_database: false,
        drop_table_if_exists: false,
        omit_auto_increment: false,
        preserve_original_language: false,
        fail_on_error: false,
        prevent_overwrite: false,
        output_compression: Default::default(),
        snapshot_session_id: None,
        insert_dialect: Default::default(),
        insert_mode: Default::default(),
        batch_size: 1000,
        split_max_mb: None,
    };

    let test_result = async {
        export_database_sql_core(&state, &request, |_| {}).await?;
        let script = std::fs::read_to_string(&export_path).map_err(|error| format!("read export script: {error}"))?;

        assert_eq!(
            script.matches("CONSTRAINT [FK_QRTRZ_TRIGGERS_JOB_DETAILS]").count(),
            1,
            "a composite foreign key must be exported as one constraint, not one per column:\n{script}"
        );
        assert!(
            script.contains(
                "CONSTRAINT [FK_QRTRZ_TRIGGERS_JOB_DETAILS] FOREIGN KEY ([sched_name], [job_name], [job_group]) \
                 REFERENCES [dbo].[QRTZ_JOB_DETAILS]([sched_name], [job_name], [job_group])"
            ),
            "composite foreign key columns must stay grouped:\n{script}"
        );

        // Replay: this is the step that used to fail with 8168.
        let mut target_client = sqlserver_connect(&target_db).await;
        for statement in script.split(";\n").map(str::trim).filter(|statement| !statement.is_empty()) {
            dbx_core::db::sqlserver::execute_batch(&mut target_client, statement)
                .await
                .map_err(|error| format!("replay failed on `{statement}`: {error}"))?;
        }

        let rows = dbx_core::db::sqlserver::execute_query(
            &mut target_client,
            "SELECT COUNT(*) FROM dbo.QRTZ_TRIGGERS t JOIN dbo.QRTZ_JOB_DETAILS j \
             ON t.sched_name = j.sched_name AND t.job_name = j.job_name AND t.job_group = j.job_group",
        )
        .await
        .map_err(|error| format!("read replayed rows: {error}"))?;
        assert_eq!(rows.rows[0][0].as_i64(), Some(1));
        Ok::<_, String>(())
    }
    .await;

    let cleanup = dbx_core::db::sqlserver::execute_batch(
        &mut master,
        &format!(
            "ALTER DATABASE [{source_db}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE [{source_db}]; \
             ALTER DATABASE [{target_db}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE [{target_db}];"
        ),
    )
    .await;
    let _ = std::fs::remove_dir_all(dir);
    cleanup.expect("drop export databases");
    test_result.expect("database export must replay a composite foreign key without 8168");
}

#[tokio::test]
#[ignore = "requires DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at SQL Server"]
async fn live_sqlserver_transfer_overwrite_replaces_tables_linked_by_foreign_keys() {
    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-11480-{suffix}");
    let source_schema = format!("dbx_11480_src_{}", &suffix[..12]);
    let target_schema = format!("dbx_11480_dst_{}", &suffix[..12]);

    let mut client = sqlserver_connect(&database).await;
    let mut fixtures = vec![format!("CREATE SCHEMA [{source_schema}]"), format!("CREATE SCHEMA [{target_schema}]")];
    for schema in [&source_schema, &target_schema] {
        fixtures.push(format!(
            "CREATE TABLE [{schema}].[job_details] (id INT NOT NULL CONSTRAINT [PK_11480_job_{schema}] PRIMARY KEY, name NVARCHAR(64) NOT NULL)"
        ));
        fixtures.push(format!(
            "CREATE TABLE [{schema}].[triggers] (id INT NOT NULL CONSTRAINT [PK_11480_trigger_{schema}] PRIMARY KEY, job_id INT NOT NULL \
             CONSTRAINT [FK_11480_{schema}] FOREIGN KEY REFERENCES [{schema}].[job_details] (id))"
        ));
    }
    fixtures.extend([
        format!("INSERT INTO [{source_schema}].[job_details] (id, name) VALUES (1, N'first'), (3, N'third')"),
        format!("INSERT INTO [{source_schema}].[triggers] (id, job_id) VALUES (10, 1), (30, 3)"),
        format!("INSERT INTO [{target_schema}].[job_details] (id, name) VALUES (1, N'stale'), (2, N'stale')"),
        format!("INSERT INTO [{target_schema}].[triggers] (id, job_id) VALUES (10, 1), (20, 2)"),
    ]);
    for statement in &fixtures {
        dbx_core::db::sqlserver::execute_batch(&mut client, statement).await.expect("create issue #11480 fixtures");
    }

    let dir = std::env::temp_dir().join(format!("dbx-live-sqlserver-11480-{suffix}"));
    std::fs::create_dir_all(&dir).expect("create issue #11480 directory");
    let storage =
        dbx_core::persistence::test_storage::open(&dir.join("storage.db")).await.expect("open issue #11480 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 {
        table_filters: HashMap::new(),
        transfer_id: format!("live-sqlserver-11480-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!["triggers".to_string(), "job_details".to_string()],
        create_table: false,
        drop_target_before_create: false,
        drop_target_confirmed: false,
        oracle_packages: None,
        content: TransferContent::DataOnly,
        objects: Some(Vec::new()),
        mode: TransferMode::Overwrite,
        target_table_name_case: TransferTableNameCase::Preserve,
        target_column_name_case: TransferColumnNameCase::Preserve,
        quote_target_column_names: true,
        ownership_policy: TransferOwnershipPolicy::Preserve,
        batch_size: 1000,
    };

    // Same sequence as the desktop and web transfer loops: parents first, with the
    // foreign-key-linked targets emptied children first beforehand.
    let test_result = async {
        let (tables, known_foreign_keys) = sort_tables_by_fk_dependency_with_foreign_keys(
            &state,
            &connection_id,
            &database,
            &source_schema,
            &request.tables,
            true,
        )
        .await?;
        let cleared =
            clear_foreign_key_linked_overwrite_targets(&state, &request, &tables, DatabaseType::SqlServer, &pool_key)
                .await?;
        assert_eq!(cleared.len(), 2, "both linked targets are cleared by the pre-pass");
        for (index, table) in tables.iter().enumerate() {
            transfer_table_with_result(
                &state,
                &request,
                table,
                index,
                &DatabaseType::SqlServer,
                &DatabaseType::SqlServer,
                &pool_key,
                &pool_key,
                &known_foreign_keys,
                &mut Vec::new(),
                None,
                cleared.contains(table),
                |_| {},
                |_| {},
            )
            .await?;
        }

        let jobs = dbx_core::db::sqlserver::execute_query(
            &mut client,
            &format!("SELECT id, name FROM [{target_schema}].[job_details] ORDER BY id"),
        )
        .await
        .map_err(|error| format!("read target jobs: {error}"))?;
        let triggers = dbx_core::db::sqlserver::execute_query(
            &mut client,
            &format!("SELECT id, job_id FROM [{target_schema}].[triggers] ORDER BY id"),
        )
        .await
        .map_err(|error| format!("read target triggers: {error}"))?;
        let jobs =
            jobs.rows.iter().map(|row| (row[0].as_i64(), row[1].as_str().map(str::to_string))).collect::<Vec<_>>();
        let triggers = triggers.rows.iter().map(|row| (row[0].as_i64(), row[1].as_i64())).collect::<Vec<_>>();
        assert_eq!(jobs, vec![(Some(1), Some("first".to_string())), (Some(3), Some("third".to_string()))]);
        assert_eq!(triggers, vec![(Some(10), Some(1)), (Some(30), Some(3))]);
        Ok::<_, String>(())
    }
    .await;

    let cleanup = dbx_core::db::sqlserver::execute_batch(
        &mut client,
        &format!(
            "IF OBJECT_ID(N'[{target_schema}].[triggers]', N'U') IS NOT NULL DROP TABLE [{target_schema}].[triggers]; \
             IF OBJECT_ID(N'[{target_schema}].[job_details]', N'U') IS NOT NULL DROP TABLE [{target_schema}].[job_details]; \
             IF OBJECT_ID(N'[{source_schema}].[triggers]', N'U') IS NOT NULL DROP TABLE [{source_schema}].[triggers]; \
             IF OBJECT_ID(N'[{source_schema}].[job_details]', N'U') IS NOT NULL DROP TABLE [{source_schema}].[job_details]; \
             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 #11480 fixtures");
    test_result.expect("SQL Server overwrite transfer should replace tables linked by foreign keys");
}