Skip to content

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

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.go
index 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.go
index 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 adv
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)
@@ -44,7 +44,11 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx adv
rule := 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.go
index 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, che
rule := 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(ct
r.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.go
index 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 advisor
rule := 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, nodeType
r.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.go
index 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 ad
rule := 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.DatatypeCo
r.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.go
index 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 advi
rule := 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.DatatypeCont
r.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.go
index 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_constraintC
return
}
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.go
index 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_tableContex
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()),
)
}
@@ -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.go
index 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.Co
rule := 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_def
columnName := 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.go
index 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_d
r.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_d
r.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.Modif
r.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.go
index 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.Con
rule := 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_index
r.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_l
r.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.go
index 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 advisor
rule := 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.go
index 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.Co
rule := 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_expressionC
r.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_expressionC
r.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.go
index 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 advis
rule := 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_expres
r.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.go
index 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_pro
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 {
@@ -133,7 +138,7 @@ func (r *NamingTableRule) handleAlterTableProperties(ctx *parser.Alter_table_pro
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()),
)
}
}
diff --git a/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.go b/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.go
index 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.Co
rule := 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_tableCon
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()),
)
}
}
@@ -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.go
index 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.Conte
rule := 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_listCont
r.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.go
index 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 advis
default:
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 advis
rule := 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_sta
r.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.go
index 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 advis
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)
@@ -44,7 +45,11 @@ func (*StatementDisallowMixInDMLAdvisor) Check(_ context.Context, checkCtx advis
rule := 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_sta
r.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.go
index 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.Co
checker := 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) error
func (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.go
index 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_tableC
tableName := 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.go
index 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.Conte
rule := 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_tableContex
func (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.go
index 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.go
index 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 advi
rule := 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.Co
r.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.go
index 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.C
rule := 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_blockCont
r.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.go
index 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 adv
rule := 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.Upda
r.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.Dele
r.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.go
index 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].Tokens
listener := &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].Tree
selectStatement := extractSimpleSelectStatement(tree)
if selectStatement == nil {
diff --git a/backend/plugin/parser/plsql/backup.go b/backend/plugin/parser/plsql/backup.go
index 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 string
tree antlr.ParserRuleContext
table *TableReference
+ baseLine int
}
// TransformDMLToSelect transforms DML statement to SELECT statement.
@@ -175,11 +176,11 @@ func generateSQLForTable(ctx base.TransformContext, statementInfoList []statemen
SourceTableName: 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 string
dmls []statementInfo
offset int
+ baseLine int
}
func (e *dmlExtractor) ExitUnit_statement(_ *parser.Unit_statementContext) {
@@ -300,6 +311,7 @@ func (e *dmlExtractor) EnterDelete_statement(ctx *parser.Delete_statementContext
statement: 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_statementContext
statement: 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.go
index 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.go
index 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.go
index 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 one
l := &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.go
index 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.Database
func (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].Tree
if tree == nil {
return nil, nil
}
diff --git a/backend/plugin/parser/plsql/query_span_test.go b/backend/plugin/parser/plsql/query_span_test.go
index 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.go
index 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.D
statement: 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.go
index 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.go
index 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, statement
return "", 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].Tree
if 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.go
index 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 := 0
prevStopTokenIndex := -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.SingleSQL
for _, item := range tree.GetChildren() {
diff --git a/backend/plugin/parser/plsql/statement_type.go b/backend/plugin/parser/plsql/statement_type.go
index 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 []string
diff --git a/backend/plugin/parser/plsql/statement_type_test.go b/backend/plugin/parser/plsql/statement_type_test.go
index 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.go
index 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.go
index 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, er
inlineUniqueKeys: 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 {