Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor: 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.goindex 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 advisorvar 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 advisorlevel: 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.goindex 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.Conttitle: 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.goindex 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 advisorchecker := 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 commentsreturn rule.generateAdvice(), nildiff --git a/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go b/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.goindex 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 achecker := 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.goindex 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 advilevel: 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.goindex 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.goindex 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.goindex 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.goindex 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.Contechecker := 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.Contexif 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.goindex 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.goindex 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.goindex 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.Contchecker := 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.goindex 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 statementfunc (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.tablesdiff --git a/backend/plugin/advisor/pg/advisor_naming_index_convention.go b/backend/plugin/advisor/pg/advisor_naming_index_convention.goindex 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.goindex 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.Contchecker := 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.goindex 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.Cchecker := 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.goindex 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.goindex 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 advischecker := 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.goindex 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.goindex 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 advif 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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 advisreturn 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.goindex 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 advisreturn 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 advischecker := 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.goindex 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.goindex 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.goindex 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 connectionif 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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 requirementsfor 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.goindex 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.goindex 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.goindex 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.goindex 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 statementsrule.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 firstr.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.goindex 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_Statustitle stringadviceList []*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.goindex 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 statementsstyleChecker := &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.goindex 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 tablesfileCheckers := 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 filereturn map[string][]*storepb.Advice{@@ -50,8 +50,10 @@ func CheckSDLIntegrity(files map[string]string) (map[string][]*storepb.Advice, esymbolTable: 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.yamlindex 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: 2code: 206title: 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: 3column: 0@@ -25,7 +25,7 @@- status: 2code: 206title: 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: 3column: 0@@ -33,7 +33,7 @@- status: 2code: 206title: 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: 7column: 0diff --git a/backend/plugin/advisor/pg/test/statement_disallow_mix_in_ddl.yaml b/backend/plugin/advisor/pg/test/statement_disallow_mix_in_ddl.yamlindex 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: 2code: 227title: 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 DDLstartposition:line: 1column: 0@@ -34,7 +34,7 @@- status: 2code: 227title: 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 DDLstartposition:line: 1column: 0diff --git a/backend/plugin/advisor/pg/test/statement_merge_alter_table.yaml b/backend/plugin/advisor/pg/test/statement_merge_alter_table.yamlindex 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-tablecontent: There are 2 statements to modify table `t`startposition:- line: 3+ line: 2column: 0endposition: nulldiff --git a/backend/plugin/advisor/pg/test/statement_object_owner_check.yaml b/backend/plugin/advisor/pg/test/statement_object_owner_check.yamlindex 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.yamlindex 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.commentcontent: Comment is required for table `d`startposition:- line: 2+ line: 3column: 0endposition: null- statement: |-@@ -38,7 +38,7 @@title: table.commentcontent: Comment is required for table `t`startposition:- line: 1+ line: 2column: 0endposition: null- statement: |-@@ -52,7 +52,7 @@title: table.commentcontent: Comment is required for table `t`startposition:- line: 1+ line: 2column: 0endposition: null- statement: |-diff --git a/backend/plugin/advisor/pg/test/table_require_pk.yaml b/backend/plugin/advisor/pg/test/table_require_pk.yamlindex 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: 1column: 0+ endposition: null- statement: ALTER TABLE "tech_book" DROP CONSTRAINT "old_pk"changeType: 1want:@@ -22,6 +23,7 @@startposition:line: 1column: 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: 1column: 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: 2column: 0+ endposition: null- statement: |-CREATE TABLE product(id INT, name TEXT);ALTER TABLE product ADD PRIMARY KEY (id);@@ -69,3 +73,4 @@startposition:line: 3column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pg/test_helper.go b/backend/plugin/advisor/pg/test_helper.goindex 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, dbTypDBSchema: schemaMetadata,ChangeType: tc.ChangeType,EnablePriorBackup: true,- AST: tree, // Pass ANTLR parse result+ AST: trees, // Pass ANTLR parse result listStatements: tc.Statement,Rule: ruleList[0],OriginalMetadata: originalMetadata,diff --git a/backend/plugin/advisor/pg/utils.go b/backend/plugin/advisor/pg/utils.goindex 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.goindex 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) (stringreturn "", 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.goindex 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.Treediff --git a/backend/plugin/parser/pg/access_tables.go b/backend/plugin/parser/pg/access_tables.goindex 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.goindex 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 stringtree antlr.ParserRuleContexttable *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, statmetadata: 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.goindex 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.goindex 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, nildiff --git a/backend/plugin/parser/pg/pg_test.go b/backend/plugin/parser/pg/pg_test.goindex 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.goindex 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.goindex 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 errorif 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 statementslistener := &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 resultsdiff --git a/backend/plugin/parser/pg/query_span_extractor.go b/backend/plugin/parser/pg/query_span_extractor.goindex 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) (*baq.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 tablesaccessTableExtractor := &accessTableExtractor{@@ -302,15 +308,19 @@ type functionDefinitionDetail struct {func buildFunctionDefinitionDetail(funcDef *functionDefinition) (*functionDefinitionDetail, error) {function := funcDef.metadatadefinition := 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.goindex 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.goindex 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.DatabasearchPath = []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.goindex 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, statementreturn "", 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, statementreturn "", 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_Itreturn "", 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_ItstartPos: 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 []stringstartPos *storepb.PositionendPos *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 statementslistener := &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.goindex 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.goindex 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 tokenline := 0if ctx.GetStop() != nil {- line = ctx.GetStop().GetLine()+ line = ctx.GetStop().GetLine() + c.baseLine}// Get statement textdiff --git a/backend/plugin/schema/pg/chunk_extraction_test.go b/backend/plugin/schema/pg/chunk_extraction_test.goindex 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 nodevar createTableNode *parser.CreatestmtContextantlr.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.goindex 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 nodevar createTableNode *parser.CreatestmtContextantlr.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.CreatestmtContextantlr.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].Tokensrewriter := 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.CreatestmtContextantlr.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.goindex 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 nodevar createTableNode *parser.CreatestmtContextantlr.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 nodevar createTableNode *parser.CreatestmtContextantlr.ParseTreeWalkerDefault.Walk(&createTableExtractor{result: &createTableNode,- }, parseResult.Tree)+ }, parseResults[0].Tree)require.NotNil(t, createTableNode, "Failed to extract CREATE TABLE AST node")// Create a mock chunkdiff --git a/backend/plugin/schema/pg/get_database_definition.go b/backend/plugin/schema/pg/get_database_definition.goindex 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].Treeif tree == nil {return false}diff --git a/backend/plugin/schema/pg/get_database_metadata.go b/backend/plugin/schema/pg/get_database_metadata.goindex 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 existsextractor.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.goindex 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, currentSchematableSDL := 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.CreatestmtContextantlr.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 parsevar createStmt *parser.CreatestmtContextantlr.ParseTreeWalkerDefault.Walk(&createTableExtractor{@@ -2965,11 +2978,15 @@ func applyTableChangesToChunk(chunk *schema.SDLChunk, currentTable, previousTablreturn 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 nodevar newCreateTableNode *parser.CreatestmtContextantlr.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 nodevar indexASTNode *parser.IndexstmtContextantlr.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 nodevar indexASTNode *parser.IndexstmtContextantlr.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.Treeif 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.Treeif 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 nodevar viewASTNode *parser.ViewstmtContextantlr.ParseTreeWalkerDefault.Walk(&viewExtractor{@@ -5856,12 +5921,12 @@ func createViewChunk(chunks *schema.SDLChunks, view *storepb.ViewMetadata, viewKif 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 nodevar commentASTNode *parser.CommentstmtContextantlr.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 nodevar viewASTNode *parser.ViewstmtContextantlr.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 nodevar mvASTNode *parser.CreatematviewstmtContextantlr.ParseTreeWalkerDefault.Walk(&materializedViewExtractor{@@ -6099,12 +6176,12 @@ func createMaterializedViewChunk(chunks *schema.SDLChunks, mv *storepb.Materialiif 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 nodevar commentASTNode *parser.CommentstmtContextantlr.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 nodevar mvASTNode *parser.CreatematviewstmtContextantlr.ParseTreeWalkerDefault.Walk(&materializedViewExtractor{@@ -6168,12 +6251,12 @@ func updateMaterializedViewChunkIfNeeded(chunks *schema.SDLChunks, currentMV, pr// New or updated commentcommentSQL := 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 nodevar commentASTNode *parser.CommentstmtContextantlr.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 nodevar enumASTNode *parser.DefinestmtContextantlr.ParseTreeWalkerDefault.Walk(&enumTypeExtractor{@@ -6333,7 +6422,7 @@ func createEnumTypeChunk(chunks *schema.SDLChunks, enumType *storepb.EnumTypeMetvar commentNode *parser.CommentstmtContextantlr.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 nodevar enumASTNode *parser.DefinestmtContextantlr.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 nodevar extensionASTNode *parser.CreateextensionstmtContextantlr.ParseTreeWalkerDefault.Walk(&extensionExtractor{@@ -7066,7 +7167,7 @@ func createExtensionChunk(chunks *schema.SDLChunks, extension *storepb.Extensionvar commentNode *parser.CommentstmtContextantlr.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 nodevar extensionASTNode *parser.CreateextensionstmtContextantlr.ParseTreeWalkerDefault.Walk(&extensionExtractor{@@ -7133,7 +7240,7 @@ func updateExtensionChunkIfNeeded(chunks *schema.SDLChunks, currentExtension, prvar commentNode *parser.CommentstmtContextantlr.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 nodevar triggerASTNode *parser.CreatetrigstmtContext@@ -7387,8 +7498,9 @@ func createTriggerChunk(chunks *schema.SDLChunks, triggerCtx *triggerWithContext// Add comment if the trigger has oneif 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 nodevar commentASTNode *parser.CommentstmtContextantlr.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 nodevar triggerASTNode *parser.CreatetrigstmtContext@@ -7460,8 +7576,9 @@ func updateTriggerChunkIfNeeded(chunks *schema.SDLChunks, currentTriggerCtx, preif currentTrigger.Comment != "" {// New or updated commentcommentSQL := 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 nodevar commentASTNode *parser.CommentstmtContextantlr.ParseTreeWalkerDefault.Walk(&commentExtractor{diff --git a/backend/plugin/schema/pg/pg_alter_parsing_test.go b/backend/plugin/schema/pg/pg_alter_parsing_test.goindex 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 sequencesdiff --git a/backend/plugin/schema/pg/walk_through.go b/backend/plugin/schema/pg/walk_through.goindex 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 statelistener := &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 walkreturn listener.advice}diff --git a/backend/runner/taskrun/database_migrate_executor.go b/backend/runner/taskrun/database_migrate_executor.goindex 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, erroreturn "", 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, errovisitor := &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.goindex 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 sticker := 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+ }}}