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。

feat(query): stream PostgreSQL notices and capture Kingbase messages

t8y212b16cb026bd
diff --git a/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java b/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java
index 41ae65634f..6bc97aac73 100644
--- a/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java
+++ b/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java
@@ -589,10 +589,12 @@ public final class JdbcExecutor {
Math.max(options.getMaxRows(), 1),
statementMessageReader
);
+ } else {
+ appendStatementWarnings(result, stmt);
}
activeStatements.remove(stmt);
stmt.close();
- return new QueryPageResult(
+ QueryPageResult page = new QueryPageResult(
result.getColumns(),
result.getColumn_types(),
result.getRows(),
@@ -602,6 +604,8 @@ public final class JdbcExecutor {
null,
false
);
+ page.setMessages(result.getMessages());
+ return page;
}
phaseStarted = System.nanoTime();
@@ -926,8 +930,9 @@ public final class JdbcExecutor {
while (rows.size() < effectivePageSize && session.rowsRead < session.maxRows) {
if (!session.resultSet.next()) {
+ QueryPageResult page = sessionPageResult(session, rows, executionTimeMs, false, null, false);
closeSession(targetSessions, session.id);
- return sessionPageResult(session, rows, executionTimeMs, false, null, false);
+ return page;
}
rows.add(rowValues(session.resultSet, session.valueReader, session.sqlTypeByIndex, session.typeNameByIndex));
session.rowsRead += 1;
@@ -935,14 +940,16 @@ public final class JdbcExecutor {
if (session.rowsRead >= session.maxRows) {
boolean truncated = session.resultSet.next();
+ QueryPageResult page = sessionPageResult(session, rows, executionTimeMs, truncated, null, false);
closeSession(targetSessions, session.id);
- return sessionPageResult(session, rows, executionTimeMs, truncated, null, false);
+ return page;
}
boolean hasMore = session.resultSet.next();
if (!hasMore) {
+ QueryPageResult page = sessionPageResult(session, rows, executionTimeMs, false, null, false);
closeSession(targetSessions, session.id);
- return sessionPageResult(session, rows, executionTimeMs, false, null, false);
+ return page;
}
session.pendingRow = rowValues(session.resultSet, session.valueReader, session.sqlTypeByIndex, session.typeNameByIndex);
@@ -960,6 +967,9 @@ public final class JdbcExecutor {
boolean hasMore
) {
QueryPageResult result = new QueryPageResult(session.columns, session.columnTypes, rows, 0L, executionTimeMs, truncated, sessionId, hasMore);
+ QueryResult messages = new QueryResult();
+ appendStatementWarnings(messages, session.statement);
+ result.setMessages(messages.getMessages());
result.setCursor_rows_read(session.rowsRead);
return result;
}
@@ -1066,6 +1076,7 @@ public final class JdbcExecutor {
StatementMessageReader statementMessageReader
) {
if (!result.getColumns().isEmpty() || !result.getRows().isEmpty()) {
+ appendStatementWarnings(result, stmt);
return result;
}
@@ -1082,6 +1093,7 @@ public final class JdbcExecutor {
break;
}
rows.add(Collections.singletonList(message));
+ result.addInformationalMessage(message, warning.getSQLState());
}
}
stmt.clearWarnings();
@@ -1102,6 +1114,7 @@ public final class JdbcExecutor {
break;
}
rows.add(Collections.singletonList(message));
+ result.addInformationalMessage(message, null);
}
}
} catch (Exception ignored) {
@@ -1111,7 +1124,7 @@ public final class JdbcExecutor {
if (rows.isEmpty()) {
return result;
}
- return new QueryResult(
+ QueryResult messageResult = new QueryResult(
Collections.singletonList("Message"),
Collections.singletonList("nvarchar"),
rows,
@@ -1119,6 +1132,8 @@ public final class JdbcExecutor {
result.getExecution_time_ms(),
truncated
);
+ messageResult.setMessages(result.getMessages());
+ return messageResult;
}
private QueryResult emptyQueryResult(long start) {
diff --git a/agents/common/src/main/java/com/dbx/agent/QueryPageResult.java b/agents/common/src/main/java/com/dbx/agent/QueryPageResult.java
index 6e37e34af3..2af2f2e416 100644
--- a/agents/common/src/main/java/com/dbx/agent/QueryPageResult.java
+++ b/agents/common/src/main/java/com/dbx/agent/QueryPageResult.java
@@ -19,6 +19,15 @@ public final class QueryPageResult {
private boolean truncated;
private String session_id;
private boolean has_more;
+ private List<java.util.Map<String, Object>> messages;
+
+ public List<java.util.Map<String, Object>> getMessages() {
+ return messages == null ? Collections.emptyList() : messages;
+ }
+
+ public void setMessages(List<java.util.Map<String, Object>> messages) {
+ this.messages = messages;
+ }
public QueryPageResult() {
this(Collections.emptyList(), Collections.emptyList(), 0L, 0L, false, null, false);
diff --git a/agents/common/src/main/java/com/dbx/agent/QueryResult.java b/agents/common/src/main/java/com/dbx/agent/QueryResult.java
index af6549c594..e38b02e2c7 100644
--- a/agents/common/src/main/java/com/dbx/agent/QueryResult.java
+++ b/agents/common/src/main/java/com/dbx/agent/QueryResult.java
@@ -27,6 +27,10 @@ public final class QueryResult {
return messages == null ? Collections.emptyList() : messages;
}
+ public void setMessages(List<Map<String, Object>> messages) {
+ this.messages = messages;
+ }
+
public void addInformationalMessage(String message, String code) {
if (messages == null) messages = new ArrayList<>();
if (messages.size() >= 512) return;
diff --git a/agents/common/src/test/java/com/dbx/agent/JdbcExecutorTest.java b/agents/common/src/test/java/com/dbx/agent/JdbcExecutorTest.java
index 63be35e506..8ff05ac81b 100644
--- a/agents/common/src/test/java/com/dbx/agent/JdbcExecutorTest.java
+++ b/agents/common/src/test/java/com/dbx/agent/JdbcExecutorTest.java
@@ -300,7 +300,7 @@ class JdbcExecutorTest {
}
@Test
- void executePageKeepsWarningsHiddenWithoutADriverMessageReader() {
+ void executePageRetainsWarningsWithoutReplacingTheResult() {
QueryPageResult result = JdbcExecutor.INSTANCE.executePage(
executionConnection(
false,
@@ -318,6 +318,7 @@ class JdbcExecutorTest {
assertEquals(Collections.emptyList(), result.getColumns());
assertEquals(Collections.emptyList(), result.getRows());
+ assertEquals("existing paged warning", result.getMessages().get(0).get("message"));
}
@Test
@@ -332,6 +333,23 @@ class JdbcExecutorTest {
assertEquals(Arrays.asList("id", "name"), result.getColumns());
assertEquals(Arrays.asList(Arrays.asList(1, "Ada")), result.getRows());
+ assertEquals("informational", result.getMessages().get(0).get("message"));
+ }
+
+ @Test
+ void executePageRetainsWarningsWithOrdinaryRows() {
+ CountingResultSetFixture fixture = countingResultSet(new Object[][]{{1, "Ada"}});
+ QueryPageResult result = JdbcExecutor.INSTANCE.executePage(
+ executionConnection(true, -1, new SQLWarning("notice with rows"), new AtomicInteger(), fixture.resultSet(), null),
+ "SELECT id, name FROM people",
+ "",
+ schema -> "",
+ new QueryPageOptions()
+ );
+
+ assertEquals(Arrays.asList("id", "name"), result.getColumns());
+ assertEquals(Arrays.asList(Arrays.asList(1, "Ada")), result.getRows());
+ assertEquals("notice with rows", result.getMessages().get(0).get("message"));
}
@Test
diff --git a/agents/drivers/kingbase-go/integration_test.go b/agents/drivers/kingbase-go/integration_test.go
index dc96cc28b5..19290e0cee 100644
--- a/agents/drivers/kingbase-go/integration_test.go
+++ b/agents/drivers/kingbase-go/integration_test.go
@@ -10,6 +10,42 @@ import (
"time"
)
+func TestKingbaseQueryMessagesIntegration(t *testing.T) {
+ host := os.Getenv("KINGBASE_TEST_HOST")
+ portText := os.Getenv("KINGBASE_TEST_PORT")
+ username := os.Getenv("KINGBASE_TEST_USERNAME")
+ password := os.Getenv("KINGBASE_TEST_PASSWORD")
+ if host == "" || portText == "" || username == "" || password == "" {
+ t.Skip("Kingbase integration environment is not configured")
+ }
+ port, err := strconv.Atoi(portText)
+ if err != nil {
+ t.Fatal(err)
+ }
+ database := os.Getenv("KINGBASE_TEST_DATABASE")
+ if database == "" {
+ database = "test"
+ }
+ server := newServer()
+ if err := server.connect(connectParams{Host: host, Port: port, Database: database, Username: username, Password: password}); err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() { _ = server.disconnect() })
+ sql := "DO $$ BEGIN RAISE NOTICE '当前用户: %, 时间: %', current_user, now(); END $$"
+ result, err := server.executeQuery(queryOptions{SQL: sql})
+ if err != nil || len(result.Messages) != 1 || !strings.Contains(result.Messages[0].Message, "当前用户:") || result.Messages[0].Code != "00000" {
+ t.Fatalf("query notice missing: %+v, err=%v", result.Messages, err)
+ }
+ page, err := server.executeQueryPage(queryOptions{SQL: sql}, 10)
+ if err != nil || len(page.Messages) != 1 {
+ t.Fatalf("paged command lost notices: %+v, err=%v", page.Messages, err)
+ }
+ result, err = server.executeQuery(queryOptions{SQL: "SELECT 1"})
+ if err != nil || len(result.Messages) != 0 {
+ t.Fatalf("previous command notices leaked: %+v, err=%v", result.Messages, err)
+ }
+}
+
func TestKingbaseIntegration(t *testing.T) {
host := os.Getenv("KINGBASE_TEST_HOST")
portText := os.Getenv("KINGBASE_TEST_PORT")
diff --git a/agents/drivers/kingbase-go/main.go b/agents/drivers/kingbase-go/main.go
index 3fa5c3b359..65ced67e9a 100644
--- a/agents/drivers/kingbase-go/main.go
+++ b/agents/drivers/kingbase-go/main.go
@@ -100,33 +100,37 @@ type completionAssistantResponse struct {
}
type queryResult struct {
- Columns []string `json:"columns"`
- ColumnTypes []string `json:"column_types"`
- Rows [][]any `json:"rows"`
- AffectedRows int64 `json:"affected_rows"`
- ExecutionTimeMS int64 `json:"execution_time_ms"`
- Truncated bool `json:"truncated"`
+ Columns []string `json:"columns"`
+ ColumnTypes []string `json:"column_types"`
+ Rows [][]any `json:"rows"`
+ AffectedRows int64 `json:"affected_rows"`
+ ExecutionTimeMS int64 `json:"execution_time_ms"`
+ Truncated bool `json:"truncated"`
+ Messages []queryMessage `json:"messages,omitempty"`
}
type queryPageResult struct {
- Columns []string `json:"columns"`
- ColumnTypes []string `json:"column_types"`
- Rows [][]any `json:"rows"`
- AffectedRows int64 `json:"affected_rows"`
- ExecutionTimeMS int64 `json:"execution_time_ms"`
- Truncated bool `json:"truncated"`
- SessionID *string `json:"session_id"`
- HasMore bool `json:"has_more"`
+ Columns []string `json:"columns"`
+ ColumnTypes []string `json:"column_types"`
+ Rows [][]any `json:"rows"`
+ AffectedRows int64 `json:"affected_rows"`
+ ExecutionTimeMS int64 `json:"execution_time_ms"`
+ Truncated bool `json:"truncated"`
+ SessionID *string `json:"session_id"`
+ HasMore bool `json:"has_more"`
+ Messages []queryMessage `json:"messages,omitempty"`
}
type querySession struct {
- rows *sql.Rows
- conn *sql.Conn
- columns []string
- columnTypes []string
- pending []any
- remaining int
- cancel context.CancelFunc
+ rows *sql.Rows
+ conn *sql.Conn
+ columns []string
+ columnTypes []string
+ pending []any
+ remaining int
+ messages *queryMessageBuffer
+ restoreMessages func()
+ cancel context.CancelFunc
}
type server struct {
@@ -750,16 +754,18 @@ func (s *server) cancelActiveQuery() {
}
}
-func (s *server) executeQuery(opts queryOptions) (queryResult, error) {
+func (s *server) executeQuery(opts queryOptions) (result queryResult, resultErr error) {
start := time.Now()
sqlText := trimStatementSQL(opts.SQL)
if isQuerySQL(sqlText) {
- rows, conn, cancel, err := s.queryRows(sqlText, opts.Schema, opts.TimeoutSecs)
+ rows, conn, cancel, messages, restore, err := s.queryRowsWithMessages(sqlText, opts.Schema, opts.TimeoutSecs)
if err != nil {
return queryResult{}, err
}
defer func() {
_ = rows.Close()
+ result.Messages = messages.drain()
+ restore()
_ = conn.Close()
s.endOperation(cancel)
}()
@@ -767,7 +773,7 @@ func (s *server) executeQuery(opts queryOptions) (queryResult, error) {
if maxRows <= 0 {
maxRows = defaultMaxRows
}
- result, err := readRows(rows, maxRows)
+ result, err = readRows(rows, maxRows)
result.ExecutionTimeMS = time.Since(start).Milliseconds()
return result, err
}
@@ -775,7 +781,15 @@ func (s *server) executeQuery(opts queryOptions) (queryResult, error) {
if err != nil {
return queryResult{}, err
}
+ messages, restore, err := captureQueryMessages(conn)
+ if err != nil {
+ _ = conn.Close()
+ s.endOperation(cancel)
+ return queryResult{}, err
+ }
defer func() {
+ result.Messages = messages.drain()
+ restore()
_ = conn.Close()
s.endOperation(cancel)
}()
@@ -801,20 +815,42 @@ func (s *server) queryRows(sqlText string, schema string, timeoutSecs int) (*sql
return rows, conn, cancel, nil
}
+func (s *server) queryRowsWithMessages(sqlText string, schema string, timeoutSecs int) (*sql.Rows, *sql.Conn, context.CancelFunc, *queryMessageBuffer, func(), error) {
+ conn, ctx, cancel, err := s.operationConn(schema, timeoutSecs)
+ if err != nil {
+ return nil, nil, nil, nil, nil, err
+ }
+ messages, restore, err := captureQueryMessages(conn)
+ if err != nil {
+ _ = conn.Close()
+ s.endOperation(cancel)
+ return nil, nil, nil, nil, nil, err
+ }
+ rows, err := conn.QueryContext(ctx, sqlText)
+ if err != nil {
+ restore()
+ _ = conn.Close()
+ s.endOperation(cancel)
+ return nil, nil, nil, nil, nil, err
+ }
+ return rows, conn, cancel, messages, restore, nil
+}
+
func (s *server) executeQueryPage(opts queryOptions, pageSize int) (queryPageResult, error) {
start := time.Now()
sqlText := trimStatementSQL(opts.SQL)
if !isQuerySQL(sqlText) {
result, err := s.executeQuery(opts)
- return queryPageResult{Columns: result.Columns, ColumnTypes: result.ColumnTypes, Rows: result.Rows, AffectedRows: result.AffectedRows, ExecutionTimeMS: result.ExecutionTimeMS, Truncated: result.Truncated}, err
+ return queryPageResult{Columns: result.Columns, ColumnTypes: result.ColumnTypes, Rows: result.Rows, AffectedRows: result.AffectedRows, ExecutionTimeMS: result.ExecutionTimeMS, Truncated: result.Truncated, Messages: result.Messages}, err
}
- rows, conn, cancel, err := s.queryRows(sqlText, opts.Schema, opts.TimeoutSecs)
+ rows, conn, cancel, messages, restore, err := s.queryRowsWithMessages(sqlText, opts.Schema, opts.TimeoutSecs)
if err != nil {
return queryPageResult{}, err
}
columns, err := rows.Columns()
if err != nil {
_ = rows.Close()
+ restore()
_ = conn.Close()
s.endOperation(cancel)
return queryPageResult{}, err
@@ -824,11 +860,13 @@ func (s *server) executeQueryPage(opts queryOptions, pageSize int) (queryPageRes
if maxRows <= 0 {
maxRows = defaultMaxRows
}
- session := &querySession{rows: rows, conn: conn, columns: columns, columnTypes: columnTypeNames(rows), remaining: maxRows, cancel: cancel}
+ session := &querySession{rows: rows, conn: conn, columns: columns, columnTypes: columnTypeNames(rows), remaining: maxRows, cancel: cancel, messages: messages, restoreMessages: restore}
result, err := readQuerySessionPage(session, pageSize)
+ result.Messages = messages.drain()
result.ExecutionTimeMS = time.Since(start).Milliseconds()
if err != nil {
_ = rows.Close()
+ restore()
_ = conn.Close()
s.endOperation(cancel)
return queryPageResult{}, err
@@ -840,6 +878,7 @@ func (s *server) executeQueryPage(opts queryOptions, pageSize int) (queryPageRes
result.SessionID = &id
} else {
_ = rows.Close()
+ restore()
_ = conn.Close()
s.endOperation(cancel)
}
@@ -852,6 +891,9 @@ func (s *server) fetchQueryPage(id string, pageSize int) (queryPageResult, error
return queryPageResult{Columns: []string{}, ColumnTypes: []string{}, Rows: [][]any{}}, nil
}
result, err := readQuerySessionPage(session, pageSize)
+ if session.messages != nil {
+ result.Messages = session.messages.drain()
+ }
if err != nil {
s.closeQuerySession(id)
return queryPageResult{}, err
@@ -870,6 +912,9 @@ func (s *server) closeQuerySession(id string) bool {
return false
}
_ = session.rows.Close()
+ if session.restoreMessages != nil {
+ session.restoreMessages()
+ }
if session.conn != nil {
_ = session.conn.Close()
}
@@ -997,13 +1042,21 @@ func columnTypeNames(rows *sql.Rows) []string {
return result
}
-func (s *server) executeTransaction(params map[string]json.RawMessage) (queryResult, error) {
+func (s *server) executeTransaction(params map[string]json.RawMessage) (result queryResult, resultErr error) {
statements := stringSliceParam(params, "statements")
conn, ctx, cancel, err := s.operationConn(stringParam(params, "schema"), intParam(params, "timeoutSecs"))
if err != nil {
return queryResult{}, err
}
+ messages, restore, err := captureQueryMessages(conn)
+ if err != nil {
+ _ = conn.Close()
+ s.endOperation(cancel)
+ return queryResult{}, err
+ }
defer func() {
+ result.Messages = messages.drain()
+ restore()
_ = conn.Close()
s.endOperation(cancel)
}()
@@ -1031,14 +1084,18 @@ func (s *server) executeTransaction(params map[string]json.RawMessage) (queryRes
func (s *server) executeBatch(params map[string]json.RawMessage) (queryResult, error) {
start := time.Now()
var affected int64
+ messages := &queryMessageBuffer{}
for _, statement := range stringSliceParam(params, "statements") {
result, err := s.executeQuery(queryOptions{SQL: statement, Schema: stringParam(params, "schema")})
if err != nil {
return queryResult{}, err
}
affected += result.AffectedRows
+ for _, message := range result.Messages {
+ messages.addMessage(message)
+ }
}
- return queryResult{Columns: []string{}, ColumnTypes: []string{}, Rows: [][]any{}, AffectedRows: affected, ExecutionTimeMS: time.Since(start).Milliseconds()}, nil
+ return queryResult{Columns: []string{}, ColumnTypes: []string{}, Rows: [][]any{}, AffectedRows: affected, ExecutionTimeMS: time.Since(start).Milliseconds(), Messages: messages.drain()}, nil
}
func (s *server) operationConn(schema string, timeoutSecs int) (*sql.Conn, context.Context, context.CancelFunc, error) {
diff --git a/agents/drivers/kingbase-go/query_messages.go b/agents/drivers/kingbase-go/query_messages.go
new file mode 100644
index 0000000000..a3033f0d19
--- /dev/null
+++ b/agents/drivers/kingbase-go/query_messages.go
@@ -0,0 +1,79 @@
+package main
+
+import (
+ "database/sql"
+ "database/sql/driver"
+ "reflect"
+ "sync"
+
+ "gitea.com/kingbase/gokb"
+)
+
+const maxQueryMessages = 1000
+const maxQueryMessageBytes = 1024 * 1024
+
+type queryMessage struct {
+ Severity string `json:"severity"`
+ Message string `json:"message"`
+ Code string `json:"code,omitempty"`
+ Detail string `json:"detail,omitempty"`
+ Hint string `json:"hint,omitempty"`
+}
+
+type queryMessageBuffer struct {
+ mu sync.Mutex
+ messages []queryMessage
+ count int
+ bytes int
+ truncated bool
+}
+
+func (buffer *queryMessageBuffer) add(notice *gokb.Error) {
+ buffer.addMessage(queryMessage{Severity: notice.Severity, Message: notice.Message, Code: string(notice.Code), Detail: notice.Detail, Hint: notice.Hint})
+}
+
+func (buffer *queryMessageBuffer) addMessage(message queryMessage) {
+ buffer.mu.Lock()
+ defer buffer.mu.Unlock()
+ if buffer.truncated {
+ return
+ }
+ size := len(message.Severity) + len(message.Message) + len(message.Code) + len(message.Detail) + len(message.Hint)
+ if buffer.count >= maxQueryMessages || size > maxQueryMessageBytes-buffer.bytes {
+ buffer.truncated = true
+ buffer.messages = append(buffer.messages, queryMessage{Severity: "WARNING", Message: "Server output limit reached; further messages are not retained."})
+ return
+ }
+ buffer.messages = append(buffer.messages, message)
+ buffer.count++
+ buffer.bytes += size
+}
+
+func (buffer *queryMessageBuffer) drain() []queryMessage {
+ buffer.mu.Lock()
+ defer buffer.mu.Unlock()
+ messages := buffer.messages
+ buffer.messages = nil
+ return messages
+}
+
+func captureQueryMessages(conn *sql.Conn) (*queryMessageBuffer, func(), error) {
+ buffer := &queryMessageBuffer{}
+ var restore func(driver.Conn)
+ err := conn.Raw(func(raw any) error {
+ driverConn := raw.(driver.Conn)
+ connectionType := reflect.TypeOf(driverConn)
+ if connectionType.Kind() != reflect.Pointer || connectionType.Elem().PkgPath() != "gitea.com/kingbase/gokb" {
+ return nil
+ }
+ previous := gokb.NoticeHandler(driverConn)
+ gokb.SetNoticeHandler(driverConn, buffer.add)
+ restore = func(driverConn driver.Conn) { gokb.SetNoticeHandler(driverConn, previous) }
+ return nil
+ })
+ return buffer, func() {
+ if restore != nil {
+ _ = conn.Raw(func(raw any) error { restore(raw.(driver.Conn)); return nil })
+ }
+ }, err
+}
diff --git a/agents/drivers/kingbase-go/query_messages_test.go b/agents/drivers/kingbase-go/query_messages_test.go
new file mode 100644
index 0000000000..94fe82d3ed
--- /dev/null
+++ b/agents/drivers/kingbase-go/query_messages_test.go
@@ -0,0 +1,40 @@
+package main
+
+import (
+ "strings"
+ "testing"
+
+ "gitea.com/kingbase/gokb"
+)
+
+func TestQueryMessagesPreserveNoticeFieldsAndRepeatedOutput(t *testing.T) {
+ buffer := &queryMessageBuffer{}
+ notice := &gokb.Error{Severity: "NOTICE", Message: "当前用户", Code: "00000", Detail: "detail", Hint: "hint"}
+ buffer.add(notice)
+ buffer.add(notice)
+ messages := buffer.drain()
+ if len(messages) != 2 || messages[0].Message != notice.Message || messages[0].Code != "00000" || messages[0].Detail != "detail" || messages[0].Hint != "hint" {
+ t.Fatalf("missing notice fields: %+v", messages)
+ }
+ if len(buffer.drain()) != 0 {
+ t.Fatal("page messages were delivered twice")
+ }
+}
+
+func TestQueryMessagesBoundCountAndBytesAcrossPages(t *testing.T) {
+ buffer := &queryMessageBuffer{}
+ for index := 0; index < maxQueryMessages; index++ {
+ buffer.add(&gokb.Error{Severity: "NOTICE", Message: "same"})
+ buffer.drain()
+ }
+ buffer.add(&gokb.Error{Message: "overflow"})
+ buffer.add(&gokb.Error{Message: "overflow again"})
+ if messages := buffer.drain(); len(messages) != 1 || messages[0].Severity != "WARNING" {
+ t.Fatalf("missing output cap: %+v", messages)
+ }
+ buffer = &queryMessageBuffer{}
+ buffer.add(&gokb.Error{Message: strings.Repeat("x", maxQueryMessageBytes+1)})
+ if messages := buffer.drain(); len(messages) != 1 || messages[0].Severity != "WARNING" {
+ t.Fatal("oversized notice was retained")
+ }
+}
diff --git a/apps/desktop/src/components/layout/ContentArea.vue b/apps/desktop/src/components/layout/ContentArea.vue
index 7ce06f4098..e0288ba2e4 100644
--- a/apps/desktop/src/components/layout/ContentArea.vue
+++ b/apps/desktop/src/components/layout/ContentArea.vue
@@ -798,6 +798,7 @@ const canShowExplainOutput = computed(() => !!props.activeTab.explainPlan || !!p
// of only the active result's — otherwise a statement with no result set
// silently loses its notices once a later statement owns the active result.
const resultMessages = computed<QueryMessage[]>(() => {
+ if (props.activeTab.liveQueryMessages?.length) return props.activeTab.liveQueryMessages;
const results = props.activeTab.results?.length ? props.activeTab.results : props.activeTab.result ? [props.activeTab.result] : [];
return results.flatMap(queryResultMessages);
});
@@ -1094,6 +1095,15 @@ watch(
},
);
+watch(
+ () => props.activeTab.liveQueryMessages?.length ?? 0,
+ (count, previousCount) => {
+ if (count > 0 && !previousCount && props.activeTab.isExecuting && !props.editorOnly && !hasTabularResult.value && (props.activeOutputView === "result" || props.activeOutputView === "summary")) {
+ emit("update:activeOutputView", props.activeTab.id, "messages");
+ }
+ },
+);
+
watch(
() => [props.activeTab.id, props.activeTab.result, props.activeTab.results, props.activeTab.isExecuting, props.activeOutputView] as const,
() => {
diff --git a/apps/desktop/src/components/layout/__tests__/ContentArea.serverMessages.spec.ts b/apps/desktop/src/components/layout/__tests__/ContentArea.serverMessages.spec.ts
index 091dc0e61c..1e06cdd069 100644
--- a/apps/desktop/src/components/layout/__tests__/ContentArea.serverMessages.spec.ts
+++ b/apps/desktop/src/components/layout/__tests__/ContentArea.serverMessages.spec.ts
@@ -25,7 +25,7 @@ async function mountResults(results: QueryResult[], activeIndex: number) {
setActivePinia(pinia);
const connection = { id: "sqlserver", name: "SQL Server", db_type: "sqlserver" as const, host: "localhost", port: 1433, username: "", password: "" };
useConnectionStore().connections = [connection];
- const tab: QueryTab = { id: "query", title: "Query", connectionId: connection.id, database: "app", mode: "query", sql: "EXEC demo", isExecuting: false, results, result: results[activeIndex], activeResultIndex: activeIndex };
+ const tab = reactive<QueryTab>({ id: "query", title: "Query", connectionId: connection.id, database: "app", mode: "query", sql: "EXEC demo", isExecuting: false, results, result: results[activeIndex], activeResultIndex: activeIndex });
useQueryStore().tabs.push(tab);
const state = reactive({ view: "result" as "result" | "messages" });
const host = document.createElement("div");
@@ -56,7 +56,7 @@ async function mountResults(results: QueryResult[], activeIndex: number) {
cleanups.push(() => app.unmount());
await nextTick();
await nextTick();
- return { host, state };
+ return { host, state, tab };
}
describe("SQL Server messages in the result surface", () => {
@@ -80,3 +80,19 @@ describe("SQL Server messages in the result surface", () => {
expect(host.querySelector('[data-test="data-grid"]')).toBeNull();
});
});
+
+describe("live server output", () => {
+ it("opens Messages while running and retains output after cancellation", async () => {
+ const { host, state, tab } = await mountResults([], 0);
+ tab.isExecuting = true;
+ await nextTick();
+ tab.liveQueryMessages = [{ severity: "NOTICE", message: "running output" }];
+ await nextTick();
+ expect(state.view).toBe("messages");
+ expect(host.textContent).toContain("running output");
+ tab.isExecuting = false;
+ await nextTick();
+ expect(host.textContent).toContain("running output");
+ expect(host.querySelector('[data-test="data-grid"]')).toBeNull();
+ });
+});
diff --git a/apps/desktop/src/composables/__tests__/useSqlExecution.spec.ts b/apps/desktop/src/composables/__tests__/useSqlExecution.spec.ts
index b718724b02..6596809278 100644
--- a/apps/desktop/src/composables/__tests__/useSqlExecution.spec.ts
+++ b/apps/desktop/src/composables/__tests__/useSqlExecution.spec.ts
@@ -664,6 +664,26 @@ SELECT @value AS Message;`;
expect(activeOutputView.value).toBe("messages");
});
+ it("keeps Messages selected after a batch with live output completes", async () => {
+ const sql = "SET client_min_messages = NOTICE; DO $$ BEGIN RAISE NOTICE 'hello'; END $$;";
+ const activeTab = ref<QueryTab | undefined>({ ...queryTab("app"), sql });
+ const activeConnection = ref<ConnectionConfig | undefined>(connection("postgres"));
+ const activeOutputView = ref<"result" | "summary" | "explain" | "chart" | "messages">("result");
+ vi.spyOn(useQueryStore(), "executeCurrentSql").mockImplementation(async () => {
+ activeOutputView.value = "messages";
+ if (activeTab.value) activeTab.value.result = { columns: [], rows: [], affected_rows: 0, execution_time_ms: 1, messages: [{ severity: "NOTICE", message: "hello" }] };
+ });
+ vi.spyOn(useHistoryStore(), "add").mockResolvedValue(undefined);
+ const execution = useSqlExecution({
+ activeTab: computed(() => activeTab.value),
+ activeConnection: computed(() => activeConnection.value),
+ executableSql: computed(() => sql),
+ activeOutputView,
+ });
+ await execution.tryExecute();
+ expect(activeOutputView.value).toBe("messages");
+ });
+
it("keeps the summary view for a MySQL INSERT that carries an INFO message", async () => {
const sql = "INSERT INTO users (name) VALUES ('a'), ('b')";
const activeTab = ref<QueryTab | undefined>({ ...queryTab("app"), sql });
diff --git a/apps/desktop/src/composables/useSqlExecution.ts b/apps/desktop/src/composables/useSqlExecution.ts
index 8a57a31364..38d9092b19 100644
--- a/apps/desktop/src/composables/useSqlExecution.ts
+++ b/apps/desktop/src/composables/useSqlExecution.ts
@@ -465,7 +465,7 @@ export function useSqlExecution(deps: {
deps.activeOutputView.value = "messages";
}
} else if (tab.result && !tab.result.columns.length && !tab.results?.some((result) => result.columns.length > 0)) {
- if (executionTabStillActive) {
+ if (executionTabStillActive && deps.activeOutputView.value !== "messages") {
deps.activeOutputView.value = statementCount === 1 ? defaultViewForResult(tab.result) : "summary";
}
}
diff --git a/apps/desktop/src/lib/backend/__tests__/queryMessagesStreaming.spec.ts b/apps/desktop/src/lib/backend/__tests__/queryMessagesStreaming.spec.ts
new file mode 100644
index 0000000000..1e3f165443
--- /dev/null
+++ b/apps/desktop/src/lib/backend/__tests__/queryMessagesStreaming.spec.ts
@@ -0,0 +1,22 @@
+import { expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({ listen: vi.fn(), invoke: vi.fn() }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mocks.invoke }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: mocks.listen }));
+
+it("filters query messages by execution and returns listener cleanup", async () => {
+ const unlisten = vi.fn();
+ mocks.listen.mockResolvedValue(unlisten);
+ const onMessages = vi.fn();
+ const { subscribeQueryMessages } = await import("../tauri");
+ const cleanup = await subscribeQueryMessages("run-1", onMessages);
+ expect(mocks.listen).toHaveBeenCalledWith("query-messages", expect.any(Function));
+ const listener = mocks.listen.mock.calls[0][1];
+ const messages = [{ severity: "NOTICE", message: "hello" }];
+ listener({ payload: { executionId: "run-2", messages } });
+ expect(onMessages).not.toHaveBeenCalled();
+ listener({ payload: { executionId: "run-1", messages } });
+ expect(onMessages).toHaveBeenCalledWith(messages);
+ cleanup();
+ expect(unlisten).toHaveBeenCalledOnce();
+});
diff --git a/apps/desktop/src/lib/backend/api.ts b/apps/desktop/src/lib/backend/api.ts
index eb6428f451..79f1a203e0 100644
--- a/apps/desktop/src/lib/backend/api.ts
+++ b/apps/desktop/src/lib/backend/api.ts
@@ -269,6 +269,7 @@ export const executeQuery = forward("executeQuery");
export const executeConditionalUpdate = forward("executeConditionalUpdate");
export const executeMulti = forward("executeMulti");
export const executeMultiWithProgress = forward("executeMultiWithProgress");
+export const subscribeQueryMessages = forward("subscribeQueryMessages");
export const executeBatch = forward("executeBatch");
export const executeScript = forward("executeScript");
export const executeScriptWith2pc = forward("executeScriptWith2pc");
diff --git a/apps/desktop/src/lib/backend/http.ts b/apps/desktop/src/lib/backend/http.ts
index 5497379a91..8ce05cb774 100644
--- a/apps/desktop/src/lib/backend/http.ts
+++ b/apps/desktop/src/lib/backend/http.ts
@@ -1541,6 +1541,10 @@ export interface ExecuteMultiProgress {
error?: BackendError;
}
+export async function subscribeQueryMessages(_executionId: string, _onMessages: (messages: import("@/types/database").QueryMessage[]) => void): Promise<() => void> {
+ return () => {};
+}
+
export async function executeMultiWithProgress(
connectionId: string,
database: string,
diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.ts
index a209b8f7f8..ab50980054 100644
--- a/apps/desktop/src/lib/backend/tauri.ts
+++ b/apps/desktop/src/lib/backend/tauri.ts
@@ -1964,6 +1964,12 @@ export interface ExecuteMultiProgress {
error?: BackendError;
}
+export async function subscribeQueryMessages(executionId: string, onMessages: (messages: import("@/types/database").QueryMessage[]) => void): Promise<() => void> {
+ return listen<{ executionId: string; messages: import("@/types/database").QueryMessage[] }>("query-messages", (event) => {
+ if (event.payload.executionId === executionId) onMessages(event.payload.messages);
+ });
+}
+
export async function executeMultiWithProgress(
connectionId: string,
database: string,
diff --git a/apps/desktop/src/lib/query/queryOutput.ts b/apps/desktop/src/lib/query/queryOutput.ts
index e903747fcf..d7218c08d6 100644
--- a/apps/desktop/src/lib/query/queryOutput.ts
+++ b/apps/desktop/src/lib/query/queryOutput.ts
@@ -1,7 +1,9 @@
import type { QueryTab } from "@/types/database";
-type QueryOutputState = Pick<QueryTab, "result" | "results" | "resultRuns" | "resultEvicted" | "explainPlan" | "explainError" | "explainTableResult" | "explainTableError" | "isExecuting" | "isExplaining">;
+type QueryOutputState = Pick<QueryTab, "result" | "results" | "resultRuns" | "resultEvicted" | "explainPlan" | "explainError" | "explainTableResult" | "explainTableError" | "isExecuting" | "isExplaining" | "liveQueryMessages">;
export function hasQueryOutput(tab: QueryOutputState | null | undefined): boolean {
- return !!tab && (!!tab.result || !!tab.results?.length || !!tab.resultRuns?.length || tab.resultEvicted === true || !!tab.explainPlan || !!tab.explainError || !!tab.explainTableResult || !!tab.explainTableError || tab.isExecuting === true || tab.isExplaining === true);
+ return (
+ !!tab && (!!tab.liveQueryMessages?.length || !!tab.result || !!tab.results?.length || !!tab.resultRuns?.length || tab.resultEvicted === true || !!tab.explainPlan || !!tab.explainError || !!tab.explainTableResult || !!tab.explainTableError || tab.isExecuting === true || tab.isExplaining === true)
+ );
}
diff --git a/apps/desktop/src/lib/query/queryResultMessages.ts b/apps/desktop/src/lib/query/queryResultMessages.ts
index 2781e74b48..737ef3c4ab 100644
--- a/apps/desktop/src/lib/query/queryResultMessages.ts
+++ b/apps/desktop/src/lib/query/queryResultMessages.ts
@@ -4,3 +4,20 @@ export function queryResultMessages(result: Pick<QueryResult, "rows" | "messages
if (result.messages?.length || result.server_message !== true) return result.messages ?? [];
return result.rows.flatMap((row) => (row[0] == null ? [] : [{ severity: "INFO", message: String(row[0]) }]));
}
+
+export function mergeQueryMessages(streamed: QueryMessage[], completed: QueryMessage[]): QueryMessage[] {
+ if (!streamed.length) return completed;
+ const remaining = new Map<string, number>();
+ for (const message of streamed) {
+ const key = JSON.stringify([message.severity, message.message, message.code ?? null, message.detail ?? null, message.hint ?? null]);
+ remaining.set(key, (remaining.get(key) ?? 0) + 1);
+ }
+ const extra = completed.filter((message) => {
+ const key = JSON.stringify([message.severity, message.message, message.code ?? null, message.detail ?? null, message.hint ?? null]);
+ const count = remaining.get(key) ?? 0;
+ if (!count) return true;
+ remaining.set(key, count - 1);
+ return false;
+ });
+ return [...streamed, ...extra];
+}
diff --git a/apps/desktop/src/stores/__tests__/queryStore.queryMessages.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.queryMessages.spec.ts
new file mode 100644
index 0000000000..6f2f8d4098
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/queryStore.queryMessages.spec.ts
@@ -0,0 +1,58 @@
+import { createPinia, setActivePinia } from "pinia";
+import { beforeEach, expect, it, vi } from "vitest";
+import type { QueryMessage, QueryResult } from "@/types/database";
+
+const mocks = vi.hoisted(() => ({ executeMulti: vi.fn(), subscribe: vi.fn(), cleanup: vi.fn() }));
+vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => true }));
+vi.mock("@/lib/backend/api", () => ({
+ executeMulti: mocks.executeMulti,
+ subscribeQueryMessages: mocks.subscribe,
+ closeClientConnectionSession: vi.fn().mockResolvedValue(undefined),
+ closeQuerySession: vi.fn().mockResolvedValue(undefined),
+ saveOpenTabsState: vi.fn().mockResolvedValue(undefined),
+ prepareQueryPaginationExecutionPlan: vi.fn(async (options) => ({ sqlToExecute: options.sql, useAgentResultSession: false })),
+}));
+vi.mock("@/stores/connectionStore", () => ({
+ useConnectionStore: () => ({
+ ensureConnected: vi.fn().mockResolvedValue(undefined),
+ getConfig: () => ({ id: "pg", name: "PostgreSQL", db_type: "postgres", database: "app", query_timeout_secs: 30 }),
+ lookupLocalCompletionTables: () => [],
+ recordConnectionLostError: vi.fn(),
+ }),
+}));
+vi.mock("@/stores/settingsStore", () => ({ useSettingsStore: () => ({ editorSettings: { pageSize: 100, autoCalculateTotalRows: false } }) }));
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ setActivePinia(createPinia());
+ mocks.subscribe.mockResolvedValue(mocks.cleanup);
+});
+
+const notice: QueryMessage = { severity: "NOTICE", message: "running output" };
+
+it.each([false, true])("retains streamed output and cleans up listeners (failed=%s)", async (failed) => {
+ let resolve!: (results: QueryResult[]) => void;
+ let reject!: (error: Error) => void;
+ mocks.executeMulti.mockReturnValue(
+ new Promise<QueryResult[]>((resolveQuery, rejectQuery) => {
+ resolve = resolveQuery;
+ reject = rejectQuery;
+ }),
+ );
+ const { useQueryStore } = await import("../queryStore");
+ const store = useQueryStore();
+ const tabId = store.createTab("pg", "app", "Query");
+ const run = store.executeTabSql(tabId, "DO $$ BEGIN RAISE NOTICE 'running output'; END $$");
+ await vi.waitFor(() => expect(mocks.executeMulti).toHaveBeenCalled());
+ const listener = mocks.subscribe.mock.calls[0][1];
+ listener([notice, notice]);
+ expect(store.tabs[0].liveQueryMessages).toEqual([notice, notice]);
+ if (failed) reject(new Error("Query canceled"));
+ else resolve([{ columns: [], rows: [], affected_rows: 0, execution_time_ms: 1, messages: [notice, notice] }]);
+ await run;
+ expect(store.tabs[0].result?.messages).toEqual([notice, notice]);
+ expect(store.tabs[0].liveQueryMessages).toBeUndefined();
+ expect(mocks.cleanup).toHaveBeenCalledOnce();
+ listener([{ ...notice, message: "late output" }]);
+ expect(store.tabs[0].result?.messages).toEqual([notice, notice]);
+});
diff --git a/apps/desktop/src/stores/queryStore.ts b/apps/desktop/src/stores/queryStore.ts
index d5d945e49b..3956a35a58 100644
--- a/apps/desktop/src/stores/queryStore.ts
+++ b/apps/desktop/src/stores/queryStore.ts
@@ -1,5 +1,6 @@
import { hasShortDataGridSqlPage } from "@/lib/dataGrid/dataGridPagination";
import { createQueryRequestTiming } from "@/lib/queryRequestTiming";
+import { mergeQueryMessages, queryResultMessages } from "@/lib/query/queryResultMessages";
import { appendNeo4jNodeCells, extractNeo4jNodeCells } from "@/lib/neo4j/neo4jNodeResult";
import { UPDATE_RESTORE_KEY, assertUpdateAllowsInteraction } from "@/lib/app/updatePreparation";
import { defineStore } from "pinia";
@@ -1768,6 +1769,7 @@ export const useQueryStore = defineStore("query", () => {
}
function clearResultPayload(tab: QueryTab, options: { evicted?: boolean; preserveCacheSnapshot?: boolean } = {}) {
+ if (!tab.isExecuting) tab.liveQueryMessages = undefined;
tab.result = undefined;
tab.results = undefined;
tab.activeResultIndex = undefined;
@@ -7113,6 +7115,7 @@ export const useQueryStore = defineStore("query", () => {
}
tab.executionId = executionId;
const tableDataNativeSelectionBlockOwner = tab.mode === "data" ? {} : undefined;
+ tab.liveQueryMessages = [];
if (tableDataNativeSelectionBlockOwner) beginDataGridNativeSelectionBlock(tableDataNativeSelectionBlockOwner);
const previousDisplayedSql = tab.resultBaseSql ?? tab.lastExecutedSql ?? tab.sql;
tab.lastExecutedSql = sql;
@@ -7164,6 +7167,7 @@ export const useQueryStore = defineStore("query", () => {
let countSql: string | undefined;
let exactQueryRowBound: number | undefined;
let useAgentResultSession = false;
+ let unsubscribeQueryMessages: (() => void) | undefined;
let paginationRowNumberColumn: string | undefined;
let executionDispatched = false;
let clientRequestStartedAt: number | undefined;
@@ -7176,6 +7180,14 @@ export const useQueryStore = defineStore("query", () => {
// the row/column locate flow. These locals live inside the try block.
let errorLocateContext: { databaseType: DatabaseType | undefined; parameterOptions: SqlParameterOptions | undefined; sourceOffset: number | undefined; executedSql: string | undefined } | undefined;
try {
+ if (isTauriRuntime()) {
+ unsubscribeQueryMessages = await api.subscribeQueryMessages(executionId, (messages) => {
+ const current = findExecutionTab(id);
+ if (current?.executionId === executionId && current.isExecuting) {
+ current.liveQueryMessages = [...(current.liveQueryMessages ?? []), ...messages].slice(0, 1001);
+ }
+ });
+ }
await waitForTabSessionReset(id);
const connStore = useConnectionStore();
const executionTarget = resumedExecutionTarget ?? options?.executionTarget;
@@ -8560,9 +8572,18 @@ export const useQueryStore = defineStore("query", () => {
syncDisplayedResultRun(current, queryBaseSql, captureResultRun);
}
} finally {
+ unsubscribeQueryMessages?.();
if (tableDataNativeSelectionBlockOwner) finishDataGridNativeSelectionBlock(tableDataNativeSelectionBlockOwner);
const current = findExecutionTab(id);
if (current?.executionId === executionId) {
+ if (producedResult && current.result && current.liveQueryMessages?.length) {
+ const results = current.results?.length ? current.results : [current.result];
+ const completed = results.flatMap(queryResultMessages);
+ const missing = mergeQueryMessages(completed, current.liveQueryMessages).slice(completed.length);
+ current.result.messages = [...queryResultMessages(current.result), ...missing];
+ current.liveQueryMessages = undefined;
+ }
+ if (!current.liveQueryMessages?.length) current.liveQueryMessages = undefined;
const liveBatch = liveBatchSqlExecutions.get(current);
if (liveBatch?.executionId === executionId) current.batchSqlExecution = liveBatch;
finishBatchSqlExecution(current, executionId, current.isCancelling === true);
diff --git a/apps/desktop/src/types/database.ts b/apps/desktop/src/types/database.ts
index b36d51d19f..17c29c758b 100644
--- a/apps/desktop/src/types/database.ts
+++ b/apps/desktop/src/types/database.ts
@@ -2100,6 +2100,7 @@ export interface QueryTab {
columnName: string;
};
executionId?: string;
+ liveQueryMessages?: QueryMessage[];
/** Ephemeral result run targeted by the current execution; null means a new run is being produced. */
executingResultRunId?: string | null;
isExplaining?: boolean;
diff --git a/crates/dbx-core/src/query/mod.rs b/crates/dbx-core/src/query/mod.rs
index abb7f4cf96..1da9e4871f 100644
--- a/crates/dbx-core/src/query/mod.rs
+++ b/crates/dbx-core/src/query/mod.rs
@@ -1,4 +1,5 @@
pub mod batch_progress;
+pub use dbx_drivers::query_messages;
pub mod document_ops;
pub mod hbase_ops;
pub mod mongo_ops;
@@ -6836,28 +6837,7 @@ async fn execute_manual_txn_postgres_statement(
sql: &str,
row_limit: usize,
) -> Result<db::QueryResult, String> {
- if db::postgres::postgres_statement_returns_rows(sql) {
- db::postgres::execute_select_query_unnamed(conn, sql, std::time::Instant::now(), row_limit).await
- } else {
- let affected = conn.execute_typed(sql, &[]).await.map_err(|e| format!("Query failed: {e}"))?;
- Ok(db::QueryResult {
- columns: vec![],
- column_types: Vec::new(),
- column_sortables: vec![],
- spatial_columns: vec![],
- spatial_values: vec![],
- rows: vec![],
- affected_rows: affected,
- execution_time_ms: 0,
- server_execute_time_us: None,
- query_timings_ms: None,
- truncated: false,
- session_id: None,
- has_more: false,
- elasticsearch_raw_body: None,
- messages: Vec::new(),
- })
- }
+ db::postgres::execute_query_on_client_unnamed(conn, sql, row_limit).await
}
async fn execute_manual_txn_mysql_statement(
diff --git a/crates/dbx-driver-postgres/src/postgres.rs b/crates/dbx-driver-postgres/src/postgres.rs
index 03e6461568..05fdafe0e8 100644
--- a/crates/dbx-driver-postgres/src/postgres.rs
+++ b/crates/dbx-driver-postgres/src/postgres.rs
@@ -2560,6 +2560,8 @@ async fn stream_select_query_inner_with_mode(
on_item: &mut impl FnMut(PostgresQueryStreamItem) -> Result<(), String>,
force_unnamed: bool,
) -> Result<u64, String> {
+ let _ = drain_postgres_notices(client).await;
+ let _notice_subscription = subscribe_postgres_notices(client).await;
let client = &EncodingClient::new(client);
match stream_select_query_prepared(client, sql, row_limit, on_item, force_unnamed).await {
Ok(rows) => Ok(rows),
@@ -2759,7 +2761,36 @@ fn postgres_connection_key_from_row(row: &tokio_postgres::Row) -> Option<Postgre
/// Notice buffers for live connections, keyed by connection identity. Entries
/// are weak so they disappear once the pooled connection (and its driver
/// task) is dropped.
-type PostgresNoticeBuffers = HashMap<PostgresConnectionKey, Weak<Mutex<Vec<QueryMessage>>>>;
+type PostgresNoticeBuffers = HashMap<PostgresConnectionKey, Weak<Mutex<PostgresNoticeBuffer>>>;
+
+#[derive(Default)]
+struct PostgresNoticeBuffer {
+ messages: dbx_driver_support::query_messages::QueryMessageBuffer,
+ sink: Option<dbx_driver_support::query_messages::QueryMessageSink>,
+}
+
+struct PostgresNoticeSubscription(Arc<Mutex<PostgresNoticeBuffer>>);
+
+impl Drop for PostgresNoticeSubscription {
+ fn drop(&mut self) {
+ self.0.lock().unwrap_or_else(|error| error.into_inner()).sink = None;
+ }
+}
+
+fn capture_postgres_notice(buffer: &Mutex<PostgresNoticeBuffer>, message: QueryMessage) {
+ let mut buffer = buffer.lock().unwrap_or_else(|error| error.into_inner());
+ if let (Some(message), Some(sink)) = (buffer.messages.push(message), buffer.sink.as_ref()) {
+ sink(message);
+ }
+}
+
+async fn subscribe_postgres_notices(client: &deadpool_postgres::Client) -> Option<PostgresNoticeSubscription> {
+ let key = postgres_client_key(&EncodingClient::new(client)).await?;
+ let buffer = postgres_notice_buffers().lock().unwrap_or_else(|error| error.into_inner()).get(&key)?.upgrade()?;
+ buffer.lock().unwrap_or_else(|error| error.into_inner()).sink =
+ dbx_driver_support::query_messages::current_query_message_sink();
+ Some(PostgresNoticeSubscription(buffer))
+}
fn postgres_notice_buffers() -> &'static Mutex<PostgresNoticeBuffers> {
static BUFFERS: OnceLock<Mutex<PostgresNoticeBuffers>> = OnceLock::new();
@@ -2940,7 +2971,7 @@ where
// No query can complete before the connection is being driven, so
// the notice buffer is handed to the driver task through a slot
// that is filled once the backend PID is known.
- let notice_buffer = Arc::new(Mutex::new(None::<Arc<Mutex<Vec<QueryMessage>>>>));
+ let notice_buffer = Arc::new(Mutex::new(None::<Arc<Mutex<PostgresNoticeBuffer>>>));
let task_buffer = Arc::clone(&notice_buffer);
let conn_task = tokio::spawn(async move {
loop {
@@ -2956,7 +2987,7 @@ where
let buffer = task_buffer.lock().unwrap_or_else(|poisoned| poisoned.into_inner()).clone();
match buffer {
Some(buffer) => {
- buffer.lock().unwrap_or_else(|poisoned| poisoned.into_inner()).push(message);
+ capture_postgres_notice(&buffer, message);
}
None => {
log::info!("[postgres][notice] {}: {}", message.severity, message.message);
@@ -2979,7 +3010,7 @@ where
// by the driver task instead. Never fail the connection over this.
if let Ok(row) = client.query_one(POSTGRES_CONNECTION_IDENTITY_SQL, &[]).await {
if let Some(key) = postgres_connection_key_from_row(&row) {
- let buffer = Arc::new(Mutex::new(Vec::new()));
+ let buffer = Arc::new(Mutex::new(PostgresNoticeBuffer::default()));
let mut buffers = postgres_notice_buffers().lock().unwrap_or_else(|poisoned| poisoned.into_inner());
buffers.retain(|_, weak| weak.strong_count() > 0);
buffers.insert(key, Arc::downgrade(&buffer));
@@ -3044,7 +3075,7 @@ fn take_notices_for_key(key: &PostgresConnectionKey) -> Vec<QueryMessage> {
let Some(buffer) = buffer else {
return Vec::new();
};
- let notices = std::mem::take(&mut *buffer.lock().unwrap_or_else(|poisoned| poisoned.into_inner()));
+ let notices = buffer.lock().unwrap_or_else(|poisoned| poisoned.into_inner()).messages.take();
notices
}
@@ -8698,6 +8729,8 @@ pub async fn execute_query_with_max_rows(
// by this statement are attached to its result.
let _ = drain_postgres_notices(client).await;
+ let _notice_subscription = subscribe_postgres_notices(client).await;
+
let result = if postgres_statement_returns_rows(sql) {
execute_select_query(client, sql, start, row_limit).await
} else {
@@ -9532,6 +9565,8 @@ async fn execute_query_with_max_rows_inner(
// raised by this statement are attached to its result.
let _ = drain_postgres_notices(client).await;
+ let _notice_subscription = subscribe_postgres_notices(client).await;
+
let result = if postgres_statement_returns_rows(sql) {
if prefer_text_protocol {
execute_select_text(client, sql, start, row_limit, None, progress_clock.as_deref()).await
@@ -9575,6 +9610,14 @@ async fn execute_query_with_max_rows_inner(
}
}
+pub async fn execute_query_on_client_unnamed(
+ client: &deadpool_postgres::Client,
+ sql: &str,
+ max_rows: usize,
+) -> Result<QueryResult, String> {
+ execute_query_with_max_rows_inner(client, sql, Some(max_rows), false, None, true).await
+}
+
// Sibling of `postgres_indexes_for_relations_sql` (~line 3288), for a single
// (schema, table) instead of a batch of oids — see the note there.
// `COALESCE(a.attname::text, pg_get_indexdef(...))` keeps the cast: a bare
@@ -11345,6 +11388,78 @@ mod tests {
}
}
+ #[tokio::test]
+ #[ignore = "requires DBX_TEST_POSTGRES_URL pointing at a PostgreSQL database"]
+ async fn postgres_query_messages_stream_and_survive_cancel_and_error() {
+ use dbx_driver_support::query_messages::{with_query_messages, QueryMessagesCallback};
+ let url = std::env::var("DBX_TEST_POSTGRES_URL").expect("DBX_TEST_POSTGRES_URL");
+ let pool = connect_with_local_timezone(&url, Duration::from_secs(10), "UTC").await.unwrap();
+ for outcome in ["success", "error", "cancel"] {
+ let emitted = Arc::new(Mutex::new(Vec::new()));
+ let output = Arc::clone(&emitted);
+ let token = CancellationToken::new();
+ let cancel = token.clone();
+ let callback: QueryMessagesCallback = Arc::new(move |messages| {
+ output.lock().unwrap().extend(messages);
+ if outcome == "cancel" {
+ cancel.cancel();
+ }
+ });
+ let ending =
+ if outcome == "error" { "RAISE EXCEPTION 'expected failure';" } else { "RAISE NOTICE 'second';" };
+ let sql = format!("DO $$ BEGIN RAISE NOTICE 'first'; PERFORM pg_sleep(2); {ending} END $$");
+ let budget = crate::execution::DbOperationBudget::with_defaults();
+ let query = with_query_messages(
+ Some(callback),
+ execute_query_with_max_rows_and_cancel(&pool, &sql, None, Some(token), budget, None, false),
+ );
+ let mut query = std::pin::pin!(query);
+ if outcome != "cancel" {
+ tokio::time::timeout(Duration::from_secs(10), async {
+ loop {
+ tokio::select! {
+ result = query.as_mut() => panic!("query finished before displaying its first notice: {result:?}"),
+ _ = tokio::time::sleep(Duration::from_millis(20)) => {
+ if !emitted.lock().unwrap().is_empty() {
+ break;
+ }
+ }
+ }
+ }
+ }).await.unwrap();
+ assert_eq!(emitted.lock().unwrap()[0].message, "first");
+ }
+ let result = query.await;
+ if outcome == "success" {
+ assert_eq!(result.unwrap().messages.len(), 2);
+ assert_eq!(emitted.lock().unwrap().len(), 2);
+ } else {
+ assert!(result.is_err());
+ assert_eq!(emitted.lock().unwrap().len(), 1);
+ assert_eq!(emitted.lock().unwrap()[0].message, "first");
+ }
+ assert!(execute_query_with_max_rows(&pool, "SELECT 1", None).await.unwrap().messages.is_empty());
+ }
+ }
+
+ #[test]
+ fn postgres_notice_subscriptions_are_connection_scoped_and_removed_on_drop() {
+ let received = Arc::new(Mutex::new(Vec::new()));
+ let output = Arc::clone(&received);
+ let first = Arc::new(Mutex::new(PostgresNoticeBuffer {
+ sink: Some(Arc::new(move |message| output.lock().unwrap().push(message))),
+ ..Default::default()
+ }));
+ let second = Mutex::new(PostgresNoticeBuffer::default());
+ let subscription = PostgresNoticeSubscription(Arc::clone(&first));
+ capture_postgres_notice(&first, test_query_message("first connection"));
+ capture_postgres_notice(&second, test_query_message("second connection"));
+ assert_eq!(received.lock().unwrap().len(), 1);
+ drop(subscription);
+ capture_postgres_notice(&first, test_query_message("after cancellation"));
+ assert_eq!(received.lock().unwrap().len(), 1);
+ }
+
#[test]
fn postgres_connection_identity_normalizes_vendor_numeric_types_to_text() {
assert!(POSTGRES_CONNECTION_IDENTITY_SQL.contains("pg_backend_pid()::text"));
@@ -11411,7 +11526,9 @@ mod tests {
#[test]
fn take_notices_for_key_returns_buffered_notices_and_empties_buffer() {
let key = ("test-host".to_string(), "9000001".to_string(), "9000001".to_string());
- let buffer = Arc::new(Mutex::new(vec![test_query_message("first"), test_query_message("second")]));
+ let buffer = Arc::new(Mutex::new(PostgresNoticeBuffer::default()));
+ capture_postgres_notice(&buffer, test_query_message("first"));
+ capture_postgres_notice(&buffer, test_query_message("second"));
postgres_notice_buffers()
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
@@ -11426,7 +11543,7 @@ mod tests {
// The buffer was drained but stays registered while the connection lives.
assert!(take_notices_for_key(&key).is_empty());
- buffer.lock().unwrap_or_else(|poisoned| poisoned.into_inner()).push(test_query_message("third"));
+ capture_postgres_notice(&buffer, test_query_message("third"));
let notices = take_notices_for_key(&key);
assert_eq!(notices.len(), 1);
assert_eq!(notices[0].message, "third");
@@ -11436,8 +11553,10 @@ mod tests {
fn take_notices_for_key_prunes_dead_buffers_and_misses_return_empty() {
let live_key = ("test-host".to_string(), "9000002".to_string(), "9000002".to_string());
let dead_key = ("test-host".to_string(), "9000003".to_string(), "9000003".to_string());
- let live = Arc::new(Mutex::new(vec![test_query_message("live")]));
- let dead = Arc::new(Mutex::new(vec![test_query_message("dead")]));
+ let live = Arc::new(Mutex::new(PostgresNoticeBuffer::default()));
+ capture_postgres_notice(&live, test_query_message("live"));
+ let dead = Arc::new(Mutex::new(PostgresNoticeBuffer::default()));
+ capture_postgres_notice(&dead, test_query_message("dead"));
{
let mut buffers = postgres_notice_buffers().lock().unwrap_or_else(|poisoned| poisoned.into_inner());
buffers.insert(live_key.clone(), Arc::downgrade(&live));
@@ -11465,8 +11584,10 @@ mod tests {
// keeps notice attribution separate.
let key_a = ("server-a".to_string(), "5432".to_string(), "42".to_string());
let key_b = ("server-b".to_string(), "5432".to_string(), "42".to_string());
- let buffer_a = Arc::new(Mutex::new(vec![test_query_message("from-a")]));
- let buffer_b = Arc::new(Mutex::new(vec![test_query_message("from-b")]));
+ let buffer_a = Arc::new(Mutex::new(PostgresNoticeBuffer::default()));
+ capture_postgres_notice(&buffer_a, test_query_message("from-a"));
+ let buffer_b = Arc::new(Mutex::new(PostgresNoticeBuffer::default()));
+ capture_postgres_notice(&buffer_b, test_query_message("from-b"));
{
let mut buffers = postgres_notice_buffers().lock().unwrap_or_else(|poisoned| poisoned.into_inner());
buffers.insert(key_a.clone(), Arc::downgrade(&buffer_a));
diff --git a/crates/dbx-driver-support/src/lib.rs b/crates/dbx-driver-support/src/lib.rs
index c0b30d6e9b..ff6952a975 100644
--- a/crates/dbx-driver-support/src/lib.rs
+++ b/crates/dbx-driver-support/src/lib.rs
@@ -10,6 +10,7 @@ pub mod elasticsearch_sql;
pub mod execution;
pub mod file_validator;
pub mod http_tunnel;
+pub mod query_messages;
pub mod runtime_config;
pub mod ssh_config;
pub mod ssh_host_key;
diff --git a/crates/dbx-driver-support/src/query_messages.rs b/crates/dbx-driver-support/src/query_messages.rs
new file mode 100644
index 0000000000..6f2104041c
--- /dev/null
+++ b/crates/dbx-driver-support/src/query_messages.rs
@@ -0,0 +1,138 @@
+use std::future::Future;
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use crate::types::QueryMessage;
+
+pub const MAX_QUERY_MESSAGES: usize = 1000;
+pub const MAX_QUERY_MESSAGE_BYTES: usize = 1024 * 1024;
+
+pub type QueryMessageSink = Arc<dyn Fn(QueryMessage) + Send + Sync>;
+pub type QueryMessagesCallback = Arc<dyn Fn(Vec<QueryMessage>) + Send + Sync>;
+
+tokio::task_local! {
+ static QUERY_MESSAGE_SINK: QueryMessageSink;
+}
+
+pub fn current_query_message_sink() -> Option<QueryMessageSink> {
+ QUERY_MESSAGE_SINK.try_with(Arc::clone).ok()
+}
+
+#[derive(Default)]
+pub struct QueryMessageBuffer {
+ messages: Vec<QueryMessage>,
+ count: usize,
+ bytes: usize,
+ truncated: bool,
+}
+
+impl QueryMessageBuffer {
+ pub fn push(&mut self, message: QueryMessage) -> Option<QueryMessage> {
+ if self.truncated {
+ return None;
+ }
+ let bytes = message.severity.len()
+ + message.message.len()
+ + message.code.as_ref().map_or(0, String::len)
+ + message.detail.as_ref().map_or(0, String::len)
+ + message.hint.as_ref().map_or(0, String::len);
+ let message = if self.count >= MAX_QUERY_MESSAGES || bytes > MAX_QUERY_MESSAGE_BYTES.saturating_sub(self.bytes)
+ {
+ self.truncated = true;
+ QueryMessage {
+ severity: "WARNING".to_string(),
+ message: "Server output limit reached; further messages are not retained.".to_string(),
+ code: None,
+ detail: None,
+ hint: None,
+ }
+ } else {
+ self.count += 1;
+ self.bytes += bytes;
+ message
+ };
+ self.messages.push(message.clone());
+ Some(message)
+ }
+
+ pub fn drain(&mut self) -> Vec<QueryMessage> {
+ std::mem::take(&mut self.messages)
+ }
+
+ pub fn take(&mut self) -> Vec<QueryMessage> {
+ let messages = self.drain();
+ *self = Self::default();
+ messages
+ }
+}
+
+pub async fn with_query_messages<F: Future>(emit: Option<QueryMessagesCallback>, run: F) -> F::Output {
+ let Some(emit) = emit else {
+ return run.await;
+ };
+ let pending = Arc::new(Mutex::new(QueryMessageBuffer::default()));
+ let sink: QueryMessageSink = {
+ let pending = Arc::clone(&pending);
+ Arc::new(move |message| {
+ pending.lock().unwrap_or_else(|error| error.into_inner()).push(message);
+ })
+ };
+ let run = QUERY_MESSAGE_SINK.scope(sink, run);
+ let mut run = std::pin::pin!(run);
+ loop {
+ let output = tokio::time::timeout(Duration::from_millis(100), run.as_mut()).await;
+ let messages = pending.lock().unwrap_or_else(|error| error.into_inner()).drain();
+ if !messages.is_empty() {
+ emit(messages);
+ }
+ if let Ok(output) = output {
+ return output;
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn notice(message: &str) -> QueryMessage {
+ QueryMessage { severity: "NOTICE".into(), message: message.into(), code: None, detail: None, hint: None }
+ }
+
+ #[tokio::test(start_paused = true)]
+ async fn query_messages_stream_before_completion_and_flush_on_error() {
+ let emitted = Arc::new(Mutex::new(Vec::new()));
+ let output = Arc::clone(&emitted);
+ let callback: QueryMessagesCallback = Arc::new(move |messages| output.lock().unwrap().extend(messages));
+ let result = with_query_messages(Some(callback), async {
+ let sink = current_query_message_sink().unwrap();
+ sink(notice("first"));
+ tokio::time::sleep(Duration::from_millis(250)).await;
+ assert_eq!(emitted.lock().unwrap().len(), 1);
+ sink(notice("second"));
+ Err::<(), _>("failed")
+ })
+ .await;
+ assert_eq!(result, Err("failed"));
+ assert_eq!(
+ emitted.lock().unwrap().iter().map(|message| message.message.as_str()).collect::<Vec<_>>(),
+ ["first", "second"]
+ );
+ assert!(current_query_message_sink().is_none());
+ }
+
+ #[test]
+ fn query_message_buffer_caps_count_and_bytes_without_resetting_on_flush() {
+ let mut buffer = QueryMessageBuffer::default();
+ for _ in 0..MAX_QUERY_MESSAGES {
+ assert!(buffer.push(notice("same")).is_some());
+ buffer.drain();
+ }
+ assert_eq!(buffer.push(notice("overflow")).unwrap().severity, "WARNING");
+ assert!(buffer.push(notice("overflow again")).is_none());
+ buffer.take();
+ assert!(buffer.push(notice("next statement")).is_some());
+ buffer.take();
+ assert_eq!(buffer.push(notice(&"x".repeat(MAX_QUERY_MESSAGE_BYTES))).unwrap().severity, "WARNING");
+ }
+}
diff --git a/crates/dbx-drivers/src/lib.rs b/crates/dbx-drivers/src/lib.rs
index b4e94b7428..d2e5721bbb 100644
--- a/crates/dbx-drivers/src/lib.rs
+++ b/crates/dbx-drivers/src/lib.rs
@@ -2,7 +2,7 @@
pub use dbx_sql_data::query_result_sql;
-pub use dbx_driver_support::{runtime_config, ssh_config};
+pub use dbx_driver_support::{query_messages, runtime_config, ssh_config};
pub use dbx_platform::download::DownloadSource;
pub use dbx_platform::{path_utils, process};
pub use dbx_sql_core::{mysql_ddl_normalize, mysql_event_sql, sql, sql_error_position, sqlserver_temporal};
diff --git a/docs/testing/server-output.md b/docs/testing/server-output.md
new file mode 100644
index 0000000000..10e08370fd
--- /dev/null
+++ b/docs/testing/server-output.md
@@ -0,0 +1,42 @@
+# SQL server output
+
+## Scope
+
+- Desktop PostgreSQL native connections forward server notices to Messages while SQL is running, including manual transactions. Output already received remains visible after cancellation or a SQL error.
+- Notices are associated with the physical PostgreSQL connection and the desktop execution ID. The subscription is removed when the statement future completes or is dropped. Old notices are discarded before another user statement.
+- Desktop events are batched every 100 ms and flushed before the command returns. Live output retains at most 1,000 messages or 1 MiB per execution, followed by an explicit truncation warning. Each PostgreSQL statement and Kingbase cursor also bounds its retained notices.
+- The Kingbase Go agent captures the pinned `gokb` driver's NOTICE callback, preserving severity, SQLSTATE, detail and hint. Messages survive normal queries, paged commands, cursor pages, batches and transaction results.
+- JDBC results expose warnings in `messages`, including paged statements with and without rows. Existing synthetic Message rows remain unchanged for compatibility.
+- This change does not introduce live output for JDBC or the Web HTTP transport. Those paths still display messages after execution returns.
+
+## Reproduction
+
+```sql
+SET client_min_messages = NOTICE;
+DO $$
+BEGIN
+ FOR message_index IN 1..10 LOOP
+ RAISE NOTICE 'Real-time message at %', clock_timestamp();
+ PERFORM pg_sleep(2);
+ END LOOP;
+END $$;
+```
+
+Messages should become available during execution. Cancel after the first few messages and confirm that they remain visible. Replace the loop with a NOTICE followed by `RAISE EXCEPTION` to exercise the error path. A subsequent `SELECT 1` must not inherit the previous statement's notices. Identical repeated messages must remain separate occurrences, without being duplicated by the final response.
+
+## Verification (2026-10-11)
+
+- PostgreSQL 18.6 on the test server, through an SSH tunnel: native notice output before completion, successful completion, SQL error, cancellation, subsequent-query isolation, and existing command notice capture pass targeted nextest tests.
+- Frontend tests cover execution-ID filtering, listener cleanup, output during execution, cancellation retention, repeated messages, and reconciliation with the final response.
+- The Kingbase Go agent passes its tests with the race detector. Its notice integration test also passes against the test server's PostgreSQL 18.6 using the actual pinned `gokb` driver. This validates the callback and result serialization, not Kingbase-specific runtime behavior.
+- JDBC executor tests cover warnings with ordinary rows, paged commands without a driver-specific reader, and paged rows without replacing existing result data.
+- Final validation: 106 frontend tests, 26 JDBC executor tests, Go race tests, affected-package Rust checks, and Vue type checking pass. The combined native notice nextest run passes all 9 tests; 2 receive nextest LEAK status (inherited output handles remain open after test exit), without assertion failures.
+- No Kingbase server instance or image is available on the test server. Verification against the reporter's Kingbase version remains outstanding.
+
+## Reference implementations
+
+- DBeaver's `PostgreServerOutputReader` extends `AsyncServerOutputReader`; `SQLEditor` reads running statement output independently of completed query results. Its asynchronous reader intentionally avoids connection-wide warnings, which can block cancellation.
+- The pinned Kingbase driver is `gitea.com/kingbase/gokb` at `29bd62a876c3`. Its [notice callback source](https://gitea.com/kingbase/gokb/src/commit/29bd62a876c3/notice.go) states: “Notice handlers are executed synchronously ... commands won't continue to be processed until the handler returns.” The callback only buffers bounded messages; it does not execute another query.
+- [PostgreSQL 18 query protocol](https://www.postgresql.org/docs/18/protocol-flow.html#PROTOCOL-FLOW-SIMPLE-QUERY): “Notices are in addition to other responses, i.e., the backend will continue processing the command.” This permits display before CommandComplete/ReadyForQuery.
+
+The behavior is tracked by discussion #10130 and the Kingbase feedback on merged PR #5451; that earlier PR only added completed-result message display.
diff --git a/packages/app-tests/queryMessagesStreaming.test.ts b/packages/app-tests/queryMessagesStreaming.test.ts
new file mode 100644
index 0000000000..1587641a56
--- /dev/null
+++ b/packages/app-tests/queryMessagesStreaming.test.ts
@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest";
+import { mergeQueryMessages } from "../../apps/desktop/src/lib/query/queryResultMessages";
+import type { QueryMessage } from "../../apps/desktop/src/types/database";
+import { hasQueryOutput } from "../../apps/desktop/src/lib/query/queryOutput";
+
+const notice: QueryMessage = { severity: "NOTICE", message: "same", code: "00000" };
+
+describe("streamed query messages", () => {
+ it("does not duplicate streamed messages in the completed response", () => {
+ expect(mergeQueryMessages([notice, notice], [notice, notice])).toEqual([notice, notice]);
+ });
+
+ it("preserves repeated occurrences and messages from other drivers", () => {
+ const warning = { severity: "WARNING", message: "other" };
+ expect(mergeQueryMessages([notice], [notice, notice, warning])).toEqual([notice, notice, warning]);
+ });
+
+ it("retains messages when execution returns no successful result", () => {
+ expect(mergeQueryMessages([notice], [])).toEqual([notice]);
+ expect(hasQueryOutput({ liveQueryMessages: [notice] })).toBe(true);
+ });
+
+ it("normalizes optional fields while keeping different details distinct", () => {
+ const detailed = { ...notice, detail: "context" };
+ expect(mergeQueryMessages([notice], [{ ...notice, hint: undefined }, detailed])).toEqual([notice, detailed]);
+ });
+});
diff --git a/src-tauri/src/commands/query.rs b/src-tauri/src/commands/query.rs
index d81de5023e..aab907b486 100644
--- a/src-tauri/src/commands/query.rs
+++ b/src-tauri/src/commands/query.rs
@@ -9,6 +9,17 @@ use dbx_core::models::connection::DatabaseType;
use dbx_core::query_cancel::RunningTaskMetadata;
use dbx_core::sql::split_sql_statements;
+fn query_messages_callback(
+ app: &AppHandle,
+ execution_id: Option<&str>,
+) -> Option<dbx_core::query::query_messages::QueryMessagesCallback> {
+ let execution_id = execution_id?.to_string();
+ let app = app.clone();
+ Some(Arc::new(move |messages| {
+ let _ = app.emit("query-messages", serde_json::json!({ "executionId": execution_id, "messages": messages }));
+ }))
+}
+
#[derive(Clone, serde::Serialize)]
#[serde(rename_all = "camelCase")]
struct ExecuteMultiProgress {
@@ -46,6 +57,7 @@ fn manual_transaction_command_error(error: String) -> ManualTransactionCommandEr
#[tauri::command]
#[allow(clippy::too_many_arguments)]
pub async fn execute_query(
+ app: AppHandle,
state: State<'_, Arc<AppState>>,
connection_id: String,
database: String,
@@ -71,26 +83,30 @@ pub async fn execute_query(
});
let cancel_token = registered_query.as_ref().map(|query| query.token());
- let result = dbx_core::query::execute_sql_statement_with_options_typed(
- &state,
- &connection_id,
- &database,
- &sql,
- schema.as_deref(),
- cancel_token,
- dbx_core::query::QueryExecutionOptions {
- max_rows,
- fetch_size,
- page_size,
- row_offset,
- catalog,
- result_session_id,
- client_session_id,
- timeout_secs,
- execution_id,
- execution_mode: execution_mode.unwrap_or_default(),
- ..Default::default()
- },
+ let messages = query_messages_callback(&app, execution_id.as_deref());
+ let result = dbx_core::query::query_messages::with_query_messages(
+ messages,
+ dbx_core::query::execute_sql_statement_with_options_typed(
+ &state,
+ &connection_id,
+ &database,
+ &sql,
+ schema.as_deref(),
+ cancel_token,
+ dbx_core::query::QueryExecutionOptions {
+ max_rows,
+ fetch_size,
+ page_size,
+ row_offset,
+ catalog,
+ result_session_id,
+ client_session_id,
+ timeout_secs,
+ execution_id,
+ execution_mode: execution_mode.unwrap_or_default(),
+ ..Default::default()
+ },
+ ),
)
.await;
@@ -246,36 +262,40 @@ pub async fn execute_multi(
schema
);
- let result = dbx_core::query::batch_progress::with_coalesced_execute_multi_progress(progress, |progress| {
- dbx_core::query::execute_multi_core_with_options_for_client_and_progress_typed(
- &state,
- &connection_id,
- &database,
- &sql,
- schema.as_deref(),
- cancel_token,
- dbx_core::query::QueryExecutionOptions {
- max_rows,
- fetch_size,
- page_size,
- row_offset,
- max_result_bytes,
- result_key_columns: result_key_columns.unwrap_or_default(),
- table_data_preview: table_data_preview.unwrap_or(false),
- catalog,
- result_session_id,
- client_session_id,
- timeout_secs,
- await_cancel_completion: false,
- execution_id,
- use_transaction,
- continue_on_error: continue_on_error.unwrap_or(false),
- execution_mode: execution_mode.unwrap_or_default(),
- preserve_explicit_transaction: preserve_explicit_transaction.unwrap_or(false),
- },
- progress,
- )
- })
+ let messages = query_messages_callback(&app, execution_id.as_deref());
+ let result = dbx_core::query::query_messages::with_query_messages(
+ messages,
+ dbx_core::query::batch_progress::with_coalesced_execute_multi_progress(progress, |progress| {
+ dbx_core::query::execute_multi_core_with_options_for_client_and_progress_typed(
+ &state,
+ &connection_id,
+ &database,
+ &sql,
+ schema.as_deref(),
+ cancel_token,
+ dbx_core::query::QueryExecutionOptions {
+ max_rows,
+ fetch_size,
+ page_size,
+ row_offset,
+ max_result_bytes,
+ result_key_columns: result_key_columns.unwrap_or_default(),
+ table_data_preview: table_data_preview.unwrap_or(false),
+ catalog,
+ result_session_id,
+ client_session_id,
+ timeout_secs,
+ await_cancel_completion: false,
+ execution_id,
+ use_transaction,
+ continue_on_error: continue_on_error.unwrap_or(false),
+ execution_mode: execution_mode.unwrap_or_default(),
+ preserve_explicit_transaction: preserve_explicit_transaction.unwrap_or(false),
+ },
+ progress,
+ )
+ }),
+ )
.await;
match &result {
Ok(results) => log::info!(
@@ -484,6 +504,7 @@ pub async fn begin_manual_transaction(
#[tauri::command]
#[allow(clippy::too_many_arguments)]
pub async fn execute_in_manual_transaction(
+ app: AppHandle,
state: State<'_, Arc<AppState>>,
txn_session_id: String,
sql: String,
@@ -497,21 +518,25 @@ pub async fn execute_in_manual_transaction(
execution_id: Option<String>,
timeout_secs: Option<u64>,
) -> Result<Vec<dbx_core::query::ExecuteMultiResult>, ManualTransactionCommandError> {
- dbx_core::query::execute_in_manual_transaction_with_options(
- &state,
- &txn_session_id,
- &sql,
- &database,
- schema.as_deref(),
- dbx_core::query::ManualTransactionExecutionOptions {
- max_rows,
- table_data_preview: table_data_preview.unwrap_or(false),
- page_size,
- result_session_id,
- classification_sql,
- execution_id,
- timeout_secs,
- },
+ let messages = query_messages_callback(&app, execution_id.as_deref());
+ dbx_core::query::query_messages::with_query_messages(
+ messages,
+ dbx_core::query::execute_in_manual_transaction_with_options(
+ &state,
+ &txn_session_id,
+ &sql,
+ &database,
+ schema.as_deref(),
+ dbx_core::query::ManualTransactionExecutionOptions {
+ max_rows,
+ table_data_preview: table_data_preview.unwrap_or(false),
+ page_size,
+ result_session_id,
+ classification_sql,
+ execution_id,
+ timeout_secs,
+ },
+ ),
)
.await
.map_err(manual_transaction_command_error)