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): return full batch results and errors from legacy driver
zipg4ad6410ca37a
diff --git a/agents/drivers/sqlserver-legacy/src/main/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgent.java b/agents/drivers/sqlserver-legacy/src/main/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgent.javaindex b5826c8df5..6cced472c5 100644--- a/agents/drivers/sqlserver-legacy/src/main/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgent.java+++ b/agents/drivers/sqlserver-legacy/src/main/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgent.java@@ -147,8 +147,13 @@ public final class SqlServerLegacyAgent extends ConfiguredJdbcAgent {@Overridepublic List<QueryResult> executeQueryResults(String sql, String schema, ExecuteQueryOptions options) {Connection conn = getConnection();- if (!manualTransactionSession || conn == null) throw new IllegalStateException("No dedicated manual transaction connection");+ if (conn == null) throw new IllegalStateException("Not connected");return unchecked(() -> {+ if (!manualTransactionSession) {+ beforeQueryExecution(conn, options.getTimeoutSecs());+ return JdbcExecutor.current().executeAll(conn, sql, options.getMaxRows(),+ options.getFetchSize(), options.getTimeoutSecs(), resultValueReader());+ }if (conn.getAutoCommit()) throw new IllegalStateException("DBX_MANUAL_TRANSACTION_STATE_LOST: autoCommit changed");beforeQueryExecution(conn, options.getTimeoutSecs());int before = transactionCount(conn, options.getTimeoutSecs());diff --git a/agents/drivers/sqlserver-legacy/src/test/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgentTest.java b/agents/drivers/sqlserver-legacy/src/test/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgentTest.javaindex b498d12541..209e256dae 100644--- a/agents/drivers/sqlserver-legacy/src/test/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgentTest.java+++ b/agents/drivers/sqlserver-legacy/src/test/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgentTest.java@@ -27,6 +27,90 @@ import java.util.Locale;import java.util.Map;class SqlServerLegacyAgentTest {+ @Test+ void autoCommitBatchesCollectEveryResultAndUpdateCountOnce() {+ SqlServerLegacyAgent agent = new SqlServerLegacyAgent();+ java.util.concurrent.atomic.AtomicInteger index = new java.util.concurrent.atomic.AtomicInteger();+ java.util.concurrent.atomic.AtomicInteger executions = new java.util.concurrent.atomic.AtomicInteger();+ java.util.concurrent.atomic.AtomicInteger drained = new java.util.concurrent.atomic.AtomicInteger();+ ResultSet first = autoCommitRows(drained, 101, 102);+ ResultSet last = autoCommitRows(new java.util.concurrent.atomic.AtomicInteger(), 303);+ java.sql.Statement statement = proxy(java.sql.Statement.class, (method, args) -> {+ switch (method.getName()) {+ case "execute": executions.incrementAndGet(); return true;+ case "setMaxRows": throw new AssertionError("Do not cap the server's batch execution");+ case "getResultSet": return index.get() == 0 ? first : last;+ case "getMoreResults": return index.incrementAndGet() == 2;+ case "getUpdateCount": return index.get() == 1 ? 7 : -1;+ default: return defaultValue(method.getReturnType());+ }+ });+ TestSupport.setPrivateConnection(agent, proxy(Connection.class, (method, args) -> {+ if (method.getName().equals("createStatement")) return statement;+ if (method.getName().equals("getAutoCommit")) return true;+ if (method.getName().equals("commit") || method.getName().equals("rollback")) {+ throw new AssertionError("Auto-commit query must not commit/rollback implicitly");+ }+ return defaultValue(method.getReturnType());+ }));++ List<com.dbx.agent.QueryResult> results = agent.executeQueryResults(+ "SELECT 101; UPDATE t SET n=7; SELECT 303", null, new com.dbx.agent.ExecuteQueryOptions(1, null, 5));+ Assertions.assertEquals(1, executions.get());+ Assertions.assertEquals(3, results.size());+ Assertions.assertEquals(101, results.get(0).getRows().get(0).get(0));+ Assertions.assertTrue(results.get(0).getTruncated());+ Assertions.assertEquals(2, drained.get());+ Assertions.assertEquals(7, results.get(1).getAffected_rows());+ Assertions.assertEquals(303, results.get(2).getRows().get(0).get(0));+ Assertions.assertTrue(agent.permitsAutomaticReconnect());+ }++ @Test+ void autoCommitBatchPropagatesErrorsAfterTheFirstResult() {+ SqlServerLegacyAgent agent = new SqlServerLegacyAgent();+ java.util.concurrent.atomic.AtomicInteger executions = new java.util.concurrent.atomic.AtomicInteger();+ java.sql.Statement statement = proxy(java.sql.Statement.class, (method, args) -> {+ switch (method.getName()) {+ case "execute": executions.incrementAndGet(); return true;+ case "getResultSet": return autoCommitRows(new java.util.concurrent.atomic.AtomicInteger(), 101);+ case "getMoreResults": throw new SQLException("late batch error");+ default: return defaultValue(method.getReturnType());+ }+ });+ TestSupport.setPrivateConnection(agent, proxy(Connection.class, (method, args) -> {+ if (method.getName().equals("createStatement")) return statement;+ if (method.getName().equals("getAutoCommit")) return true;+ return defaultValue(method.getReturnType());+ }));+ RuntimeException error = Assertions.assertThrows(RuntimeException.class, () -> agent.executeQueryResults(+ "SELECT 101; RAISERROR('late batch error',16,1)", null, new com.dbx.agent.ExecuteQueryOptions(1, null, 5)));+ Assertions.assertTrue(error.getMessage().contains("late batch error"));+ Assertions.assertEquals(1, executions.get());+ }++ private static ResultSet autoCommitRows(java.util.concurrent.atomic.AtomicInteger drained, int... values) {+ java.sql.ResultSetMetaData metadata = proxy(java.sql.ResultSetMetaData.class, (method, args) -> {+ switch (method.getName()) {+ case "getColumnCount": return 1;+ case "getColumnLabel": return "n";+ case "getColumnType": return Types.INTEGER;+ case "getColumnTypeName": return "int";+ default: return defaultValue(method.getReturnType());+ }+ });+ java.util.concurrent.atomic.AtomicInteger row = new java.util.concurrent.atomic.AtomicInteger(-1);+ return proxy(ResultSet.class, (method, args) -> {+ switch (method.getName()) {+ case "next": if (row.incrementAndGet() >= values.length) return false; drained.incrementAndGet(); return true;+ case "getMetaData": return metadata;+ case "getObject":+ case "getInt": return values[row.get()];+ default: return defaultValue(method.getReturnType());+ }+ });+ }+private static final class ManualFixture {final SqlServerLegacyAgent agent = new SqlServerLegacyAgent();final java.util.concurrent.atomic.AtomicInteger count = new java.util.concurrent.atomic.AtomicInteger();diff --git a/crates/dbx-core/src/query/mod.rs b/crates/dbx-core/src/query/mod.rsindex fe45816660..66d758b492 100644--- a/crates/dbx-core/src/query/mod.rs+++ b/crates/dbx-core/src/query/mod.rs@@ -7,6 +7,7 @@ pub mod plugin_data;pub mod plugin_plan;pub mod query_cancel;pub mod redis_ops;+mod sqlserver_agent_batch;pub mod sqlserver_manual_transaction;pub mod two_phase_commit;@@ -3335,6 +3336,8 @@ async fn execute_multi_core_with_options_for_client_and_progress_typed_inner(};let compatibility_mode = connection_sql_compatibility_mode(state, &pool_key, db_type).await;+ let complete_sqlserver_agent_batch =+ is_sqlserver_agent && sqlserver_agent_batch::requires_complete_results(sql, &options);let execution_plan =query_execution_plan_with_compatibility(sql, db_type, is_sqlserver_agent, compatibility_mode.as_deref());let continue_on_error = options.continue_on_error && !execution_plan.stop_on_error;@@ -3412,6 +3415,7 @@ async fn execute_multi_core_with_options_for_client_and_progress_typed_inner(};if statements.len() == 1+ && !complete_sqlserver_agent_batch&& !mysql_single_statement_uses_batch_route(db_type,mysql_pool.is_some(),@@ -3476,24 +3480,56 @@ async fn execute_multi_core_with_options_for_client_and_progress_typed_inner());break;}- match execute_sql_statement_with_options_typed(- state,- connection_id,- database,- stmt,- schema,- cancel_token.clone(),- statement_options.clone(),- )- .await- {- Ok(r) => {- report_execute_multi_progress(progress.as_ref(), statement_index, statements.len(), &r, true, None);- results.push(ExecuteMultiResult::success_with_index_and_optional_server_large_values(- r,- statement_index,- options.table_data_preview,- ));+ let execution = if complete_sqlserver_agent_batch {+ Box::pin(sqlserver_agent_batch::execute(+ state,+ &pool_key,+ database,+ stmt,+ schema,+ cancel_token.clone(),+ statement_options.clone(),+ ))+ .await+ } else {+ execute_sql_statement_with_options_typed(+ state,+ connection_id,+ database,+ stmt,+ schema,+ cancel_token.clone(),+ statement_options.clone(),+ )+ .await+ .map(|result| vec![result])+ };+ match execution {+ Ok(batch_results) => {+ for result in batch_results {+ report_execute_multi_progress(+ progress.as_ref(),+ statement_index,+ statements.len(),+ &result,+ true,+ None,+ );+ results.push(if complete_sqlserver_agent_batch {+ // One GO batch can contain several statements/results;+ // do not label every result as its first statement.+ ExecuteMultiResult::success_with_optional_server_large_values(+ result,+ options.table_data_preview,+ )+ } else {+ ExecuteMultiResult::success_with_index_and_optional_server_large_values(+ result,+ statement_index,+ options.table_data_preview,+ )+ });+ }}Err(error) => {let action = query_execution_error_action(db_type, stmt, &error);@@ -8249,14 +8285,31 @@ for line in sys.stdin:print(json.dumps({'ready': True}), flush=True)for line in sys.stdin:req = json.loads(line)+ with open(sys.argv[1], 'a') as calls:+ calls.write(json.dumps(req) + '\n')if req['method'] == 'handshake':result = {'protocolVersion': 2, 'agentProtocolVersion': 2, 'capabilities': ['multi_session']}- elif req['method'] == 'execute_query':+ elif req['method'] in ('execute_query', 'execute_query_page'):result = {'columns': ['sql'], 'column_types': ['nvarchar'], 'column_sortables': [],'rows': [[req['params']['sql']]], 'affected_rows': 0, 'execution_time_ms': 1,'truncated': False, 'session_id': None, 'has_more': False}+ if req['params'].get('returnAllResults'):+ result = [result]+ sql = req['params']['sql']+ if 'RAISERROR' in sql:+ print(json.dumps({'jsonrpc':'2.0', 'id':req['id'], 'error': {+ 'code': -1, 'message': 'late SQL Server batch error', 'data': {+ 'category': 'sql', 'sqlState': 'S0001', 'vendorCode': 50000,+ 'retryable': False, 'sessionDisposition': 'keep', 'stage': 'execute'+ }}}), flush=True)+ continue+ if 'SELECT 101' in sql and 'SELECT 303' in sql:+ result = [dict(result[0], columns=[name], rows=rows) for name, rows in [+ ('first_result', [[101], [102], [103]]), ('second_result', [[202]]), ('third_result', [[303]])]]+ elif req['method'] == 'fetch_query_page':+ result = {'columns': ['next_page'], 'rows': [[2]], 'affected_rows': 0, 'execution_time_ms': 1}elif req['method'] in ('execute_batch', 'execute_transaction'):if req['params'].get('schema') is not None:print(json.dumps({@@ -8278,8 +8331,10 @@ for line in sys.stdin:let python = if cfg!(windows) { "python" } else { "python3" };let runtime = crate::db::agent_driver::AgentRuntimeClient::spawn(- crate::db::agent_driver::AgentLaunchSpec::new(python)- .with_args([script_path.to_string_lossy().to_string()]),+ crate::db::agent_driver::AgentLaunchSpec::new(python).with_args([+ script_path.to_string_lossy().to_string(),+ dir.join("calls.jsonl").to_string_lossy().to_string(),+ ]),"test",).await@@ -8332,6 +8387,172 @@ for line in sys.stdin:let _ = std::fs::remove_dir_all(dir);}+ fn sqlserver_agent_calls(dir: &std::path::Path) -> Vec<serde_json::Value> {+ std::fs::read_to_string(dir.join("calls.jsonl"))+ .unwrap()+ .lines()+ .map(|line| serde_json::from_str(line).unwrap())+ .filter(|request: &serde_json::Value| {+ matches!(request["method"].as_str(), Some("execute_query" | "execute_query_page" | "fetch_query_page"))+ })+ .collect()+ }++ #[tokio::test]+ async fn sqlserver_agent_multi_execution_collects_all_results_without_cursor_or_replay() {+ for page_size in [None, Some(100)] {+ let (state, dir, runtime) = sqlserver_agent_echo_state().await;+ let sql = "SELECT 101 AS first_result; SELECT 202 AS second_result; SELECT 303 AS third_result;";+ let results = execute_multi_core_with_options_for_client_and_progress_typed(+ &state,+ "conn-1",+ "",+ sql,+ None,+ None,+ QueryExecutionOptions { max_rows: Some(1), page_size, ..Default::default() },+ None,+ )+ .await+ .unwrap();+ assert_eq!(results.len(), 3);+ assert_eq!(results[0].result.rows, vec![vec![serde_json::json!(101)]]);+ assert!(results[0].result.truncated);+ assert_eq!(results[1].result.rows, vec![vec![serde_json::json!(202)]]);+ assert_eq!(results[2].result.rows, vec![vec![serde_json::json!(303)]]);+ assert!(results.iter().all(|result| result.statement_index.is_none()));+ let calls = sqlserver_agent_calls(&dir);+ assert_eq!(calls.len(), 1);+ assert_eq!(calls[0]["method"], "execute_query");+ assert_eq!(calls[0]["params"]["returnAllResults"], true);+ assert_eq!(calls[0]["params"]["sql"], sql);+ assert_eq!(calls[0]["params"]["maxRows"], 1);+ runtime.kill();+ drop(state);+ let _ = std::fs::remove_dir_all(dir);+ }+ }++ #[tokio::test]+ async fn sqlserver_agent_multi_execution_keeps_go_batches_and_variable_scope() {+ let (state, dir, runtime) = sqlserver_agent_echo_state().await;+ let first = "DECLARE @n INT; SET @n=1; SELECT @n;";+ let second = "SELECT 2 AS n;";+ let results = execute_multi_core_with_options_for_client_and_progress_typed(+ &state,+ "conn-1",+ "",+ &format!("{first}\nGO\n{second}"),+ None,+ None,+ QueryExecutionOptions::default(),+ None,+ )+ .await+ .unwrap();+ assert_eq!(results.len(), 2);+ let calls = sqlserver_agent_calls(&dir);+ assert_eq!(calls.len(), 2);+ assert_eq!(calls[0]["params"]["sql"], first);+ assert_eq!(calls[1]["params"]["sql"], second);+ assert!(calls.iter().all(|call| call["params"]["returnAllResults"] == true));+ runtime.kill();+ drop(state);+ let _ = std::fs::remove_dir_all(dir);+ }++ #[tokio::test]+ async fn sqlserver_agent_multi_execution_preserves_errors_and_go_continue_policy() {+ for continue_on_error in [false, true] {+ let (state, dir, runtime) = sqlserver_agent_echo_state().await;+ let results = execute_multi_core_with_options_for_client_and_progress_typed(+ &state,+ "conn-1",+ "",+ "SELECT 1; RAISERROR('late',16,1);\nGO\nSELECT 2;",+ None,+ None,+ QueryExecutionOptions { continue_on_error, ..Default::default() },+ None,+ )+ .await+ .unwrap();+ assert!(results[0].execution_error);+ assert!(results[0].result.rows[0][0].as_str().unwrap().contains("late SQL Server batch error"));+ assert!(results[0].error.is_some());+ assert_eq!(results.len(), if continue_on_error { 2 } else { 1 });+ assert_eq!(sqlserver_agent_calls(&dir).len(), if continue_on_error { 2 } else { 1 });+ assert!(matches!(state.pool_handle("conn-1").await, Some(PoolKind::Agent(_))));+ runtime.kill();+ drop(state);+ let _ = std::fs::remove_dir_all(dir);+ }+ }++ #[tokio::test]+ async fn sqlserver_agent_multi_execution_preserves_single_query_and_fetch_cursors() {+ for session_id in [None, Some("cursor-1".to_string())] {+ let (state, dir, runtime) = sqlserver_agent_echo_state().await;+ let results = execute_multi_core_with_options_for_client_and_progress_typed(+ &state,+ "conn-1",+ "",+ "SELECT 1 AS n;",+ None,+ None,+ QueryExecutionOptions {+ page_size: Some(100),+ result_session_id: session_id.clone(),+ ..Default::default()+ },+ None,+ )+ .await+ .unwrap();+ assert_eq!(results.len(), 1);+ let calls = sqlserver_agent_calls(&dir);+ assert_eq!(calls.len(), 1);+ assert_eq!(+ calls[0]["method"],+ if session_id.is_some() { "fetch_query_page" } else { "execute_query_page" }+ );+ assert!(calls[0]["params"].get("returnAllResults").is_none());+ runtime.kill();+ drop(state);+ let _ = std::fs::remove_dir_all(dir);+ }+ }++ #[tokio::test]+ async fn sqlserver_agent_multi_execution_preserves_read_only_and_pre_dispatch_cancel() {+ for read_only in [true, false] {+ let (state, dir, runtime) = sqlserver_agent_echo_state().await;+ state.configs.write().await.get_mut("conn-1").unwrap().read_only = read_only;+ let cancel = CancellationToken::new();+ if !read_only {+ cancel.cancel();+ }+ let results = execute_multi_core_with_options_for_client_and_progress_typed(+ &state,+ "conn-1",+ "",+ "SELECT 1; UPDATE users SET n=2;",+ None,+ Some(cancel),+ QueryExecutionOptions::default(),+ None,+ )+ .await+ .unwrap();+ assert_eq!(results.len(), 1);+ assert!(results[0].execution_error);+ assert!(sqlserver_agent_calls(&dir).is_empty());+ runtime.kill();+ drop(state);+ let _ = std::fs::remove_dir_all(dir);+ }+ }+#[tokio::test]async fn sqlserver_agent_write_paths_do_not_request_schema_switch() {let (state, dir, runtime) = sqlserver_agent_echo_state().await;diff --git a/crates/dbx-core/src/query/sqlserver_agent_batch.rs b/crates/dbx-core/src/query/sqlserver_agent_batch.rsnew file mode 100644index 0000000000..a45e14edd8--- /dev/null+++ b/crates/dbx-core/src/query/sqlserver_agent_batch.rs@@ -0,0 +1,107 @@+//! SQL Server Agent batches keep their variable scope and consume every JDBC+//! response. A cursor session still owns a single SELECT's pagination.+use super::*;++pub(super) fn requires_complete_results(sql: &str, options: &QueryExecutionOptions) -> bool {+ if options.result_session_id.is_some() {+ return false;+ }+ if options.page_size.is_none() {+ return true;+ }+ // Cursor fallback can also be requested for scripts that the pagination+ // parser cannot rewrite. Only a single query can safely own that cursor;+ // DECLARE/EXEC/GO and multiple SELECTs must collect the whole batch instead.+ !matches!(Parser::parse_sql(&MsSqlDialect {}, sql).as_deref(), Ok([Statement::Query(_)]))+}++pub(super) async fn execute(+ state: &AppState,+ pool_key: &str,+ database: &str,+ sql: &str,+ schema: Option<&str>,+ cancel_token: Option<CancellationToken>,+ options: QueryExecutionOptions,+) -> Result<Vec<db::QueryResult>, QueryExecutionError> {+ check_read_only_for_connection(state, pool_key, sql).await?;+ let client = match state.pool_handle(pool_key).await {+ Some(PoolKind::Agent(client)) => client,+ _ => return Err("SQL Server Agent connection is no longer available".into()),+ };+ let execution_sql = sql_for_execution_context_with_identifier_quote(+ Some(DatabaseType::SqlServer),+ sql,+ schema,+ client.identifier_quote(),+ );+ let mut params = agent_execute_query_params(+ &execution_sql,+ Some(database),+ schema_for_execution_context(Some(DatabaseType::SqlServer), schema),+ options.clone(),+ );+ params["returnAllResults"] = serde_json::json!(true);+ let result: Result<Vec<db::QueryResult>, AgentCallError> = async {+ let lock_started = std::time::Instant::now();+ let mut locked = match cancel_token.as_ref() {+ Some(token) => {+ tokio::select! {+ biased;+ _ = token.cancelled() => return Err(AgentCallError::Canceled {+ stage: AgentErrorStage::Cancel,+ operation_outcome: AgentOperationOutcome::Unknown,+ }),+ guard = client.lock() => guard,+ }+ }+ None => client.lock().await,+ };+ let lock_ms = lock_started.elapsed().as_secs_f64() * 1000.0;+ let results: Vec<db::QueryResult> = locked+ .execute_query_typed_with_timeout_and_cancel(+ params,+ resolve_query_timeout(options.timeout_secs),+ cancel_token.clone(),+ )+ .await?;+ Ok(results+ .into_iter()+ .map(|mut result| {+ if let Some(timings) = result.query_timings_ms.as_mut() {+ timings.insert("core_lock".into(), lock_ms);+ }+ truncate_result_with_max_rows(result, options.max_rows)+ })+ .collect())+ }+ .await;+ if let Err(error) = result.as_ref() {+ discard_agent_pool_after_typed_error(state, pool_key, &client, error, RecoveryScope::UserOperation).await;+ }+ result.map_err(Into::into)+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn sqlserver_agent_complete_results_keeps_single_query_cursors() {+ let options = QueryExecutionOptions { page_size: Some(100), ..Default::default() };+ for sql in ["SELECT id FROM users;", "WITH t AS (SELECT 1 AS n) SELECT n FROM t;", "SELECT ';' AS text;"] {+ assert!(!requires_complete_results(sql, &options), "{sql}");+ }+ for sql in [+ "SELECT 1; SELECT 2;",+ "DECLARE @n INT; SET @n=1; SELECT @n;",+ "EXEC dbo.multi_results;",+ "SELECT 1\nGO\nSELECT 2",+ ] {+ assert!(requires_complete_results(sql, &options), "{sql}");+ }+ assert!(requires_complete_results("SELECT 1", &QueryExecutionOptions::default()));+ let fetch = QueryExecutionOptions { result_session_id: Some("cursor".into()), ..options };+ assert!(!requires_complete_results("SELECT 1; SELECT 2;", &fetch));+ }+}diff --git a/crates/dbx-core/tests/live_sqlserver_legacy_batch_results.rs b/crates/dbx-core/tests/live_sqlserver_legacy_batch_results.rsnew file mode 100644index 0000000000..876f7a65ab--- /dev/null+++ b/crates/dbx-core/tests/live_sqlserver_legacy_batch_results.rs@@ -0,0 +1,119 @@+//! Opt-in coverage for the core -> rebuilt SQL Server Agent -> real server path.+use dbx_core::connection::AppState;+use dbx_core::models::connection::ConnectionConfig;+use dbx_core::query::{execute_multi_core_with_options_for_client, QueryExecutionOptions};+use serde_json::json;++#[tokio::test]+#[ignore = "requires DBX_TEST_SQLSERVER_HOST/PASSWORD, DBX_TEST_SQLSERVER_AGENT_JAR and DBX_TEST_SQLSERVER_JAVA"]+async fn sqlserver_legacy_auto_commit_keeps_all_results_scope_and_late_errors() {+ let host = std::env::var("DBX_TEST_SQLSERVER_HOST").expect("SQL Server test host");+ let password = std::env::var("DBX_TEST_SQLSERVER_PASSWORD").expect("SQL Server test password");+ let database = std::env::var("DBX_TEST_SQLSERVER_DATABASE").unwrap_or_else(|_| "tempdb".into());+ let config: ConnectionConfig = serde_json::from_value(json!({+ "id":"legacy-batch-live", "name":"SQL Server legacy batch live test", "db_type":"sqlserver",+ "driver_profile":"sqlserver-legacy", "host":host,+ "port":std::env::var("DBX_TEST_SQLSERVER_PORT").ok().and_then(|p| p.parse::<u16>().ok()).unwrap_or(1433),+ "port_explicit":true, "username":std::env::var("DBX_TEST_SQLSERVER_USER").unwrap_or_else(|_| "sa".into()),+ "password":password, "database":database,+ "url_params":std::env::var("DBX_TEST_SQLSERVER_URL_PARAMS").ok(),+ "connect_timeout_secs":10, "query_timeout_secs":30, "keepalive_interval_secs":0+ }))+ .unwrap();+ let dir = tempfile::tempdir().unwrap();+ let storage = dbx_core::persistence::test_storage::open(&dir.path().join("state.db")).await.unwrap();+ let state = AppState::new_with_plugin_and_agent_dir_and_app_version(+ storage,+ dir.path().join("plugins"),+ dir.path().join("agents"),+ "0.6.37",+ );+ let jar = std::env::var("DBX_TEST_SQLSERVER_AGENT_JAR").expect("rebuilt SQL Server Agent JAR");+ dbx_core::agent_service::import_agent_jar(&state.agent_manager, "sqlserver-legacy", std::path::Path::new(&jar))+ .await+ .unwrap();+ state+ .agent_manager+ .mutate_state(|manager| {+ manager.java_runtime = dbx_core::agent_manager::JavaRuntimeConfig {+ mode: dbx_core::agent_manager::JavaRuntimeMode::Custom,+ custom_java_path: Some(std::env::var("DBX_TEST_SQLSERVER_JAVA").expect("Java 21 executable")),+ };+ })+ .unwrap();+ state.configs.write().await.insert(config.id.clone(), config.clone());++ // Pin every execution to the test connection so the private temp table+ // measures whether a batch was replayed while collecting later results.+ let options = QueryExecutionOptions { client_session_id: Some("legacy-batch-live".into()), ..Default::default() };+ let sql = "SELECT 101 AS first_result; SELECT 202 AS second_result; SELECT 303 AS third_result;";+ for page_size in [None, Some(100)] {+ let results = execute_multi_core_with_options_for_client(+ &state,+ &config.id,+ &database,+ sql,+ Some("dbo"),+ None,+ QueryExecutionOptions { page_size, ..options.clone() },+ )+ .await+ .unwrap();+ let rows: Vec<_> = results.iter().filter(|result| !result.result.columns.is_empty()).collect();+ assert_eq!(rows.len(), 3);+ for (result, expected) in rows.iter().zip([101, 202, 303]) {+ assert_eq!(result.result.rows, vec![vec![json!(expected)]]);+ }+ }+ let scope = execute_multi_core_with_options_for_client(+ &state, &config.id, &database,+ "DECLARE @rows TABLE (n INT); INSERT INTO @rows VALUES (1),(2),(3); SELECT n FROM @rows ORDER BY n; SELECT COUNT(*) AS total FROM @rows;",+ None, None, QueryExecutionOptions { max_rows: Some(1), ..options.clone() },+ ).await.unwrap();+ let rows: Vec<_> = scope.iter().filter(|result| !result.result.columns.is_empty()).collect();+ assert_eq!(rows.len(), 2);+ assert_eq!(rows[0].result.rows, vec![vec![json!(1)]]);+ assert!(rows[0].result.truncated);+ assert_eq!(rows[1].result.rows, vec![vec![json!(3)]]);++ let temp = execute_multi_core_with_options_for_client(+ &state, &config.id, &database,+ "CREATE TABLE #dbx_batch_counter (n INT); INSERT INTO #dbx_batch_counter VALUES (0); UPDATE #dbx_batch_counter SET n=n+1; SELECT n AS first FROM #dbx_batch_counter; UPDATE #dbx_batch_counter SET n=n+1; SELECT n AS second FROM #dbx_batch_counter;",+ None, None, options.clone(),+ ).await.unwrap();+ assert_eq!(temp.iter().map(|result| result.result.affected_rows).sum::<u64>(), 3);+ let rows: Vec<_> = temp.iter().filter(|result| !result.result.columns.is_empty()).collect();+ assert_eq!(rows[0].result.rows, vec![vec![json!(1)]]);+ assert_eq!(rows[1].result.rows, vec![vec![json!(2)]]);++ let go = execute_multi_core_with_options_for_client(+ &state,+ &config.id,+ &database,+ "SELECT 1 AS n;\nGO\nSELECT 2 AS n;",+ None,+ None,+ options.clone(),+ )+ .await+ .unwrap();+ assert_eq!(go.len(), 2);+ assert_eq!(go[0].result.rows, vec![vec![json!(1)]]);+ assert_eq!(go[1].result.rows, vec![vec![json!(2)]]);++ let error = execute_multi_core_with_options_for_client(+ &state,+ &config.id,+ &database,+ "SELECT 1 AS n; RAISERROR('DBX batch late error',16,1);",+ None,+ None,+ options.clone(),+ )+ .await+ .unwrap();+ assert_eq!(error.len(), 1);+ assert!(error[0].execution_error);+ assert!(error[0].result.rows[0][0].as_str().unwrap().contains("DBX batch late error"));+ state.close_client_session_pool(&config.id, Some(&database), "legacy-batch-live").await.unwrap();+}