Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

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.go
index 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.go
index a1af4f9191..3ce85f4f84 100644
--- a/backend/plugin/parser/pg/access_tables.go
+++ b/backend/plugin/parser/pg/access_tables.go
@@ -3,8 +3,7 @@ package pg
import (
"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.BasePostgreSQLParserListener
err error
defaultDatabase string
searchPath []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 default
if 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.go
new file mode 100644
index 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.go
index 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.go
index d87573ccd8..e7e30d5f8c 100644
--- a/backend/plugin/parser/pg/pg.go
+++ b/backend/plugin/parser/pg/pg.go
@@ -1,11 +1,15 @@
package pg
import (
+ "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.go
index 6c7f4b4191..8885861542 100644
--- a/backend/plugin/parser/pg/plsql.go
+++ b/backend/plugin/parser/pg/plsql.go
@@ -1,45 +1,22 @@
package pg
import (
- 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 statement
if 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.go
index 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.go
index bf432ccd40..299328638c 100644
--- a/backend/plugin/parser/pg/query_antlr.go
+++ b/backend/plugin/parser/pg/query_antlr.go
@@ -1,13 +1,14 @@
package pg
import (
- "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 error
if 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.go
index 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 map
accessesMap := 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.go
index 542adec39b..93eb101195 100644
--- a/backend/plugin/parser/pg/resource_change.go
+++ b/backend/plugin/parser/pg/resource_change.go
@@ -3,11 +3,9 @@ package pg
import (
"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 summary
if 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.Relname
if 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 := searchPath
if 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.go
index 687f0894f7..148870e55e 100644
--- a/backend/plugin/parser/pg/statement_type.go
+++ b/backend/plugin/parser/pg/statement_type.go
@@ -1,7 +1,8 @@
package pg
import (
- "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 []StatementTypeWithPosition
for _, 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, nil
diff --git a/backend/plugin/parser/pg/statement_type_antlr.go b/backend/plugin/parser/pg/statement_type_antlr.go
index 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 pg
import (
- "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.yaml
index 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.mod
index b59b3bf744..56eb3bf545 100644
--- a/go.mod
+++ b/go.mod
@@ -34,7 +34,7 @@ require (
github.com/bmatcuk/doublestar/v4 v4.10.0
github.com/bytebase/gomongo v0.0.0-20260211083148-d2ea344b4b65
github.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-4f43b2c93e35
github.com/caarlos0/env/v11 v11.4.0
github.com/cenkalti/backoff/v5 v5.0.3
github.com/cockroachdb/cockroachdb-parser v0.25.2
diff --git a/go.sum b/go.sum
index 76f88d6940..0b28a97b51 100644
--- a/go.sum
+++ b/go.sum
@@ -253,8 +253,8 @@ github.com/bytebase/gomongo v0.0.0-20260211083148-d2ea344b4b65 h1:RvViQx0e24DeDJ
github.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=