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): 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.java
index 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 {
@Override
public 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.java
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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();
+}