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(oracle): recover row-iteration panics to keep agent alive

t8y2dca6d0e5f63a
diff --git a/agents/drivers/oracle-go/main.go b/agents/drivers/oracle-go/main.go
index 00daec6168..5e082fb3b6 100644
--- a/agents/drivers/oracle-go/main.go
+++ b/agents/drivers/oracle-go/main.go
@@ -636,19 +636,28 @@ func newRuntimeServer() *runtimeServer {
return &runtimeServer{sessions: map[string]*agentSession{}}
}
-func (r *runtimeServer) handleLine(line string) (response, bool) {
+func (r *runtimeServer) handleLine(line string) (resp response, shutdown bool) {
var req request
+ // Last-resort guard: a panic anywhere on the request path must not kill
+ // the agent process and break the RPC stream, so convert it to a readable
+ // error response instead of an end-of-stream failure.
+ defer func() {
+ if recovered := recover(); recovered != nil {
+ resp = errorResponse(req.ID, fmt.Errorf("agent request panic: %v", recovered))
+ shutdown = false
+ }
+ }()
if err := json.Unmarshal([]byte(line), &req); err != nil {
return errorResponse(nil, err), false
}
if len(req.ID) == 0 {
req.ID = json.RawMessage("1")
}
- result, shutdown, err := r.dispatch(req.Method, req.Params)
+ result, shouldShutdown, err := r.dispatch(req.Method, req.Params)
if err != nil {
return errorResponse(req.ID, err), false
}
- return response{JSONRPC: "2.0", ID: req.ID, Result: result}, shutdown
+ return response{JSONRPC: "2.0", ID: req.ID, Result: result}, shouldShutdown
}
func (r *runtimeServer) dispatch(method string, params map[string]json.RawMessage) (any, bool, error) {
@@ -3762,36 +3771,72 @@ func (s *server) executeQueryPage(opts queryOptions, pageSize int) (queryPageRes
HasMore: false,
}, err
}
- rows, err := s.queryRowsWithOracleValueRewriteIfNeeded(sqlText, opts.TimeoutSecs, opts.DeferLOBs)
- if err != nil {
- return queryPageResult{}, err
- }
- columns, err := rows.Columns()
+ result, session, err := s.runPagedOracleSelect(sqlText, opts, pageSize, start)
if err != nil {
- s.closeRows(rows)
return queryPageResult{}, err
}
- columnTypes := columnTypeNames(rows)
- maxRows := opts.MaxRows
- if maxRows <= 0 {
- maxRows = defaultMaxRows
- }
- session := &querySession{rows: rows, columns: columns, columnTypes: columnTypes, remaining: maxRows}
- result, err := readQuerySessionPage(session, pageSize)
- result.ExecutionTimeMS = time.Since(start).Milliseconds()
- if err != nil {
- s.closeRows(rows)
- return queryPageResult{}, err
- }
- if result.HasMore {
+ if session != nil {
sessionID := s.storeQuerySession(session)
result.SessionID = &sessionID
- } else {
- s.closeRows(rows)
}
return result, nil
}
+// runPagedOracleSelect executes a SELECT through the value-rewrite path and
+// reads its first page. It returns the live session when more pages remain.
+// When the first page panics while decoding an unsupported column type (before
+// any row was streamed to the client), it retries once with the placeholder
+// projection so the remaining columns stay readable; panics on later pages
+// surface as errors instead.
+func (s *server) runPagedOracleSelect(sqlText string, opts queryOptions, pageSize int, start time.Time) (queryPageResult, *querySession, error) {
+ for attempt := 0; ; attempt++ {
+ rows, err := s.queryRowsWithOracleValueRewriteIfNeeded(sqlText, opts.TimeoutSecs, opts.DeferLOBs)
+ if err != nil {
+ return queryPageResult{}, nil, err
+ }
+ columns, err := rows.Columns()
+ if err != nil {
+ s.closeRows(rows)
+ return queryPageResult{}, nil, err
+ }
+ columnTypes := columnTypeNames(rows)
+ maxRows := opts.MaxRows
+ if maxRows <= 0 {
+ maxRows = defaultMaxRows
+ }
+ session := &querySession{rows: rows, columns: columns, columnTypes: columnTypes, remaining: maxRows}
+ result, err := readQuerySessionPage(session, pageSize)
+ result.ExecutionTimeMS = time.Since(start).Milliseconds()
+ if err != nil {
+ s.closeRows(rows)
+ var panicErr oracleDriverPanicError
+ if attempt == 0 && errors.As(err, &panicErr) {
+ if placeholder, ok := oraclePlaceholderRetrySQL(sqlText, s.loadOracleColumnMeta); ok {
+ sqlText = placeholder
+ continue
+ }
+ }
+ return queryPageResult{}, nil, err
+ }
+ if result.HasMore {
+ return result, session, nil
+ }
+ s.closeRows(rows)
+ return result, nil, nil
+ }
+}
+
+// oraclePlaceholderRetrySQL returns the placeholder projection used to retry a
+// query whose first page panicked while decoding values of an unsupported
+// column type. It reports false when no placeholder rewrite applies.
+func oraclePlaceholderRetrySQL(sqlText string, loadColumns oracleColumnMetaLoader) (string, bool) {
+ placeholder, err := rewriteOracleSelectSQL(sqlText, loadColumns, true)
+ if err != nil || placeholder == sqlText {
+ return "", false
+ }
+ return placeholder, true
+}
+
func (s *server) fetchQueryPage(sessionID string, pageSize int) (queryPageResult, error) {
session := s.sessions[sessionID]
if session == nil {
@@ -3828,32 +3873,13 @@ func (s *server) startTableRead(opts queryOptions, pageSize int) (queryPageResul
if !isQuerySQL(sqlText) {
return queryPageResult{}, errors.New("table read requires a SELECT query")
}
- rows, err := s.queryRowsWithOracleValueRewriteIfNeeded(sqlText, opts.TimeoutSecs, opts.DeferLOBs)
+ result, session, err := s.runPagedOracleSelect(sqlText, opts, pageSize, start)
if err != nil {
return queryPageResult{}, err
}
- columns, err := rows.Columns()
- if err != nil {
- s.closeRows(rows)
- return queryPageResult{}, err
- }
- columnTypes := columnTypeNames(rows)
- maxRows := opts.MaxRows
- if maxRows <= 0 {
- maxRows = defaultMaxRows
- }
- session := &querySession{rows: rows, columns: columns, columnTypes: columnTypes, remaining: maxRows}
- result, err := readQuerySessionPage(session, pageSize)
- result.ExecutionTimeMS = time.Since(start).Milliseconds()
- if err != nil {
- s.closeRows(rows)
- return queryPageResult{}, err
- }
- if result.HasMore {
+ if session != nil {
sessionID := s.storeTableReadSession(session)
result.SessionID = &sessionID
- } else {
- s.closeRows(rows)
}
return result, nil
}
@@ -3912,11 +3938,21 @@ func (s *server) closeAllQuerySessions() {
}
}
-func readQuerySessionPage(session *querySession, pageSize int) (queryPageResult, error) {
+func readQuerySessionPage(session *querySession, pageSize int) (result queryPageResult, err error) {
+ // go-ora can panic while decoding row values for column types it does not
+ // support (for example custom object types). Convert those panics to errors
+ // so row iteration failures never terminate the agent process and break
+ // the RPC stream.
+ defer func() {
+ if recovered := recover(); recovered != nil {
+ result = queryPageResult{}
+ err = oracleDriverPanicError{value: recovered}
+ }
+ }()
if pageSize <= 0 {
pageSize = defaultMaxRows
}
- result := queryPageResult{Columns: session.columns, ColumnTypes: session.columnTypes, Rows: [][]any{}, SessionID: nil, HasMore: false}
+ result = queryPageResult{Columns: session.columns, ColumnTypes: session.columnTypes, Rows: [][]any{}, SessionID: nil, HasMore: false}
for len(result.Rows) < pageSize && session.remaining > 0 {
if session.pending != nil {
result.Rows = append(result.Rows, session.pending)
diff --git a/agents/drivers/oracle-go/main_test.go b/agents/drivers/oracle-go/main_test.go
index ac6ed234e9..6711ab05d2 100644
--- a/agents/drivers/oracle-go/main_test.go
+++ b/agents/drivers/oracle-go/main_test.go
@@ -2971,13 +2971,15 @@ func contains(values []string, target string) bool {
}
type oracleViewSourceQueryStep struct {
- queryContains string
- args []driver.Value
- columns []string
- rows [][]driver.Value
- err error
- exec bool
- panicText string
+ queryContains string
+ args []driver.Value
+ columns []string
+ rows [][]driver.Value
+ err error
+ exec bool
+ panicText string
+ nextPanicText string
+ columnsPanicText string
}
type oracleViewSourceDriver struct {
@@ -3038,7 +3040,12 @@ func (c *oracleViewSourceConn) QueryContext(
if len(columns) == 0 {
columns = []string{"SOURCE"}
}
- return &oracleViewSourceRows{columns: columns, values: step.rows}, nil
+ return &oracleViewSourceRows{
+ columns: columns,
+ values: step.rows,
+ nextPanicText: step.nextPanicText,
+ columnsPanicText: step.columnsPanicText,
+ }, nil
}
func (c *oracleViewSourceConn) ExecContext(
@@ -3068,12 +3075,17 @@ func (c *oracleViewSourceConn) ExecContext(
}
type oracleViewSourceRows struct {
- columns []string
- values [][]driver.Value
- next int
+ columns []string
+ values [][]driver.Value
+ next int
+ nextPanicText string
+ columnsPanicText string
}
func (r *oracleViewSourceRows) Columns() []string {
+ if r.columnsPanicText != "" {
+ panic(r.columnsPanicText)
+ }
return r.columns
}
@@ -3082,6 +3094,9 @@ func (r *oracleViewSourceRows) Close() error {
}
func (r *oracleViewSourceRows) Next(dest []driver.Value) error {
+ if r.nextPanicText != "" {
+ panic(r.nextPanicText)
+ }
if r.next >= len(r.values) {
return io.EOF
}
@@ -3374,6 +3389,131 @@ func TestOracleQueryRowsKeepsSTAsTextErrorWhenPlaceholderAlsoFails(t *testing.T)
}
}
+func TestReadQuerySessionPageConvertsPanicToError(t *testing.T) {
+ // A nil *sql.Rows makes rows.Next() panic with a nil pointer dereference,
+ // which stands in for go-ora panicking while decoding an unknown type.
+ session := &querySession{rows: nil, columns: []string{"A"}, columnTypes: []string{"NUMBER"}, remaining: 1}
+ result, err := readQuerySessionPage(session, 10)
+ var panicErr oracleDriverPanicError
+ if !errors.As(err, &panicErr) {
+ t.Fatalf("expected oracle driver panic error, got %v", err)
+ }
+ if len(result.Rows) != 0 {
+ t.Fatalf("panic path must not return rows, got %v", result.Rows)
+ }
+}
+
+func TestExecuteQueryPageRetriesWithPlaceholderOnRowIterationPanic(t *testing.T) {
+ db, scripted := openOracleViewSourceTestDB(t, []oracleViewSourceQueryStep{
+ {
+ queryContains: "SELECT * FROM SDE.TEST_GEOM",
+ args: []driver.Value{},
+ columns: []string{"ID", "GEOM"},
+ rows: [][]driver.Value{{int64(1), "raw geometry bytes"}},
+ nextPanicText: "simulated go-ora decode panic on custom type column",
+ },
+ {
+ queryContains: "ALL_TAB_COLUMNS",
+ args: []driver.Value{"SDE", "TEST_GEOM"},
+ columns: []string{"COLUMN_NAME", "DATA_TYPE", "DATA_TYPE_OWNER"},
+ rows: [][]driver.Value{
+ {"ID", "NUMBER", nil},
+ {"GEOM", "ST_GEOMETRY", "SDE"},
+ },
+ },
+ {
+ queryContains: "'<ST_GEOMETRY>'",
+ args: []driver.Value{},
+ columns: []string{"ID", "GEOM", "__DBX_LARGE_VALUE_BYTES_C_1"},
+ rows: [][]driver.Value{{int64(1), "<ST_GEOMETRY>", "D:1"}},
+ },
+ })
+ s := newServer()
+ s.db = db
+ result, err := s.executeQueryPage(queryOptions{SQL: "SELECT * FROM SDE.TEST_GEOM"}, 10)
+ if err != nil {
+ t.Fatalf("expected placeholder retry to serve the first page, got %v", err)
+ }
+ if scripted.next != len(scripted.steps) {
+ t.Fatalf("expected %d queries, got %d", len(scripted.steps), scripted.next)
+ }
+ if len(result.Rows) != 1 {
+ t.Fatalf("expected one placeholder row, got %v", result.Rows)
+ }
+ want := []any{int64(1), "<ST_GEOMETRY>", "D:1"}
+ if !reflect.DeepEqual(result.Rows[0], want) {
+ t.Fatalf("unexpected row: %v, want %v", result.Rows[0], want)
+ }
+ if result.SessionID != nil || result.HasMore {
+ t.Fatalf("fully drained page must not keep a session: %v %v", result.SessionID, result.HasMore)
+ }
+}
+
+func TestExecuteQueryPageSurfacesPanicWhenPlaceholderNotApplicable(t *testing.T) {
+ db, scripted := openOracleViewSourceTestDB(t, []oracleViewSourceQueryStep{
+ {
+ queryContains: "SELECT * FROM SDE.TEST_GEOM",
+ args: []driver.Value{},
+ columns: []string{"ID"},
+ rows: [][]driver.Value{{int64(1)}},
+ nextPanicText: "simulated go-ora decode panic on custom type column",
+ },
+ {
+ queryContains: "ALL_TAB_COLUMNS",
+ args: []driver.Value{"SDE", "TEST_GEOM"},
+ columns: []string{"COLUMN_NAME", "DATA_TYPE", "DATA_TYPE_OWNER"},
+ rows: [][]driver.Value{{"ID", "NUMBER", nil}},
+ },
+ })
+ s := newServer()
+ s.db = db
+ result, err := s.executeQueryPage(queryOptions{SQL: "SELECT * FROM SDE.TEST_GEOM"}, 10)
+ var panicErr oracleDriverPanicError
+ if !errors.As(err, &panicErr) {
+ t.Fatalf("expected oracle driver panic error, got %v", err)
+ }
+ if scripted.next != len(scripted.steps) {
+ t.Fatalf("expected %d queries, got %d", len(scripted.steps), scripted.next)
+ }
+ if len(result.Rows) != 0 {
+ t.Fatalf("failed query must not return rows, got %v", result.Rows)
+ }
+}
+
+func TestRuntimeHandleLineRecoversRequestPanic(t *testing.T) {
+ db, _ := openOracleViewSourceTestDB(t, []oracleViewSourceQueryStep{
+ {
+ queryContains: "SELECT * FROM SDE.TEST_GEOM",
+ args: []driver.Value{},
+ columnsPanicText: "simulated go-ora panic while describing columns",
+ },
+ })
+ runtime := newRuntimeServer()
+ session := newServer()
+ session.db = db
+ runtime.sessions["agent-session-1"] = &agentSession{server: session}
+
+ resp, shutdown := runtime.handleLine(`{"jsonrpc":"2.0","id":5,"method":"execute_query_page","params":{"agentSessionId":"agent-session-1","sql":"SELECT * FROM SDE.TEST_GEOM","pageSize":10}}`)
+ if shutdown {
+ t.Fatal("recovered panic must not shut down the agent")
+ }
+ if resp.Error == nil {
+ t.Fatalf("expected panic error response, got %+v", resp)
+ }
+ if !strings.Contains(resp.Error.Message, "agent request panic") {
+ t.Fatalf("unexpected error message: %s", resp.Error.Message)
+ }
+ if string(resp.ID) != "5" {
+ t.Fatalf("panic response must keep the request id, got %s", resp.ID)
+ }
+
+ // The RPC stream must survive the panic and keep serving requests.
+ followUp, shutdown := runtime.handleLine(`{"jsonrpc":"2.0","id":6,"method":"handshake","params":{}}`)
+ if shutdown || followUp.Error != nil {
+ t.Fatalf("handshake after recovered panic failed: shutdown=%v error=%v", shutdown, followUp.Error)
+ }
+}
+
func TestManualTransactionBeginCommitRollback(t *testing.T) {
db, driver := openOracleManualTxTestDB(t)
s := newServer()