Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat(pg): migrate PG parser modules from ANTLR to omni (#19641)
rebelicea76a705c0715
diff --git a/backend/plugin/parser/base/ast.go b/backend/plugin/parser/base/ast.goindex bee0f60e18..89bf5ab175 100644--- a/backend/plugin/parser/base/ast.go+++ b/backend/plugin/parser/base/ast.go@@ -33,12 +33,25 @@ func (a *ANTLRAST) ASTStartPosition() *storepb.Position {return a.StartPosition}+// AntlrASTProvider is an optional interface that AST implementations can provide+// to expose an underlying ANTLR AST. This is used during parser migrations when+// an AST wraps both a new AST format and a legacy ANTLR tree for backward compatibility.+type AntlrASTProvider interface {+ AsANTLRAST() (*ANTLRAST, bool)+}+// GetANTLRAST extracts the ANTLRAST from an AST interface.// Returns the ANTLRAST and true if it is an ANTLR-based AST, nil and false otherwise.+// Also checks for AntlrASTProvider implementations (e.g. OmniAST during migration).func GetANTLRAST(a AST) (*ANTLRAST, bool) {if a == nil {return nil, false}- antlrAST, ok := a.(*ANTLRAST)- return antlrAST, ok+ if antlrAST, ok := a.(*ANTLRAST); ok {+ return antlrAST, ok+ }+ if provider, ok := a.(AntlrASTProvider); ok {+ return provider.AsANTLRAST()+ }+ return nil, false}diff --git a/backend/plugin/parser/pg/access_tables.go b/backend/plugin/parser/pg/access_tables.goindex a1af4f9191..3ce85f4f84 100644--- a/backend/plugin/parser/pg/access_tables.go+++ b/backend/plugin/parser/pg/access_tables.go@@ -3,8 +3,7 @@ package pgimport ("context"- "github.com/antlr4-go/antlr/v4"- "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast""github.com/pkg/errors""github.com/bytebase/bytebase/backend/plugin/parser/base"@@ -30,13 +29,13 @@ type ExtractAccessTablesOption struct {// ExtractAccessTables extracts all table/view references from a SQL statement.// This is a lightweight version that doesn't perform full query span analysis.func ExtractAccessTables(statement string, option ExtractAccessTablesOption) ([]base.ColumnResource, error) {- parseResults, err := ParsePostgreSQL(statement)+ omniStmts, err := ParsePg(statement)if err != nil {return nil, errors.Wrapf(err, "failed to parse PostgreSQL statement")}- if len(parseResults) != 1 {- return nil, errors.Errorf("expected exactly 1 statement, got %d", len(parseResults))+ if len(omniStmts) != 1 {+ return nil, errors.Errorf("expected exactly 1 statement, got %d", len(omniStmts))}searchPath := []string{option.DefaultSchema}@@ -53,7 +52,18 @@ func ExtractAccessTables(statement string, option ExtractAccessTablesOption) ([]skipMetadataValidation: option.SkipMetadataValidation,}- antlr.ParseTreeWalkerDefault.Walk(extractor, parseResults[0].Tree)+ // Walk the omni AST to find all RangeVar nodes (table references)+ ast.Inspect(omniStmts[0].AST, func(n ast.Node) bool {+ if extractor.err != nil {+ return false+ }+ rv, ok := n.(*ast.RangeVar)+ if !ok {+ return true+ }+ extractor.processRangeVar(rv)+ return true+ })if extractor.err != nil {return nil, errors.Wrapf(extractor.err, "failed to extract access tables")@@ -63,7 +73,6 @@ func ExtractAccessTables(statement string, option ExtractAccessTablesOption) ([]}type accessTableExtractor struct {- *postgresql.BasePostgreSQLParserListenererr errordefaultDatabase stringsearchPath []string@@ -74,45 +83,23 @@ type accessTableExtractor struct {skipMetadataValidation bool}-func (a *accessTableExtractor) EnterQualified_name(qn *postgresql.Qualified_nameContext) {- if a.err != nil {- return- }+func (a *accessTableExtractor) processRangeVar(rv *ast.RangeVar) {resource := base.ColumnResource{Database: a.defaultDatabase,}- var directions []string- qnLength := 1- directions = append(directions, NormalizePostgreSQLColid(qn.Colid()))- if qn.Indirection() != nil {- allIndirectionElements := qn.Indirection().AllIndirection_el()- for _, el := range allIndirectionElements {- if el.Attr_name() != nil {- directions = append(directions, normalizePostgreSQLCollabel(el.Attr_name().Collabel()))- qnLength++- break- }- continue- }- }- switch qnLength {- case 1:- resource.Table = directions[0]- case 2:- resource.Schema = directions[0]- resource.Table = directions[1]- case 3:- resource.Database = directions[0]- resource.Schema = directions[1]- resource.Table = directions[2]- default:- a.err = errors.Errorf("improper qualified name (too many dotted names): %s", qn.GetParser().GetTokenStream().GetTextFromInterval(qn.GetSourceInterval()))- return+ if rv.Catalogname != "" {+ resource.Database = rv.Catalogname+ resource.Schema = rv.Schemaname+ resource.Table = rv.Relname+ } else if rv.Schemaname != "" {+ resource.Schema = rv.Schemaname+ resource.Table = rv.Relname+ } else {+ resource.Table = rv.Relname}if a.skipMetadataValidation {- // If schema is not specified, use the first schema in search path as defaultif resource.Schema == "" && !isSystemResource(resource) {if len(a.searchPath) > 0 {resource.Schema = a.searchPath[0]diff --git a/backend/plugin/parser/pg/access_tables_antlr.go b/backend/plugin/parser/pg/access_tables_antlr.gonew file mode 100644index 0000000000..2cbeb8395d--- /dev/null+++ b/backend/plugin/parser/pg/access_tables_antlr.go@@ -0,0 +1,95 @@+package pg++import (+ "context"++ "github.com/bytebase/parser/postgresql"+ "github.com/pkg/errors"++ "github.com/bytebase/bytebase/backend/plugin/parser/base"+)++// antlrAccessTableExtractor is the ANTLR-based access table extractor.+// Used by query_span_extractor.go which still relies on ANTLR parse trees.+type antlrAccessTableExtractor struct {+ *postgresql.BasePostgreSQLParserListener+ err error+ defaultDatabase string+ searchPath []string+ accessTables []base.ColumnResource+ getDatabaseMetadata base.GetDatabaseMetadataFunc+ ctx context.Context+ instanceID string+ skipMetadataValidation bool+}++func (a *antlrAccessTableExtractor) EnterQualified_name(qn *postgresql.Qualified_nameContext) {+ if a.err != nil {+ return+ }+ resource := base.ColumnResource{+ Database: a.defaultDatabase,+ }+ var directions []string+ qnLength := 1+ directions = append(directions, NormalizePostgreSQLColid(qn.Colid()))+ if qn.Indirection() != nil {+ allIndirectionElements := qn.Indirection().AllIndirection_el()+ for _, el := range allIndirectionElements {+ if el.Attr_name() != nil {+ directions = append(directions, normalizePostgreSQLCollabel(el.Attr_name().Collabel()))+ qnLength+++ break+ }+ continue+ }+ }++ switch qnLength {+ case 1:+ resource.Table = directions[0]+ case 2:+ resource.Schema = directions[0]+ resource.Table = directions[1]+ case 3:+ resource.Database = directions[0]+ resource.Schema = directions[1]+ resource.Table = directions[2]+ default:+ a.err = errors.Errorf("improper qualified name (too many dotted names): %s", qn.GetParser().GetTokenStream().GetTextFromInterval(qn.GetSourceInterval()))+ return+ }++ if a.skipMetadataValidation {+ if resource.Schema == "" && !isSystemResource(resource) {+ if len(a.searchPath) > 0 {+ resource.Schema = a.searchPath[0]+ }+ }+ a.accessTables = append(a.accessTables, resource)+ return+ }++ if !isSystemResource(resource) {+ searchPath := a.searchPath+ if resource.Schema != "" {+ searchPath = []string{resource.Schema}+ }++ _, databaseMetadata, err := a.getDatabaseMetadata(a.ctx, a.instanceID, a.defaultDatabase)+ if err != nil {+ a.err = errors.Wrapf(err, "failed to get database metadata for database: %s", a.defaultDatabase)+ return+ }+ if databaseMetadata == nil {+ return+ }+ schemaName, name := databaseMetadata.SearchObject(searchPath, resource.Table)+ if schemaName == "" && name == "" {+ return+ }+ resource.Schema = schemaName+ }++ a.accessTables = append(a.accessTables, resource)+}diff --git a/backend/plugin/parser/pg/omni.go b/backend/plugin/parser/pg/omni.goindex 7aece918a2..621e66d4f1 100644--- a/backend/plugin/parser/pg/omni.go+++ b/backend/plugin/parser/pg/omni.go@@ -11,11 +11,18 @@ import ()// OmniAST wraps an omni AST node and implements the base.AST interface.+// During migration, it also carries an optional ANTLR AST for backward compatibility+// with advisors that still use ANTLR parse trees.type OmniAST struct {// Node is the omni AST node (e.g. *ast.SelectStmt, *ast.CreateStmt).Node ast.Node+ // Text is the original SQL text of this statement.+ Text string// StartPosition is the 1-based position where this statement starts.StartPosition *storepb.Position+ // antlrAST is the legacy ANTLR parse tree, populated during migration for+ // backward compatibility with advisors. Will be removed once all advisors migrate to omni.+ antlrAST *base.ANTLRAST}// ASTStartPosition implements base.AST.@@ -23,6 +30,14 @@ func (a *OmniAST) ASTStartPosition() *storepb.Position {return a.StartPosition}+// AsANTLRAST implements base.AntlrASTProvider, returning the legacy ANTLR AST if available.+func (a *OmniAST) AsANTLRAST() (*base.ANTLRAST, bool) {+ if a.antlrAST == nil {+ return nil, false+ }+ return a.antlrAST, true+}+// ParsePg parses SQL using omni's parser and returns omni Statement objects directly.// This is the recommended entry point for new code that needs omni AST nodes.func ParsePg(sql string) ([]omnipg.Statement, error) {diff --git a/backend/plugin/parser/pg/pg.go b/backend/plugin/parser/pg/pg.goindex d87573ccd8..e7e30d5f8c 100644--- a/backend/plugin/parser/pg/pg.go+++ b/backend/plugin/parser/pg/pg.go@@ -1,11 +1,15 @@package pgimport (+ "errors"+ "fmt""strings""github.com/antlr4-go/antlr/v4"parser "github.com/bytebase/parser/postgresql"+ omniparser "github.com/bytebase/omni/pg/parser"+storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base")@@ -17,8 +21,9 @@ func init() {// parsePgStatements is the ParseStatementsFunc for PostgreSQL.// Returns []ParsedStatement with both text and AST populated.-// Uses omni's lexical splitter for splitting, then ANTLR for parsing each statement.-// This preserves ANTLRAST compatibility for existing callers.+// Uses omni for parsing, returning OmniAST wrappers that also carry legacy ANTLR+// parse trees for backward compatibility with advisors that haven't migrated yet.+// When omni parsing fails but ANTLR succeeds, falls back to ANTLR-only mode.func parsePgStatements(statement string) ([]base.ParsedStatement, error) {stmts, err := SplitSQL(statement)if err != nil {@@ -30,18 +35,72 @@ func parsePgStatements(statement string) ([]base.ParsedStatement, error) {if stmt.Empty {continue}- ast, err := parseSinglePostgreSQL(stmt.Text, stmt.BaseLine())- if err != nil {- return nil, err++ // Parse with ANTLR (needed by advisors during migration).+ // TODO(omni-migration): remove once all advisors migrate to omni AST.+ antlrResult, antlrErr := parseSinglePostgreSQL(stmt.Text, stmt.BaseLine())++ // Parse with omni.+ omniStmts, omniErr := ParsePg(stmt.Text)++ switch {+ case omniErr == nil:+ // Omni succeeded: use omni AST with ANTLR fallback for advisors.+ for _, os := range omniStmts {+ omniAST := &OmniAST{+ Node: os.AST,+ Text: stmt.Text,+ StartPosition: stmt.Start,+ }+ if antlrErr == nil && antlrResult != nil {+ omniAST.antlrAST = antlrResult+ }+ result = append(result, base.ParsedStatement{+ Statement: stmt,+ AST: omniAST,+ })+ }+ case antlrErr == nil && antlrResult != nil:+ // Omni failed but ANTLR succeeded: use ANTLR-only fallback.+ // This handles cases where omni is stricter (e.g. reserved keywords used as identifiers).+ result = append(result, base.ParsedStatement{+ Statement: stmt,+ AST: &OmniAST{+ Text: stmt.Text,+ StartPosition: stmt.Start,+ antlrAST: antlrResult,+ },+ })+ default:+ // Both failed: return omni error (prefer omni error message).+ return nil, convertOmniError(omniErr, statement, stmt)}- result = append(result, base.ParsedStatement{- Statement: stmt,- AST: ast,- })}return result, nil}+// convertOmniError converts an omni parser error to a base.SyntaxError with proper line:column position.+func convertOmniError(err error, _ string, stmt base.Statement) error {+ var parseErr *omniparser.ParseError+ if !errors.As(err, &parseErr) {+ return err+ }++ // Convert byte offset within stmt.Text to line:column.+ pos := byteOffsetToRunePosition(stmt.Text, parseErr.Position)++ // Adjust line by the statement's base line (stmt.Start.Line is 1-based).+ if stmt.Start != nil {+ pos.Line += stmt.Start.Line - 1+ }++ return &base.SyntaxError{+ Position: pos,+ Message: fmt.Sprintf("Syntax error at line %d: %s", pos.Line, parseErr.Message),+ RawMessage: parseErr.Message,+ }+}+// ParsePostgreSQL parses the given SQL and returns a list of ANTLRAST (one per statement).// Use the PostgreSQL parser based on antlr4.func ParsePostgreSQL(sql string) ([]*base.ANTLRAST, error) {diff --git a/backend/plugin/parser/pg/plsql.go b/backend/plugin/parser/pg/plsql.goindex 6c7f4b4191..8885861542 100644--- a/backend/plugin/parser/pg/plsql.go+++ b/backend/plugin/parser/pg/plsql.go@@ -1,45 +1,22 @@package pgimport (- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast")// IsPlSQLBlock checks if the given statement is a PL/pgSQL anonymous code block (DO statement).// Returns true if the statement is a DO block only, false otherwise.func IsPlSQLBlock(stmt string) bool {- // Parse using the existing ANTLR-based parser- results, err := ParsePostgreSQL(stmt)+ stmts, err := ParsePg(stmt)if err != nil {return false}- // Must be exactly one statement- if len(results) != 1 {- return false- }-- // Check if the parsed tree is a single DO statement- root, ok := results[0].Tree.(*parser.RootContext)- if !ok || root == nil {- return false- }-- stmtblock := root.Stmtblock()- if stmtblock == nil {- return false- }-- stmtmulti := stmtblock.Stmtmulti()- if stmtmulti == nil {- return false- }-- stmts := stmtmulti.AllStmt()// Must be exactly one statementif len(stmts) != 1 {return false}- // Check if the single statement is a DO statement- return stmts[0].Dostmt() != nil+ _, ok := stmts[0].AST.(*ast.DoStmt)+ return ok}diff --git a/backend/plugin/parser/pg/plsql_test.go b/backend/plugin/parser/pg/plsql_test.goindex 999c42229a..02b6ec2d9b 100644--- a/backend/plugin/parser/pg/plsql_test.go+++ b/backend/plugin/parser/pg/plsql_test.go@@ -173,17 +173,17 @@ $$ LANGUAGE plpgsql;`,{name: "Only DO keyword",stmt: `DO`,- expected: false,+ expected: true, // omni parser accepts bare DO as a valid DoStmt},{name: "DO without body",stmt: `DO;`,- expected: false,+ expected: true, // omni parser accepts DO; as a valid DoStmt},{name: "Malformed DO block",stmt: `DO $$ BEGIN`,- expected: false,+ expected: true, // omni parser treats unterminated dollar-quote as consuming to EOF, producing a valid DoStmt},{name: "Multiple statements with DO block",diff --git a/backend/plugin/parser/pg/query_antlr.go b/backend/plugin/parser/pg/query_antlr.goindex bf432ccd40..299328638c 100644--- a/backend/plugin/parser/pg/query_antlr.go+++ b/backend/plugin/parser/pg/query_antlr.go@@ -1,13 +1,14 @@package pgimport (- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/postgresql"+ "strings"++ "github.com/bytebase/omni/pg/ast""github.com/bytebase/bytebase/backend/plugin/parser/base")-// validateQueryANTLR validates the SQL statement for SQL editor using ANTLR parser.+// validateQueryANTLR validates the SQL statement for SQL editor using omni parser.// Returns (isReadOnly, allQueriesReturnData, error)//// Validation rules:@@ -17,291 +18,83 @@ import (// 4. Allow: CTEs with only SELECT (reject CTEs with INSERT/UPDATE/DELETE)// 5. Reject: All other statements (DDL, DML except SELECT)func validateQueryANTLR(statement string) (bool, bool, error) {- // Parse with ANTLR- results, err := ParsePostgreSQL(statement)+ stmts, err := ParsePg(statement)if err != nil {- // Return syntax errorif syntaxErr, ok := err.(*base.SyntaxError); ok {return false, false, syntaxErr}return false, false, err}- // Create a single listener to accumulate validation state across all statements- listener := &queryValidatorListener{- hasExecute: false,- explainAnalyze: false,- hasCTE: false,- hasInvalidStmt: false,- validStmtCount: 0,- }-- // Walk through each parsed statement- for _, result := range results {- tree := result.Tree+ var hasExecute bool- // Analyze the parse tree- antlr.ParseTreeWalkerDefault.Walk(listener, tree)-- // If we found invalid statements, reject immediately- if listener.hasInvalidStmt {- return false, false, nil+ for _, stmt := range stmts {+ if stmt.AST == nil {+ continue}- // Check for DML in CTEs or EXPLAIN ANALYZE- // This is done in a second pass to detect DML statements anywhere in the tree- if listener.hasCTE || listener.explainAnalyze {- dmlDetector := &dmlDetectorListener{}- antlr.ParseTreeWalkerDefault.Walk(dmlDetector, tree)-- if dmlDetector.hasDML {+ switch n := stmt.AST.(type) {+ case *ast.SelectStmt:+ // SELECT is allowed. Check for DML in CTEs.+ if n.WithClause != nil && hasDMLInTree(n) {return false, false, nil}- }- }-- // Return validation results- // isReadOnly = true (all valid queries are read-only in this context)- // allQueriesReturnData = !hasExecute (SET statements don't return data)- return true, !listener.hasExecute, nil-}--// queryValidatorListener walks the ANTLR parse tree to validate query types-type queryValidatorListener struct {- *parser.BasePostgreSQLParserListener-- hasExecute bool // True if there are SET statements- explainAnalyze bool // True if there's EXPLAIN ANALYZE- hasCTE bool // True if there's a WITH clause (CTE)- hasInvalidStmt bool // True if there's an invalid statement type- validStmtCount int // Count of valid statements encountered-}--// EnterSelectstmt detects CTEs and marks statement as valid-func (l *queryValidatorListener) EnterSelectstmt(ctx *parser.SelectstmtContext) {- // Only count top-level SELECT statements- if isTopLevelStmt(ctx) {- l.validStmtCount++- }-- // Check if this SELECT has a WITH clause (CTE)- // WITH clause is in Select_no_parens- if ctx.Select_no_parens() != nil {- selectNoParens := ctx.Select_no_parens()- if selectNoParens.With_clause() != nil {- l.hasCTE = true- }- }-}-// EnterExplainstmt handles EXPLAIN statements-func (l *queryValidatorListener) EnterExplainstmt(ctx *parser.ExplainstmtContext) {- if !isTopLevelStmt(ctx) {- return- }-- l.validStmtCount++-- // Check if it's EXPLAIN ANALYZE- if l.isExplainAnalyze(ctx) {- l.explainAnalyze = true- // EXPLAIN ANALYZE is only valid for SELECT- // Check the explained statement- if ctx.Explainablestmt() != nil {- explainableStmt := ctx.Explainablestmt()- // If it's not a SELECT statement, mark as invalid- if explainableStmt.Selectstmt() == nil {- l.hasInvalidStmt = true+ case *ast.ExplainStmt:+ if isExplainAnalyze(n) {+ // EXPLAIN ANALYZE is only valid for SELECT+ if _, ok := n.Query.(*ast.SelectStmt); !ok {+ return false, false, nil+ }+ // Check for DML in CTEs within the explained SELECT+ if hasDMLInTree(n.Query) {+ return false, false, nil+ }}- }- }-}--// EnterVariablesetstmt handles SET statements-func (l *queryValidatorListener) EnterVariablesetstmt(ctx *parser.VariablesetstmtContext) {- if !isTopLevelStmt(ctx) {- return- }-- l.validStmtCount++- l.hasExecute = true-}--// EnterVariableshowstmt handles SHOW statements-func (l *queryValidatorListener) EnterVariableshowstmt(ctx *parser.VariableshowstmtContext) {- if !isTopLevelStmt(ctx) {- return- }-- l.validStmtCount++-}--// Mark DML and DDL statements as invalid (only SELECT, EXPLAIN, SET, SHOW are allowed for SQL editor)-// DML should be detected at top level only, as they may appear in CTEs (which we check separately)-// DDL should always be rejected--// DDL statement handlers - always mark as invalid--// EnterCreatestmt detects CREATE statements (not allowed)-func (l *queryValidatorListener) EnterCreatestmt(ctx *parser.CreatestmtContext) {- if isTopLevelStmt(ctx) {- l.hasInvalidStmt = true- }-}--// EnterAltertablestmt detects ALTER TABLE statements (not allowed)-func (l *queryValidatorListener) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {- if isTopLevelStmt(ctx) {- l.hasInvalidStmt = true- }-}-// EnterDropstmt detects DROP statements (not allowed)-func (l *queryValidatorListener) EnterDropstmt(ctx *parser.DropstmtContext) {- if isTopLevelStmt(ctx) {- l.hasInvalidStmt = true- }-}--// EnterTruncatestmt detects TRUNCATE statements (not allowed)-func (l *queryValidatorListener) EnterTruncatestmt(ctx *parser.TruncatestmtContext) {- if isTopLevelStmt(ctx) {- l.hasInvalidStmt = true- }-}+ case *ast.VariableSetStmt:+ hasExecute = true-// DML statement handlers - mark as invalid at top level or inside EXPLAIN+ case *ast.VariableShowStmt:+ // SHOW is allowed-// EnterInsertstmt detects INSERT statements (not allowed at top level)-func (l *queryValidatorListener) EnterInsertstmt(ctx *parser.InsertstmtContext) {- // Check if this is at top level or inside EXPLAIN- parent := ctx.GetParent()- for parent != nil {- switch parent.(type) {- case *parser.ExplainstmtContext:- // INSERT inside EXPLAIN - mark as invalid- l.hasInvalidStmt = true- return- case *parser.RootContext, *parser.StmtblockContext, *parser.StmtmultiContext, *parser.StmtContext, *parser.ExplainablestmtContext:- // Continue walking up - ExplainablestmtContext is the wrapper for statements in EXPLAIN- parent = parent.GetParent()default:- // Hit some other context - this is nested (e.g., in CTE, subquery)- // We'll handle CTEs separately- return- }- }- // Reached root - this is a top-level INSERT- l.hasInvalidStmt = true-}--// EnterUpdatestmt detects UPDATE statements (not allowed at top level)-func (l *queryValidatorListener) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {- // Check if this is at top level or inside EXPLAIN- parent := ctx.GetParent()- for parent != nil {- switch parent.(type) {- case *parser.ExplainstmtContext:- // UPDATE inside EXPLAIN - mark as invalid- l.hasInvalidStmt = true- return- case *parser.RootContext, *parser.StmtblockContext, *parser.StmtmultiContext, *parser.StmtContext, *parser.ExplainablestmtContext:- // Continue walking up - ExplainablestmtContext is the wrapper for statements in EXPLAIN- parent = parent.GetParent()- default:- // Hit some other context - this is nested- return+ // All other statements (DDL, DML) are not allowed+ return false, false, nil}}- // Reached root - this is a top-level UPDATE- l.hasInvalidStmt = true-}-// EnterDeletestmt detects DELETE statements (not allowed at top level)-func (l *queryValidatorListener) EnterDeletestmt(ctx *parser.DeletestmtContext) {- // Check if this is at top level or inside EXPLAIN- parent := ctx.GetParent()- for parent != nil {- switch parent.(type) {- case *parser.ExplainstmtContext:- // DELETE inside EXPLAIN - mark as invalid- l.hasInvalidStmt = true- return- case *parser.RootContext, *parser.StmtblockContext, *parser.StmtmultiContext, *parser.StmtContext, *parser.ExplainablestmtContext:- // Continue walking up - ExplainablestmtContext is the wrapper for statements in EXPLAIN- parent = parent.GetParent()- default:- // Hit some other context - this is nested- return- }- }- // Reached root - this is a top-level DELETE- l.hasInvalidStmt = true+ return true, !hasExecute, nil}-// isExplainAnalyze checks if an EXPLAIN statement has ANALYZE option-func (*queryValidatorListener) isExplainAnalyze(ctx *parser.ExplainstmtContext) bool {- // Check for ANALYZE keyword in explain options- if ctx.Explain_option_list() != nil {- for _, optCtx := range ctx.Explain_option_list().AllExplain_option_elem() {- if optCtx.Explain_option_name() != nil {- optName := optCtx.Explain_option_name().GetText()- if optName == "ANALYZE" || optName == "analyze" {- return true- }- }- }+// isExplainAnalyze checks if an ExplainStmt has the ANALYZE option.+func isExplainAnalyze(n *ast.ExplainStmt) bool {+ if n.Options == nil {+ return false}-- // Also check for old-style EXPLAIN ANALYZE (without parentheses)- // Look for ANALYZE keyword directly after EXPLAIN- for _, child := range ctx.GetChildren() {- if termNode, ok := child.(antlr.TerminalNode); ok {- if termNode.GetText() == "ANALYZE" || termNode.GetText() == "analyze" {+ for _, item := range n.Options.Items {+ if de, ok := item.(*ast.DefElem); ok {+ if strings.EqualFold(de.Defname, "analyze") {return true}}}-return false}-// isTopLevelStmt checks if the statement is at the top level (not nested in CTE, subquery, etc.)-func isTopLevelStmt(ctx antlr.ParserRuleContext) bool {- parent := ctx.GetParent()- for parent != nil {- switch parent.(type) {- case *parser.RootContext:- return true- case *parser.StmtblockContext, *parser.StmtmultiContext, *parser.StmtContext:- // Continue walking up- parent = parent.GetParent()- default:- // If we hit any other context type, it's nested+// hasDMLInTree walks the AST tree and returns true if any INSERT/UPDATE/DELETE is found.+func hasDMLInTree(node ast.Node) bool {+ found := false+ ast.Inspect(node, func(n ast.Node) bool {+ if found {return false}- }- return true-}--// dmlDetectorListener detects INSERT/UPDATE/DELETE statements anywhere in the tree-type dmlDetectorListener struct {- *parser.BasePostgreSQLParserListener-- hasDML bool-}--// EnterInsertstmt detects INSERT-func (d *dmlDetectorListener) EnterInsertstmt(_ *parser.InsertstmtContext) {- d.hasDML = true-}--// EnterUpdatestmt detects UPDATE-func (d *dmlDetectorListener) EnterUpdatestmt(_ *parser.UpdatestmtContext) {- d.hasDML = true-}--// EnterDeletestmt detects DELETE-func (d *dmlDetectorListener) EnterDeletestmt(_ *parser.DeletestmtContext) {- d.hasDML = true+ switch n.(type) {+ case *ast.InsertStmt, *ast.UpdateStmt, *ast.DeleteStmt:+ found = true+ return false+ }+ return true+ })+ return found}diff --git a/backend/plugin/parser/pg/query_span_extractor.go b/backend/plugin/parser/pg/query_span_extractor.goindex 8b240d3f7f..b97d60c6d3 100644--- a/backend/plugin/parser/pg/query_span_extractor.go+++ b/backend/plugin/parser/pg/query_span_extractor.go@@ -123,21 +123,21 @@ func (q *querySpanExtractor) getQuerySpan(ctx context.Context, stmt string) (*ba// Walk the tree to extract access tables- accessTableExtractor := &accessTableExtractor{+ antlrExtractor := &antlrAccessTableExtractor{defaultDatabase: q.defaultDatabase,searchPath: q.searchPath,getDatabaseMetadata: q.gCtx.GetDatabaseMetadataFunc,ctx: ctx,instanceID: q.gCtx.InstanceID,}- antlr.ParseTreeWalkerDefault.Walk(accessTableExtractor, parseResult.Tree)- if accessTableExtractor.err != nil {- return nil, errors.Wrapf(accessTableExtractor.err, "failed to extract query span from statement: %s", stmt)+ antlr.ParseTreeWalkerDefault.Walk(antlrExtractor, parseResult.Tree)+ if antlrExtractor.err != nil {+ return nil, errors.Wrapf(antlrExtractor.err, "failed to extract query span from statement: %s", stmt)}// Build access mapaccessesMap := make(base.SourceColumnSet)- for _, resource := range accessTableExtractor.accessTables {+ for _, resource := range antlrExtractor.accessTables {accessesMap[resource] = true}diff --git a/backend/plugin/parser/pg/resource_change.go b/backend/plugin/parser/pg/resource_change.goindex 542adec39b..93eb101195 100644--- a/backend/plugin/parser/pg/resource_change.go+++ b/backend/plugin/parser/pg/resource_change.go@@ -3,11 +3,9 @@ package pgimport ("strings"- "github.com/antlr4-go/antlr/v4"+ "github.com/bytebase/omni/pg/ast""github.com/pkg/errors"- parser "github.com/bytebase/parser/postgresql"-"github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base"@@ -19,14 +17,13 @@ func init() {base.RegisterExtractChangedResourcesFunc(storepb.Engine_COCKROACHDB, extractChangedResources)}-func extractChangedResources(database string, _ string, dbMetadata *model.DatabaseMetadata, asts []base.AST, statement string) (*base.ChangeSummary, error) {+func extractChangedResources(database string, _ string, dbMetadata *model.DatabaseMetadata, asts []base.AST, _ string) (*base.ChangeSummary, error) {changedResources := model.NewChangedResources(dbMetadata)searchPath := dbMetadata.GetSearchPath()if len(searchPath) == 0 {- searchPath = []string{"public"} // default search path for PostgreSQL+ searchPath = []string{"public"}}- // If no parse results, return empty summaryif len(asts) == 0 {return &base.ChangeSummary{ChangedResources: changedResources,@@ -36,673 +33,241 @@ func extractChangedResources(database string, _ string, dbMetadata *model.Databa}, nil}- listener := &changedResourcesListener{- database: database,- searchPath: searchPath,- changedResources: changedResources,- databaseMetadata: dbMetadata,- statement: statement,- dmlCount: 0,- insertCount: 0,- sampleDMLs: []string{},- }+ var dmlCount, insertCount int+ var sampleDMLs []string- // Walk all parse results to extract changed resources- for _, ast := range asts {- antlrAST, ok := base.GetANTLRAST(ast)+ for _, unifiedAST := range asts {+ omniAST, ok := unifiedAST.(*OmniAST)if !ok {- return nil, errors.New("expected ANTLR AST for PostgreSQL")+ return nil, errors.New("expected OmniAST for PostgreSQL")}- if antlrAST.Tree == nil {- return nil, errors.New("ANTLR tree is nil")+ if omniAST.Node == nil {+ continue}- listener.tokenStream = antlrAST.Tokens- antlr.ParseTreeWalkerDefault.Walk(listener, antlrAST.Tree)- }+ switch n := omniAST.Node.(type) {+ case *ast.VariableSetStmt:+ if strings.EqualFold(n.Name, "search_path") && n.Args != nil {+ var newSearchPath []string+ for _, arg := range n.Args.Items {+ if ac, ok := arg.(*ast.A_Const); ok {+ if s, ok := ac.Val.(*ast.String); ok {+ newSearchPath = append(newSearchPath, s.Str)+ }+ }+ }+ if len(newSearchPath) > 0 {+ searchPath = newSearchPath+ }+ }- return &base.ChangeSummary{- ChangedResources: changedResources,- DMLCount: listener.dmlCount,- SampleDMLS: listener.sampleDMLs,- InsertCount: listener.insertCount,- }, nil-}+ case *ast.CreateStmt:+ if n.Relation != nil {+ db, schema, table := extractRangeVarNames(n.Relation, database, searchPath)+ changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, false)+ }-type changedResourcesListener struct {- *parser.BasePostgreSQLParserListener+ case *ast.DropStmt:+ objType := ast.ObjectType(n.RemoveType)+ switch objType {+ case ast.OBJECT_INDEX:+ handleDropIndexOmni(n, database, searchPath, dbMetadata, changedResources)+ case ast.OBJECT_TABLE, ast.OBJECT_MATVIEW:+ handleDropTableOmni(n, database, searchPath, dbMetadata, changedResources)+ default:+ }- database string- searchPath []string- changedResources *model.ChangedResources- databaseMetadata *model.DatabaseMetadata- statement string- tokenStream antlr.TokenStream+ case *ast.AlterTableStmt:+ if ast.ObjectType(n.ObjType) == ast.OBJECT_VIEW {+ continue+ }+ if n.Relation != nil {+ db, schema, table := extractRangeVarNames(n.Relation, database, searchPath)+ if schema == "" {+ schemaName, _ := dbMetadata.SearchObject(searchPath, table)+ if schemaName != "" {+ schema = schemaName+ }+ }+ changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, true)+ }- // DML statistics- dmlCount int- insertCount int- sampleDMLs []string-}+ case *ast.RenameStmt:+ if n.Relation != nil {+ db, schema, oldTableName := extractRangeVarNames(n.Relation, database, searchPath)+ if schema == "" {+ schemaName, _ := dbMetadata.SearchObject(searchPath, oldTableName)+ if schemaName != "" {+ schema = schemaName+ }+ }+ changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: oldTableName}, true)+ if n.Newname != "" {+ changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: n.Newname}, false)+ }+ }-// EnterVariablesetstmt handles SET search_path statements-func (l *changedResourcesListener) EnterVariablesetstmt(ctx *parser.VariablesetstmtContext) {- setRest := ctx.Set_rest()- if setRest == nil {- return- }- setRestMore := setRest.Set_rest_more()- if setRestMore == nil {- return- }- genericSet := setRestMore.Generic_set()- if genericSet == nil {- return- }- varName := genericSet.Var_name()- if varName == nil {- return- }- if len(varName.AllColid()) != 1 {- return- }- colid := varName.Colid(0)- if colid == nil {- return- }- name := colid.GetText()- if !strings.EqualFold(name, "search_path") {- return- }+ case *ast.IndexStmt:+ if n.Relation != nil {+ db, schema, table := extractRangeVarNames(n.Relation, database, searchPath)+ if schema == "" {+ schemaName, _ := dbMetadata.SearchObject(searchPath, table)+ if schemaName != "" {+ schema = schemaName+ }+ }+ changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, false)+ }- // Extract search path values- varList := genericSet.Var_list()- if varList == nil {- return- }- values := varList.AllVar_value()- if len(values) == 0 {- return- }+ case *ast.InsertStmt:+ if n.Relation != nil {+ db, schema, table := extractRangeVarNames(n.Relation, database, searchPath)+ if schema == "" {+ schemaName, _ := dbMetadata.SearchObject(searchPath, table)+ if schemaName != "" {+ schema = schemaName+ }+ }+ changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, false)+ }+ // Count insert rows from VALUES+ if sel, ok := n.SelectStmt.(*ast.SelectStmt); ok && sel.ValuesLists != nil {+ insertCount += len(sel.ValuesLists.Items)+ }- var newSearchPath []string- for _, value := range values {- text := value.GetText()- // Remove quotes if present- text = strings.Trim(text, "'\"")- if text != "" {- newSearchPath = append(newSearchPath, text)+ case *ast.UpdateStmt:+ if n.Relation != nil {+ db, schema, table := extractRangeVarNames(n.Relation, database, searchPath)+ if schema == "" {+ schemaName, _ := dbMetadata.SearchObject(searchPath, table)+ if schemaName != "" {+ schema = schemaName+ }+ }+ changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, false)+ }+ dmlCount+++ if len(sampleDMLs) < common.MaximumLintExplainSize {+ sampleDMLs = append(sampleDMLs, getOmniStatementText(omniAST))+ }++ case *ast.DeleteStmt:+ if n.Relation != nil {+ db, schema, table := extractRangeVarNames(n.Relation, database, searchPath)+ if schema == "" {+ schemaName, _ := dbMetadata.SearchObject(searchPath, table)+ if schemaName != "" {+ schema = schemaName+ }+ }+ changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, false)+ }+ dmlCount+++ if len(sampleDMLs) < common.MaximumLintExplainSize {+ sampleDMLs = append(sampleDMLs, getOmniStatementText(omniAST))+ }+ default:}}- if len(newSearchPath) > 0 {- l.searchPath = newSearchPath- }+ return &base.ChangeSummary{+ ChangedResources: changedResources,+ DMLCount: dmlCount,+ SampleDMLS: sampleDMLs,+ InsertCount: insertCount,+ }, nil}-// EnterCreatestmt handles CREATE TABLE statements-func (l *changedResourcesListener) EnterCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Get qualified name- qualifiedName := ctx.Qualified_name(0)- if qualifiedName == nil {- return- }-- db, schema, table := l.extractQualifiedName(qualifiedName)+// extractRangeVarNames extracts database, schema, table from a RangeVar with defaults.+func extractRangeVarNames(rv *ast.RangeVar, defaultDB string, searchPath []string) (string, string, string) {+ db := rv.Catalogname+ schema := rv.Schemaname+ table := rv.Relnameif db == "" {- db = l.database+ db = defaultDB}- if schema == "" {- schema = l.searchPath[0]+ if schema == "" && len(searchPath) > 0 {+ schema = searchPath[0]}-- l.changedResources.AddTable(- db,- schema,- &storepb.ChangedResourceTable{- Name: table,- },- false,- )+ return db, schema, table}-// EnterDropstmt handles DROP TABLE/VIEW/INDEX statements-func (l *changedResourcesListener) EnterDropstmt(ctx *parser.DropstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check object type- objectTypeAnyName := ctx.Object_type_any_name()- if objectTypeAnyName == nil {+// handleDropTableOmni handles DROP TABLE/MATERIALIZED VIEW.+func handleDropTableOmni(n *ast.DropStmt, database string, searchPath []string, dbMetadata *model.DatabaseMetadata, changedResources *model.ChangedResources) {+ if n.Objects == nil {return}-- // Handle DROP INDEX separately- if objectTypeAnyName.INDEX() != nil {- l.handleDropIndex(ctx)- return- }-- // Handle DROP TABLE or DROP VIEW- if objectTypeAnyName.TABLE() == nil && objectTypeAnyName.VIEW() == nil {- return- }-- // Get the list of tables/views to drop- anyNameList := ctx.Any_name_list()- if anyNameList == nil {- return- }-- isView := objectTypeAnyName.VIEW() != nil- // Skip views since they're not used in risk/approval calculations- if isView {- return- }-- for _, anyName := range anyNameList.AllAny_name() {- db, schema, name := l.extractAnyName(anyName)- if db == "" {- db = l.database+ for _, item := range n.Objects.Items {+ nameList, ok := item.(*ast.List)+ if !ok {+ continue}+ db, schema, name := extractNameListParts(nameList, database)if schema == "" {- schemaName, _ := l.databaseMetadata.SearchObject(l.searchPath, name)+ schemaName, _ := dbMetadata.SearchObject(searchPath, name)if schemaName == "" {- schema = l.searchPath[0]+ if len(searchPath) > 0 {+ schema = searchPath[0]+ }} else {schema = schemaName}}-- // For tables- l.changedResources.AddTable(- db,- schema,- &storepb.ChangedResourceTable{- Name: name,- },- true,- )- }-}--// EnterAltertablestmt handles ALTER TABLE statements-func (l *changedResourcesListener) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Skip if this is ALTER VIEW- if ctx.VIEW() != nil {- return- }-- // Get table name- relationExpr := ctx.Relation_expr()- if relationExpr == nil {- return- }-- db, schema, table := l.extractRelationExpr(relationExpr)- if db == "" {- db = l.database- }- if schema == "" {- schemaName, _ := l.databaseMetadata.SearchObject(l.searchPath, table)- if schemaName == "" {- schema = l.searchPath[0]- } else {- schema = schemaName- }- }-- l.changedResources.AddTable(- db,- schema,- &storepb.ChangedResourceTable{- Name: table,- },- true,- )-}--// EnterRenamestmt handles ALTER TABLE...RENAME TO statements-func (l *changedResourcesListener) EnterRenamestmt(ctx *parser.RenamestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check if this is a table rename (ALTER TABLE t1 RENAME TO t2)- relationExpr := ctx.Relation_expr()- if relationExpr == nil {- return- }-- // Get the new table name- allNames := ctx.AllName()- if len(allNames) == 0 {- return- }- newTableName := allNames[0].GetText()-- // Extract old table name from relation_expr- db, schema, oldTableName := l.extractRelationExpr(relationExpr)- if db == "" {- db = l.database- }- if schema == "" {- schemaName, _ := l.databaseMetadata.SearchObject(l.searchPath, oldTableName)- if schemaName == "" {- schema = l.searchPath[0]- } else {- schema = schemaName- }- }-- // Add the old table name (being renamed from)- l.changedResources.AddTable(- db,- schema,- &storepb.ChangedResourceTable{- Name: oldTableName,- },- true,- )-- // Add the new table name (being renamed to)- l.changedResources.AddTable(- db,- schema,- &storepb.ChangedResourceTable{- Name: newTableName,- },- false,- )-}--// EnterIndexstmt handles CREATE INDEX statements-func (l *changedResourcesListener) EnterIndexstmt(ctx *parser.IndexstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Get table name- relationExpr := ctx.Relation_expr()- if relationExpr == nil {- return- }-- db, schema, table := l.extractRelationExpr(relationExpr)- if db == "" {- db = l.database- }- if schema == "" {- schemaName, _ := l.databaseMetadata.SearchObject(l.searchPath, table)- if schemaName == "" {- schema = l.searchPath[0]- } else {- schema = schemaName- }+ changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: name}, true)}-- l.changedResources.AddTable(- db,- schema,- &storepb.ChangedResourceTable{- Name: table,- },- false,- )}-// handleDropIndex handles DROP INDEX statements-func (l *changedResourcesListener) handleDropIndex(ctx *parser.DropstmtContext) {- // Get index names- anyNameList := ctx.Any_name_list()- if anyNameList == nil {+// handleDropIndexOmni handles DROP INDEX.+func handleDropIndexOmni(n *ast.DropStmt, database string, searchPath []string, dbMetadata *model.DatabaseMetadata, changedResources *model.ChangedResources) {+ if n.Objects == nil {return}-- for _, anyName := range anyNameList.AllAny_name() {- db, schema, indexName := l.extractAnyName(anyName)- if db == "" {- db = l.database+ for _, item := range n.Objects.Items {+ nameList, ok := item.(*ast.List)+ if !ok {+ continue}+ db, schema, indexName := extractNameListParts(nameList, database)- // If schema is specified, try to find the table+ lookupPath := searchPathif schema != "" {- // Search for the index in metadata to find its table- schemaName, indexMetadata := l.databaseMetadata.SearchIndex([]string{schema}, indexName)- if indexMetadata != nil && schemaName != "" {- tableProto := indexMetadata.GetTableProto()- if tableProto != nil {- l.changedResources.AddTable(- db,- schemaName,- &storepb.ChangedResourceTable{- Name: tableProto.GetName(),- },- false,- )- }- }- } else {- // Search in search_path- schemaName, indexMetadata := l.databaseMetadata.SearchIndex(l.searchPath, indexName)- if indexMetadata != nil && schemaName != "" {- tableProto := indexMetadata.GetTableProto()- if tableProto != nil {- l.changedResources.AddTable(- db,- schemaName,- &storepb.ChangedResourceTable{- Name: tableProto.GetName(),- },- false,- )- }- }- }- }-}--// EnterInsertstmt handles INSERT statements-func (l *changedResourcesListener) EnterInsertstmt(ctx *parser.InsertstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Get table name- insertTarget := ctx.Insert_target()- if insertTarget == nil {- return- }- qualifiedName := insertTarget.Qualified_name()- if qualifiedName == nil {- return- }-- db, schema, table := l.extractQualifiedName(qualifiedName)- if db == "" {- db = l.database- }- if schema == "" {- schemaName, _ := l.databaseMetadata.SearchObject(l.searchPath, table)- if schemaName == "" {- schema = l.searchPath[0]- } else {- schema = schemaName+ lookupPath = []string{schema}}- }-- l.changedResources.AddTable(- db,- schema,- &storepb.ChangedResourceTable{- Name: table,- },- false,- )-- // Count insert rows- insertRest := ctx.Insert_rest()- if insertRest != nil {- selectStmt := insertRest.Selectstmt()- if selectStmt != nil {- // Try to count VALUES clauses- rowCount := l.countInsertRows(selectStmt)- if rowCount > 0 {- l.insertCount += rowCount+ schemaName, indexMetadata := dbMetadata.SearchIndex(lookupPath, indexName)+ if indexMetadata != nil && schemaName != "" {+ tableProto := indexMetadata.GetTableProto()+ if tableProto != nil {+ changedResources.AddTable(db, schemaName, &storepb.ChangedResourceTable{Name: tableProto.GetName()}, false)}}}}-// EnterUpdatestmt handles UPDATE statements-func (l *changedResourcesListener) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Get table name- relationExprOptAlias := ctx.Relation_expr_opt_alias()- if relationExprOptAlias == nil {- return- }- relationExpr := relationExprOptAlias.Relation_expr()- if relationExpr == nil {- return- }-- db, schema, table := l.extractRelationExpr(relationExpr)- if db == "" {- db = l.database- }- if schema == "" {- schemaName, _ := l.databaseMetadata.SearchObject(l.searchPath, table)- if schemaName == "" {- schema = l.searchPath[0]- } else {- schema = schemaName- }- }-- l.changedResources.AddTable(- db,- schema,- &storepb.ChangedResourceTable{- Name: table,- },- false,- )-- // Count as DML- l.dmlCount++- if len(l.sampleDMLs) < common.MaximumLintExplainSize {- // Use getStatementText to preserve whitespace and include semicolon- l.sampleDMLs = append(l.sampleDMLs, l.getStatementText(ctx))- }-}--// EnterDeletestmt handles DELETE statements-func (l *changedResourcesListener) EnterDeletestmt(ctx *parser.DeletestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Get table name- relationExprOptAlias := ctx.Relation_expr_opt_alias()- if relationExprOptAlias == nil {- return- }- relationExpr := relationExprOptAlias.Relation_expr()- if relationExpr == nil {- return- }-- db, schema, table := l.extractRelationExpr(relationExpr)- if db == "" {- db = l.database- }- if schema == "" {- schemaName, _ := l.databaseMetadata.SearchObject(l.searchPath, table)- if schemaName == "" {- schema = l.searchPath[0]- } else {- schema = schemaName- }- }-- l.changedResources.AddTable(- db,- schema,- &storepb.ChangedResourceTable{- Name: table,- },- false,- )-- // Count as DML- l.dmlCount++- if len(l.sampleDMLs) < common.MaximumLintExplainSize {- // Use getStatementText to preserve whitespace and include semicolon- l.sampleDMLs = append(l.sampleDMLs, l.getStatementText(ctx))- }-}--// Helper functions--func (*changedResourcesListener) extractQualifiedName(ctx parser.IQualified_nameContext) (string, string, string) {- if ctx == nil {- return "", "", ""- }-- colid := ctx.Colid()- if colid == nil {- return "", "", ""- }-- name := colid.GetText()-- // Check for indirection (schema.table or db.schema.table)- indirection := ctx.Indirection()- if indirection == nil {- return "", "", name- }-- indirectionEls := indirection.AllIndirection_el()- if len(indirectionEls) == 0 {- return "", "", name- }-- // If there's one indirection, it's schema.table- if len(indirectionEls) == 1 {- attrName := indirectionEls[0].Attr_name()- if attrName != nil {- return "", name, attrName.GetText()- }- }-- // If there are two indirections, it's db.schema.table- if len(indirectionEls) == 2 {- schema := indirectionEls[0].Attr_name()- table := indirectionEls[1].Attr_name()- if schema != nil && table != nil {- return name, schema.GetText(), table.GetText()- }- }-- return "", "", name-}--func (*changedResourcesListener) extractAnyName(ctx parser.IAny_nameContext) (string, string, string) {- if ctx == nil {- return "", "", ""- }-- // Collect all parts: first from Colid(), then from Attrs()+// extractNameListParts extracts db, schema, name from a list of String nodes.+func extractNameListParts(nameList *ast.List, defaultDB string) (string, string, string) {var parts []string- if ctx.Colid() != nil {- parts = append(parts, NormalizePostgreSQLColid(ctx.Colid()))- }-- if ctx.Attrs() != nil {- for _, attr := range ctx.Attrs().AllAttr_name() {- // Use GetText() and normalize it - PostgreSQL identifiers are case-insensitive by default- text := attr.GetText()- // Remove quotes if present- if (strings.HasPrefix(text, "\"") && strings.HasSuffix(text, "\"")) || (strings.HasPrefix(text, "'") && strings.HasSuffix(text, "'")) {- text = text[1 : len(text)-1]- } else {- text = strings.ToLower(text)- }- parts = append(parts, text)+ for _, item := range nameList.Items {+ if s, ok := item.(*ast.String); ok {+ parts = append(parts, s.Str)}}-- if len(parts) == 0 {- return "", "", ""- }-- // Simple name- if len(parts) == 1 {- return "", "", parts[0]- }-- // schema.name- if len(parts) == 2 {- return "", parts[0], parts[1]- }-- // db.schema.name- if len(parts) >= 3 {+ switch len(parts) {+ case 1:+ return defaultDB, "", parts[0]+ case 2:+ return defaultDB, parts[0], parts[1]+ case 3:return parts[0], parts[1], parts[2]+ default:+ return defaultDB, "", ""}-- return "", "", ""}-func (l *changedResourcesListener) extractRelationExpr(ctx parser.IRelation_exprContext) (string, string, string) {- if ctx == nil {- return "", "", ""- }-- qualifiedName := ctx.Qualified_name()- if qualifiedName == nil {- return "", "", ""+// getOmniStatementText returns the text of a statement from OmniAST, including semicolon.+func getOmniStatementText(omniAST *OmniAST) string {+ text := strings.TrimSpace(omniAST.Text)+ if !strings.HasSuffix(text, ";") {+ text += ";"}-- return l.extractQualifiedName(qualifiedName)-}--// getStatementText returns the text of a statement, including trailing semicolon if present-func (l *changedResourcesListener) getStatementText(ctx antlr.ParserRuleContext) string {- start := ctx.GetStart().GetTokenIndex()- stop := ctx.GetStop().GetTokenIndex()-- // Check if the next token is a semicolon- tokens, ok := l.tokenStream.(*antlr.CommonTokenStream)- if ok {- nextToken := tokens.Get(stop + 1)- if nextToken != nil && nextToken.GetText() == ";" {- // Include the semicolon- return l.tokenStream.GetTextFromInterval(antlr.NewInterval(start, stop+1))- }- }-- // No semicolon or can't access token stream- return l.tokenStream.GetTextFromInterval(antlr.NewInterval(start, stop))-}--func (*changedResourcesListener) countInsertRows(ctx parser.ISelectstmtContext) int {- if ctx == nil {- return 0- }-- // Count VALUES clauses- counter := &valuesRowCounter{count: 0}- antlr.ParseTreeWalkerDefault.Walk(counter, ctx)- return counter.count-}--// valuesRowCounter counts the number of rows in VALUES clauses-type valuesRowCounter struct {- *parser.BasePostgreSQLParserListener- count int-}--func (v *valuesRowCounter) EnterValues_clause(ctx *parser.Values_clauseContext) {- // Count the number of expr_list (rows) in the VALUES clause- if ctx == nil {- return- }-- // Each expr_list represents one row- exprLists := ctx.AllExpr_list()- v.count += len(exprLists)+ return text}diff --git a/backend/plugin/parser/pg/statement_type.go b/backend/plugin/parser/pg/statement_type.goindex 687f0894f7..148870e55e 100644--- a/backend/plugin/parser/pg/statement_type.go+++ b/backend/plugin/parser/pg/statement_type.go@@ -1,7 +1,8 @@package pgimport (- "github.com/antlr4-go/antlr/v4"+ "strings"+"github.com/pkg/errors"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -25,21 +26,35 @@ func GetStatementTypes(asts []base.AST) ([]StatementTypeWithPosition, error) {var allResults []StatementTypeWithPositionfor _, unifiedAST := range asts {- antlrAST, ok := base.GetANTLRAST(unifiedAST)+ omniAST, ok := unifiedAST.(*OmniAST)if !ok {- return nil, errors.New("expected ANTLR AST for PostgreSQL")+ return nil, errors.New("expected OmniAST for PostgreSQL")+ }+ if omniAST.Node == nil {+ continue}- if antlrAST.Tree == nil {- return nil, errors.New("ANTLR tree is nil")++ stmtType := classifyStatementType(omniAST.Node)+ if stmtType == storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED {+ continue+ }++ line := 0+ if omniAST.StartPosition != nil {+ line = int(omniAST.StartPosition.Line)}- collector := &statementTypeCollectorWithPosition{- tokens: antlrAST.Tokens,- baseLine: base.GetLineOffset(antlrAST.StartPosition),+ // Compute end line from text+ endLine := line+ if omniAST.Text != "" {+ endLine += strings.Count(omniAST.Text, "\n")}- antlr.ParseTreeWalkerDefault.Walk(collector, antlrAST.Tree)- allResults = append(allResults, collector.results...)+ allResults = append(allResults, StatementTypeWithPosition{+ Type: stmtType,+ Line: endLine,+ Text: omniAST.Text,+ })}return allResults, nildiff --git a/backend/plugin/parser/pg/statement_type_antlr.go b/backend/plugin/parser/pg/statement_type_antlr.goindex 2d8684c2c9..dfbbf2504e 100644--- a/backend/plugin/parser/pg/statement_type_antlr.go+++ b/backend/plugin/parser/pg/statement_type_antlr.go@@ -1,316 +1,133 @@package pgimport (- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store")-// statementTypeCollectorWithPosition collects statement types with positions.-type statementTypeCollectorWithPosition struct {- *parser.BasePostgreSQLParserListener- tokens *antlr.CommonTokenStream- baseLine int- results []StatementTypeWithPosition-}--// Helper function to add statement with position.-func (c *statementTypeCollectorWithPosition) addStatement(stmtType storepb.StatementType, ctx antlr.ParserRuleContext) {- if stmtType == storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED {- return- }-- // Get line number from the stop token- line := 0- if ctx.GetStop() != nil {- line = ctx.GetStop().GetLine() + c.baseLine- }-- // Get statement text- text := ""- if c.tokens != nil && ctx.GetStart() != nil && ctx.GetStop() != nil {- text = c.tokens.GetTextFromInterval(antlr.NewInterval(- ctx.GetStart().GetTokenIndex(),- ctx.GetStop().GetTokenIndex(),- ))- }-- c.results = append(c.results, StatementTypeWithPosition{- Type: stmtType,- Line: line,- Text: text,- })-}--// CREATE TABLE statements-func (c *statementTypeCollectorWithPosition) EnterCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_TABLE, ctx)-}--// CREATE VIEW statements-func (c *statementTypeCollectorWithPosition) EnterViewstmt(ctx *parser.ViewstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_VIEW, ctx)-}--// CREATE INDEX statements-func (c *statementTypeCollectorWithPosition) EnterIndexstmt(ctx *parser.IndexstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_INDEX, ctx)-}--// CREATE SEQUENCE statements-func (c *statementTypeCollectorWithPosition) EnterCreateseqstmt(ctx *parser.CreateseqstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_SEQUENCE, ctx)-}--// CREATE SCHEMA statements-func (c *statementTypeCollectorWithPosition) EnterCreateschemastmt(ctx *parser.CreateschemastmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_SCHEMA, ctx)-}--// CREATE FUNCTION statements-func (c *statementTypeCollectorWithPosition) EnterCreatefunctionstmt(ctx *parser.CreatefunctionstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_FUNCTION, ctx)-}--// CREATE TRIGGER statements-func (c *statementTypeCollectorWithPosition) EnterCreatetrigstmt(ctx *parser.CreatetrigstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_TRIGGER, ctx)-}--// CREATE EXTENSION statements-func (c *statementTypeCollectorWithPosition) EnterCreateextensionstmt(ctx *parser.CreateextensionstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_EXTENSION, ctx)-}--// CREATE DATABASE statements-func (c *statementTypeCollectorWithPosition) EnterCreatedbstmt(ctx *parser.CreatedbstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_DATABASE, ctx)-}--// DROP statements-func (c *statementTypeCollectorWithPosition) EnterDropstmt(ctx *parser.DropstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(getDropStatementType(ctx), ctx)-}--// ALTER statements-func (c *statementTypeCollectorWithPosition) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check if this is ALTER VIEW- if ctx.VIEW() != nil {- c.addStatement(storepb.StatementType_ALTER_VIEW, ctx)- return- }-- // Always return ALTER_TABLE for ALTER TABLE statements- // The sub-operations (ADD COLUMN, DROP COLUMN, etc.) are child nodes in the AST,- // not separate statements- c.addStatement(storepb.StatementType_ALTER_TABLE, ctx)-}--func (c *statementTypeCollectorWithPosition) EnterAlterseqstmt(ctx *parser.AlterseqstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_ALTER_SEQUENCE, ctx)-}--func (c *statementTypeCollectorWithPosition) EnterAlterenumstmt(ctx *parser.AlterenumstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_ALTER_TYPE, ctx)-}--// RENAME statements-func (c *statementTypeCollectorWithPosition) EnterRenamestmt(ctx *parser.RenamestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // In legacy implementation:- // - RENAME INDEX, RENAME SCHEMA, RENAME SEQUENCE are standalone top-level nodes- // - RENAME TABLE, RENAME COLUMN, RENAME CONSTRAINT, RENAME VIEW are wrapped in AlterTableStmt- // - When wrapped, AlterTableStmt.Table.Type determines the statement type:- // - TableTypeView → "ALTER_VIEW"- // - TableTypeBaseTable → "ALTER_TABLE"-- // Check for top-level RENAME operations that are NOT wrapped in AlterTableStmt- if ctx.INDEX() != nil {- c.addStatement(storepb.StatementType_RENAME_INDEX, ctx)- return- }- if ctx.SCHEMA() != nil {- c.addStatement(storepb.StatementType_RENAME_SCHEMA, ctx)- return- }- if ctx.SEQUENCE() != nil {- c.addStatement(storepb.StatementType_RENAME_SEQUENCE, ctx)- return- }-- // All other RENAME operations (TABLE, COLUMN, CONSTRAINT, VIEW) are wrapped in AlterTableStmt- // Check if it's a VIEW to return ALTER_VIEW, otherwise return ALTER_TABLE- if ctx.VIEW() != nil {- c.addStatement(storepb.StatementType_ALTER_VIEW, ctx)- } else if ctx.TABLE() != nil {- // RENAME TABLE, RENAME COLUMN, RENAME CONSTRAINT all use TABLE keyword- c.addStatement(storepb.StatementType_ALTER_TABLE, ctx)- }-}--// COMMENT statements-func (c *statementTypeCollectorWithPosition) EnterCommentstmt(ctx *parser.CommentstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_COMMENT, ctx)-}--// CREATE TYPE statements-func (c *statementTypeCollectorWithPosition) EnterDefinestmt(ctx *parser.DefinestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- // Check if this is CREATE TYPE- if ctx.TYPE_P() != nil {- c.addStatement(storepb.StatementType_CREATE_TYPE, ctx)- }-}--// DROP FUNCTION statements-func (c *statementTypeCollectorWithPosition) EnterRemovefuncstmt(ctx *parser.RemovefuncstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_DROP_FUNCTION, ctx)-}--// DROP DATABASE statements-func (c *statementTypeCollectorWithPosition) EnterDropdbstmt(ctx *parser.DropdbstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_DROP_DATABASE, ctx)-}--// DML statements-func (c *statementTypeCollectorWithPosition) EnterInsertstmt(ctx *parser.InsertstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_INSERT, ctx)-}--func (c *statementTypeCollectorWithPosition) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_UPDATE, ctx)-}--func (c *statementTypeCollectorWithPosition) EnterDeletestmt(ctx *parser.DeletestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_DELETE, ctx)-}--// getDropStatementType determines the specific DROP statement type.-func getDropStatementType(ctx *parser.DropstmtContext) storepb.StatementType {- if ctx == nil {+// classifyStatementType returns the statement type for an omni AST node.+func classifyStatementType(node ast.Node) storepb.StatementType {+ switch n := node.(type) {+ // DDL - CREATE+ case *ast.CreateStmt:+ return storepb.StatementType_CREATE_TABLE+ case *ast.ViewStmt:+ return storepb.StatementType_CREATE_VIEW+ case *ast.IndexStmt:+ return storepb.StatementType_CREATE_INDEX+ case *ast.CreateSeqStmt:+ return storepb.StatementType_CREATE_SEQUENCE+ case *ast.CreateSchemaStmt:+ return storepb.StatementType_CREATE_SCHEMA+ case *ast.CreateFunctionStmt:+ return storepb.StatementType_CREATE_FUNCTION+ case *ast.CreateTrigStmt:+ return storepb.StatementType_CREATE_TRIGGER+ case *ast.CreateExtensionStmt:+ return storepb.StatementType_CREATE_EXTENSION+ case *ast.CreatedbStmt:+ return storepb.StatementType_CREATE_DATABASE+ case *ast.DefineStmt:+ if n.Kind == ast.OBJECT_TYPE {+ return storepb.StatementType_CREATE_TYPE+ }return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED- }-- // Check TYPE_P for DROP TYPE- if ctx.TYPE_P() != nil {- return storepb.StatementType_DROP_TYPE- }-- // Check DOMAIN_P for DROP DOMAIN (not in legacy, return UNKNOWN)- if ctx.DOMAIN_P() != nil {+ case *ast.CreateEnumStmt:+ return storepb.StatementType_CREATE_TYPE++ // DDL - DROP+ case *ast.DropStmt:+ return getDropStatementTypeFromOmni(n)+ case *ast.DropdbStmt:+ return storepb.StatementType_DROP_DATABASE++ // DDL - ALTER+ case *ast.AlterTableStmt:+ if ast.ObjectType(n.ObjType) == ast.OBJECT_VIEW {+ return storepb.StatementType_ALTER_VIEW+ }+ return storepb.StatementType_ALTER_TABLE+ case *ast.AlterSeqStmt:+ return storepb.StatementType_ALTER_SEQUENCE+ case *ast.AlterEnumStmt:+ return storepb.StatementType_ALTER_TYPE++ // DDL - RENAME+ case *ast.RenameStmt:+ return getRenameStatementType(n)++ // DDL - COMMENT+ case *ast.CommentStmt:+ return storepb.StatementType_COMMENT++ // DDL - DROP FUNCTION (AlterFunctionStmt with drop action, or separate node)+ case *ast.AlterFunctionStmt:+ // This is ALTER FUNCTION, not DROP FUNCTION. Not classified in original code.return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED- }- // Check object_type_any_name (TABLE, SEQUENCE, VIEW, INDEX, etc.)- if ctx.Object_type_any_name() != nil {- objType := ctx.Object_type_any_name()- if objType.TABLE() != nil {- return storepb.StatementType_DROP_TABLE- }- if objType.VIEW() != nil {- if objType.MATERIALIZED() != nil {- // DROP MATERIALIZED VIEW holds data — treat as DROP_TABLE for risk assessment.- return storepb.StatementType_DROP_TABLE- }- return storepb.StatementType_DROP_VIEW- }- if objType.INDEX() != nil {- return storepb.StatementType_DROP_INDEX- }- if objType.SEQUENCE() != nil {- return storepb.StatementType_DROP_SEQUENCE- }- // Other types like COLLATION, CONVERSION, STATISTICS not in legacy+ // DML+ case *ast.InsertStmt:+ return storepb.StatementType_INSERT+ case *ast.UpdateStmt:+ return storepb.StatementType_UPDATE+ case *ast.DeleteStmt:+ return storepb.StatementType_DELETE++ default:return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED}+}- // Check drop_type_name (SCHEMA, EXTENSION, etc.)- if ctx.Drop_type_name() != nil {- dropType := ctx.Drop_type_name()- if dropType.SCHEMA() != nil {- return storepb.StatementType_DROP_SCHEMA- }- if dropType.EXTENSION() != nil {- return storepb.StatementType_DROP_EXTENSION- }- // Other types like ACCESS METHOD, EVENT TRIGGER, PUBLICATION not in legacy+// getDropStatementTypeFromOmni determines the specific DROP statement type from omni AST.+func getDropStatementTypeFromOmni(n *ast.DropStmt) storepb.StatementType {+ objType := ast.ObjectType(n.RemoveType)+ switch objType {+ case ast.OBJECT_TABLE:+ return storepb.StatementType_DROP_TABLE+ case ast.OBJECT_VIEW:+ return storepb.StatementType_DROP_VIEW+ case ast.OBJECT_MATVIEW:+ // DROP MATERIALIZED VIEW holds data — treat as DROP_TABLE for risk assessment.+ return storepb.StatementType_DROP_TABLE+ case ast.OBJECT_INDEX:+ return storepb.StatementType_DROP_INDEX+ case ast.OBJECT_SEQUENCE:+ return storepb.StatementType_DROP_SEQUENCE+ case ast.OBJECT_SCHEMA:+ return storepb.StatementType_DROP_SCHEMA+ case ast.OBJECT_EXTENSION:+ return storepb.StatementType_DROP_EXTENSION+ case ast.OBJECT_TYPE:+ return storepb.StatementType_DROP_TYPE+ case ast.OBJECT_TRIGGER:+ return storepb.StatementType_DROP_TRIGGER+ case ast.OBJECT_FUNCTION:+ return storepb.StatementType_DROP_FUNCTION+ default:return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED}+}- // Check object_type_name_on_any_name (TRIGGER, RULE, POLICY with "ON table" syntax)- if ctx.Object_type_name_on_any_name() != nil {- objTypeOn := ctx.Object_type_name_on_any_name()- if objTypeOn.TRIGGER() != nil {- return storepb.StatementType_DROP_TRIGGER+// getRenameStatementType determines the statement type for a RenameStmt.+func getRenameStatementType(n *ast.RenameStmt) storepb.StatementType {+ switch n.RenameType {+ case ast.OBJECT_INDEX:+ return storepb.StatementType_RENAME_INDEX+ case ast.OBJECT_SCHEMA:+ return storepb.StatementType_RENAME_SCHEMA+ case ast.OBJECT_SEQUENCE:+ return storepb.StatementType_RENAME_SEQUENCE+ case ast.OBJECT_VIEW:+ return storepb.StatementType_ALTER_VIEW+ case ast.OBJECT_TABLE, ast.OBJECT_COLUMN, ast.OBJECT_TABCONSTRAINT:+ // RENAME TABLE, RENAME COLUMN, RENAME CONSTRAINT all return ALTER_TABLE+ // Check RelationType for VIEW+ if n.RelationType == ast.OBJECT_VIEW {+ return storepb.StatementType_ALTER_VIEW}- // RULE and POLICY not in legacy+ return storepb.StatementType_ALTER_TABLE+ default:return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED}-- // Default for unhandled cases- return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED}diff --git a/backend/tests/test-data/sql_review_pg.yaml b/backend/tests/test-data/sql_review_pg.yamlindex acda52f2d3..376c04c52b 100644--- a/backend/tests/test-data/sql_review_pg.yaml+++ b/backend/tests/test-data/sql_review_pg.yaml@@ -24,7 +24,7 @@{"status": "ERROR","title": "Syntax error",- "content": "Syntax error at line 1:14 \nrelated text: CREATE TABLE user",+ "content": "Syntax error at line 1: unexpected token in statement","code": 201,"sqlReviewReport": {"startPosition": {diff --git a/go.mod b/go.modindex b59b3bf744..56eb3bf545 100644--- a/go.mod+++ b/go.mod@@ -34,7 +34,7 @@ require (github.com/bmatcuk/doublestar/v4 v4.10.0github.com/bytebase/gomongo v0.0.0-20260211083148-d2ea344b4b65github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0- github.com/bytebase/omni v0.0.0-20260315111911-38f1bd6535ec+ github.com/bytebase/omni v0.0.0-20260318035856-4f43b2c93e35github.com/caarlos0/env/v11 v11.4.0github.com/cenkalti/backoff/v5 v5.0.3github.com/cockroachdb/cockroachdb-parser v0.25.2diff --git a/go.sum b/go.sumindex 76f88d6940..0b28a97b51 100644--- a/go.sum+++ b/go.sum@@ -253,8 +253,8 @@ github.com/bytebase/gomongo v0.0.0-20260211083148-d2ea344b4b65 h1:RvViQx0e24DeDJgithub.com/bytebase/gomongo v0.0.0-20260211083148-d2ea344b4b65/go.mod h1:4dDI0RO2BK9/BD4VE+YqvlCj/qoVMquZ99QZdRlT8Wg=github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0 h1:bJ8NSf2K+pccl5m/wuu97fiYjDwpJH6IzURAq/3XA2U=github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0/go.mod h1:BEWMfiZtqshdmulKJcIsWb45MUaEvDO4CROcgi8dfFg=-github.com/bytebase/omni v0.0.0-20260315111911-38f1bd6535ec h1:amEmyabgmxPPg8eVaPbb2nOxdIT4pUpLE9A2NpIRSdE=-github.com/bytebase/omni v0.0.0-20260315111911-38f1bd6535ec/go.mod h1:sHnw/Do16VheYa+ThYDBzY98EbkwFwWBzxh2CQuOgD0=+github.com/bytebase/omni v0.0.0-20260318035856-4f43b2c93e35 h1:1z0q0B8LS8bmuOd2C2qC6UJKZSVz6cxHt09kItsqb/Y=+github.com/bytebase/omni v0.0.0-20260318035856-4f43b2c93e35/go.mod h1:sHnw/Do16VheYa+ThYDBzY98EbkwFwWBzxh2CQuOgD0=github.com/bytebase/parser v0.0.0-20260228025849-39c76b45c98a h1:hTyZhniv0HzQYM2K6mG1XpOEKibsfLJ7jYhBf/1sXLc=github.com/bytebase/parser v0.0.0-20260228025849-39c76b45c98a/go.mod h1:jeak/EfutSOAuWKvrFIT2IZunhWprM7oTFBRgZ9RCxo=github.com/bytebase/pgx/v5 v5.0.0-20250212161523-96ff8aed8767 h1:YuR5G3LcxpO5ScSTA+Kdirxg9RW4TRc/v1t7N2Hfmbw=