Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor(parser/plsql): change ParsePLSQL to return list of AST nodes (#18056)
h3n4l839912625e50
diff --git a/backend/plugin/advisor/oracle/generic_checker.go b/backend/plugin/advisor/oracle/generic_checker.goindex 7967a75a41..ece915ea6b 100644--- a/backend/plugin/advisor/oracle/generic_checker.go+++ b/backend/plugin/advisor/oracle/generic_checker.go@@ -54,11 +54,17 @@ func (r *BaseRule) GetAdviceList() ([]*storepb.Advice, error) {return r.adviceList, nil}+// SetBaseLine sets the base line for the rule.+func (r *BaseRule) SetBaseLine(baseLine int) {+ r.baseLine = baseLine+}+// GenericChecker is the only type that embeds BasePlSqlParserListener.// It dispatches parse tree events to registered rules.type GenericChecker struct {*parser.BasePlSqlParserListener- rules []Rule+ rules []Rule+ baseLine int}// NewGenericChecker creates a new GenericChecker with the given rules.@@ -69,6 +75,16 @@ func NewGenericChecker(rules []Rule) *GenericChecker {}}+// SetBaseLine sets the base line number for error reporting.+func (g *GenericChecker) SetBaseLine(baseLine int) {+ g.baseLine = baseLine+}++// GetBaseLine returns the current base line number.+func (g *GenericChecker) GetBaseLine() int {+ return g.baseLine+}+// EnterEveryRule is called when the parser enters any rule context.func (g *GenericChecker) EnterEveryRule(ctx antlr.ParserRuleContext) {nodeType := g.getNodeType(ctx)diff --git a/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.goindex ee7b51c9da..e13714fbf6 100644--- a/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.go@@ -31,9 +31,9 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx advreturn nil, nil}- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -44,7 +44,11 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx advrule := NewStatementPriorBackupCheckRule(ctx, level, string(checkCtx.Rule.Type), checkCtx)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -75,15 +79,23 @@ type statementInfo struct {}func prepareTransformation(databaseName, statement string) ([]statementInfo, error) {- tree, _, err := plsqlparser.ParsePLSQL(statement)+ results, err := plsqlparser.ParsePLSQL(statement)if err != nil {return nil, errors.Wrap(err, "failed to parse PLSQL")}+ if len(results) == 0 {+ return nil, errors.New("no parse results")+ }extractor := &dmlExtractor{databaseName: databaseName,}- antlr.ParseTreeWalkerDefault.Walk(extractor, tree)++ // Walk each parse result tree to extract DML statements+ for _, result := range results {+ antlr.ParseTreeWalkerDefault.Walk(extractor, result.Tree)+ }+return extractor.dmls, nil}diff --git a/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.go b/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.goindex f39a643080..e8de7b7549 100644--- a/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.go+++ b/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -28,9 +29,9 @@ type ColumnAddNotNullColumnRequireDefaultAdvisor struct {// Check checks for adding not null column requires default.func (*ColumnAddNotNullColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -41,7 +42,11 @@ func (*ColumnAddNotNullColumnRequireDefaultAdvisor) Check(_ context.Context, cherule := NewColumnAddNotNullColumnRequireDefaultRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -122,7 +127,7 @@ func (r *ColumnAddNotNullColumnRequireDefaultRule) handleColumnDefinitionExit(ctr.level,advisor.NotNullColumnWithNoDefault.Int32(),fmt.Sprintf("Adding not null column %q requires default.", normalizeIdentifier(ctx.Column_name(), r.currentDatabase)),- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}}diff --git a/backend/plugin/advisor/oracle/rule_column_comment_convention.go b/backend/plugin/advisor/oracle/rule_column_comment_convention.goindex 1526619b6e..09c4902870 100644--- a/backend/plugin/advisor/oracle/rule_column_comment_convention.go+++ b/backend/plugin/advisor/oracle/rule_column_comment_convention.go@@ -28,9 +28,9 @@ type ColumnCommentConventionAdvisor struct {}func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -45,7 +45,11 @@ func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisorrule := NewColumnCommentConventionRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase, payload, checkCtx.ClassificationConfig)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -105,8 +109,6 @@ func (r *ColumnCommentConventionRule) OnExit(_ antlr.ParserRuleContext, nodeTyper.handleCreateTableExit()case "Add_column_clause":r.handleAddColumnClauseExit()- case "Sql_script":- r.handleSQLScriptExit()default:}return nil@@ -130,7 +132,7 @@ func (r *ColumnCommentConventionRule) handleColumnDefinition(ctx *parser.Column_}columnName := fmt.Sprintf(`%s.%s`, r.tableName, normalizeIdentifier(ctx.Column_name(), r.currentDatabase))r.columnNames = append(r.columnNames, columnName)- r.columnLine[columnName] = ctx.GetStart().GetLine()+ r.columnLine[columnName] = r.baseLine + ctx.GetStart().GetLine()}func (r *ColumnCommentConventionRule) handleAlterTable(ctx *parser.Alter_tableContext) {@@ -150,7 +152,9 @@ func (r *ColumnCommentConventionRule) handleCommentOnColumn(ctx *parser.Comment_r.columnComment[columnName] = plsqlparser.NormalizeQuotedString(ctx.Quoted_string())}-func (r *ColumnCommentConventionRule) handleSQLScriptExit() {+// GetAdviceList returns the advice list.+// We override this to perform final checks after all statements have been processed.+func (r *ColumnCommentConventionRule) GetAdviceList() ([]*storepb.Advice, error) {for _, columnName := range r.columnNames {comment, ok := r.columnComment[columnName]if !ok || comment == "" {@@ -183,4 +187,5 @@ func (r *ColumnCommentConventionRule) handleSQLScriptExit() {}}}+ return r.BaseRule.GetAdviceList()}diff --git a/backend/plugin/advisor/oracle/rule_column_maximum_character_length.go b/backend/plugin/advisor/oracle/rule_column_maximum_character_length.goindex 088941d33d..eb3978152d 100644--- a/backend/plugin/advisor/oracle/rule_column_maximum_character_length.go+++ b/backend/plugin/advisor/oracle/rule_column_maximum_character_length.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -29,9 +30,9 @@ type ColumnMaximumCharacterLengthAdvisor struct {// Check checks for maximum character length.func (*ColumnMaximumCharacterLengthAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -50,7 +51,11 @@ func (*ColumnMaximumCharacterLengthAdvisor) Check(_ context.Context, checkCtx adrule := NewColumnMaximumCharacterLengthRule(level, string(checkCtx.Rule.Type), payload.Number)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -113,6 +118,6 @@ func (r *ColumnMaximumCharacterLengthRule) handleDatatype(ctx *parser.DatatypeCor.level,advisor.CharLengthExceedsLimit.Int32(),fmt.Sprintf("The maximum character length is %d.", r.maximum),- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}diff --git a/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.go b/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.goindex e726f4b905..c5ff4d2910 100644--- a/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.go+++ b/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -29,9 +30,9 @@ type ColumnMaximumVarcharLengthAdvisor struct {// Check checks for maximum varchar length.func (*ColumnMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -50,7 +51,11 @@ func (*ColumnMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advirule := NewColumnMaximumVarcharLengthRule(level, string(checkCtx.Rule.Type), payload.Number)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -113,6 +118,6 @@ func (r *ColumnMaximumVarcharLengthRule) handleDatatype(ctx *parser.DatatypeContr.level,advisor.VarcharLengthExceedsLimit.Int32(),fmt.Sprintf("The maximum varchar length is %d.", r.maximum),- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}diff --git a/backend/plugin/advisor/oracle/rule_column_no_null.go b/backend/plugin/advisor/oracle/rule_column_no_null.goindex b2f79814a4..709e908526 100644--- a/backend/plugin/advisor/oracle/rule_column_no_null.go+++ b/backend/plugin/advisor/oracle/rule_column_no_null.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -31,9 +32,9 @@ type ColumnNoNullAdvisor struct {// Check checks for column no NULL value.func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -44,7 +45,11 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (rule := NewColumnNoNullRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -142,7 +147,7 @@ func (r *ColumnNoNullRule) handleColumnDefinition(ctx *parser.Column_definitionC}columnName := normalizeIdentifier(ctx.Column_name(), r.currentDatabase)r.columnID = fmt.Sprintf(`%s.%s`, r.tableName, columnName)- r.nullableColumns[r.columnID] = ctx.GetStart().GetLine()+ r.nullableColumns[r.columnID] = r.baseLine + ctx.GetStart().GetLine()}func (r *ColumnNoNullRule) handleInlineConstraint(ctx *parser.Inline_constraintContext) {@@ -150,7 +155,7 @@ func (r *ColumnNoNullRule) handleInlineConstraint(ctx *parser.Inline_constraintCreturn}if ctx.NULL_() != nil {- r.nullableColumns[r.columnID] = ctx.GetStart().GetLine()+ r.nullableColumns[r.columnID] = r.baseLine + ctx.GetStart().GetLine()}if ctx.NOT() != nil || ctx.PRIMARY() != nil {delete(r.nullableColumns, r.columnID)diff --git a/backend/plugin/advisor/oracle/rule_column_require.go b/backend/plugin/advisor/oracle/rule_column_require.goindex 6090c59a5b..104e1c206b 100644--- a/backend/plugin/advisor/oracle/rule_column_require.go+++ b/backend/plugin/advisor/oracle/rule_column_require.go@@ -14,6 +14,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -30,9 +31,9 @@ type ColumnRequireAdvisor struct {// Check checks for column requirement.func (*ColumnRequireAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -47,7 +48,11 @@ func (*ColumnRequireAdvisor) Check(_ context.Context, checkCtx advisor.Context)rule := NewColumnRequireRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase, columnList)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -137,7 +142,7 @@ func (r *ColumnRequireRule) handleCreateTableExit(ctx *parser.Create_tableContexr.level,advisor.NoRequiredColumn.Int32(),fmt.Sprintf("Table %q requires columns: %s", tableName, strings.Join(missingColumns, ", ")),- common.ConvertANTLRLineToPosition(ctx.GetStop().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStop().GetLine()),)}@@ -170,7 +175,7 @@ func (r *ColumnRequireRule) handleAlterTableExit(ctx *parser.Alter_tableContext)r.level,advisor.NoRequiredColumn.Int32(),fmt.Sprintf("Table %q requires columns: %s", tableName, strings.Join(missingColumns, ", ")),- common.ConvertANTLRLineToPosition(ctx.GetStop().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStop().GetLine()),)}diff --git a/backend/plugin/advisor/oracle/rule_column_require_default.go b/backend/plugin/advisor/oracle/rule_column_require_default.goindex 7c2d26a505..c80ba3847c 100644--- a/backend/plugin/advisor/oracle/rule_column_require_default.go+++ b/backend/plugin/advisor/oracle/rule_column_require_default.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -29,9 +30,9 @@ type ColumnRequireDefaultAdvisor struct {// Check checks for column default requirement.func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -42,7 +43,11 @@ func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Corule := NewColumnRequireDefaultRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -134,7 +139,7 @@ func (r *ColumnRequireDefaultRule) handleColumnDefinition(ctx *parser.Column_defcolumnName := normalizeIdentifier(ctx.Column_name(), r.currentDatabase)columnID := fmt.Sprintf(`%s.%s`, r.tableName, columnName)if ctx.DEFAULT() == nil {- r.noDefaultColumns[columnID] = ctx.GetStart().GetLine()+ r.noDefaultColumns[columnID] = r.baseLine + ctx.GetStart().GetLine()} else {delete(r.noDefaultColumns, columnID)}diff --git a/backend/plugin/advisor/oracle/rule_column_type_disallow_list.go b/backend/plugin/advisor/oracle/rule_column_type_disallow_list.goindex 202411a8a2..68f5891249 100644--- a/backend/plugin/advisor/oracle/rule_column_type_disallow_list.go+++ b/backend/plugin/advisor/oracle/rule_column_type_disallow_list.go@@ -29,9 +29,9 @@ type ColumnTypeDisallowListAdvisor struct {// Check checks for column type disallow list.func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -47,7 +47,11 @@ func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.rule := NewColumnTypeDisallowListRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase, payload.List)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -110,7 +114,7 @@ func (r *ColumnTypeDisallowListRule) handleColumnDefinition(ctx *parser.Column_dr.level,advisor.DisabledColumnType.Int32(),fmt.Sprintf("Disallow column type %s but column \"%s\" is", ctx.Datatype().GetText(), normalizeIdentifier(ctx.Column_name(), r.currentDatabase)),- common.ConvertANTLRLineToPosition(ctx.Datatype().GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.Datatype().GetStart().GetLine()),)}if ctx.Regular_id() != nil {@@ -120,7 +124,7 @@ func (r *ColumnTypeDisallowListRule) handleColumnDefinition(ctx *parser.Column_dr.level,advisor.DisabledColumnType.Int32(),fmt.Sprintf("Disallow column type %s but column \"%s\" is", ctx.Regular_id().GetText(), normalizeIdentifier(ctx.Column_name(), r.currentDatabase)),- common.ConvertANTLRLineToPosition(ctx.Regular_id().GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.Regular_id().GetStart().GetLine()),)break}@@ -134,7 +138,7 @@ func (r *ColumnTypeDisallowListRule) handleModifyColProperties(ctx *parser.Modifr.level,advisor.DisabledColumnType.Int32(),fmt.Sprintf("Disallow column type %s but column \"%s\" is", ctx.Datatype().GetText(), normalizeIdentifier(ctx.Column_name(), r.currentDatabase)),- common.ConvertANTLRLineToPosition(ctx.Datatype().GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.Datatype().GetStart().GetLine()),)}}diff --git a/backend/plugin/advisor/oracle/rule_index_key_number_limit.go b/backend/plugin/advisor/oracle/rule_index_key_number_limit.goindex e5e8e157bf..b2d2f56369 100644--- a/backend/plugin/advisor/oracle/rule_index_key_number_limit.go+++ b/backend/plugin/advisor/oracle/rule_index_key_number_limit.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -28,9 +29,9 @@ type IndexKeyNumberLimitAdvisor struct {// Check checks for index key number limit.func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -49,7 +50,11 @@ func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Conrule := NewIndexKeyNumberLimitRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase, payload.Number)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -100,7 +105,7 @@ func (r *IndexKeyNumberLimitRule) handleTableIndexClause(ctx *parser.Table_indexr.level,advisor.IndexKeyNumberExceedsLimit.Int32(),fmt.Sprintf("Index key number should be less than or equal to %d", r.max),- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}}@@ -112,7 +117,7 @@ func (r *IndexKeyNumberLimitRule) handleOutOfLineConstraint(ctx *parser.Out_of_lr.level,advisor.IndexKeyNumberExceedsLimit.Int32(),fmt.Sprintf("Index key number should be less than or equal to %d", r.max),- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}}diff --git a/backend/plugin/advisor/oracle/rule_insert_must_specify_column.go b/backend/plugin/advisor/oracle/rule_insert_must_specify_column.goindex 58de3a6fe7..7a2a38d521 100644--- a/backend/plugin/advisor/oracle/rule_insert_must_specify_column.go+++ b/backend/plugin/advisor/oracle/rule_insert_must_specify_column.go@@ -11,6 +11,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -27,9 +28,9 @@ type InsertMustSpecifyColumnAdvisor struct {// Check checks for to enforce column specified.func (*InsertMustSpecifyColumnAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -40,7 +41,11 @@ func (*InsertMustSpecifyColumnAdvisor) Check(_ context.Context, checkCtx advisorrule := NewInsertMustSpecifyColumnRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -84,7 +89,7 @@ func (r *InsertMustSpecifyColumnRule) handleInsertIntoClause(ctx *parser.Insert_r.level,advisor.InsertNotSpecifyColumn.Int32(),"INSERT statement should specify column name.",- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}}diff --git a/backend/plugin/advisor/oracle/rule_naming_identifier_case.go b/backend/plugin/advisor/oracle/rule_naming_identifier_case.goindex 3cf04a1fe6..4bb148dc08 100644--- a/backend/plugin/advisor/oracle/rule_naming_identifier_case.go+++ b/backend/plugin/advisor/oracle/rule_naming_identifier_case.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -29,9 +30,9 @@ type NamingIdentifierCaseAdvisor struct {// Check checks for identifier case.func (*NamingIdentifierCaseAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -46,7 +47,11 @@ func (*NamingIdentifierCaseAdvisor) Check(_ context.Context, checkCtx advisor.Corule := NewNamingIdentifierCaseRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase, payload.Upper)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -94,7 +99,7 @@ func (r *NamingIdentifierCaseRule) handleIDExpression(ctx *parser.Id_expressionCr.level,advisor.NamingCaseMismatch.Int32(),fmt.Sprintf("Identifier %q should be upper case", identifier),- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}} else {@@ -103,7 +108,7 @@ func (r *NamingIdentifierCaseRule) handleIDExpression(ctx *parser.Id_expressionCr.level,advisor.NamingCaseMismatch.Int32(),fmt.Sprintf("Identifier %q should be lower case", identifier),- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}}diff --git a/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.go b/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.goindex ba7912d334..ae27c6381c 100644--- a/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.go+++ b/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.go@@ -29,9 +29,9 @@ type NamingIdentifierNoKeywordAdvisor struct {// Check checks for identifier naming convention without keyword.func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -42,7 +42,11 @@ func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advisrule := NewNamingIdentifierNoKeywordRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -87,7 +91,7 @@ func (r *NamingIdentifierNoKeywordRule) handleIDExpression(ctx *parser.Id_expresr.level,advisor.NameIsKeywordIdentifier.Int32(),fmt.Sprintf("Identifier %q is a keyword and should be avoided", identifier),- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}}diff --git a/backend/plugin/advisor/oracle/rule_naming_table.go b/backend/plugin/advisor/oracle/rule_naming_table.goindex 793f76ff03..d636c9a80e 100644--- a/backend/plugin/advisor/oracle/rule_naming_table.go+++ b/backend/plugin/advisor/oracle/rule_naming_table.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -29,9 +30,9 @@ type NamingTableAdvisor struct {// Check checks for table naming convention.func (*NamingTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -46,7 +47,11 @@ func (*NamingTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([rule := NewNamingTableRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase, format, maxLength)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -99,7 +104,7 @@ func (r *NamingTableRule) handleCreateTable(ctx *parser.Create_tableContext) {r.level,advisor.NamingTableConventionMismatch.Int32(),fmt.Sprintf(`"%s" mismatches table naming convention, naming format should be %q`, tableName, r.format),- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}if r.maxLength > 0 && len(tableName) > r.maxLength {@@ -107,7 +112,7 @@ func (r *NamingTableRule) handleCreateTable(ctx *parser.Create_tableContext) {r.level,advisor.NamingTableConventionMismatch.Int32(),fmt.Sprintf("\"%s\" mismatches table naming convention, its length should be within %d characters", tableName, r.maxLength),- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}}@@ -125,7 +130,7 @@ func (r *NamingTableRule) handleAlterTableProperties(ctx *parser.Alter_table_pror.level,advisor.NamingTableConventionMismatch.Int32(),fmt.Sprintf(`"%s" mismatches table naming convention, naming format should be %q`, tableName, r.format),- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}if r.maxLength > 0 && len(tableName) > r.maxLength {@@ -133,7 +138,7 @@ func (r *NamingTableRule) handleAlterTableProperties(ctx *parser.Alter_table_pror.level,advisor.NamingTableConventionMismatch.Int32(),fmt.Sprintf("\"%s\" mismatches table naming convention, its length should be within %d characters", tableName, r.maxLength),- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}}diff --git a/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.go b/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.goindex f96217403d..dd87a00dff 100644--- a/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.go+++ b/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.go@@ -29,9 +29,9 @@ type NamingTableNoKeywordAdvisor struct {// Check checks for table naming convention without keyword.func (*NamingTableNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -42,7 +42,11 @@ func (*NamingTableNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Corule := NewNamingTableNoKeywordRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -91,7 +95,7 @@ func (r *NamingTableNoKeywordRule) handleCreateTable(ctx *parser.Create_tableConr.level,advisor.NameIsKeywordIdentifier.Int32(),fmt.Sprintf("Table name %q is a keyword identifier and should be avoided.", tableName),- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}}@@ -106,7 +110,7 @@ func (r *NamingTableNoKeywordRule) handleAlterTableProperties(ctx *parser.Alter_r.level,advisor.NameIsKeywordIdentifier.Int32(),fmt.Sprintf("Table name %q is a keyword identifier and should be avoided.", tableName),- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}}diff --git a/backend/plugin/advisor/oracle/rule_select_no_select_all.go b/backend/plugin/advisor/oracle/rule_select_no_select_all.goindex ebc20e7a35..b43aca6aa6 100644--- a/backend/plugin/advisor/oracle/rule_select_no_select_all.go+++ b/backend/plugin/advisor/oracle/rule_select_no_select_all.go@@ -11,6 +11,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -27,9 +28,9 @@ type SelectNoSelectAllAdvisor struct {// Check checks for no select all.func (*SelectNoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -40,7 +41,11 @@ func (*SelectNoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Conterule := NewSelectNoSelectAllRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -84,7 +89,7 @@ func (r *SelectNoSelectAllRule) handleSelectedList(ctx *parser.Selected_listContr.level,advisor.StatementSelectAll.Int32(),"Avoid using SELECT *.",- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}}diff --git a/backend/plugin/advisor/oracle/rule_statement_disallow_mix_in_ddl.go b/backend/plugin/advisor/oracle/rule_statement_disallow_mix_in_ddl.goindex fe29eac7cc..93a903d162 100644--- a/backend/plugin/advisor/oracle/rule_statement_disallow_mix_in_ddl.go+++ b/backend/plugin/advisor/oracle/rule_statement_disallow_mix_in_ddl.go@@ -11,6 +11,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -30,9 +31,9 @@ func (*StatementDisallowMixInDDLAdvisor) Check(_ context.Context, checkCtx advisdefault:return nil, nil}- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -43,7 +44,11 @@ func (*StatementDisallowMixInDDLAdvisor) Check(_ context.Context, checkCtx advisrule := NewStatementDisallowMixInDDLRule(level, string(checkCtx.Rule.Type))checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -84,7 +89,7 @@ func (r *StatementDisallowMixInDDLRule) handleUnitStatement(ctx *parser.Unit_star.level,advisor.StatementDisallowMixDDLDML.Int32(),"Alter schema can only run DDL",- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}}diff --git a/backend/plugin/advisor/oracle/rule_statement_disallow_mix_in_dml.go b/backend/plugin/advisor/oracle/rule_statement_disallow_mix_in_dml.goindex 4f94a745ac..ceb4d053f7 100644--- a/backend/plugin/advisor/oracle/rule_statement_disallow_mix_in_dml.go+++ b/backend/plugin/advisor/oracle/rule_statement_disallow_mix_in_dml.go@@ -11,6 +11,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -31,9 +32,9 @@ func (*StatementDisallowMixInDMLAdvisor) Check(_ context.Context, checkCtx advisreturn nil, nil}- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -44,7 +45,11 @@ func (*StatementDisallowMixInDMLAdvisor) Check(_ context.Context, checkCtx advisrule := NewStatementDisallowMixInDMLRule(level, string(checkCtx.Rule.Type))checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -85,7 +90,7 @@ func (r *StatementDisallowMixInDMLRule) handleUnitStatement(ctx *parser.Unit_star.level,advisor.StatementDisallowMixDDLDML.Int32(),"Data change can only run DML",- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}}diff --git a/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.go b/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.goindex ab7f5adc5f..2c1a371a15 100644--- a/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.go+++ b/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.go@@ -28,9 +28,9 @@ type StatementDmlDryRunAdvisor struct {}func (*StatementDmlDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsql.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -42,7 +42,11 @@ func (*StatementDmlDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Cochecker := NewGenericChecker([]Rule{rule})if checkCtx.Driver != nil {- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }}return checker.GetAdviceList()@@ -94,25 +98,25 @@ func (*StatementDmlDryRunRule) OnExit(_ antlr.ParserRuleContext, _ string) errorfunc (r *StatementDmlDryRunRule) handleInsertStatement(ctx *parser.Insert_statementContext) {if plsql.IsTopLevelStatement(ctx.GetParent()) {- r.handleStmt(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx), ctx.GetStart().GetLine())+ r.handleStmt(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx), r.baseLine+ctx.GetStart().GetLine())}}func (r *StatementDmlDryRunRule) handleUpdateStatement(ctx *parser.Update_statementContext) {if plsql.IsTopLevelStatement(ctx.GetParent()) {- r.handleStmt(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx), ctx.GetStart().GetLine())+ r.handleStmt(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx), r.baseLine+ctx.GetStart().GetLine())}}func (r *StatementDmlDryRunRule) handleDeleteStatement(ctx *parser.Delete_statementContext) {if plsql.IsTopLevelStatement(ctx.GetParent()) {- r.handleStmt(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx), ctx.GetStart().GetLine())+ r.handleStmt(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx), r.baseLine+ctx.GetStart().GetLine())}}func (r *StatementDmlDryRunRule) handleMergeStatement(ctx *parser.Merge_statementContext) {if plsql.IsTopLevelStatement(ctx.GetParent()) {- r.handleStmt(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx), ctx.GetStart().GetLine())+ r.handleStmt(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx), r.baseLine+ctx.GetStart().GetLine())}}diff --git a/backend/plugin/advisor/oracle/rule_table_comment_convention.go b/backend/plugin/advisor/oracle/rule_table_comment_convention.goindex a514dc4bc9..acebb70ee5 100644--- a/backend/plugin/advisor/oracle/rule_table_comment_convention.go+++ b/backend/plugin/advisor/oracle/rule_table_comment_convention.go@@ -28,9 +28,9 @@ type TableCommentConventionAdvisor struct {}func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -45,7 +45,11 @@ func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.rule := NewTableCommentConventionRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase, payload, checkCtx.ClassificationConfig)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -106,7 +110,7 @@ func (r *TableCommentConventionRule) handleCreateTable(ctx *parser.Create_tableCtableName := fmt.Sprintf("%s.%s", schemaName, normalizeIdentifier(ctx.Table_name(), r.currentDatabase))r.tableNames = append(r.tableNames, tableName)- r.tableLine[tableName] = ctx.GetStart().GetLine()+ r.tableLine[tableName] = r.baseLine + ctx.GetStart().GetLine()}func (r *TableCommentConventionRule) handleCommentOnTable(ctx *parser.Comment_on_tableContext) {diff --git a/backend/plugin/advisor/oracle/rule_table_no_foreign_key.go b/backend/plugin/advisor/oracle/rule_table_no_foreign_key.goindex 240f91257a..a96ac8bf88 100644--- a/backend/plugin/advisor/oracle/rule_table_no_foreign_key.go+++ b/backend/plugin/advisor/oracle/rule_table_no_foreign_key.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -28,9 +29,9 @@ type TableNoForeignKeyAdvisor struct {// Check checks for table disallow foreign key.func (*TableNoForeignKeyAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -41,7 +42,11 @@ func (*TableNoForeignKeyAdvisor) Check(_ context.Context, checkCtx advisor.Conterule := NewTableNoForeignKeyRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -123,7 +128,7 @@ func (r *TableNoForeignKeyRule) handleCreateTable(ctx *parser.Create_tableContexfunc (r *TableNoForeignKeyRule) handleReferencesClause(ctx *parser.References_clauseContext) {r.tableWithFK[r.tableName] = true- r.tableLine[r.tableName] = ctx.GetStop().GetLine()+ r.tableLine[r.tableName] = r.baseLine + ctx.GetStop().GetLine()}func (r *TableNoForeignKeyRule) handleAlterTable(ctx *parser.Alter_tableContext) {diff --git a/backend/plugin/advisor/oracle/rule_table_require_pk.go b/backend/plugin/advisor/oracle/rule_table_require_pk.goindex ea98863bc3..7b0be4908f 100644--- a/backend/plugin/advisor/oracle/rule_table_require_pk.go+++ b/backend/plugin/advisor/oracle/rule_table_require_pk.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -28,9 +29,9 @@ type TableRequirePKAdvisor struct {// Check checks table requires PK.func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -41,7 +42,11 @@ func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context)rule := NewTableRequirePKRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -128,7 +133,7 @@ func (r *TableRequirePKRule) handleCreateTable(ctx *parser.Create_tableContext)r.tableName = fmt.Sprintf("%s.%s", schemaName, normalizeIdentifier(ctx.Table_name(), r.currentDatabase))r.tableWitPK[r.tableName] = false- r.tableLine[r.tableName] = ctx.GetStop().GetLine()+ r.tableLine[r.tableName] = r.baseLine + ctx.GetStop().GetLine()}func (r *TableRequirePKRule) handleInlineConstraint(ctx *parser.Inline_constraintContext) {@@ -170,6 +175,6 @@ func (r *TableRequirePKRule) handleDropTable(ctx *parser.Drop_tableContext) {func (r *TableRequirePKRule) handleDropPrimaryKey(ctx *parser.Drop_primary_key_or_unique_or_generic_clauseContext) {if _, exists := r.tableWitPK[r.tableName]; exists && ctx.PRIMARY() != nil {r.tableWitPK[r.tableName] = false- r.tableLine[r.tableName] = ctx.GetStop().GetLine()+ r.tableLine[r.tableName] = r.baseLine + ctx.GetStop().GetLine()}}diff --git a/backend/plugin/advisor/oracle/rule_where_no_leading_wildcard_like.go b/backend/plugin/advisor/oracle/rule_where_no_leading_wildcard_like.goindex d0c09ef48f..4ae6d8a3c4 100644--- a/backend/plugin/advisor/oracle/rule_where_no_leading_wildcard_like.go+++ b/backend/plugin/advisor/oracle/rule_where_no_leading_wildcard_like.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -28,9 +29,9 @@ type WhereNoLeadingWildcardLikeAdvisor struct {// Check checks for no leading wildcard LIKE.func (*WhereNoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -41,7 +42,11 @@ func (*WhereNoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx advirule := NewWhereNoLeadingWildcardLikeRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -94,7 +99,7 @@ func (r *WhereNoLeadingWildcardLikeRule) handleCompoundExpression(ctx *parser.Cor.level,advisor.StatementLeadingWildcardLike.Int32(),"Avoid using leading wildcard LIKE.",- common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),)}}diff --git a/backend/plugin/advisor/oracle/rule_where_require_for_select.go b/backend/plugin/advisor/oracle/rule_where_require_for_select.goindex 0f87458ea7..e47460e104 100644--- a/backend/plugin/advisor/oracle/rule_where_require_for_select.go+++ b/backend/plugin/advisor/oracle/rule_where_require_for_select.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -28,9 +29,9 @@ type WhereRequireForSelectAdvisor struct {// Check checks for WHERE clause requirement.func (*WhereRequireForSelectAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -41,7 +42,11 @@ func (*WhereRequireForSelectAdvisor) Check(_ context.Context, checkCtx advisor.Crule := NewWhereRequireForSelectRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -92,7 +97,7 @@ func (r *WhereRequireForSelectRule) handleQueryBlock(ctx *parser.Query_blockContr.level,advisor.StatementNoWhere.Int32(),"WHERE clause is required for SELECT statement.",- common.ConvertANTLRLineToPosition(ctx.GetStop().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStop().GetLine()),)}}diff --git a/backend/plugin/advisor/oracle/rule_where_require_for_update_delete.go b/backend/plugin/advisor/oracle/rule_where_require_for_update_delete.goindex dfecf5bcd1..d80658e691 100644--- a/backend/plugin/advisor/oracle/rule_where_require_for_update_delete.go+++ b/backend/plugin/advisor/oracle/rule_where_require_for_update_delete.go@@ -11,6 +11,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -27,9 +28,9 @@ type WhereRequireForUpdateDeleteAdvisor struct {// Check checks for WHERE clause requirement.func (*WhereRequireForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ stmtList, ok := checkCtx.AST.([]*plsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -40,7 +41,11 @@ func (*WhereRequireForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx advrule := NewWhereRequireForUpdateDeleteRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, stmtNode := range stmtList {+ rule.SetBaseLine(stmtNode.BaseLine)+ checker.SetBaseLine(stmtNode.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ }return checker.GetAdviceList()}@@ -89,7 +94,7 @@ func (r *WhereRequireForUpdateDeleteRule) handleUpdateStatement(ctx *parser.Updar.level,advisor.StatementNoWhere.Int32(),"WHERE clause is required for UPDATE statement.",- common.ConvertANTLRLineToPosition(ctx.GetStop().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStop().GetLine()),)}}@@ -100,7 +105,7 @@ func (r *WhereRequireForUpdateDeleteRule) handleDeleteStatement(ctx *parser.Deler.level,advisor.StatementNoWhere.Int32(),"WHERE clause is required for DELETE statement.",- common.ConvertANTLRLineToPosition(ctx.GetStop().GetLine()),+ common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStop().GetLine()),)}}diff --git a/backend/plugin/db/oracle/query.go b/backend/plugin/db/oracle/query.goindex a2497cce54..ced81f19e8 100644--- a/backend/plugin/db/oracle/query.go+++ b/backend/plugin/db/oracle/query.go@@ -223,10 +223,18 @@ func addLimitFor12cAndLater(statement string, limit int) string {// addFetchNextClause adds a FETCH NEXT clause to a SELECT statement using AST parsing.// This provides more precise placement of the limit clause compared to simple string wrapping.func addFetchNextClause(statement string, limitCount int) (string, error) {- tree, stream, err := plsqlparser.ParsePLSQL(statement)+ results, err := plsqlparser.ParsePLSQL(statement)if err != nil {return "", err}+ if len(results) == 0 {+ return "", errors.New("no parse results")+ }+ if len(results) > 1 {+ return "", errors.Errorf("expected single statement, got %d statements", len(results))+ }+ tree := results[0].Tree+ stream := results[0].Tokenslistener := &plsqlRewriter{limitCount: limitCount,@@ -313,10 +321,18 @@ func (r *plsqlRewriter) overrideFetchClause(fetchClause plsql.IFetch_clauseConte// For Oracle, we think the statement like "SELECT xxx FROM DUAL" does not need a limit clause.// More details, xxx can not be a subquery.func skipAddLimit(stmt string) (bool, error) {- tree, _, err := plsqlparser.ParsePLSQL(stmt)+ results, err := plsqlparser.ParsePLSQL(stmt)if err != nil {return false, err}+ if len(results) == 0 {+ return false, nil+ }+ // Multiple statements should not skip limit+ if len(results) > 1 {+ return false, nil+ }+ tree := results[0].TreeselectStatement := extractSimpleSelectStatement(tree)if selectStatement == nil {diff --git a/backend/plugin/parser/plsql/backup.go b/backend/plugin/parser/plsql/backup.goindex 86a38367ab..16bcc133c6 100644--- a/backend/plugin/parser/plsql/backup.go+++ b/backend/plugin/parser/plsql/backup.go@@ -49,6 +49,7 @@ type statementInfo struct {statement stringtree antlr.ParserRuleContexttable *TableReference+ baseLine int}// TransformDMLToSelect transforms DML statement to SELECT statement.@@ -175,11 +176,11 @@ func generateSQLForTable(ctx base.TransformContext, statementInfoList []statemenSourceTableName: table.Table,TargetTableName: targetTable,StartPosition: &store.Position{- Line: int32(statementInfoList[0].tree.GetStart().GetLine()),+ Line: int32(statementInfoList[0].tree.GetStart().GetLine() + statementInfoList[0].baseLine),Column: int32(statementInfoList[0].tree.GetStart().GetColumn()),},EndPosition: &store.Position{- Line: int32(statementInfoList[len(statementInfoList)-1].tree.GetStop().GetLine()),+ Line: int32(statementInfoList[len(statementInfoList)-1].tree.GetStop().GetLine() + statementInfoList[len(statementInfoList)-1].baseLine),Column: int32(statementInfoList[len(statementInfoList)-1].tree.GetStop().GetColumn()),},}, nil@@ -245,15 +246,24 @@ func (e *suffixSelectClauseExtractor) EnterUpdate_statement(ctx *parser.Update_s}func prepareTransformation(databaseName, statement string) ([]statementInfo, error) {- tree, _, err := ParsePLSQL(statement)+ results, err := ParsePLSQL(statement)if err != nil {return nil, errors.Wrap(err, "failed to parse PLSQL")}+ if len(results) == 0 {+ return nil, errors.New("no parse results")+ }extractor := &dmlExtractor{databaseName: databaseName,}- antlr.ParseTreeWalkerDefault.Walk(extractor, tree)++ // Walk each parse result tree to extract DML statements+ for _, result := range results {+ extractor.baseLine = result.BaseLine+ antlr.ParseTreeWalkerDefault.Walk(extractor, result.Tree)+ }+return extractor.dmls, nil}@@ -277,6 +287,7 @@ type dmlExtractor struct {databaseName stringdmls []statementInfooffset int+ baseLine int}func (e *dmlExtractor) ExitUnit_statement(_ *parser.Unit_statementContext) {@@ -300,6 +311,7 @@ func (e *dmlExtractor) EnterDelete_statement(ctx *parser.Delete_statementContextstatement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),tree: ctx,table: extractor.table,+ baseLine: e.baseLine,})}}@@ -317,6 +329,7 @@ func (e *dmlExtractor) EnterUpdate_statement(ctx *parser.Update_statementContextstatement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),tree: ctx,table: extractor.table,+ baseLine: e.baseLine,})}}diff --git a/backend/plugin/parser/plsql/plsql.go b/backend/plugin/parser/plsql/plsql.goindex c47a481d62..5a4e5b0add 100644--- a/backend/plugin/parser/plsql/plsql.go+++ b/backend/plugin/parser/plsql/plsql.go@@ -19,13 +19,9 @@ func init() {}// parsePLSQLForRegistry is the ParseFunc for PL/SQL.-// Returns antlr.Tree on success.+// Returns []*ParseResult on success.func parsePLSQLForRegistry(statement string) (any, error) {- tree, _, err := ParsePLSQL(statement + ";")- if err != nil {- return nil, err- }- return tree, nil+ return ParsePLSQL(statement + ";")}type Version struct {@@ -61,9 +57,72 @@ func ParseVersion(banner string) (*Version, error) {return nil, errors.Errorf("failed to parse version from banner: %s", banner)}-// ParsePLSQL parses the given PLSQL.-func ParsePLSQL(sql string) (antlr.Tree, *antlr.CommonTokenStream, error) {+// ParseResult is the result of parsing a PL/SQL statement.+type ParseResult struct {+ Tree antlr.Tree+ Tokens *antlr.CommonTokenStream+ BaseLine int+}++// ParsePLSQL parses the given PLSQL and returns a list of parse results.+// It first parses the whole statement to get the AST, then splits by unit_statement+// and sql_plus_command nodes, and re-parses each individual statement.+func ParsePLSQL(sql string) ([]*ParseResult, error) {sql = addSemicolonIfNeeded(sql)++ // First pass: parse the whole statement to get the AST for splitting+ tree, tokens, err := parsePLSQLInternal(sql, 0)+ if err != nil {+ return nil, err+ }++ // Type assert to ensure we have a sql_script context+ sqlScript, ok := tree.(*parser.Sql_scriptContext)+ if !ok {+ return nil, errors.Errorf("expected sql_script context, got %T", tree)+ }++ // Iterate through children in order to preserve statement ordering and re-parse each one+ var result []*ParseResult+ for _, child := range sqlScript.GetChildren() {+ var stmtText string+ var stmtBaseLine int++ // Type assert to get the specific statement type+ if stmt, ok := child.(parser.IUnit_statementContext); ok {+ stmtText = tokens.GetTextFromTokens(stmt.GetStart(), stmt.GetStop())+ stmtBaseLine = stmt.GetStart().GetLine() - 1 // Convert to 0-based+ } else if sqlPlusCmd, ok := child.(parser.ISql_plus_commandContext); ok {+ stmtText = tokens.GetTextFromTokens(sqlPlusCmd.GetStart(), sqlPlusCmd.GetStop())+ stmtBaseLine = sqlPlusCmd.GetStart().GetLine() - 1 // Convert to 0-based+ } else {+ // Skip other node types (e.g., EOF)+ continue+ }++ // Skip empty statements+ if strings.TrimSpace(stmtText) == "" || stmtText == ";" {+ continue+ }++ // Re-parse the individual statement with correct base line+ stmtTree, stmtTokens, err := parsePLSQLInternal(stmtText, stmtBaseLine)+ if err != nil {+ return nil, err+ }++ result = append(result, &ParseResult{+ Tree: stmtTree,+ Tokens: stmtTokens,+ BaseLine: stmtBaseLine,+ })+ }++ return result, nil+}++// parsePLSQLInternal is the internal parsing function that parses a single SQL statement.+func parsePLSQLInternal(sql string, baseLine int) (antlr.Tree, *antlr.CommonTokenStream, error) {lexer := parser.NewPlSqlLexer(antlr.NewInputStream(sql))stream := antlr.NewCommonTokenStream(lexer, 0)p := parser.NewPlSqlParser(stream)@@ -71,12 +130,14 @@ func ParsePLSQL(sql string) (antlr.Tree, *antlr.CommonTokenStream, error) {lexerErrorListener := &base.ParseErrorListener{Statement: sql,+ BaseLine: baseLine,}lexer.RemoveErrorListeners()lexer.AddErrorListener(lexerErrorListener)parserErrorListener := &base.ParseErrorListener{Statement: sql,+ BaseLine: baseLine,}p.RemoveErrorListeners()p.AddErrorListener(parserErrorListener)@@ -95,6 +156,13 @@ func ParsePLSQL(sql string) (antlr.Tree, *antlr.CommonTokenStream, error) {return tree, stream, nil}+// ParsePLSQLForStringsManipulation parses the whole SQL without splitting.+// This is used for strings manipulation which needs to see all statements together.+func ParsePLSQLForStringsManipulation(sql string) (antlr.Tree, antlr.TokenStream, error) {+ sql = addSemicolonIfNeeded(sql)+ return parsePLSQLInternal(sql, 0)+}+func addSemicolonIfNeeded(sql string) string {lexer := parser.NewPlSqlLexer(antlr.NewInputStream(sql))stream := antlr.NewCommonTokenStream(lexer, 0)@@ -246,13 +314,16 @@ func NormalizeTableName(tableName parser.ITable_nameContext) string {// EquivalentType returns true if the given type is equivalent to the given text.func EquivalentType(tp parser.IDatatypeContext, text string) (bool, error) {- tree, _, err := ParsePLSQL(fmt.Sprintf(`CREATE TABLE t(a %s);`, text))+ results, err := ParsePLSQL(fmt.Sprintf(`CREATE TABLE t(a %s);`, text))if err != nil {return false, err}+ if len(results) == 0 {+ return false, errors.New("no parse results")+ }listener := &typeEquivalentListener{tp: tp, equivalent: false}- antlr.ParseTreeWalkerDefault.Walk(listener, tree)+ antlr.ParseTreeWalkerDefault.Walk(listener, results[0].Tree)return listener.equivalent, nil}diff --git a/backend/plugin/parser/plsql/plsql_test.go b/backend/plugin/parser/plsql/plsql_test.goindex e6571f625e..1c1445c267 100644--- a/backend/plugin/parser/plsql/plsql_test.go+++ b/backend/plugin/parser/plsql/plsql_test.go@@ -43,13 +43,51 @@ func TestPLSQLParser(t *testing.T) {}for _, test := range tests {- tree, _, err := ParsePLSQL(test.statement)- _, ok := tree.(*parser.Sql_scriptContext)+ results, err := ParsePLSQL(test.statement)if test.errorMessage == "" {- require.True(t, ok)require.NoError(t, err)+ require.NotEmpty(t, results)+ _, ok := results[0].Tree.(*parser.Sql_scriptContext)+ require.True(t, ok)} else {require.EqualError(t, err, test.errorMessage)}}}++func TestPLSQLParser_MultipleStatements(t *testing.T) {+ tests := []struct {+ statement string+ expectedCount int // Number of individual statements+ expectedLines []int // BaseLine for each result+ }{+ {+ statement: "SELECT * FROM t1;",+ expectedCount: 1,+ expectedLines: []int{0},+ },+ {+ statement: `SELECT * FROM t1;+SELECT * FROM t2;`,+ expectedCount: 2,+ expectedLines: []int{0, 1},+ },+ {+ statement: `SELECT * FROM t1;+SELECT * FROM t2;+INSERT INTO t3 VALUES (1, 2);`,+ expectedCount: 3,+ expectedLines: []int{0, 1, 2},+ },+ }++ for _, test := range tests {+ results, err := ParsePLSQL(test.statement)+ require.NoError(t, err)+ require.Equal(t, test.expectedCount, len(results), "Statement: %s", test.statement)++ for i, result := range results {+ require.Equal(t, test.expectedLines[i], result.BaseLine, "Statement %d", i+1)+ }+ }+}diff --git a/backend/plugin/parser/plsql/query.go b/backend/plugin/parser/plsql/query.goindex 94493b593f..2273bdd15f 100644--- a/backend/plugin/parser/plsql/query.go+++ b/backend/plugin/parser/plsql/query.go@@ -14,17 +14,25 @@ func init() {// validateQuery validates the SQL statement for SQL editor.func validateQuery(statement string) (bool, bool, error) {- tree, _, err := ParsePLSQL(statement)+ results, err := ParsePLSQL(statement)if err != nil {return false, false, err}+ if len(results) == 0 {+ return false, false, nil+ }++ // Validate all statements, not just the first onel := &queryValidateListener{validate: true,}- antlr.ParseTreeWalkerDefault.Walk(l, tree)- if !l.validate {- return false, false, nil+ for _, result := range results {+ antlr.ParseTreeWalkerDefault.Walk(l, result.Tree)+ if !l.validate {+ return false, false, nil+ }}+return true, true, nil}diff --git a/backend/plugin/parser/plsql/query_span_extractor.go b/backend/plugin/parser/plsql/query_span_extractor.goindex 8b73c78c6b..6b4e3c2848 100644--- a/backend/plugin/parser/plsql/query_span_extractor.go+++ b/backend/plugin/parser/plsql/query_span_extractor.go@@ -57,10 +57,17 @@ func (q *querySpanExtractor) getDatabaseMetadata(schema string) (*model.Databasefunc (q *querySpanExtractor) getQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {q.ctx = ctx- tree, _, err := ParsePLSQL(statement)+ parseResults, err := ParsePLSQL(statement)if err != nil {return nil, errors.Wrapf(err, "failed to parse statement: %s", statement)}+ if len(parseResults) == 0 {+ return nil, nil+ }+ if len(parseResults) > 1 {+ return nil, errors.Errorf("query span extraction only supports single statement, got %d statements", len(parseResults))+ }+ tree := parseResults[0].Treeif tree == nil {return nil, nil}diff --git a/backend/plugin/parser/plsql/query_span_test.go b/backend/plugin/parser/plsql/query_span_test.goindex b927ffdf15..71c008c197 100644--- a/backend/plugin/parser/plsql/query_span_test.go+++ b/backend/plugin/parser/plsql/query_span_test.go@@ -228,9 +228,10 @@ func TestGetAccessTables(t *testing.T) {}for _, test := range tests {- r, _, err := ParsePLSQL(test.statement)+ results, err := ParsePLSQL(test.statement)require.NoError(t, err)- resources := getAccessTables("DB", r)+ require.NotEmpty(t, results)+ resources := getAccessTables("DB", results[0].Tree)require.Equal(t, test.expected, resources, test.statement)}}diff --git a/backend/plugin/parser/plsql/resource_change.go b/backend/plugin/parser/plsql/resource_change.goindex 013b0d7c4a..dcf07c2bf3 100644--- a/backend/plugin/parser/plsql/resource_change.go+++ b/backend/plugin/parser/plsql/resource_change.go@@ -17,9 +17,9 @@ func init() {func extractChangedResources(currentDatabase string, _ string, dbSchema *model.DatabaseSchema, asts any, statement string) (*base.ChangeSummary, error) {// currentDatabase is the same as currentSchema for Oracle.- tree, ok := asts.(antlr.Tree)+ results, ok := asts.([]*ParseResult)if !ok {- return nil, errors.Errorf("failed to convert ast to antlr.Tree")+ return nil, errors.Errorf("failed to convert ast to []*ParseResult, got %T", asts)}changedResources := model.NewChangedResources(dbSchema)@@ -30,7 +30,9 @@ func extractChangedResources(currentDatabase string, _ string, dbSchema *model.Dstatement: statement,}- antlr.ParseTreeWalkerDefault.Walk(l, tree)+ for _, result := range results {+ antlr.ParseTreeWalkerDefault.Walk(l, result.Tree)+ }return &base.ChangeSummary{ChangedResources: changedResources,diff --git a/backend/plugin/parser/plsql/resource_change_test.go b/backend/plugin/parser/plsql/resource_change_test.goindex dfc43afa2a..d15276fea1 100644--- a/backend/plugin/parser/plsql/resource_change_test.go+++ b/backend/plugin/parser/plsql/resource_change_test.go@@ -43,9 +43,12 @@ func TestExtractChangedResources(t *testing.T) {InsertCount: 1,}- asts, _, err := ParsePLSQL(statement)+ results, err := ParsePLSQL(statement)require.NoError(t, err)- got, err := extractChangedResources("DB", "", nil /* dbSchema */, asts, statement)+ require.NotEmpty(t, results)++ // Pass the full results array to extractChangedResources+ got, err := extractChangedResources("DB", "", nil /* dbSchema */, results, statement)require.NoError(t, err)require.Equal(t, want, got)}diff --git a/backend/plugin/parser/plsql/restore.go b/backend/plugin/parser/plsql/restore.goindex 7ecfd21c45..a1718c2101 100644--- a/backend/plugin/parser/plsql/restore.go+++ b/backend/plugin/parser/plsql/restore.go@@ -30,20 +30,26 @@ func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statementreturn "", errors.Errorf("failed to extract single SQL: %v", err)}- tree, _, err := ParsePLSQL(originalSQL)+ results, err := ParsePLSQL(originalSQL)if err != nil {return "", err}+ if len(results) == 0 {+ return "", errors.New("no parse results")+ }+ // For restore SQL generation, we only examine the first statement to determine+ // the table structure and operation type, even if extractSQL returns multiple statements.+ // This is because:+ // 1. All statements modify the same table (validated during backup creation)+ // 2. All statements are the same operation type (UPDATE or DELETE)+ // 3. The restore SQL is generated based on the backup table contents, not by+ // reversing individual statements - we just need to know the table structure+ tree := results[0].Treeif tree == nil {return "", errors.Errorf("no parse result")}- // We only need the first parse result.- // There are two cases:- // 1. The statement is a single SQL statement.- // 2. The statement is a multi SQL statement, but all SQL statements' backup is in the same table.- // So we only need to restore the first SQL statement.sqlForComment, truncated := common.TruncateString(originalSQL, maxCommentLength)if truncated {sqlForComment += "..."diff --git a/backend/plugin/parser/plsql/split.go b/backend/plugin/parser/plsql/split.goindex a0bc33564a..7cbe1b58ad 100644--- a/backend/plugin/parser/plsql/split.go+++ b/backend/plugin/parser/plsql/split.go@@ -17,11 +17,19 @@ func init() {}// SplitSQL splits the given SQL statement into multiple SQL statements.+// TODO(zp): Consolidate with split logic in ParsePLSQL?func SplitSQL(statement string) ([]base.SingleSQL, error) {- tree, tokens, err := ParsePLSQL(statement)+ tree, stream, err := ParsePLSQLForStringsManipulation(statement)if err != nil {return nil, err}+ if tree == nil {+ return nil, nil+ }+ tokens, ok := stream.(*antlr.CommonTokenStream)+ if !ok {+ return nil, nil+ }byteOffsetStart := 0prevStopTokenIndex := -1@@ -87,10 +95,17 @@ func SplitSQL(statement string) ([]base.SingleSQL, error) {}func SplitSQLForCompletion(statement string) ([]base.SingleSQL, error) {- tree, tokens, err := ParsePLSQL(statement)+ tree, stream, err := ParsePLSQLForStringsManipulation(statement)if err != nil {return nil, err}+ if tree == nil {+ return nil, nil+ }+ tokens, ok := stream.(*antlr.CommonTokenStream)+ if !ok {+ return nil, nil+ }var result []base.SingleSQLfor _, item := range tree.GetChildren() {diff --git a/backend/plugin/parser/plsql/statement_type.go b/backend/plugin/parser/plsql/statement_type.goindex c36c5446dd..9a96dbcbc2 100644--- a/backend/plugin/parser/plsql/statement_type.go+++ b/backend/plugin/parser/plsql/statement_type.go@@ -7,18 +7,13 @@ import ()func GetStatementTypes(asts any) ([]string, error) {- node, ok := asts.(antlr.Tree)+ nodes, ok := asts.([]*ParseResult)if !ok {return nil, errors.Errorf("invalid ast type %T", asts)}sqlTypeSet := make(map[string]bool)- for _, child := range node.GetChildren() {- _, ok := child.(*antlr.TerminalNodeImpl)- if ok {- continue- }-- t := getStatementType(child)+ for _, node := range nodes {+ t := getStatementType(node.Tree)sqlTypeSet[t] = true}var sqlTypes []stringdiff --git a/backend/plugin/parser/plsql/statement_type_test.go b/backend/plugin/parser/plsql/statement_type_test.goindex 3d6339fb4a..fb0c28dc9a 100644--- a/backend/plugin/parser/plsql/statement_type_test.go+++ b/backend/plugin/parser/plsql/statement_type_test.go@@ -30,9 +30,10 @@ func TestGetStatementType(t *testing.T) {a.NoError(yaml.Unmarshal(byteValue, &tests))for _, test := range tests {- result, _, err := ParsePLSQL(test.Statement)+ results, err := ParsePLSQL(test.Statement)a.NoError(err)- sqlType, err := GetStatementTypes(result)+ a.NotEmpty(results)+ sqlType, err := GetStatementTypes(results)a.NoError(err)a.Equal(test.Want, sqlType)}diff --git a/backend/plugin/parser/plsql/strings_test.go b/backend/plugin/parser/plsql/strings_test.goindex fbb5dd6f20..c38d106524 100644--- a/backend/plugin/parser/plsql/strings_test.go+++ b/backend/plugin/parser/plsql/strings_test.go@@ -46,9 +46,10 @@ func TestStringsManipulate(t *testing.T) {a.NoError(yaml.Unmarshal(byteValue, &tests))for i, t := range tests {- tree, tokens, err := ParsePLSQL(t.Input)+ tree, stream, err := ParsePLSQLForStringsManipulation(t.Input)a.NoError(err)- manipulator := NewStringsManipulator(tree, tokens)+ a.NotNil(tree)+ manipulator := NewStringsManipulator(tree, stream)actions := convertActionsForTest(t.Actions)result, err := manipulator.Manipulate(actions...)a.NoError(err)diff --git a/backend/plugin/schema/oracle/get_database_metadata.go b/backend/plugin/schema/oracle/get_database_metadata.goindex fcad9f4bb1..d7a84cc1a2 100644--- a/backend/plugin/schema/oracle/get_database_metadata.go+++ b/backend/plugin/schema/oracle/get_database_metadata.go@@ -21,10 +21,13 @@ func init() {// GetDatabaseMetadata parses the Oracle schema text and returns the database metadata.func GetDatabaseMetadata(schemaText string) (*storepb.DatabaseSchemaMetadata, error) {- tree, _, err := oracleparser.ParsePLSQL(schemaText)+ results, err := oracleparser.ParsePLSQL(schemaText)if err != nil {return nil, errors.Wrapf(err, "failed to parse Oracle schema")}+ if len(results) == 0 {+ return nil, errors.New("no parse results")+ }extractor := &metadataExtractor{currentSchema: "",@@ -41,9 +44,11 @@ func GetDatabaseMetadata(schemaText string) (*storepb.DatabaseSchemaMetadata, erinlineUniqueKeys: make(map[string][]string),}- // Walk the parse tree- if tree != nil {- antlr.ParseTreeWalkerDefault.Walk(extractor, tree)+ // Walk all parse result trees to extract metadata from all statements+ for _, result := range results {+ if result.Tree != nil {+ antlr.ParseTreeWalkerDefault.Walk(extractor, result.Tree)+ }}if extractor.err != nil {