25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(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.goindex 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) (queryPageResHasMore: 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) (queryPageResulif !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.goindex 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()