Skip to content

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

refactor: standardize PostgreSQL parser interface to return list of ParseResults (#18137)

h3n4l6b980863239b
diff --git a/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go b/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go
index c936d5b36e..68c52407c4 100644
--- a/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go
+++ b/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go
@@ -49,7 +49,7 @@ func (*BuiltinPriorBackupCheckAdvisor) Check(_ context.Context, checkCtx advisor
var adviceList []*storepb.Advice
// Check for DDL statements in DML context
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -59,10 +59,16 @@ func (*BuiltinPriorBackupCheckAdvisor) Check(_ context.Context, checkCtx advisor
level: level,
title: title,
},
- tokens: tree.Tokens,
}
checker := NewGenericChecker([]Rule{ddlRule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ ddlRule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ ddlRule.tokens = parseResult.Tokens
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
+
adviceList = append(adviceList, checker.GetAdviceList()...)
// Check if backup schema exists
@@ -284,13 +290,15 @@ type statementInfo struct {
}
func prepareTransformation(statement string) ([]statementInfo, error) {
- tree, err := pg.ParsePostgreSQL(statement)
+ parseResults, err := pg.ParsePostgreSQL(statement)
if err != nil {
return nil, errors.Wrap(err, "failed to parse statement")
}
extractor := &dmlExtractor{}
- antlr.ParseTreeWalkerDefault.Walk(extractor, tree.Tree)
+ for _, parseResult := range parseResults {
+ antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)
+ }
return extractor.dmls, nil
}
diff --git a/backend/plugin/advisor/pg/advisor_collation_allowlist.go b/backend/plugin/advisor/pg/advisor_collation_allowlist.go
index 94e0397491..ea2ebe3348 100644
--- a/backend/plugin/advisor/pg/advisor_collation_allowlist.go
+++ b/backend/plugin/advisor/pg/advisor_collation_allowlist.go
@@ -27,7 +27,7 @@ type CollationAllowlistAdvisor struct {
// Check checks for collation allowlist.
func (*CollationAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -52,11 +52,16 @@ func (*CollationAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Cont
title: string(checkCtx.Rule.Type),
},
allowlist: allowlist,
- tokens: tree.Tokens,
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ rule.tokens = parseResult.Tokens
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_column_comment_convention.go b/backend/plugin/advisor/pg/advisor_column_comment_convention.go
index d01a112d0f..56c485099f 100644
--- a/backend/plugin/advisor/pg/advisor_column_comment_convention.go
+++ b/backend/plugin/advisor/pg/advisor_column_comment_convention.go
@@ -28,7 +28,7 @@ type ColumnCommentConventionAdvisor struct {
}
func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -51,7 +51,11 @@ func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
// Now validate all collected columns against comments
return rule.generateAdvice(), nil
diff --git a/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go b/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go
index 46f946dc4b..59fb501fa2 100644
--- a/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go
+++ b/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go
@@ -30,7 +30,7 @@ type ColumnDefaultDisallowVolatileAdvisor struct {
// Check checks for column default volatile functions.
func (*ColumnDefaultDisallowVolatileAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -50,7 +50,11 @@ func (*ColumnDefaultDisallowVolatileAdvisor) Check(_ context.Context, checkCtx a
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go b/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go
index e2c857228c..6643681e31 100644
--- a/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go
+++ b/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go
@@ -28,7 +28,7 @@ type ColumnDisallowChangingTypeAdvisor struct {
// Check checks for disallow changing column type.
func (*ColumnDisallowChangingTypeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -43,11 +43,16 @@ func (*ColumnDisallowChangingTypeAdvisor) Check(_ context.Context, checkCtx advi
level: level,
title: string(checkCtx.Rule.Type),
},
- tokens: tree.Tokens,
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ rule.tokens = parseResult.Tokens
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go b/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go
index c04be90b9c..2ee55f65c5 100644
--- a/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go
+++ b/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go
@@ -29,7 +29,7 @@ type ColumnMaximumCharacterLengthAdvisor struct {
// Check checks for maximum character length.
func (*ColumnMaximumCharacterLengthAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -56,7 +56,12 @@ func (*ColumnMaximumCharacterLengthAdvisor) Check(_ context.Context, checkCtx ad
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_column_no_null.go b/backend/plugin/advisor/pg/advisor_column_no_null.go
index a48a4c0e15..04e5a25db1 100644
--- a/backend/plugin/advisor/pg/advisor_column_no_null.go
+++ b/backend/plugin/advisor/pg/advisor_column_no_null.go
@@ -30,7 +30,7 @@ type ColumnNoNullAdvisor struct {
// Check checks for column no NULL value.
func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -51,7 +51,14 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
+
+ // Generate advice after all parse trees have been walked
+ rule.generateAdvice()
return checker.GetAdviceList(), nil
}
@@ -98,53 +105,58 @@ func (r *columnNoNullRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string)
return nil
}
-func (r *columnNoNullRule) OnExit(ctx antlr.ParserRuleContext, _ string) error {
- // Generate advice when we exit the root node
- if _, ok := ctx.(*parser.RootContext); ok {
- var columnList []columnName
- for column := range r.nullableColumns {
- columnList = append(columnList, column)
- }
+func (*columnNoNullRule) OnExit(antlr.ParserRuleContext, string) error {
+ return nil
+}
- if len(columnList) > 0 {
- // Order it cause the random iteration order in Go
- slices.SortFunc(columnList, func(i, j columnName) int {
- if i.schema != j.schema {
- if i.schema < j.schema {
- return -1
- }
- return 1
- }
- if i.table != j.table {
- if i.table < j.table {
- return -1
- }
- return 1
- }
- if i.column < j.column {
+// generateAdvice generates advice for all nullable columns.
+// This should be called AFTER walking all parse trees to avoid duplicates.
+func (r *columnNoNullRule) generateAdvice() {
+ var columnList []columnName
+ for column := range r.nullableColumns {
+ columnList = append(columnList, column)
+ }
+
+ if len(columnList) > 0 {
+ // Order it cause the random iteration order in Go
+ slices.SortFunc(columnList, func(i, j columnName) int {
+ if i.schema != j.schema {
+ if i.schema < j.schema {
return -1
}
- if i.column > j.column {
- return 1
+ return 1
+ }
+ if i.table != j.table {
+ if i.table < j.table {
+ return -1
}
- return 0
- })
- }
+ return 1
+ }
+ if i.column < j.column {
+ return -1
+ }
+ if i.column > j.column {
+ return 1
+ }
+ return 0
+ })
+ }
- for _, column := range columnList {
- r.AddAdvice(&storepb.Advice{
- Status: r.level,
- Code: code.ColumnCannotNull.Int32(),
- Title: r.title,
- Content: fmt.Sprintf("Column %q in %s cannot have NULL value", column.column, column.normalizeTableName()),
- StartPosition: &storepb.Position{
- Line: int32(r.nullableColumns[column]),
- Column: 0,
- },
- })
- }
+ for _, column := range columnList {
+ // Note: We already added baseLine offset when storing the line number,
+ // but AddAdvice will add it again, so we need to subtract it first
+ lineNumber := r.nullableColumns[column]
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
+ Code: code.ColumnCannotNull.Int32(),
+ Title: r.title,
+ Content: fmt.Sprintf("Column %q in %s cannot have NULL value", column.column, column.normalizeTableName()),
+ StartPosition: &storepb.Position{
+ Line: int32(lineNumber - r.baseLine),
+ Column: 0,
+ },
+ })
}
- return nil
}
func (r *columnNoNullRule) handleCreatestmt(ctx *parser.CreatestmtContext) {
@@ -245,7 +257,8 @@ func (r *columnNoNullRule) addColumn(schema, table, column string, line int) {
if schema == "" {
schema = "public"
}
- r.nullableColumns[columnName{schema: schema, table: table, column: column}] = line
+ // Store absolute line number (adding baseLine offset now, not later in AddAdvice)
+ r.nullableColumns[columnName{schema: schema, table: table, column: column}] = line + r.baseLine
}
func (r *columnNoNullRule) removeColumn(schema, table, column string) {
diff --git a/backend/plugin/advisor/pg/advisor_column_require_default.go b/backend/plugin/advisor/pg/advisor_column_require_default.go
index 5db46335c6..0f152f0388 100644
--- a/backend/plugin/advisor/pg/advisor_column_require_default.go
+++ b/backend/plugin/advisor/pg/advisor_column_require_default.go
@@ -30,7 +30,7 @@ type ColumnRequireDefaultAdvisor struct {
// Check checks for column default requirement.
func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -48,7 +48,12 @@ func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Co
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_column_required.go b/backend/plugin/advisor/pg/advisor_column_required.go
index d80cfd3bb3..5d192da9e2 100644
--- a/backend/plugin/advisor/pg/advisor_column_required.go
+++ b/backend/plugin/advisor/pg/advisor_column_required.go
@@ -33,7 +33,7 @@ type ColumnRequirementAdvisor struct {
// Check checks for the column requirement.
func (*ColumnRequirementAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -64,7 +64,11 @@ func (*ColumnRequirementAdvisor) Check(_ context.Context, checkCtx advisor.Conte
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go b/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go
index bd4a8d1407..320461947c 100644
--- a/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go
+++ b/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go
@@ -30,7 +30,7 @@ type ColumnTypeDisallowListAdvisor struct {
// Check checks for column type restriction.
func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -60,7 +60,12 @@ func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_comment_convention.go b/backend/plugin/advisor/pg/advisor_comment_convention.go
index c57e586050..fa594bec3e 100644
--- a/backend/plugin/advisor/pg/advisor_comment_convention.go
+++ b/backend/plugin/advisor/pg/advisor_comment_convention.go
@@ -27,7 +27,7 @@ type CommentConventionAdvisor struct {
// Check checks for comment length.
func (*CommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -51,7 +51,12 @@ func (*CommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Conte
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_encoding_allowlist.go b/backend/plugin/advisor/pg/advisor_encoding_allowlist.go
index 05e1fc3607..f69962e168 100644
--- a/backend/plugin/advisor/pg/advisor_encoding_allowlist.go
+++ b/backend/plugin/advisor/pg/advisor_encoding_allowlist.go
@@ -28,7 +28,7 @@ type EncodingAllowlistAdvisor struct {
// Check checks for encoding allowlist.
func (*EncodingAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -58,7 +58,12 @@ func (*EncodingAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Conte
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_index_create_concurrently.go b/backend/plugin/advisor/pg/advisor_index_create_concurrently.go
index d2f8d0c52b..e828ab4fa1 100644
--- a/backend/plugin/advisor/pg/advisor_index_create_concurrently.go
+++ b/backend/plugin/advisor/pg/advisor_index_create_concurrently.go
@@ -27,7 +27,7 @@ type IndexConcurrentlyAdvisor struct {
// Check checks for to create index concurrently.
func (*IndexConcurrentlyAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -46,7 +46,12 @@ func (*IndexConcurrentlyAdvisor) Check(_ context.Context, checkCtx advisor.Conte
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_index_key_number_limit.go b/backend/plugin/advisor/pg/advisor_index_key_number_limit.go
index 33af5fb6e8..98b06718eb 100644
--- a/backend/plugin/advisor/pg/advisor_index_key_number_limit.go
+++ b/backend/plugin/advisor/pg/advisor_index_key_number_limit.go
@@ -29,7 +29,7 @@ type IndexKeyNumberLimitAdvisor struct {
// Check checks for index key number limit.
func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -53,7 +53,12 @@ func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Con
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go b/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go
index 8aee20c74b..cee0a0f6fb 100644
--- a/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go
+++ b/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go
@@ -29,7 +29,7 @@ type IndexNoDuplicateColumnAdvisor struct {
// Check checks for no duplicate columns in index.
func (*IndexNoDuplicateColumnAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -48,7 +48,11 @@ func (*IndexNoDuplicateColumnAdvisor) Check(_ context.Context, checkCtx advisor.
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.go b/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.go
index e5467f660e..bb39ec9651 100644
--- a/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.go
+++ b/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.go
@@ -29,7 +29,7 @@ type IndexPrimaryKeyTypeAllowlistAdvisor struct {
// Check checks for primary key type allowlist.
func (*IndexPrimaryKeyTypeAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -50,7 +50,12 @@ func (*IndexPrimaryKeyTypeAllowlistAdvisor) Check(_ context.Context, checkCtx ad
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_index_total_number_limit.go b/backend/plugin/advisor/pg/advisor_index_total_number_limit.go
index 922f267fb9..65953251ff 100644
--- a/backend/plugin/advisor/pg/advisor_index_total_number_limit.go
+++ b/backend/plugin/advisor/pg/advisor_index_total_number_limit.go
@@ -30,7 +30,7 @@ type IndexTotalNumberLimitAdvisor struct {
// Check checks for index total number limit.
func (*IndexTotalNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -52,7 +52,13 @@ func (*IndexTotalNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.C
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
+
rule.generateAdvice()
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.go b/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.go
index 1bde147729..fa9fb0184a 100644
--- a/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.go
+++ b/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.go
@@ -28,7 +28,7 @@ type InsertDisallowOrderByRandAdvisor struct {
// Check checks for to disallow order by rand in INSERT statements.
func (*InsertDisallowOrderByRandAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -47,7 +47,12 @@ func (*InsertDisallowOrderByRandAdvisor) Check(_ context.Context, checkCtx advis
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go b/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go
index d6780d363c..0268b98c36 100644
--- a/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go
+++ b/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go
@@ -27,7 +27,7 @@ type InsertMustSpecifyColumnAdvisor struct {
// Check checks for to enforce column specified.
func (*InsertMustSpecifyColumnAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -46,7 +46,12 @@ func (*InsertMustSpecifyColumnAdvisor) Check(_ context.Context, checkCtx advisor
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_insert_row_limit.go b/backend/plugin/advisor/pg/advisor_insert_row_limit.go
index 4db38027bf..bf8659ca16 100644
--- a/backend/plugin/advisor/pg/advisor_insert_row_limit.go
+++ b/backend/plugin/advisor/pg/advisor_insert_row_limit.go
@@ -32,7 +32,7 @@ type InsertRowLimitAdvisor struct {
// Check checks for the INSERT row limit.
func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -60,7 +60,12 @@ func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Contex
if payload.Number > 0 {
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_migration_compatibility.go b/backend/plugin/advisor/pg/advisor_migration_compatibility.go
index bb0352e33c..9eca0c0fe4 100644
--- a/backend/plugin/advisor/pg/advisor_migration_compatibility.go
+++ b/backend/plugin/advisor/pg/advisor_migration_compatibility.go
@@ -27,7 +27,7 @@ type CompatibilityAdvisor struct {
// Check checks schema backward compatibility.
func (*CompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -46,7 +46,12 @@ func (*CompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.Context)
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_naming_column.go b/backend/plugin/advisor/pg/advisor_naming_column.go
index c904e809b9..8607c2414c 100644
--- a/backend/plugin/advisor/pg/advisor_naming_column.go
+++ b/backend/plugin/advisor/pg/advisor_naming_column.go
@@ -29,7 +29,7 @@ type NamingColumnConventionAdvisor struct {
// Check checks for column naming convention.
func (*NamingColumnConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -55,7 +55,11 @@ func (*NamingColumnConventionAdvisor) Check(_ context.Context, checkCtx advisor.
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go
index 3e7dd71907..da0f40cfc8 100644
--- a/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go
+++ b/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go
@@ -30,7 +30,7 @@ type NamingFKConventionAdvisor struct {
// Check checks for foreign key naming convention.
func (*NamingFKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -57,7 +57,11 @@ func (*NamingFKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Cont
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go b/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go
index 28bd8230d6..6a8d94392a 100644
--- a/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go
+++ b/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go
@@ -30,7 +30,7 @@ type FullyQualifiedObjectNameAdvisor struct {
// Check checks for fully qualified object names.
func (*FullyQualifiedObjectNameAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -50,7 +50,12 @@ func (*FullyQualifiedObjectNameAdvisor) Check(_ context.Context, checkCtx adviso
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
@@ -338,7 +343,7 @@ func (*fullyQualifiedObjectNameRule) isFullyQualified(objName string) bool {
// findAllTablesInSelect finds all table references in a SELECT statement
func (r *fullyQualifiedObjectNameRule) findAllTablesInSelect(statement string) []base.ColumnResource {
// Parse the statement to extract table references
- result, err := pgparser.ParsePostgreSQL(statement)
+ parseResults, err := pgparser.ParsePostgreSQL(statement)
if err != nil {
return nil
}
@@ -348,8 +353,10 @@ func (r *fullyQualifiedObjectNameRule) findAllTablesInSelect(statement string) [
schemaNameMap: r.getSchemaNameMapFromPublic(),
}
- if result.Tree != nil {
- antlr.ParseTreeWalkerDefault.Walk(collector, result.Tree)
+ for _, parseResult := range parseResults {
+ if parseResult.Tree != nil {
+ antlr.ParseTreeWalkerDefault.Walk(collector, parseResult.Tree)
+ }
}
return collector.tables
diff --git a/backend/plugin/advisor/pg/advisor_naming_index_convention.go b/backend/plugin/advisor/pg/advisor_naming_index_convention.go
index 1492960780..9108d17626 100644
--- a/backend/plugin/advisor/pg/advisor_naming_index_convention.go
+++ b/backend/plugin/advisor/pg/advisor_naming_index_convention.go
@@ -30,7 +30,7 @@ type NamingIndexConventionAdvisor struct {
// Check checks for index naming convention.
func (*NamingIndexConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -57,7 +57,12 @@ func (*NamingIndexConventionAdvisor) Check(_ context.Context, checkCtx advisor.C
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go
index a342bb1263..ffb52d3b5e 100644
--- a/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go
+++ b/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go
@@ -30,7 +30,7 @@ type NamingPKConventionAdvisor struct {
// Check checks for primary key naming convention.
func (*NamingPKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -59,7 +59,11 @@ func (*NamingPKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Cont
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_naming_table.go b/backend/plugin/advisor/pg/advisor_naming_table.go
index d6cf5e597d..c548cf6bda 100644
--- a/backend/plugin/advisor/pg/advisor_naming_table.go
+++ b/backend/plugin/advisor/pg/advisor_naming_table.go
@@ -29,7 +29,7 @@ type NamingTableConventionAdvisor struct {
// Check checks for table naming convention.
func (*NamingTableConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -55,7 +55,11 @@ func (*NamingTableConventionAdvisor) Check(_ context.Context, checkCtx advisor.C
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go
index 70e4f8eeb2..c8991f638c 100644
--- a/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go
+++ b/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go
@@ -30,7 +30,7 @@ type NamingUKConventionAdvisor struct {
// Check checks for unique key naming convention.
func (*NamingUKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -57,7 +57,12 @@ func (*NamingUKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Cont
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.go b/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.go
index 1998b002b9..732f413a6d 100644
--- a/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.go
+++ b/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.go
@@ -26,7 +26,7 @@ type StatementAddCheckNotValidAdvisor struct {
// Check checks for to add check not valid.
func (*StatementAddCheckNotValidAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -45,7 +45,11 @@ func (*StatementAddCheckNotValidAdvisor) Check(_ context.Context, checkCtx advis
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.go b/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.go
index e6db8b0881..c906d1151c 100644
--- a/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.go
+++ b/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.go
@@ -26,7 +26,7 @@ type StatementAddFKNotValidAdvisor struct {
// Check checks for adding foreign key constraints without NOT VALID.
func (*StatementAddFKNotValidAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -44,7 +44,12 @@ func (*StatementAddFKNotValidAdvisor) Check(_ context.Context, checkCtx advisor.
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go b/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go
index 784d75a9a4..d6b3d69a54 100644
--- a/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go
+++ b/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go
@@ -29,7 +29,7 @@ type StatementAffectedRowLimitAdvisor struct {
// Check checks for UPDATE/DELETE affected row limit.
func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -58,7 +58,12 @@ func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx adv
if payload.Number > 0 && checkCtx.Driver != nil {
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.go b/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.go
index 73a4e77b1c..bf0cc61eaa 100644
--- a/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.go
+++ b/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.go
@@ -24,7 +24,7 @@ type StatementCheckSetRoleVariable struct {
}
func (*StatementCheckSetRoleVariable) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -42,7 +42,12 @@ func (*StatementCheckSetRoleVariable) Check(_ context.Context, checkCtx advisor.
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
if !rule.hasSetRole {
rule.AddAdvice(&storepb.Advice{
diff --git a/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go b/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go
index 959394338b..c09a362e83 100644
--- a/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go
+++ b/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go
@@ -24,7 +24,7 @@ type StatementCreateSpecifySchema struct {
}
func (*StatementCreateSpecifySchema) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -42,7 +42,12 @@ func (*StatementCreateSpecifySchema) Check(_ context.Context, checkCtx advisor.C
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.go b/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.go
index 59b1c26efe..4a67f53211 100644
--- a/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.go
+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.go
@@ -26,7 +26,7 @@ type StatementDisallowAddColumnWithDefaultAdvisor struct {
// Check checks for to disallow add column with default.
func (*StatementDisallowAddColumnWithDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -44,7 +44,12 @@ func (*StatementDisallowAddColumnWithDefaultAdvisor) Check(_ context.Context, ch
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.go b/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.go
index 9a2ca1196a..5c5e162cda 100644
--- a/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.go
+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.go
@@ -28,7 +28,7 @@ type StatementDisallowAddNotNullAdvisor struct {
// Check checks for to disallow add not null.
func (*StatementDisallowAddNotNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -46,7 +46,12 @@ func (*StatementDisallowAddNotNullAdvisor) Check(_ context.Context, checkCtx adv
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go b/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go
index 262ecde3a9..29385b8419 100644
--- a/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go
+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go
@@ -27,7 +27,7 @@ type StatementDisallowCommitAdvisor struct {
// Check checks for disallowing COMMIT statements.
func (*StatementDisallowCommitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -43,7 +43,12 @@ func (*StatementDisallowCommitAdvisor) Check(_ context.Context, checkCtx advisor
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_ddl.go b/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_ddl.go
index 3dc46f1ff0..4cd643cf5a 100644
--- a/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_ddl.go
+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_ddl.go
@@ -32,7 +32,7 @@ func (*StatementDisallowMixInDDLAdvisor) Check(_ context.Context, checkCtx advis
return nil, nil
}
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -48,7 +48,12 @@ func (*StatementDisallowMixInDDLAdvisor) Check(_ context.Context, checkCtx advis
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_dml.go b/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_dml.go
index f8ec4c1a5f..44a3b42f1b 100644
--- a/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_dml.go
+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_dml.go
@@ -34,7 +34,7 @@ func (*StatementDisallowMixInDMLAdvisor) Check(_ context.Context, checkCtx advis
return nil, nil
}
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -54,7 +54,11 @@ func (*StatementDisallowMixInDMLAdvisor) Check(_ context.Context, checkCtx advis
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_on_del_cascade.go b/backend/plugin/advisor/pg/advisor_statement_disallow_on_del_cascade.go
index f007002f3f..b85276c444 100644
--- a/backend/plugin/advisor/pg/advisor_statement_disallow_on_del_cascade.go
+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_on_del_cascade.go
@@ -27,7 +27,7 @@ type StatementDisallowOnDelCascadeAdvisor struct {
// Check checks for ON DELETE CASCADE.
func (*StatementDisallowOnDelCascadeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -46,7 +46,12 @@ func (*StatementDisallowOnDelCascadeAdvisor) Check(_ context.Context, checkCtx a
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_rm_tbl_cascade.go b/backend/plugin/advisor/pg/advisor_statement_disallow_rm_tbl_cascade.go
index 254226495c..2aa679de97 100644
--- a/backend/plugin/advisor/pg/advisor_statement_disallow_rm_tbl_cascade.go
+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_rm_tbl_cascade.go
@@ -26,7 +26,7 @@ type StatementDisallowRemoveTblCascadeAdvisor struct {
// Check checks for CASCADE option in DROP TABLE and TRUNCATE TABLE statements.
func (*StatementDisallowRemoveTblCascadeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -44,7 +44,12 @@ func (*StatementDisallowRemoveTblCascadeAdvisor) Check(_ context.Context, checkC
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go b/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go
index 8aa38ae58c..d79416ab43 100644
--- a/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go
+++ b/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go
@@ -28,7 +28,7 @@ type StatementDMLDryRunAdvisor struct {
// Check checks for DML dry run.
func (*StatementDMLDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -52,7 +52,12 @@ func (*StatementDMLDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Co
// Only run EXPLAIN queries if we have a database connection
if rule.driver != nil {
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.go b/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.go
index 32e19348d9..888c658e53 100644
--- a/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.go
+++ b/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.go
@@ -28,7 +28,7 @@ type StatementMaximumLimitValueAdvisor struct {
// Check checks for maximum LIMIT value.
func (*StatementMaximumLimitValueAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -51,7 +51,12 @@ func (*StatementMaximumLimitValueAdvisor) Check(_ context.Context, checkCtx advi
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go b/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go
index a5cb7aa508..7a3b9a4705 100644
--- a/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go
+++ b/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go
@@ -27,7 +27,7 @@ type StatementMergeAlterTableAdvisor struct {
// Check checks for no redundant ALTER TABLE statements.
func (*StatementMergeAlterTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -46,7 +46,12 @@ func (*StatementMergeAlterTableAdvisor) Check(_ context.Context, checkCtx adviso
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return rule.generateAdvice(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_no_leading_wildcard_like.go b/backend/plugin/advisor/pg/advisor_statement_no_leading_wildcard_like.go
index 9ac0f88590..065df43a34 100644
--- a/backend/plugin/advisor/pg/advisor_statement_no_leading_wildcard_like.go
+++ b/backend/plugin/advisor/pg/advisor_statement_no_leading_wildcard_like.go
@@ -27,7 +27,7 @@ type StatementNoLeadingWildcardLikeAdvisor struct {
// Check checks for no leading wildcard LIKE.
func (*StatementNoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -47,7 +47,12 @@ func (*StatementNoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_no_select_all.go b/backend/plugin/advisor/pg/advisor_statement_no_select_all.go
index 98be21fdea..0d2f2494df 100644
--- a/backend/plugin/advisor/pg/advisor_statement_no_select_all.go
+++ b/backend/plugin/advisor/pg/advisor_statement_no_select_all.go
@@ -27,7 +27,7 @@ type NoSelectAllAdvisor struct {
// Check checks for no "select *".
func (*NoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -46,7 +46,12 @@ func (*NoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_non_transactional.go b/backend/plugin/advisor/pg/advisor_statement_non_transactional.go
index f94823bbd0..36238365ca 100644
--- a/backend/plugin/advisor/pg/advisor_statement_non_transactional.go
+++ b/backend/plugin/advisor/pg/advisor_statement_non_transactional.go
@@ -27,7 +27,7 @@ type NonTransactionalAdvisor struct {
// Check checks for non-transactional statements.
func (*NonTransactionalAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -46,7 +46,12 @@ func (*NonTransactionalAdvisor) Check(_ context.Context, checkCtx advisor.Contex
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go b/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go
index c245951b7d..2bc0f2b479 100644
--- a/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go
+++ b/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go
@@ -33,7 +33,7 @@ type StatementObjectOwnerCheckAdvisor struct {
}
func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -63,7 +63,12 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx adv
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_where_required_select.go b/backend/plugin/advisor/pg/advisor_statement_where_required_select.go
index 20d0a44ffa..4af600d1f5 100644
--- a/backend/plugin/advisor/pg/advisor_statement_where_required_select.go
+++ b/backend/plugin/advisor/pg/advisor_statement_where_required_select.go
@@ -26,7 +26,7 @@ type StatementWhereRequiredSelectAdvisor struct {
// Check checks for WHERE clause requirement in SELECT statements.
func (*StatementWhereRequiredSelectAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -45,7 +45,12 @@ func (*StatementWhereRequiredSelectAdvisor) Check(_ context.Context, checkCtx ad
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_where_required_update_delete.go b/backend/plugin/advisor/pg/advisor_statement_where_required_update_delete.go
index ccb701468c..4349a4d08f 100644
--- a/backend/plugin/advisor/pg/advisor_statement_where_required_update_delete.go
+++ b/backend/plugin/advisor/pg/advisor_statement_where_required_update_delete.go
@@ -27,7 +27,7 @@ type StatementWhereRequiredUpdateDeleteAdvisor struct {
// Check checks for WHERE clause requirement in UPDATE/DELETE statements.
func (*StatementWhereRequiredUpdateDeleteAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -46,7 +46,12 @@ func (*StatementWhereRequiredUpdateDeleteAdvisor) Check(_ context.Context, check
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_table_comment_convention.go b/backend/plugin/advisor/pg/advisor_table_comment_convention.go
index edc07ac60b..de0fc56168 100644
--- a/backend/plugin/advisor/pg/advisor_table_comment_convention.go
+++ b/backend/plugin/advisor/pg/advisor_table_comment_convention.go
@@ -28,7 +28,7 @@ type TableCommentConventionAdvisor struct {
}
func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -56,7 +56,12 @@ func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
// Check each created table for comment requirements
for tableKey, tableInfo := range rule.createdTables {
diff --git a/backend/plugin/advisor/pg/advisor_table_disallow_partition.go b/backend/plugin/advisor/pg/advisor_table_disallow_partition.go
index 01339a3839..7c1a790693 100644
--- a/backend/plugin/advisor/pg/advisor_table_disallow_partition.go
+++ b/backend/plugin/advisor/pg/advisor_table_disallow_partition.go
@@ -28,7 +28,7 @@ type TableDisallowPartitionAdvisor struct {
// Check checks for partitioned tables.
func (*TableDisallowPartitionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -47,7 +47,12 @@ func (*TableDisallowPartitionAdvisor) Check(_ context.Context, checkCtx advisor.
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go b/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go
index b8374a9b0c..836c084443 100644
--- a/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go
+++ b/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go
@@ -30,7 +30,7 @@ type TableDropNamingConventionAdvisor struct {
// Check checks for table drop with naming convention.
func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -54,7 +54,12 @@ func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advis
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_table_no_fk.go b/backend/plugin/advisor/pg/advisor_table_no_fk.go
index 6d1fa71abc..f673f879f0 100644
--- a/backend/plugin/advisor/pg/advisor_table_no_fk.go
+++ b/backend/plugin/advisor/pg/advisor_table_no_fk.go
@@ -28,7 +28,7 @@ type TableNoFKAdvisor struct {
// Check checks table disallow foreign key.
func (*TableNoFKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -47,7 +47,12 @@ func (*TableNoFKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/pg/advisor_table_require_pk.go b/backend/plugin/advisor/pg/advisor_table_require_pk.go
index 0e07736a85..d6086a8db3 100644
--- a/backend/plugin/advisor/pg/advisor_table_require_pk.go
+++ b/backend/plugin/advisor/pg/advisor_table_require_pk.go
@@ -29,7 +29,7 @@ type TableRequirePKAdvisor struct {
// Check parses the given statement and checks for errors.
func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := getANTLRTree(checkCtx)
+ parseResults, err := getANTLRTree(checkCtx)
if err != nil {
return nil, err
}
@@ -50,7 +50,12 @@ func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context)
}
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
// Simple Solution: Validate final state after walking all statements
rule.validateFinalState()
@@ -114,10 +119,11 @@ func (r *tableRequirePKRule) handleCreatestmt(ctx *parser.CreatestmtContext) {
}
// Simple Solution: Just record the table mention (ALWAYS update for last occurrence)
+ // Store absolute line numbers (with baseLine offset added now)
key := fmt.Sprintf("%s.%s", schemaName, tableName)
r.tableMentions[key] = &tableMention{
- startLine: ctx.GetStart().GetLine(),
- endLine: ctx.GetStop().GetLine(),
+ startLine: ctx.GetStart().GetLine() + r.baseLine,
+ endLine: ctx.GetStop().GetLine() + r.baseLine,
}
}
@@ -137,10 +143,11 @@ func (r *tableRequirePKRule) handleAltertablestmt(ctx *parser.AltertablestmtCont
}
// Simple Solution: Just record the table mention (ALWAYS update for last occurrence)
+ // Store absolute line numbers (with baseLine offset added now)
key := fmt.Sprintf("%s.%s", schemaName, tableName)
r.tableMentions[key] = &tableMention{
- startLine: ctx.GetStart().GetLine(),
- endLine: ctx.GetStop().GetLine(),
+ startLine: ctx.GetStart().GetLine() + r.baseLine,
+ endLine: ctx.GetStop().GetLine() + r.baseLine,
}
}
@@ -198,13 +205,15 @@ func (r *tableRequirePKRule) validateFinalState() {
content = fmt.Sprintf("%s, related statement: %q", content, statement)
}
+ // Note: We already added baseLine offset when storing the line number,
+ // but AddAdvice will add it again, so we need to subtract it first
r.AddAdvice(&storepb.Advice{
Status: r.level,
Code: code.TableNoPK.Int32(),
Title: r.title,
Content: content,
StartPosition: &storepb.Position{
- Line: int32(mention.startLine),
+ Line: int32(mention.startLine - r.baseLine),
Column: 0,
},
})
diff --git a/backend/plugin/advisor/pg/generic_checker.go b/backend/plugin/advisor/pg/generic_checker.go
index b3f909ed58..434bc192c9 100644
--- a/backend/plugin/advisor/pg/generic_checker.go
+++ b/backend/plugin/advisor/pg/generic_checker.go
@@ -32,7 +32,8 @@ type Rule interface {
type GenericChecker struct {
*parser.BasePostgreSQLParserListener
- rules []Rule
+ rules []Rule
+ baseLine int
}
// NewGenericChecker creates a new instance of GenericChecker with the given rules.
@@ -43,6 +44,11 @@ func NewGenericChecker(rules []Rule) *GenericChecker {
}
}
+// SetBaseLine sets the base line number for error reporting.
+func (g *GenericChecker) SetBaseLine(baseLine int) {
+ g.baseLine = baseLine
+}
+
// EnterEveryRule is called when any rule is entered.
// It dispatches the event to all registered rules.
func (g *GenericChecker) EnterEveryRule(ctx antlr.ParserRuleContext) {
@@ -94,6 +100,12 @@ type BaseRule struct {
level storepb.Advice_Status
title string
adviceList []*storepb.Advice
+ baseLine int
+}
+
+// SetBaseLine sets the base line for the rule.
+func (r *BaseRule) SetBaseLine(baseLine int) {
+ r.baseLine = baseLine
}
// GetAdviceList returns the accumulated advice.
@@ -102,6 +114,10 @@ func (r *BaseRule) GetAdviceList() []*storepb.Advice {
}
// AddAdvice adds a new advice to the list.
+// Automatically adds baseLine offset to the line number.
func (r *BaseRule) AddAdvice(advice *storepb.Advice) {
+ if advice.StartPosition != nil {
+ advice.StartPosition.Line += int32(r.baseLine)
+ }
r.adviceList = append(r.adviceList, advice)
}
diff --git a/backend/plugin/advisor/pg/sdl_check.go b/backend/plugin/advisor/pg/sdl_check.go
index 2b25b4ef77..4bc3adeeb7 100644
--- a/backend/plugin/advisor/pg/sdl_check.go
+++ b/backend/plugin/advisor/pg/sdl_check.go
@@ -23,16 +23,19 @@ import (
//
// For integrity checks (foreign key validation, duplicate detection, etc.), use CheckSDLIntegrity from sdl_integrity_check.go.
func CheckSDLStyle(statement string) ([]*storepb.Advice, error) {
- tree, err := pgparser.ParsePostgreSQL(statement)
+ parseResults, err := pgparser.ParsePostgreSQL(statement)
if err != nil {
return nil, err
}
- // Run style/convention checks
+ // Run style/convention checks on all statements
styleChecker := &sdlChecker{
BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
}
- antlr.ParseTreeWalkerDefault.Walk(styleChecker, tree.Tree)
+
+ for _, parseResult := range parseResults {
+ antlr.ParseTreeWalkerDefault.Walk(styleChecker, parseResult.Tree)
+ }
return styleChecker.adviceList, nil
}
diff --git a/backend/plugin/advisor/pg/sdl_integrity_check.go b/backend/plugin/advisor/pg/sdl_integrity_check.go
index 880dc61d28..b7b2b3be44 100644
--- a/backend/plugin/advisor/pg/sdl_integrity_check.go
+++ b/backend/plugin/advisor/pg/sdl_integrity_check.go
@@ -32,7 +32,7 @@ func CheckSDLIntegrity(files map[string]string) (map[string][]*storepb.Advice, e
// Parse each file and build individual symbol tables
fileCheckers := make([]*fileSymbolTable, 0, len(files))
for filePath, statement := range files {
- tree, err := pgparser.ParsePostgreSQL(statement)
+ parseResults, err := pgparser.ParsePostgreSQL(statement)
if err != nil {
// Return parse error for this file
return map[string][]*storepb.Advice{
@@ -50,8 +50,10 @@ func CheckSDLIntegrity(files map[string]string) (map[string][]*storepb.Advice, e
symbolTable: newSymbolTable(),
}
- // Build symbol table for this file
- antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ // Build symbol table for this file - process all statements
+ for _, parseResult := range parseResults {
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
fileCheckers = append(fileCheckers, &fileSymbolTable{
filePath: filePath,
diff --git a/backend/plugin/advisor/pg/test/statement_disallow_commit.yaml b/backend/plugin/advisor/pg/test/statement_disallow_commit.yaml
index 58b8b737c7..c8a201180f 100644
--- a/backend/plugin/advisor/pg/test/statement_disallow_commit.yaml
+++ b/backend/plugin/advisor/pg/test/statement_disallow_commit.yaml
@@ -7,7 +7,7 @@
- status: 2
code: 206
title: statement.disallow-commit
- content: 'Commit is not allowed, related statement: "COMMIT;"'
+ content: 'Commit is not allowed, related statement: "CREATE TABLE techBook(id int, name varchar(255));"'
startposition:
line: 3
column: 0
@@ -25,7 +25,7 @@
- status: 2
code: 206
title: statement.disallow-commit
- content: 'Commit is not allowed, related statement: "COMMIT;"'
+ content: 'Commit is not allowed, related statement: "CREATE TABLE techBook(id int, name varchar(255));"'
startposition:
line: 3
column: 0
@@ -33,7 +33,7 @@
- status: 2
code: 206
title: statement.disallow-commit
- content: 'Commit is not allowed, related statement: "COMMIT;"'
+ content: 'Commit is not allowed, related statement: "CREATE TABLE techBook(id int, name varchar(255));"'
startposition:
line: 7
column: 0
diff --git a/backend/plugin/advisor/pg/test/statement_disallow_mix_in_ddl.yaml b/backend/plugin/advisor/pg/test/statement_disallow_mix_in_ddl.yaml
index 70e3e82b33..2f4264c02a 100644
--- a/backend/plugin/advisor/pg/test/statement_disallow_mix_in_ddl.yaml
+++ b/backend/plugin/advisor/pg/test/statement_disallow_mix_in_ddl.yaml
@@ -26,7 +26,7 @@
- status: 2
code: 227
title: statement.disallow-mix-in-ddl
- content: Alter schema can only run DDL, "DELETE FROM tech_book WHERE a > 1;" is not DDL
+ content: Alter schema can only run DDL, "ALTER TABLE tech_book ADD COLUMN author TEXT;" is not DDL
startposition:
line: 1
column: 0
@@ -34,7 +34,7 @@
- status: 2
code: 227
title: statement.disallow-mix-in-ddl
- content: Alter schema can only run DDL, "UPDATE tech_book SET id = 1;" is not DDL
+ content: Alter schema can only run DDL, "LTER TABLE tech_book ADD COLUMN author TEXT;" is not DDL
startposition:
line: 1
column: 0
diff --git a/backend/plugin/advisor/pg/test/statement_merge_alter_table.yaml b/backend/plugin/advisor/pg/test/statement_merge_alter_table.yaml
index 88e5ef986d..b3f7f4bef9 100644
--- a/backend/plugin/advisor/pg/test/statement_merge_alter_table.yaml
+++ b/backend/plugin/advisor/pg/test/statement_merge_alter_table.yaml
@@ -11,6 +11,6 @@
title: statement.merge-alter-table
content: There are 2 statements to modify table `t`
startposition:
- line: 3
+ line: 2
column: 0
endposition: null
diff --git a/backend/plugin/advisor/pg/test/statement_object_owner_check.yaml b/backend/plugin/advisor/pg/test/statement_object_owner_check.yaml
index 8ddd9dce80..c3efd52dfa 100644
--- a/backend/plugin/advisor/pg/test/statement_object_owner_check.yaml
+++ b/backend/plugin/advisor/pg/test/statement_object_owner_check.yaml
@@ -1,7 +1,3 @@
-# Basic test cases for statement.object-owner-check advisor
-# Since this advisor requires metadata and owner information, we use simple statements
-# that will pass when the owner matches the current role
-
- statement: CREATE TABLE public.t(id int);
changeType: 1
- statement: CREATE SCHEMA s1;
diff --git a/backend/plugin/advisor/pg/test/table_comment.yaml b/backend/plugin/advisor/pg/test/table_comment.yaml
index 261c7e3a64..f825e809d8 100644
--- a/backend/plugin/advisor/pg/test/table_comment.yaml
+++ b/backend/plugin/advisor/pg/test/table_comment.yaml
@@ -24,7 +24,7 @@
title: table.comment
content: Comment is required for table `d`
startposition:
- line: 2
+ line: 3
column: 0
endposition: null
- statement: |-
@@ -38,7 +38,7 @@
title: table.comment
content: Comment is required for table `t`
startposition:
- line: 1
+ line: 2
column: 0
endposition: null
- statement: |-
@@ -52,7 +52,7 @@
title: table.comment
content: Comment is required for table `t`
startposition:
- line: 1
+ line: 2
column: 0
endposition: null
- statement: |-
diff --git a/backend/plugin/advisor/pg/test/table_require_pk.yaml b/backend/plugin/advisor/pg/test/table_require_pk.yaml
index aa72fb531c..96ba12f5c6 100644
--- a/backend/plugin/advisor/pg/test/table_require_pk.yaml
+++ b/backend/plugin/advisor/pg/test/table_require_pk.yaml
@@ -12,6 +12,7 @@
startposition:
line: 1
column: 0
+ endposition: null
- statement: ALTER TABLE "tech_book" DROP CONSTRAINT "old_pk"
changeType: 1
want:
@@ -22,6 +23,7 @@
startposition:
line: 1
column: 0
+ endposition: null
- statement: ALTER TABLE "tech_book" DROP CONSTRAINT "old_index"
changeType: 1
- statement: ALTER TABLE "tech_book" DROP CONSTRAINT IF EXISTS constraint_not_in_catalog
@@ -36,6 +38,7 @@
startposition:
line: 1
column: 0
+ endposition: null
- statement: |-
ALTER TABLE tech_book ADD COLUMN column_not_in_pk int;
ALTER TABLE "tech_book" DROP COLUMN column_not_in_pk;
@@ -56,6 +59,7 @@
startposition:
line: 2
column: 0
+ endposition: null
- statement: |-
CREATE TABLE product(id INT, name TEXT);
ALTER TABLE product ADD PRIMARY KEY (id);
@@ -69,3 +73,4 @@
startposition:
line: 3
column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/pg/test_helper.go b/backend/plugin/advisor/pg/test_helper.go
index 08b9214ab8..cf64c8b97f 100644
--- a/backend/plugin/advisor/pg/test_helper.go
+++ b/backend/plugin/advisor/pg/test_helper.go
@@ -81,11 +81,11 @@ func RunANTLRAdvisorRuleTest(t *testing.T, rule advisor.SQLReviewRuleType, dbTyp
}
// Parse SQL using ANTLR for pg advisors
- tree, err := pg.ParsePostgreSQL(tc.Statement)
+ trees, err := pg.ParsePostgreSQL(tc.Statement)
require.NoError(t, err, "Failed to parse SQL: %s", tc.Statement)
// Always walk through the catalog to build metadata.
- advice := schema.WalkThrough(dbType, finalMetadata, tree)
+ advice := schema.WalkThrough(dbType, finalMetadata, trees)
require.Nil(t, advice, "Failed to walk through final catalog: %s", tc.Statement)
ruleList := []*storepb.SQLReviewRule{
@@ -105,7 +105,7 @@ func RunANTLRAdvisorRuleTest(t *testing.T, rule advisor.SQLReviewRuleType, dbTyp
DBSchema: schemaMetadata,
ChangeType: tc.ChangeType,
EnablePriorBackup: true,
- AST: tree, // Pass ANTLR parse result
+ AST: trees, // Pass ANTLR parse result list
Statements: tc.Statement,
Rule: ruleList[0],
OriginalMetadata: originalMetadata,
diff --git a/backend/plugin/advisor/pg/utils.go b/backend/plugin/advisor/pg/utils.go
index d2dba4d134..3940924f0b 100644
--- a/backend/plugin/advisor/pg/utils.go
+++ b/backend/plugin/advisor/pg/utils.go
@@ -30,20 +30,21 @@ func isTopLevel(ctx antlr.Tree) bool {
}
}
-// getANTLRTree extracts the ANTLR parse tree from the advisor context.
+// getANTLRTree extracts the ANTLR parse trees from the advisor context.
// The AST must be pre-parsed and passed via checkCtx.AST (e.g., in tests or by the framework).
// This enforces proper AST caching and makes any missing cache obvious.
-func getANTLRTree(checkCtx advisor.Context) (*pg.ParseResult, error) {
+// Returns all parse results for multi-statement SQL review.
+func getANTLRTree(checkCtx advisor.Context) ([]*pg.ParseResult, error) {
if checkCtx.AST == nil {
return nil, errors.New("AST is not provided in context - must be parsed before calling advisor")
}
- parseResult, ok := checkCtx.AST.(*pg.ParseResult)
+ parseResults, ok := checkCtx.AST.([]*pg.ParseResult)
if !ok {
- return nil, errors.Errorf("AST type mismatch: expected *pg.ParseResult, got %T", checkCtx.AST)
+ return nil, errors.Errorf("AST type mismatch: expected []*pg.ParseResult, got %T", checkCtx.AST)
}
- return parseResult, nil
+ return parseResults, nil
}
// extractTableName extracts the table name (last component) from a qualified name.
diff --git a/backend/plugin/db/pg/query.go b/backend/plugin/db/pg/query.go
index aafe641c6d..3cec09eb0d 100644
--- a/backend/plugin/db/pg/query.go
+++ b/backend/plugin/db/pg/query.go
@@ -198,11 +198,17 @@ func getStatementWithResultLimitInline(statement string, limitCount int) (string
return "", errors.New("empty statement")
}
- parseResult, err := pgparser.ParsePostgreSQL(statement)
+ parseResults, err := pgparser.ParsePostgreSQL(statement)
if err != nil {
return "", errors.Wrap(err, "failed to parse statement")
}
+ if len(parseResults) != 1 {
+ return "", errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+
+ parseResult := parseResults[0]
+
listener := &postgresqlRewriter{
limitCount: limitCount,
outerMostQuery: true,
diff --git a/backend/plugin/parser/base/interface.go b/backend/plugin/parser/base/interface.go
index 71129d80f7..36e1f0b3f6 100644
--- a/backend/plugin/parser/base/interface.go
+++ b/backend/plugin/parser/base/interface.go
@@ -267,7 +267,7 @@ func RegisterParseFunc(engine storepb.Engine, f ParseFunc) {
// The return type (any) varies by database engine:
// - TiDB: []ast.StmtNode (github.com/pingcap/tidb/pkg/parser/ast)
// - MySQL, MariaDB, OceanBase: []*ParseResult (github.com/bytebase/bytebase/backend/plugin/parser/mysql)
-// - PostgreSQL: *ParseResult (github.com/bytebase/bytebase/backend/plugin/parser/pg) - ANTLR-based
+// - PostgreSQL: []*ParseResult (github.com/bytebase/bytebase/backend/plugin/parser/pg) - ANTLR-based
// - CockroachDB: statements.Statements (github.com/cockroachdb/cockroachdb-parser/pkg/sql/parser/statements)
// - Redshift: antlr.Tree
// - Oracle: antlr.Tree
diff --git a/backend/plugin/parser/pg/access_tables.go b/backend/plugin/parser/pg/access_tables.go
index a02377cf44..a1af4f9191 100644
--- a/backend/plugin/parser/pg/access_tables.go
+++ b/backend/plugin/parser/pg/access_tables.go
@@ -30,11 +30,15 @@ type ExtractAccessTablesOption struct {
// ExtractAccessTables extracts all table/view references from a SQL statement.
// This is a lightweight version that doesn't perform full query span analysis.
func ExtractAccessTables(statement string, option ExtractAccessTablesOption) ([]base.ColumnResource, error) {
- parseResult, err := ParsePostgreSQL(statement)
+ parseResults, err := ParsePostgreSQL(statement)
if err != nil {
return nil, errors.Wrapf(err, "failed to parse PostgreSQL statement")
}
+ if len(parseResults) != 1 {
+ return nil, errors.Errorf("expected exactly 1 statement, got %d", len(parseResults))
+ }
+
searchPath := []string{option.DefaultSchema}
if option.DefaultSchema == "" {
searchPath = []string{"public"}
@@ -49,7 +53,7 @@ func ExtractAccessTables(statement string, option ExtractAccessTablesOption) ([]
skipMetadataValidation: option.SkipMetadataValidation,
}
- antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)
+ antlr.ParseTreeWalkerDefault.Walk(extractor, parseResults[0].Tree)
if extractor.err != nil {
return nil, errors.Wrapf(extractor.err, "failed to extract access tables")
diff --git a/backend/plugin/parser/pg/backup.go b/backend/plugin/parser/pg/backup.go
index b572549f4c..d98962ce8c 100644
--- a/backend/plugin/parser/pg/backup.go
+++ b/backend/plugin/parser/pg/backup.go
@@ -12,7 +12,7 @@ import (
parser "github.com/bytebase/parser/postgresql"
"github.com/bytebase/bytebase/backend/common"
- storebp "github.com/bytebase/bytebase/backend/generated-go/store"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
"github.com/bytebase/bytebase/backend/store/model"
)
@@ -55,10 +55,11 @@ type statementInfo struct {
statement string
tree antlr.ParserRuleContext
table *TableReference
+ baseLine int
}
func init() {
- base.RegisterTransformDMLToSelect(storebp.Engine_POSTGRES, TransformDMLToSelect)
+ base.RegisterTransformDMLToSelect(storepb.Engine_POSTGRES, TransformDMLToSelect)
}
func TransformDMLToSelect(ctx context.Context, tCtx base.TransformContext, statement string, _ string, targetSchema string, tablePrefix string) ([]base.BackupStatement, error) {
@@ -164,12 +165,12 @@ func generateSQLForTable(statementInfoList []statementInfo, targetSchema string,
SourceSchema: table.Schema,
SourceTableName: table.Table,
TargetTableName: targetTable,
- StartPosition: &storebp.Position{
- Line: int32(statementInfoList[0].tree.GetStart().GetLine()),
+ StartPosition: &storepb.Position{
+ Line: int32(statementInfoList[0].tree.GetStart().GetLine() + statementInfoList[0].baseLine),
Column: int32(statementInfoList[0].tree.GetStart().GetColumn()),
},
- EndPosition: &storebp.Position{
- Line: int32(statementInfoList[len(statementInfoList)-1].tree.GetStop().GetLine()),
+ EndPosition: &storepb.Position{
+ Line: int32(statementInfoList[len(statementInfoList)-1].tree.GetStop().GetLine() + statementInfoList[len(statementInfoList)-1].baseLine),
Column: int32(statementInfoList[len(statementInfoList)-1].tree.GetStop().GetColumn()),
},
}, nil
@@ -235,7 +236,7 @@ func (e *suffixSelectClauseExtractor) EnterDeletestmt(ctx *parser.DeletestmtCont
}
func prepareTransformation(ctx context.Context, tCtx base.TransformContext, statement string) ([]statementInfo, error) {
- tree, err := ParsePostgreSQL(statement)
+ parseResults, err := ParsePostgreSQL(statement)
if err != nil {
return nil, errors.Wrap(err, "failed to parse statement")
}
@@ -253,18 +254,28 @@ func prepareTransformation(ctx context.Context, tCtx base.TransformContext, stat
metadata: metadata,
searchPath: metadata.GetSearchPath(),
}
- antlr.ParseTreeWalkerDefault.Walk(extractor, tree.Tree)
- return extractor.dmls, extractor.err
+
+ // Walk all parse results to extract DML statements
+ for _, parseResult := range parseResults {
+ extractor.currentBaseLine = parseResult.BaseLine
+ antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)
+ if extractor.err != nil {
+ return nil, extractor.err
+ }
+ }
+
+ return extractor.dmls, nil
}
type dmlExtractor struct {
*parser.BasePostgreSQLParserListener
- metadata *model.DatabaseMetadata
- searchPath []string
- dmls []statementInfo
- offset int
- err error
+ metadata *model.DatabaseMetadata
+ searchPath []string
+ dmls []statementInfo
+ offset int
+ err error
+ currentBaseLine int
}
func isTopLevel(ctx antlr.Tree) bool {
@@ -346,6 +357,7 @@ func (e *dmlExtractor) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {
statement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),
tree: ctx,
table: table,
+ baseLine: e.currentBaseLine,
})
}
}
@@ -366,6 +378,7 @@ func (e *dmlExtractor) EnterDeletestmt(ctx *parser.DeletestmtContext) {
statement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),
tree: ctx,
table: table,
+ baseLine: e.currentBaseLine,
})
}
}
diff --git a/backend/plugin/parser/pg/extract_params_test.go b/backend/plugin/parser/pg/extract_params_test.go
index 300ef41494..370336a886 100644
--- a/backend/plugin/parser/pg/extract_params_test.go
+++ b/backend/plugin/parser/pg/extract_params_test.go
@@ -73,10 +73,11 @@ $$ LANGUAGE SQL;`,
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- res, err := ParsePostgreSQL(tt.definition)
+ parseResults, err := ParsePostgreSQL(tt.definition)
require.NoError(t, err, "failed to parse function definition")
+ require.Len(t, parseResults, 1, "expected exactly 1 statement")
- root, ok := res.Tree.(*postgresql.RootContext)
+ root, ok := parseResults[0].Tree.(*postgresql.RootContext)
require.True(t, ok, "expected RootContext")
stmtblock := root.Stmtblock()
stmtmulti := stmtblock.Stmtmulti()
diff --git a/backend/plugin/parser/pg/pg.go b/backend/plugin/parser/pg/pg.go
index bb5c8198fe..bc2c16d7be 100644
--- a/backend/plugin/parser/pg/pg.go
+++ b/backend/plugin/parser/pg/pg.go
@@ -21,24 +21,50 @@ func parsePostgreSQLForRegistry(statement string) (any, error) {
}
type ParseResult struct {
- Tree antlr.Tree
- Tokens *antlr.CommonTokenStream
+ Tree antlr.Tree
+ Tokens *antlr.CommonTokenStream
+ BaseLine int
}
-// ParsePostgreSQL parses the given SQL and returns the ParseResult.
+// ParsePostgreSQL parses the given SQL and returns a list of ParseResult (one per statement).
// Use the PostgreSQL parser based on antlr4.
-func ParsePostgreSQL(sql string) (*ParseResult, error) {
+func ParsePostgreSQL(sql string) ([]*ParseResult, error) {
+ stmts, err := SplitSQL(sql)
+ if err != nil {
+ return nil, err
+ }
+
+ var results []*ParseResult
+ for _, stmt := range stmts {
+ if stmt.Empty {
+ continue
+ }
+
+ parseResult, err := parseSinglePostgreSQL(stmt.Text, stmt.BaseLine)
+ if err != nil {
+ return nil, err
+ }
+ results = append(results, parseResult)
+ }
+
+ return results, nil
+}
+
+// parseSinglePostgreSQL parses a single PostgreSQL statement and returns the ParseResult.
+func parseSinglePostgreSQL(sql string, baseLine int) (*ParseResult, error) {
lexer := parser.NewPostgreSQLLexer(antlr.NewInputStream(sql))
stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
p := parser.NewPostgreSQLParser(stream)
lexerErrorListener := &base.ParseErrorListener{
Statement: sql,
+ BaseLine: baseLine,
}
lexer.RemoveErrorListeners()
lexer.AddErrorListener(lexerErrorListener)
parserErrorListener := &base.ParseErrorListener{
Statement: sql,
+ BaseLine: baseLine,
}
p.RemoveErrorListeners()
p.AddErrorListener(parserErrorListener)
@@ -55,8 +81,9 @@ func ParsePostgreSQL(sql string) (*ParseResult, error) {
}
result := &ParseResult{
- Tree: tree,
- Tokens: stream,
+ Tree: tree,
+ Tokens: stream,
+ BaseLine: baseLine,
}
return result, nil
diff --git a/backend/plugin/parser/pg/pg_test.go b/backend/plugin/parser/pg/pg_test.go
index fff725f25f..b5940fb8ae 100644
--- a/backend/plugin/parser/pg/pg_test.go
+++ b/backend/plugin/parser/pg/pg_test.go
@@ -24,15 +24,16 @@ func TestPostgreSQLParser(t *testing.T) {
},
{
statement: "SELECT 1;\n SELEC 5;\nSELECT 6;",
- errorMessage: "Syntax error at line 2:4 \nrelated text: SELECT 1;\n SELEC",
+ errorMessage: "Syntax error at line 2:4 \nrelated text: \n SELEC",
},
}
for _, test := range tests {
- res, err := ParsePostgreSQL(test.statement)
- if res != nil {
- _, ok := res.Tree.(*parser.RootContext)
- require.True(t, ok)
+ parseResults, err := ParsePostgreSQL(test.statement)
+ // Assert each element's Tree is a RootContext
+ for i, result := range parseResults {
+ _, ok := result.Tree.(*parser.RootContext)
+ require.True(t, ok, "parseResults[%d].Tree should be a RootContext", i)
}
if test.errorMessage == "" {
require.NoError(t, err)
diff --git a/backend/plugin/parser/pg/plsql.go b/backend/plugin/parser/pg/plsql.go
index 681881de68..6c7f4b4191 100644
--- a/backend/plugin/parser/pg/plsql.go
+++ b/backend/plugin/parser/pg/plsql.go
@@ -8,13 +8,18 @@ import (
// Returns true if the statement is a DO block only, false otherwise.
func IsPlSQLBlock(stmt string) bool {
// Parse using the existing ANTLR-based parser
- result, err := ParsePostgreSQL(stmt)
+ results, err := ParsePostgreSQL(stmt)
if err != nil {
return false
}
+ // Must be exactly one statement
+ if len(results) != 1 {
+ return false
+ }
+
// Check if the parsed tree is a single DO statement
- root, ok := result.Tree.(*parser.RootContext)
+ root, ok := results[0].Tree.(*parser.RootContext)
if !ok || root == nil {
return false
}
diff --git a/backend/plugin/parser/pg/query_antlr.go b/backend/plugin/parser/pg/query_antlr.go
index 7afd43da09..bf432ccd40 100644
--- a/backend/plugin/parser/pg/query_antlr.go
+++ b/backend/plugin/parser/pg/query_antlr.go
@@ -18,7 +18,7 @@ import (
// 5. Reject: All other statements (DDL, DML except SELECT)
func validateQueryANTLR(statement string) (bool, bool, error) {
// Parse with ANTLR
- result, err := ParsePostgreSQL(statement)
+ results, err := ParsePostgreSQL(statement)
if err != nil {
// Return syntax error
if syntaxErr, ok := err.(*base.SyntaxError); ok {
@@ -27,8 +27,7 @@ func validateQueryANTLR(statement string) (bool, bool, error) {
return false, false, err
}
- // Analyze the parse tree
- tree := result.Tree
+ // Create a single listener to accumulate validation state across all statements
listener := &queryValidatorListener{
hasExecute: false,
explainAnalyze: false,
@@ -37,22 +36,28 @@ func validateQueryANTLR(statement string) (bool, bool, error) {
validStmtCount: 0,
}
- antlr.ParseTreeWalkerDefault.Walk(listener, tree)
+ // Walk through each parsed statement
+ for _, result := range results {
+ tree := result.Tree
- // If we found invalid statements, reject
- if listener.hasInvalidStmt {
- return false, false, nil
- }
-
- // Check for DML in CTEs or EXPLAIN ANALYZE
- // This is done in a second pass to detect DML statements anywhere in the tree
- if listener.hasCTE || listener.explainAnalyze {
- dmlDetector := &dmlDetectorListener{}
- antlr.ParseTreeWalkerDefault.Walk(dmlDetector, tree)
+ // Analyze the parse tree
+ antlr.ParseTreeWalkerDefault.Walk(listener, tree)
- if dmlDetector.hasDML {
+ // If we found invalid statements, reject immediately
+ if listener.hasInvalidStmt {
return false, false, nil
}
+
+ // Check for DML in CTEs or EXPLAIN ANALYZE
+ // This is done in a second pass to detect DML statements anywhere in the tree
+ if listener.hasCTE || listener.explainAnalyze {
+ dmlDetector := &dmlDetectorListener{}
+ antlr.ParseTreeWalkerDefault.Walk(dmlDetector, tree)
+
+ if dmlDetector.hasDML {
+ return false, false, nil
+ }
+ }
}
// Return validation results
diff --git a/backend/plugin/parser/pg/query_span_extractor.go b/backend/plugin/parser/pg/query_span_extractor.go
index 86c4e724a5..ed5567c02d 100644
--- a/backend/plugin/parser/pg/query_span_extractor.go
+++ b/backend/plugin/parser/pg/query_span_extractor.go
@@ -107,11 +107,17 @@ func (q *querySpanExtractor) getQuerySpan(ctx context.Context, stmt string) (*ba
q.ctx = ctx
// Parse the statement using ANTLR
- parseResult, err := ParsePostgreSQL(stmt)
+ parseResults, err := ParsePostgreSQL(stmt)
if err != nil {
return nil, err
}
+ if len(parseResults) != 1 {
+ return nil, errors.Errorf("expected exactly 1 statement, got %d", len(parseResults))
+ }
+
+ parseResult := parseResults[0]
+
// Walk the tree to extract access tables
accessTableExtractor := &accessTableExtractor{
@@ -302,15 +308,19 @@ type functionDefinitionDetail struct {
func buildFunctionDefinitionDetail(funcDef *functionDefinition) (*functionDefinitionDetail, error) {
function := funcDef.metadata
definition := function.GetDefinition()
- res, err := ParsePostgreSQL(definition)
+ parseResults, err := ParsePostgreSQL(definition)
if err != nil {
return nil, errors.Wrapf(err, "failed to parse function definition: %s", definition)
}
+ if len(parseResults) != 1 {
+ return nil, errors.Errorf("expected exactly 1 statement in function definition, got %d", len(parseResults))
+ }
+
// Navigate: root -> stmtblock -> stmt -> createfunctionstmt
- root, ok := res.Tree.(*postgresql.RootContext)
+ root, ok := parseResults[0].Tree.(*postgresql.RootContext)
if !ok {
- return nil, errors.Errorf("expecting RootContext but got %T", res.Tree)
+ return nil, errors.Errorf("expecting RootContext but got %T", parseResults[0].Tree)
}
stmtblock := root.Stmtblock()
@@ -426,15 +436,19 @@ const (
)
func (q *querySpanExtractor) getColumnsFromFunction(name, definition string) ([]base.QuerySpanResult, error) {
- res, err := ParsePostgreSQL(definition)
+ parseResults, err := ParsePostgreSQL(definition)
if err != nil {
return nil, errors.Wrapf(err, "failed to parse function definition: %s", definition)
}
+ if len(parseResults) != 1 {
+ return nil, errors.Errorf("expected exactly 1 statement in function definition, got %d", len(parseResults))
+ }
+
// Navigate: root -> stmtblock -> stmt -> createfunctionstmt
- root, ok := res.Tree.(*postgresql.RootContext)
+ root, ok := parseResults[0].Tree.(*postgresql.RootContext)
if !ok {
- return nil, errors.Errorf("expecting RootContext but got %T", res.Tree)
+ return nil, errors.Errorf("expecting RootContext but got %T", parseResults[0].Tree)
}
stmtblock := root.Stmtblock()
@@ -633,16 +647,20 @@ func (l *returnQueryListener) EnterStmt_return(ctx *postgresql.Stmt_returnContex
}
func (q *querySpanExtractor) getColumnsFromComplexPLPGSQL(name string, columnNames []string, definition string) ([]base.QuerySpanResult, error) {
- res, err := ParsePostgreSQL(definition)
+ parseResults, err := ParsePostgreSQL(definition)
if err != nil {
return nil, errors.Wrapf(err, "failed to parse PLpgSQL function body for function %s", name)
}
+ if len(parseResults) != 1 {
+ return nil, errors.Errorf("expected exactly 1 statement in function definition, got %d", len(parseResults))
+ }
+
listener := &plpgSQLListener{
q: q,
variables: make(map[string]*base.QuerySpanResult),
}
- antlr.ParseTreeWalkerDefault.Walk(listener, res.Tree)
+ antlr.ParseTreeWalkerDefault.Walk(listener, parseResults[0].Tree)
if listener.err != nil {
return nil, errors.Wrapf(listener.err, "failed to extract table source from PLpgSQL function body for function %s", name)
}
diff --git a/backend/plugin/parser/pg/query_test.go b/backend/plugin/parser/pg/query_test.go
index 3a9df19dc9..6df7655982 100644
--- a/backend/plugin/parser/pg/query_test.go
+++ b/backend/plugin/parser/pg/query_test.go
@@ -96,6 +96,37 @@ func TestValidateSQLForEditor(t *testing.T) {
valid: false,
allQuery: false,
},
+ // Multi-statement tests
+ {
+ sql: `SELECT * FROM t1; SELECT * FROM t2;`,
+ valid: true,
+ allQuery: true,
+ },
+ {
+ sql: `SELECT * FROM t1; SELECT * FROM t2; SHOW search_path;`,
+ valid: true,
+ allQuery: true,
+ },
+ {
+ sql: `SET work_mem = '128MB'; SELECT * FROM t1;`,
+ valid: true,
+ allQuery: false, // SET doesn't return data
+ },
+ {
+ sql: `SELECT * FROM t1; INSERT INTO t2 VALUES (1);`,
+ valid: false, // INSERT not allowed
+ allQuery: false,
+ },
+ {
+ sql: `SELECT * FROM t1; CREATE TABLE t2 (a int);`,
+ valid: false, // DDL not allowed
+ allQuery: false,
+ },
+ {
+ sql: `EXPLAIN SELECT * FROM t1; SELECT * FROM t2;`,
+ valid: true,
+ allQuery: true,
+ },
}
for _, test := range tests {
diff --git a/backend/plugin/parser/pg/resource_change.go b/backend/plugin/parser/pg/resource_change.go
index ba951c3ff0..f276d928f3 100644
--- a/backend/plugin/parser/pg/resource_change.go
+++ b/backend/plugin/parser/pg/resource_change.go
@@ -20,13 +20,9 @@ func init() {
}
func extractChangedResources(database string, _ string, dbMetadata *model.DatabaseMetadata, asts any, statement string) (*base.ChangeSummary, error) {
- parseResult, ok := asts.(*ParseResult)
+ parseResults, ok := asts.([]*ParseResult)
if !ok {
- return nil, errors.Errorf("invalid ast type %T, expected *ParseResult", asts)
- }
-
- if parseResult == nil || parseResult.Tree == nil {
- return nil, errors.New("parse result or tree is nil")
+ return nil, errors.Errorf("invalid ast type %T, expected []*ParseResult", asts)
}
changedResources := model.NewChangedResources(dbMetadata)
@@ -35,19 +31,36 @@ func extractChangedResources(database string, _ string, dbMetadata *model.Databa
searchPath = []string{"public"} // default search path for PostgreSQL
}
+ // If no parse results, return empty summary
+ if len(parseResults) == 0 {
+ return &base.ChangeSummary{
+ ChangedResources: changedResources,
+ DMLCount: 0,
+ SampleDMLS: []string{},
+ InsertCount: 0,
+ }, nil
+ }
+
listener := &changedResourcesListener{
database: database,
searchPath: searchPath,
changedResources: changedResources,
databaseMetadata: dbMetadata,
statement: statement,
- tokenStream: parseResult.Tokens,
dmlCount: 0,
insertCount: 0,
sampleDMLs: []string{},
}
- antlr.ParseTreeWalkerDefault.Walk(listener, parseResult.Tree)
+ // Walk all parse results to extract changed resources
+ for _, parseResult := range parseResults {
+ if parseResult == nil || parseResult.Tree == nil {
+ return nil, errors.New("parse result or tree is nil")
+ }
+
+ listener.tokenStream = parseResult.Tokens
+ antlr.ParseTreeWalkerDefault.Walk(listener, parseResult.Tree)
+ }
return &base.ChangeSummary{
ChangedResources: changedResources,
diff --git a/backend/plugin/parser/pg/restore.go b/backend/plugin/parser/pg/restore.go
index 7c803e14b9..6126efbce7 100644
--- a/backend/plugin/parser/pg/restore.go
+++ b/backend/plugin/parser/pg/restore.go
@@ -34,11 +34,33 @@ func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statement
return "", errors.Errorf("no original SQL")
}
- tree, err := ParsePostgreSQL(statement)
+ parseResults, err := ParsePostgreSQL(statement)
if err != nil {
return "", err
}
+ // Find the parse result that contains the statement at the backup position
+ var targetResult *ParseResult
+ for _, parseResult := range parseResults {
+ // Walk the tree to find if this parse result contains the target statement
+ finder := &statementAtPositionFinder{
+ startPos: backupItem.StartPosition,
+ endPos: backupItem.EndPosition,
+ baseLine: parseResult.BaseLine,
+ }
+ antlr.ParseTreeWalkerDefault.Walk(finder, parseResult.Tree)
+ if finder.found {
+ targetResult = parseResult
+ break
+ }
+ }
+
+ if targetResult == nil {
+ return "", errors.Errorf("could not find statement at position (line %d:%d - %d:%d)",
+ backupItem.StartPosition.Line, backupItem.StartPosition.Column,
+ backupItem.EndPosition.Line, backupItem.EndPosition.Column)
+ }
+
sqlForComment, truncated := common.TruncateString(originalSQL, maxCommentLength)
if truncated {
sqlForComment += "..."
@@ -49,7 +71,7 @@ func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statement
return "", errors.Wrap(err, "failed to get prepend statements")
}
- return doGenerate(ctx, rCtx, sqlForComment, tree, backupItem, prependStatements)
+ return doGenerate(ctx, rCtx, sqlForComment, targetResult, backupItem, prependStatements)
}
func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment string, tree *ParseResult, backupItem *storepb.PriorBackupDetail_Item, prependStatements string) (string, error) {
@@ -223,7 +245,7 @@ func extractSingleSQL(statement string, backupItem *storepb.PriorBackupDetail_It
return "", errors.Errorf("backup item is nil")
}
- tree, err := ParsePostgreSQL(statement)
+ parseResults, err := ParsePostgreSQL(statement)
if err != nil {
return "", errors.Wrapf(err, "failed to parse statement")
}
@@ -232,7 +254,13 @@ func extractSingleSQL(statement string, backupItem *storepb.PriorBackupDetail_It
startPos: backupItem.StartPosition,
endPos: backupItem.EndPosition,
}
- antlr.ParseTreeWalkerDefault.Walk(l, tree.Tree)
+
+ // Walk all parse results to find statements within the specified position range
+ for _, parseResult := range parseResults {
+ l.baseLine = parseResult.BaseLine
+ antlr.ParseTreeWalkerDefault.Walk(l, parseResult.Tree)
+ }
+
return strings.Join(l.originalSQL, ";\n"), nil
}
@@ -242,15 +270,16 @@ type originalSQLExtractor struct {
originalSQL []string
startPos *storepb.Position
endPos *storepb.Position
+ baseLine int
}
func (l *originalSQLExtractor) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {
if isTopLevel(ctx.GetParent()) {
if inRange(&storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(ctx.GetStart().GetLine()) + int32(l.baseLine),
Column: int32(ctx.GetStart().GetColumn()),
}, &storepb.Position{
- Line: int32(ctx.GetStop().GetLine()),
+ Line: int32(ctx.GetStop().GetLine()) + int32(l.baseLine),
Column: int32(ctx.GetStop().GetColumn()),
}, l.startPos, l.endPos) {
l.originalSQL = append(l.originalSQL, ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx))
@@ -261,10 +290,10 @@ func (l *originalSQLExtractor) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {
func (l *originalSQLExtractor) EnterDeletestmt(ctx *parser.DeletestmtContext) {
if isTopLevel(ctx.GetParent()) {
if inRange(&storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(ctx.GetStart().GetLine()) + int32(l.baseLine),
Column: int32(ctx.GetStart().GetColumn()),
}, &storepb.Position{
- Line: int32(ctx.GetStop().GetLine()),
+ Line: int32(ctx.GetStop().GetLine()) + int32(l.baseLine),
Column: int32(ctx.GetStop().GetColumn()),
}, l.startPos, l.endPos) {
l.originalSQL = append(l.originalSQL, ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx))
@@ -284,14 +313,20 @@ func inRange(start, end, targetStart, targetEnd *storepb.Position) bool {
func getPrependStatements(statement string) (string, error) {
// Parse with ANTLR
- parseResult, err := ParsePostgreSQL(statement)
+ parseResults, err := ParsePostgreSQL(statement)
if err != nil {
return "", errors.Wrap(err, "failed to parse statement")
}
- // Create listener to find SET role statements
+ // Create listener to find SET role statements across all parsed statements
listener := &setRoleListener{}
- antlr.ParseTreeWalkerDefault.Walk(listener, parseResult.Tree)
+ for _, parseResult := range parseResults {
+ antlr.ParseTreeWalkerDefault.Walk(listener, parseResult.Tree)
+ // If we found a SET role statement, return it immediately
+ if listener.setRoleText != "" {
+ break
+ }
+ }
return listener.setRoleText, nil
}
@@ -328,3 +363,36 @@ func (l *setRoleListener) EnterVariablesetstmt(ctx *parser.VariablesetstmtContex
}
}
}
+
+// statementAtPositionFinder finds if a parse tree contains a statement at the given position.
+type statementAtPositionFinder struct {
+ *parser.BasePostgreSQLParserListener
+ startPos *storepb.Position
+ endPos *storepb.Position
+ baseLine int
+ found bool
+}
+
+func (f *statementAtPositionFinder) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {
+ if isTopLevel(ctx.GetParent()) && inRange(&storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()) + int32(f.baseLine),
+ Column: int32(ctx.GetStart().GetColumn()),
+ }, &storepb.Position{
+ Line: int32(ctx.GetStop().GetLine()) + int32(f.baseLine),
+ Column: int32(ctx.GetStop().GetColumn()),
+ }, f.startPos, f.endPos) {
+ f.found = true
+ }
+}
+
+func (f *statementAtPositionFinder) EnterDeletestmt(ctx *parser.DeletestmtContext) {
+ if isTopLevel(ctx.GetParent()) && inRange(&storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()) + int32(f.baseLine),
+ Column: int32(ctx.GetStart().GetColumn()),
+ }, &storepb.Position{
+ Line: int32(ctx.GetStop().GetLine()) + int32(f.baseLine),
+ Column: int32(ctx.GetStop().GetColumn()),
+ }, f.startPos, f.endPos) {
+ f.found = true
+ }
+}
diff --git a/backend/plugin/parser/pg/statement_type.go b/backend/plugin/parser/pg/statement_type.go
index 160e416c82..472ed6577b 100644
--- a/backend/plugin/parser/pg/statement_type.go
+++ b/backend/plugin/parser/pg/statement_type.go
@@ -16,20 +16,29 @@ type StatementTypeWithPosition struct {
// GetStatementTypes returns statement types with position information.
// The line numbers are one-based.
func GetStatementTypes(asts any) ([]StatementTypeWithPosition, error) {
- parseResult, ok := asts.(*ParseResult)
+ parseResults, ok := asts.([]*ParseResult)
if !ok {
- return nil, errors.Errorf("invalid ast type %T, expected *ParseResult", asts)
+ return nil, errors.Errorf("invalid ast type %T, expected []*ParseResult", asts)
}
- if parseResult == nil || parseResult.Tree == nil {
- return nil, errors.New("invalid parse result")
+ if len(parseResults) == 0 {
+ return []StatementTypeWithPosition{}, nil
}
- collector := &statementTypeCollectorWithPosition{
- tokens: parseResult.Tokens,
- }
+ var allResults []StatementTypeWithPosition
+ for _, parseResult := range parseResults {
+ if parseResult == nil || parseResult.Tree == nil {
+ return nil, errors.New("invalid parse result")
+ }
+
+ collector := &statementTypeCollectorWithPosition{
+ tokens: parseResult.Tokens,
+ baseLine: parseResult.BaseLine,
+ }
- antlr.ParseTreeWalkerDefault.Walk(collector, parseResult.Tree)
+ antlr.ParseTreeWalkerDefault.Walk(collector, parseResult.Tree)
+ allResults = append(allResults, collector.results...)
+ }
- return collector.results, nil
+ return allResults, nil
}
diff --git a/backend/plugin/parser/pg/statement_type_antlr.go b/backend/plugin/parser/pg/statement_type_antlr.go
index 4aec35577a..0d68bf7f8d 100644
--- a/backend/plugin/parser/pg/statement_type_antlr.go
+++ b/backend/plugin/parser/pg/statement_type_antlr.go
@@ -56,8 +56,9 @@ const (
// statementTypeCollectorWithPosition collects statement types with positions.
type statementTypeCollectorWithPosition struct {
*parser.BasePostgreSQLParserListener
- tokens *antlr.CommonTokenStream
- results []StatementTypeWithPosition
+ tokens *antlr.CommonTokenStream
+ baseLine int
+ results []StatementTypeWithPosition
}
// Helper function to add statement with position.
@@ -69,7 +70,7 @@ func (c *statementTypeCollectorWithPosition) addStatement(stmtType string, ctx a
// Get line number from the stop token
line := 0
if ctx.GetStop() != nil {
- line = ctx.GetStop().GetLine()
+ line = ctx.GetStop().GetLine() + c.baseLine
}
// Get statement text
diff --git a/backend/plugin/schema/pg/chunk_extraction_test.go b/backend/plugin/schema/pg/chunk_extraction_test.go
index 54fb94523b..620cf7aef8 100644
--- a/backend/plugin/schema/pg/chunk_extraction_test.go
+++ b/backend/plugin/schema/pg/chunk_extraction_test.go
@@ -331,14 +331,15 @@ func TestNewTableASTParsing(t *testing.T) {
"name" text NOT NULL
);`
- parseResult, err := pgparser.ParsePostgreSQL(tableSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(tableSDL)
require.NoError(t, err)
+ require.Len(t, parseResults, 1, "Should parse single statement")
// Extract the CREATE TABLE AST node
var createTableNode *parser.CreatestmtContext
antlr.ParseTreeWalkerDefault.Walk(&createTableExtractor{
result: &createTableNode,
- }, parseResult.Tree)
+ }, parseResults[0].Tree)
require.NotNil(t, createTableNode, "Should extract CREATE TABLE AST node")
diff --git a/backend/plugin/schema/pg/column_rewrite_test.go b/backend/plugin/schema/pg/column_rewrite_test.go
index c1f6b12602..7f77c00248 100644
--- a/backend/plugin/schema/pg/column_rewrite_test.go
+++ b/backend/plugin/schema/pg/column_rewrite_test.go
@@ -298,14 +298,15 @@ func TestColumnRewriteOperations(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
// Parse the original SDL to create an AST chunk
- parseResult, err := pgparser.ParsePostgreSQL(tc.originalSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(tc.originalSDL)
require.NoError(t, err, "Failed to parse original SDL")
+ require.Len(t, parseResults, 1, "Should parse single statement")
// Extract the CREATE TABLE AST node
var createTableNode *parser.CreatestmtContext
antlr.ParseTreeWalkerDefault.Walk(&createTableExtractor{
result: &createTableNode,
- }, parseResult.Tree)
+ }, parseResults[0].Tree)
require.NotNil(t, createTableNode, "Failed to extract CREATE TABLE AST node")
// Create a mock chunk
@@ -379,13 +380,14 @@ func TestColumnCommaHandlingEdgeCases(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
// Parse the SDL
- parseResult, err := pgparser.ParsePostgreSQL(tc.originalSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(tc.originalSDL)
require.NoError(t, err, "Failed to parse SDL")
+ require.Len(t, parseResults, 1, "Should parse single statement")
var createTableNode *parser.CreatestmtContext
antlr.ParseTreeWalkerDefault.Walk(&createTableExtractor{
result: &createTableNode,
- }, parseResult.Tree)
+ }, parseResults[0].Tree)
require.NotNil(t, createTableNode, "Failed to extract CREATE TABLE AST")
// Extract columns
@@ -397,7 +399,7 @@ func TestColumnCommaHandlingEdgeCases(t *testing.T) {
columnDef := columnDefs.Map[columnName]
// Get the rewriter
- tokenStream := parseResult.Tokens
+ tokenStream := parseResults[0].Tokens
rewriter := antlr.NewTokenStreamRewriter(tokenStream)
// Test the deleteColumnFromAST function directly
@@ -439,13 +441,14 @@ func TestColumnRewriteWithCollation(t *testing.T) {
}
// Parse and test
- parseResult, err := pgparser.ParsePostgreSQL(originalSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(originalSDL)
require.NoError(t, err)
+ require.Len(t, parseResults, 1, "Should parse single statement")
var createTableNode *parser.CreatestmtContext
antlr.ParseTreeWalkerDefault.Walk(&createTableExtractor{
result: &createTableNode,
- }, parseResult.Tree)
+ }, parseResults[0].Tree)
require.NotNil(t, createTableNode)
chunk := &schema.SDLChunk{
diff --git a/backend/plugin/schema/pg/constraint_rewrite_test.go b/backend/plugin/schema/pg/constraint_rewrite_test.go
index c3b351dc69..4dafb57649 100644
--- a/backend/plugin/schema/pg/constraint_rewrite_test.go
+++ b/backend/plugin/schema/pg/constraint_rewrite_test.go
@@ -668,14 +668,15 @@ func TestConstraintRewriteOperations(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
// Parse the original SDL to create an AST chunk
- parseResult, err := pgparser.ParsePostgreSQL(tc.originalSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(tc.originalSDL)
require.NoError(t, err, "Failed to parse original SDL")
+ require.Len(t, parseResults, 1, "Should parse single statement")
// Extract the CREATE TABLE AST node
var createTableNode *parser.CreatestmtContext
antlr.ParseTreeWalkerDefault.Walk(&createTableExtractor{
result: &createTableNode,
- }, parseResult.Tree)
+ }, parseResults[0].Tree)
require.NotNil(t, createTableNode, "Failed to extract CREATE TABLE AST node")
// Create a mock chunk
@@ -745,14 +746,15 @@ func TestConstraintModificationOperations(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
// Parse the original SDL to create an AST chunk
- parseResult, err := pgparser.ParsePostgreSQL(tc.originalSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(tc.originalSDL)
require.NoError(t, err, "Failed to parse original SDL")
+ require.Len(t, parseResults, 1, "Should parse single statement")
// Extract the CREATE TABLE AST node
var createTableNode *parser.CreatestmtContext
antlr.ParseTreeWalkerDefault.Walk(&createTableExtractor{
result: &createTableNode,
- }, parseResult.Tree)
+ }, parseResults[0].Tree)
require.NotNil(t, createTableNode, "Failed to extract CREATE TABLE AST node")
// Create a mock chunk
diff --git a/backend/plugin/schema/pg/get_database_definition.go b/backend/plugin/schema/pg/get_database_definition.go
index 63e4c8ff60..3000fde325 100644
--- a/backend/plugin/schema/pg/get_database_definition.go
+++ b/backend/plugin/schema/pg/get_database_definition.go
@@ -2109,7 +2109,7 @@ func isDefinitionProcedure(definition string) bool {
}
// Parse the definition to get AST
- parseResult, err := pgparser.ParsePostgreSQL(definition)
+ parseResults, err := pgparser.ParsePostgreSQL(definition)
if err != nil {
// If parsing fails, fall back to string-based detection
// This should rarely happen for valid definitions
@@ -2119,7 +2119,12 @@ func isDefinitionProcedure(definition string) bool {
strings.HasPrefix(upperDef, "CREATE OR REPLACE PROCEDURE")
}
- tree := parseResult.Tree
+ // For function/procedure definition, we expect exactly one statement
+ if len(parseResults) != 1 {
+ return false
+ }
+
+ tree := parseResults[0].Tree
if tree == nil {
return false
}
diff --git a/backend/plugin/schema/pg/get_database_metadata.go b/backend/plugin/schema/pg/get_database_metadata.go
index cdb93b567e..69c5886587 100644
--- a/backend/plugin/schema/pg/get_database_metadata.go
+++ b/backend/plugin/schema/pg/get_database_metadata.go
@@ -25,7 +25,7 @@ func init() {
// GetDatabaseMetadata parses the SQL schema text and returns the database metadata.
func GetDatabaseMetadata(schemaText string) (*storepb.DatabaseSchemaMetadata, error) {
- parseResult, err := pgparser.ParsePostgreSQL(schemaText)
+ parseResults, err := pgparser.ParsePostgreSQL(schemaText)
if err != nil {
return nil, errors.Wrapf(err, "failed to parse PostgreSQL schema")
}
@@ -47,9 +47,11 @@ func GetDatabaseMetadata(schemaText string) (*storepb.DatabaseSchemaMetadata, er
// Always ensure public schema exists
extractor.getOrCreateSchema("public")
- // Only walk the tree if it's not empty
- if parseResult.Tree != nil {
- antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)
+ // Walk all parsed statements
+ for _, parseResult := range parseResults {
+ if parseResult.Tree != nil {
+ antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)
+ }
}
if extractor.err != nil {
diff --git a/backend/plugin/schema/pg/get_sdl_diff.go b/backend/plugin/schema/pg/get_sdl_diff.go
index 9731d91c91..fe0b445c65 100644
--- a/backend/plugin/schema/pg/get_sdl_diff.go
+++ b/backend/plugin/schema/pg/get_sdl_diff.go
@@ -140,7 +140,7 @@ func ChunkSDLText(sdlText string) (*schema.SDLChunks, error) {
}, nil
}
- parseResult, err := pgparser.ParsePostgreSQL(sdlText)
+ parseResults, err := pgparser.ParsePostgreSQL(sdlText)
if err != nil {
return nil, errors.Wrap(err, "failed to parse SDL text")
}
@@ -161,10 +161,13 @@ func ChunkSDLText(sdlText string) (*schema.SDLChunks, error) {
ColumnComments: make(map[string]map[string]antlr.ParserRuleContext),
IndexComments: make(map[string]map[string]antlr.ParserRuleContext),
},
- tokens: parseResult.Tokens,
}
- antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)
+ // Walk all parsed statements
+ for _, parseResult := range parseResults {
+ extractor.tokens = parseResult.Tokens
+ antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)
+ }
return extractor.chunks, nil
}
@@ -2787,12 +2790,16 @@ func applyMinimalChangesToChunks(previousChunks *schema.SDLChunks, currentSchema
tableSDL := buf.String()
// Parse the generated SDL to create AST node
- parseResult, err := pgparser.ParsePostgreSQL(tableSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(tableSDL)
if err != nil {
return errors.Wrapf(err, "failed to parse generated SDL for new table %s", tableKey)
}
// Extract the CREATE TABLE AST node
+ if len(parseResults) != 1 {
+ return errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
var createTableNode *parser.CreatestmtContext
antlr.ParseTreeWalkerDefault.Walk(&createTableExtractor{
result: &createTableNode,
@@ -2915,11 +2922,17 @@ func applyTableChangesToChunk(chunk *schema.SDLChunk, currentTable, previousTabl
}
// Parse the individual chunk text to get a fresh AST with its own tokenStream
- parseResult, err := pgparser.ParsePostgreSQL(originalChunkText)
+ parseResults, err := pgparser.ParsePostgreSQL(originalChunkText)
if err != nil {
return errors.Wrapf(err, "failed to parse original chunk text: %s", originalChunkText)
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
+
// Extract the CREATE TABLE AST node from the fresh parse
var createStmt *parser.CreatestmtContext
antlr.ParseTreeWalkerDefault.Walk(&createTableExtractor{
@@ -2965,11 +2978,15 @@ func applyTableChangesToChunk(chunk *schema.SDLChunk, currentTable, previousTabl
return errors.Wrapf(err, "failed to parse modified SQL: %s", modifiedSQL)
}
+ if len(finalParseResult) != 1 {
+ return errors.Errorf("expected exactly one statement in modified SQL, got %d", len(finalParseResult))
+ }
+
// Extract the final CREATE TABLE AST node
var newCreateTableNode *parser.CreatestmtContext
antlr.ParseTreeWalkerDefault.Walk(&createTableExtractor{
result: &newCreateTableNode,
- }, finalParseResult.Tree)
+ }, finalParseResult[0].Tree)
if newCreateTableNode == nil {
return errors.New("failed to extract CREATE TABLE AST node from modified text")
@@ -4388,11 +4405,17 @@ func createIndexChunk(chunks *schema.SDLChunks, extIndex *extendedIndexMetadata,
}
// Parse the SDL to get AST node
- parseResult, err := pgparser.ParsePostgreSQL(indexSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(indexSDL)
if err != nil {
return errors.Wrapf(err, "failed to parse generated index SDL: %s", indexSDL)
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
+
// Extract the CREATE INDEX AST node
var indexASTNode *parser.IndexstmtContext
antlr.ParseTreeWalkerDefault.Walk(&indexExtractor{
@@ -4451,11 +4474,17 @@ func updateIndexChunkIfNeeded(chunks *schema.SDLChunks, currentIndex, previousIn
}
// Parse the SDL to get AST node
- parseResult, err := pgparser.ParsePostgreSQL(indexSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(indexSDL)
if err != nil {
return errors.Wrapf(err, "failed to parse generated index SDL: %s", indexSDL)
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
+
// Extract the CREATE INDEX AST node
var indexASTNode *parser.IndexstmtContext
antlr.ParseTreeWalkerDefault.Walk(&indexExtractor{
@@ -4666,11 +4695,17 @@ func extractFunctionSignatureFromDefinition(function *storepb.FunctionMetadata)
}
// Parse the function definition to extract signature
- parseResult, err := pgparser.ParsePostgreSQL(function.Definition)
+ parseResults, err := pgparser.ParsePostgreSQL(function.Definition)
if err != nil {
return ""
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return ""
+ }
+ parseResult := parseResults[0]
+
tree := parseResult.Tree
// Extract the CREATE FUNCTION node using a walker
@@ -4911,11 +4946,17 @@ func extractFunctionASTFromSDL(sdl string) (antlr.ParserRuleContext, error) {
}
// Parse the SDL to get AST
- parseResult, err := pgparser.ParsePostgreSQL(sdl)
+ parseResults, err := pgparser.ParsePostgreSQL(sdl)
if err != nil {
return nil, errors.Wrap(err, "failed to parse function SDL")
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return nil, errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
+
tree := parseResult.Tree
// Extract the CREATE FUNCTION node using a walker
@@ -5217,11 +5258,17 @@ func extractAlterSequenceASTFromSDL(sdl string) (antlr.ParserRuleContext, error)
return nil, errors.New("empty ALTER SEQUENCE SDL provided")
}
- parseResult, err := pgparser.ParsePostgreSQL(sdl)
+ parseResults, err := pgparser.ParsePostgreSQL(sdl)
if err != nil {
return nil, errors.Wrap(err, "failed to parse ALTER SEQUENCE SDL")
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return nil, errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
+
tree := parseResult.Tree
if tree == nil {
return nil, errors.New("parse result tree is nil")
@@ -5245,11 +5292,17 @@ func extractCommentASTFromSDL(sdl string) (antlr.ParserRuleContext, error) {
return nil, errors.New("empty COMMENT SDL provided")
}
- parseResult, err := pgparser.ParsePostgreSQL(sdl)
+ parseResults, err := pgparser.ParsePostgreSQL(sdl)
if err != nil {
return nil, errors.Wrap(err, "failed to parse COMMENT SDL")
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return nil, errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
+
tree := parseResult.Tree
if tree == nil {
return nil, errors.New("parse result tree is nil")
@@ -5373,11 +5426,17 @@ func extractSequenceASTFromSDL(sdl string) (antlr.ParserRuleContext, error) {
}
// Parse the SDL to get AST
- parseResult, err := pgparser.ParsePostgreSQL(sdl)
+ parseResults, err := pgparser.ParsePostgreSQL(sdl)
if err != nil {
return nil, errors.Wrap(err, "failed to parse sequence SDL")
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return nil, errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
+
tree := parseResult.Tree
// Extract the CREATE SEQUENCE node using a walker
@@ -5831,11 +5890,17 @@ func createViewChunk(chunks *schema.SDLChunks, view *storepb.ViewMetadata, viewK
}
// Parse the SDL to get AST node
- parseResult, err := pgparser.ParsePostgreSQL(viewSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(viewSDL)
if err != nil {
return errors.Wrapf(err, "failed to parse generated view SDL: %s", viewSDL)
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
+
// Extract the CREATE VIEW AST node
var viewASTNode *parser.ViewstmtContext
antlr.ParseTreeWalkerDefault.Walk(&viewExtractor{
@@ -5856,12 +5921,12 @@ func createViewChunk(chunks *schema.SDLChunks, view *storepb.ViewMetadata, viewK
if view.Comment != "" {
commentSQL := generateCommentOnViewSQL(schemaName, view.Name, view.Comment)
commentParseResult, err := pgparser.ParsePostgreSQL(commentSQL)
- if err == nil && commentParseResult.Tree != nil {
+ if err == nil && len(commentParseResult) > 0 && commentParseResult[0].Tree != nil {
// Extract COMMENT ON VIEW AST node
var commentASTNode *parser.CommentstmtContext
antlr.ParseTreeWalkerDefault.Walk(&commentExtractor{
result: &commentASTNode,
- }, commentParseResult.Tree)
+ }, commentParseResult[0].Tree)
if commentASTNode != nil {
chunk.CommentStatements = []antlr.ParserRuleContext{commentASTNode}
@@ -5901,11 +5966,17 @@ func updateViewChunkIfNeeded(chunks *schema.SDLChunks, currentView, previousView
}
// Parse the SDL to get AST node
- parseResult, err := pgparser.ParsePostgreSQL(viewSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(viewSDL)
if err != nil {
return errors.Wrapf(err, "failed to parse generated view SDL: %s", viewSDL)
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
+
// Extract the CREATE VIEW AST node
var viewASTNode *parser.ViewstmtContext
antlr.ParseTreeWalkerDefault.Walk(&viewExtractor{
@@ -6074,11 +6145,17 @@ func createMaterializedViewChunk(chunks *schema.SDLChunks, mv *storepb.Materiali
}
// Parse the SDL to get AST node
- parseResult, err := pgparser.ParsePostgreSQL(mvSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(mvSDL)
if err != nil {
return errors.Wrapf(err, "failed to parse generated materialized view SDL: %s", mvSDL)
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
+
// Extract the CREATE MATERIALIZED VIEW AST node
var mvASTNode *parser.CreatematviewstmtContext
antlr.ParseTreeWalkerDefault.Walk(&materializedViewExtractor{
@@ -6099,12 +6176,12 @@ func createMaterializedViewChunk(chunks *schema.SDLChunks, mv *storepb.Materiali
if mv.Comment != "" {
commentSQL := generateCommentOnMaterializedViewSQL(schemaName, mv.Name, mv.Comment)
commentParseResult, err := pgparser.ParsePostgreSQL(commentSQL)
- if err == nil && commentParseResult.Tree != nil {
+ if err == nil && len(commentParseResult) > 0 && commentParseResult[0].Tree != nil {
// Extract COMMENT ON MATERIALIZED VIEW AST node
var commentASTNode *parser.CommentstmtContext
antlr.ParseTreeWalkerDefault.Walk(&commentExtractor{
result: &commentASTNode,
- }, commentParseResult.Tree)
+ }, commentParseResult[0].Tree)
if commentASTNode != nil {
chunk.CommentStatements = []antlr.ParserRuleContext{commentASTNode}
@@ -6142,11 +6219,17 @@ func updateMaterializedViewChunkIfNeeded(chunks *schema.SDLChunks, currentMV, pr
}
// Parse the new SDL to get a fresh AST node
- parseResult, err := pgparser.ParsePostgreSQL(mvSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(mvSDL)
if err != nil {
return errors.Wrapf(err, "failed to parse generated materialized view SDL: %s", mvSDL)
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
+
// Extract the CREATE MATERIALIZED VIEW AST node
var mvASTNode *parser.CreatematviewstmtContext
antlr.ParseTreeWalkerDefault.Walk(&materializedViewExtractor{
@@ -6168,12 +6251,12 @@ func updateMaterializedViewChunkIfNeeded(chunks *schema.SDLChunks, currentMV, pr
// New or updated comment
commentSQL := generateCommentOnMaterializedViewSQL(schemaName, currentMV.Name, currentMV.Comment)
commentParseResult, err := pgparser.ParsePostgreSQL(commentSQL)
- if err == nil && commentParseResult.Tree != nil {
+ if err == nil && len(commentParseResult) > 0 && commentParseResult[0].Tree != nil {
// Extract COMMENT ON MATERIALIZED VIEW AST node
var commentASTNode *parser.CommentstmtContext
antlr.ParseTreeWalkerDefault.Walk(&commentExtractor{
result: &commentASTNode,
- }, commentParseResult.Tree)
+ }, commentParseResult[0].Tree)
if commentASTNode != nil {
chunk.CommentStatements = []antlr.ParserRuleContext{commentASTNode}
@@ -6304,11 +6387,17 @@ func createEnumTypeChunk(chunks *schema.SDLChunks, enumType *storepb.EnumTypeMet
}
// Parse the SDL to get AST node
- parseResult, err := pgparser.ParsePostgreSQL(enumSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(enumSDL)
if err != nil {
return errors.Wrapf(err, "failed to parse generated enum type SDL: %s", enumSDL)
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
+
// Extract the CREATE TYPE AS ENUM AST node
var enumASTNode *parser.DefinestmtContext
antlr.ParseTreeWalkerDefault.Walk(&enumTypeExtractor{
@@ -6333,7 +6422,7 @@ func createEnumTypeChunk(chunks *schema.SDLChunks, enumType *storepb.EnumTypeMet
var commentNode *parser.CommentstmtContext
antlr.ParseTreeWalkerDefault.Walk(&commentExtractor{
result: &commentNode,
- }, commentParseResult.Tree)
+ }, commentParseResult[0].Tree)
if commentNode != nil {
chunk.CommentStatements = []antlr.ParserRuleContext{commentNode}
}
@@ -6367,11 +6456,17 @@ func updateEnumTypeChunkIfNeeded(chunks *schema.SDLChunks, currentEnum, previous
}
// Parse the SDL to get AST node
- parseResult, err := pgparser.ParsePostgreSQL(enumSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(enumSDL)
if err != nil {
return errors.Wrapf(err, "failed to parse generated enum type SDL: %s", enumSDL)
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
+
// Extract the CREATE TYPE AS ENUM AST node
var enumASTNode *parser.DefinestmtContext
antlr.ParseTreeWalkerDefault.Walk(&enumTypeExtractor{
@@ -7037,11 +7132,17 @@ func createExtensionChunk(chunks *schema.SDLChunks, extension *storepb.Extension
}
// Parse the SDL to get AST node
- parseResult, err := pgparser.ParsePostgreSQL(extensionSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(extensionSDL)
if err != nil {
return errors.Wrapf(err, "failed to parse generated extension SDL: %s", extensionSDL)
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
+
// Extract the CREATE EXTENSION AST node
var extensionASTNode *parser.CreateextensionstmtContext
antlr.ParseTreeWalkerDefault.Walk(&extensionExtractor{
@@ -7066,7 +7167,7 @@ func createExtensionChunk(chunks *schema.SDLChunks, extension *storepb.Extension
var commentNode *parser.CommentstmtContext
antlr.ParseTreeWalkerDefault.Walk(&commentExtractor{
result: &commentNode,
- }, commentParseResult.Tree)
+ }, commentParseResult[0].Tree)
if commentNode != nil {
chunk.CommentStatements = []antlr.ParserRuleContext{commentNode}
}
@@ -7099,11 +7200,17 @@ func updateExtensionChunkIfNeeded(chunks *schema.SDLChunks, currentExtension, pr
}
// Parse the SDL to get AST node
- parseResult, err := pgparser.ParsePostgreSQL(extensionSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(extensionSDL)
if err != nil {
return errors.Wrapf(err, "failed to parse generated extension SDL: %s", extensionSDL)
}
+ // Expect single statement
+ if len(parseResults) != 1 {
+ return errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
+
// Extract the CREATE EXTENSION AST node
var extensionASTNode *parser.CreateextensionstmtContext
antlr.ParseTreeWalkerDefault.Walk(&extensionExtractor{
@@ -7133,7 +7240,7 @@ func updateExtensionChunkIfNeeded(chunks *schema.SDLChunks, currentExtension, pr
var commentNode *parser.CommentstmtContext
antlr.ParseTreeWalkerDefault.Walk(&commentExtractor{
result: &commentNode,
- }, commentParseResult.Tree)
+ }, commentParseResult[0].Tree)
if commentNode != nil {
chunk.CommentStatements = []antlr.ParserRuleContext{commentNode}
}
@@ -7363,10 +7470,14 @@ func createTriggerChunk(chunks *schema.SDLChunks, triggerCtx *triggerWithContext
}
// Parse the SDL to get AST node
- parseResult, err := pgparser.ParsePostgreSQL(triggerSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(triggerSDL)
if err != nil {
return errors.Wrapf(err, "failed to parse generated trigger SDL: %s", triggerSDL)
}
+ if len(parseResults) != 1 {
+ return errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
// Extract the CREATE TRIGGER AST node
var triggerASTNode *parser.CreatetrigstmtContext
@@ -7387,8 +7498,9 @@ func createTriggerChunk(chunks *schema.SDLChunks, triggerCtx *triggerWithContext
// Add comment if the trigger has one
if trigger.Comment != "" {
commentSQL := generateCommentOnTriggerSQL(schemaName, tableName, trigger.Name, trigger.Comment)
- commentParseResult, err := pgparser.ParsePostgreSQL(commentSQL)
- if err == nil && commentParseResult.Tree != nil {
+ commentParseResults, err := pgparser.ParsePostgreSQL(commentSQL)
+ if err == nil && len(commentParseResults) > 0 && commentParseResults[0].Tree != nil {
+ commentParseResult := commentParseResults[0]
// Extract COMMENT ON TRIGGER AST node
var commentASTNode *parser.CommentstmtContext
antlr.ParseTreeWalkerDefault.Walk(&commentExtractor{
@@ -7436,10 +7548,14 @@ func updateTriggerChunkIfNeeded(chunks *schema.SDLChunks, currentTriggerCtx, pre
}
// Parse the new SDL to get a fresh AST node
- parseResult, err := pgparser.ParsePostgreSQL(triggerSDL)
+ parseResults, err := pgparser.ParsePostgreSQL(triggerSDL)
if err != nil {
return errors.Wrapf(err, "failed to parse generated trigger SDL: %s", triggerSDL)
}
+ if len(parseResults) != 1 {
+ return errors.Errorf("expected exactly one statement, got %d", len(parseResults))
+ }
+ parseResult := parseResults[0]
// Extract the CREATE TRIGGER AST node
var triggerASTNode *parser.CreatetrigstmtContext
@@ -7460,8 +7576,9 @@ func updateTriggerChunkIfNeeded(chunks *schema.SDLChunks, currentTriggerCtx, pre
if currentTrigger.Comment != "" {
// New or updated comment
commentSQL := generateCommentOnTriggerSQL(schemaName, tableName, currentTrigger.Name, currentTrigger.Comment)
- commentParseResult, err := pgparser.ParsePostgreSQL(commentSQL)
- if err == nil && commentParseResult.Tree != nil {
+ commentParseResults, err := pgparser.ParsePostgreSQL(commentSQL)
+ if err == nil && len(commentParseResults) > 0 && commentParseResults[0].Tree != nil {
+ commentParseResult := commentParseResults[0]
// Extract COMMENT ON TRIGGER AST node
var commentASTNode *parser.CommentstmtContext
antlr.ParseTreeWalkerDefault.Walk(&commentExtractor{
diff --git a/backend/plugin/schema/pg/pg_alter_parsing_test.go b/backend/plugin/schema/pg/pg_alter_parsing_test.go
index 5a8a94514f..7eee92c051 100644
--- a/backend/plugin/schema/pg/pg_alter_parsing_test.go
+++ b/backend/plugin/schema/pg/pg_alter_parsing_test.go
@@ -15,9 +15,10 @@ import (
func TestAlterColumnAddIdentityParsing(t *testing.T) {
ddl := `ALTER TABLE orders ALTER COLUMN id ADD GENERATED BY DEFAULT AS IDENTITY;`
- parseResult, err := pgparser.ParsePostgreSQL(ddl)
+ parseResults, err := pgparser.ParsePostgreSQL(ddl)
require.NoError(t, err)
- require.NotNil(t, parseResult.Tree, "Parse tree should exist")
+ require.Len(t, parseResults, 1, "Should parse single statement")
+ require.NotNil(t, parseResults[0].Tree, "Parse tree should exist")
}
// TestAlterColumnAddIdentityMetadata tests ALTER COLUMN ADD IDENTITY creates sequences
diff --git a/backend/plugin/schema/pg/walk_through.go b/backend/plugin/schema/pg/walk_through.go
index a2ab9678b7..614c850fba 100644
--- a/backend/plugin/schema/pg/walk_through.go
+++ b/backend/plugin/schema/pg/walk_through.go
@@ -26,37 +26,47 @@ func init() {
// WalkThrough walks through the PostgreSQL ANTLR parse tree and builds catalog metadata.
func WalkThrough(d *model.DatabaseMetadata, ast any) *storepb.Advice {
// ANTLR-based walkthrough
- parseResult, ok := ast.(*pgparser.ParseResult)
+ parseResults, ok := ast.([]*pgparser.ParseResult)
if !ok {
return &storepb.Advice{
Status: storepb.Advice_ERROR,
Code: code.Internal.Int32(),
- Title: fmt.Sprintf("PostgreSQL walk-through expects *pgparser.ParseResult, got %T", ast),
- Content: fmt.Sprintf("PostgreSQL walk-through expects *pgparser.ParseResult, got %T", ast),
- StartPosition: &storepb.Position{
- Line: 0,
- },
- }
- }
- root, ok := parseResult.Tree.(parser.IRootContext)
- if !ok {
- return &storepb.Advice{
- Status: storepb.Advice_ERROR,
- Code: code.Internal.Int32(),
- Title: fmt.Sprintf("invalid ANTLR tree type %T", parseResult.Tree),
- Content: fmt.Sprintf("invalid ANTLR tree type %T", parseResult.Tree),
+ Title: fmt.Sprintf("PostgreSQL walk-through expects []*pgparser.ParseResult, got %T", ast),
+ Content: fmt.Sprintf("PostgreSQL walk-through expects []*pgparser.ParseResult, got %T", ast),
StartPosition: &storepb.Position{
Line: 0,
},
}
}
+
// Build listener with database state
listener := &pgCatalogListener{
BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
databaseState: d,
}
- // Walk through the parse tree
- antlr.ParseTreeWalkerDefault.Walk(listener, root)
+
+ // Walk through all parse results
+ for _, parseResult := range parseResults {
+ root, ok := parseResult.Tree.(parser.IRootContext)
+ if !ok {
+ return &storepb.Advice{
+ Status: storepb.Advice_ERROR,
+ Code: code.Internal.Int32(),
+ Title: fmt.Sprintf("invalid ANTLR tree type %T", parseResult.Tree),
+ Content: fmt.Sprintf("invalid ANTLR tree type %T", parseResult.Tree),
+ StartPosition: &storepb.Position{
+ Line: 0,
+ },
+ }
+ }
+ // Walk through the parse tree
+ antlr.ParseTreeWalkerDefault.Walk(listener, root)
+ // Return immediately if error encountered
+ if listener.advice != nil {
+ return listener.advice
+ }
+ }
+
// Return any error encountered during walk
return listener.advice
}
diff --git a/backend/runner/taskrun/database_migrate_executor.go b/backend/runner/taskrun/database_migrate_executor.go
index 13a81fdb75..80647dc6af 100644
--- a/backend/runner/taskrun/database_migrate_executor.go
+++ b/backend/runner/taskrun/database_migrate_executor.go
@@ -529,7 +529,7 @@ func getPrependStatements(engine storepb.Engine, statement string) (string, erro
return "", nil
}
- parseResult, err := pg.ParsePostgreSQL(statement)
+ parseResults, err := pg.ParsePostgreSQL(statement)
if err != nil {
return "", errors.Wrap(err, "failed to parse statement")
}
@@ -537,7 +537,16 @@ func getPrependStatements(engine storepb.Engine, statement string) (string, erro
visitor := &prependStatementsVisitor{
statement: statement,
}
- antlr.ParseTreeWalkerDefault.Walk(visitor, parseResult.Tree)
+
+ // Walk through all statements to find the first SET role/search_path statement
+ // The visitor will stop after finding the first one due to its internal check
+ for _, result := range parseResults {
+ antlr.ParseTreeWalkerDefault.Walk(visitor, result.Tree)
+ // If we found a result, stop walking remaining statements
+ if visitor.result != "" {
+ break
+ }
+ }
return visitor.result, nil
}
diff --git a/backend/tests/rollout.go b/backend/tests/rollout.go
index b83d9e6ff5..03424cd8c4 100644
--- a/backend/tests/rollout.go
+++ b/backend/tests/rollout.go
@@ -69,17 +69,36 @@ func (ctl *controller) waitRollout(ctx context.Context, issueName, rolloutName s
ticker := time.NewTicker(300 * time.Millisecond)
defer ticker.Stop()
- for range ticker.C {
- issueResp, err := ctl.issueServiceClient.GetIssue(ctx, connect.NewRequest(&v1pb.GetIssueRequest{Name: issueName}))
- if err != nil {
- return err
- }
- issue := issueResp.Msg
- if issue.ApprovalStatus == v1pb.Issue_ERROR {
- return errors.Errorf("approval finding error: %v", issue.ApprovalStatusError)
- }
- if issue.ApprovalStatus == v1pb.Issue_APPROVED || issue.ApprovalStatus == v1pb.Issue_SKIPPED {
- break
+ // Add timeout to prevent infinite loops
+ timeout := time.After(2 * time.Minute)
+ startTime := time.Now()
+
+ // Wait for approval
+waitApproval:
+ for {
+ select {
+ case <-timeout:
+ // Timeout - fetch current state for debugging
+ issueResp, err := ctl.issueServiceClient.GetIssue(ctx, connect.NewRequest(&v1pb.GetIssueRequest{Name: issueName}))
+ if err != nil {
+ return errors.Wrapf(err, "timeout after %v waiting for approval (failed to fetch issue state)", time.Since(startTime))
+ }
+ issue := issueResp.Msg
+ return errors.Errorf("timeout after %v waiting for approval to complete, current approval status: %s, approval status error: %v",
+ time.Since(startTime), issue.ApprovalStatus.String(), issue.ApprovalStatusError)
+
+ case <-ticker.C:
+ issueResp, err := ctl.issueServiceClient.GetIssue(ctx, connect.NewRequest(&v1pb.GetIssueRequest{Name: issueName}))
+ if err != nil {
+ return err
+ }
+ issue := issueResp.Msg
+ if issue.ApprovalStatus == v1pb.Issue_ERROR {
+ return errors.Errorf("approval finding error: %v", issue.ApprovalStatusError)
+ }
+ if issue.ApprovalStatus == v1pb.Issue_APPROVED || issue.ApprovalStatus == v1pb.Issue_SKIPPED {
+ break waitApproval
+ }
}
}