Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor(parser): eliminate ParseResult type, return ANTLRAST directly (#18537)
h3n4la3dd854472ae
diff --git a/backend/plugin/advisor/advisor.go b/backend/plugin/advisor/advisor.goindex 64ca51aa2b..b1afad459e 100644--- a/backend/plugin/advisor/advisor.go+++ b/backend/plugin/advisor/advisor.go@@ -102,31 +102,6 @@ func Register(dbType storepb.Engine, ruleType storepb.SQLReviewRule_Type, f Advi}}-// GetANTLRParseResults extracts ANTLR parse results from the advisor context.-// This is a unified helper for all ANTLR-based engines (MySQL, MSSQL, Oracle, Snowflake, PostgreSQL).-func GetANTLRParseResults(checkCtx Context) ([]*base.ParseResult, error) {- if checkCtx.ParsedStatements == nil {- return nil, errors.New("ParsedStatements is not provided in context")- }-- var parseResults []*base.ParseResult- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- return nil, errors.New("AST type mismatch: expected ANTLR-based parser result")- }- parseResults = append(parseResults, &base.ParseResult{- Tree: antlrAST.Tree,- Tokens: antlrAST.Tokens,- BaseLine: stmt.BaseLine,- })- }- return parseResults, nil-}-// Check runs the advisor and returns the advices.func Check(ctx context.Context, dbType storepb.Engine, ruleType storepb.SQLReviewRule_Type, checkCtx Context) (adviceList []*storepb.Advice, err error) {defer func() {diff --git a/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.goindex e2db3c8dbd..866b5721b0 100644--- a/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.go@@ -39,12 +39,6 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx adv}var adviceList []*storepb.Advice- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -76,9 +70,16 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx adv// Use the refactored rule for DDL/DML checkingrule := NewStatementDisallowMixDMLRule(level, title)checker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }rule.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}if rule.hasDDL {@@ -91,7 +92,7 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx adv})}- statementInfoList := prepareTransformation(checkCtx.DBSchema.Name, stmtList)+ statementInfoList := prepareTransformation(checkCtx.DBSchema.Name, checkCtx.ParsedStatements)groupByTable := make(map[string][]statementInfo)for _, item := range statementInfoList {@@ -206,13 +207,20 @@ type statementInfo struct {table *TableReference}-func prepareTransformation(databaseName string, parseResults []*base.ParseResult) []statementInfo {+func prepareTransformation(databaseName string, parsedStatements []base.ParsedStatement) []statementInfo {extractor := &dmlExtractor{databaseName: databaseName,}- for _, parseResult := range parseResults {- antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)+ for _, stmt := range parsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(extractor, antlrAST.Tree)}return extractor.dmlsdiff --git a/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.go b/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.goindex ee1b0ffe9f..3456030da7 100644--- a/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.go+++ b/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.go@@ -18,6 +18,7 @@ import ("github.com/bytebase/bytebase/backend/common/log"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")@@ -35,12 +36,6 @@ type ColumnMaximumVarcharLengthAdvisor struct {// Check checks for maximum varchar length.func (*ColumnMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -60,9 +55,16 @@ func (*ColumnMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advi// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_column_no_null.go b/backend/plugin/advisor/mssql/rule_column_no_null.goindex fe1c217710..c039b8c7d4 100644--- a/backend/plugin/advisor/mssql/rule_column_no_null.go+++ b/backend/plugin/advisor/mssql/rule_column_no_null.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")@@ -28,12 +29,6 @@ type ColumnNoNullAdvisor struct {// Check checks for column no NULL value..func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -45,9 +40,16 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_column_require.go b/backend/plugin/advisor/mssql/rule_column_require.goindex 9008c99f6e..3667c6bf94 100644--- a/backend/plugin/advisor/mssql/rule_column_require.go+++ b/backend/plugin/advisor/mssql/rule_column_require.go@@ -15,6 +15,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")@@ -32,12 +33,6 @@ type ColumnRequireAdvisor struct {// Check checks for column requirement..func (*ColumnRequireAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -54,9 +49,16 @@ func (*ColumnRequireAdvisor) Check(_ context.Context, checkCtx advisor.Context)// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_column_type_disallow_list.go b/backend/plugin/advisor/mssql/rule_column_type_disallow_list.goindex 998a6184f0..5e6dfcb4bf 100644--- a/backend/plugin/advisor/mssql/rule_column_type_disallow_list.go+++ b/backend/plugin/advisor/mssql/rule_column_type_disallow_list.go@@ -15,6 +15,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -30,12 +31,6 @@ type ColumnTypeDisallowListAdvisor struct {}func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -56,9 +51,16 @@ func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_function_disallow_create_or_alter.go b/backend/plugin/advisor/mssql/rule_function_disallow_create_or_alter.goindex 50d03d0a59..f0442c228e 100644--- a/backend/plugin/advisor/mssql/rule_function_disallow_create_or_alter.go+++ b/backend/plugin/advisor/mssql/rule_function_disallow_create_or_alter.go@@ -10,6 +10,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")func init() {@@ -20,12 +21,6 @@ type FunctionDisallowCreateOrAlterAdvisor struct{}// Check implements advisor.Advisor.func (*FunctionDisallowCreateOrAlterAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -37,9 +32,16 @@ func (*FunctionDisallowCreateOrAlterAdvisor) Check(_ context.Context, checkCtx a// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_index_not_redundant.go b/backend/plugin/advisor/mssql/rule_index_not_redundant.goindex 5cc9a9bb39..99fe37c32b 100644--- a/backend/plugin/advisor/mssql/rule_index_not_redundant.go+++ b/backend/plugin/advisor/mssql/rule_index_not_redundant.go@@ -11,6 +11,7 @@ import ("github.com/bytebase/bytebase/backend/common""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -30,12 +31,6 @@ type IndexNotRedundantAdvisor struct{}// TODO(zp): we currently don't have runtime checks for indexes created in the statements.func (IndexNotRedundantAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -47,9 +42,16 @@ func (IndexNotRedundantAdvisor) Check(_ context.Context, checkCtx advisor.Contex// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_migration_compatibility.go b/backend/plugin/advisor/mssql/rule_migration_compatibility.goindex b2c2a7cef3..eb0a7d12ae 100644--- a/backend/plugin/advisor/mssql/rule_migration_compatibility.go+++ b/backend/plugin/advisor/mssql/rule_migration_compatibility.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"advisorcode "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")@@ -29,12 +30,6 @@ type MigrationCompatibilityAdvisor struct {// Check checks for migration compatibility.func (*MigrationCompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,9 +41,16 @@ func (*MigrationCompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_naming_identifier_no_keyword.go b/backend/plugin/advisor/mssql/rule_naming_identifier_no_keyword.goindex aa27053f55..4eeafdd3b9 100644--- a/backend/plugin/advisor/mssql/rule_naming_identifier_no_keyword.go+++ b/backend/plugin/advisor/mssql/rule_naming_identifier_no_keyword.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")@@ -29,12 +30,6 @@ type NamingIdentifierNoKeywordAdvisor struct {// Check checks for identifier naming convention without keyword.func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,9 +41,16 @@ func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_naming_table.go b/backend/plugin/advisor/mssql/rule_naming_table.goindex 880ee96c58..c123cb3776 100644--- a/backend/plugin/advisor/mssql/rule_naming_table.go+++ b/backend/plugin/advisor/mssql/rule_naming_table.go@@ -14,6 +14,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")@@ -31,12 +32,6 @@ type NamingTableAdvisor struct {// Check checks for table naming convention..func (*NamingTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -62,9 +57,16 @@ func (*NamingTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_naming_table_no_keyword.go b/backend/plugin/advisor/mssql/rule_naming_table_no_keyword.goindex 32bf4bad5f..badd45faab 100644--- a/backend/plugin/advisor/mssql/rule_naming_table_no_keyword.go+++ b/backend/plugin/advisor/mssql/rule_naming_table_no_keyword.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")@@ -29,12 +30,6 @@ type NamingTableNoKeywordAdvisor struct {// Check checks for table naming convention without keyword.func (*NamingTableNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,9 +41,16 @@ func (*NamingTableNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Co// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_procedure_disallow_create_or_alter.go b/backend/plugin/advisor/mssql/rule_procedure_disallow_create_or_alter.goindex 298c8eeab7..242a5a552c 100644--- a/backend/plugin/advisor/mssql/rule_procedure_disallow_create_or_alter.go+++ b/backend/plugin/advisor/mssql/rule_procedure_disallow_create_or_alter.go@@ -10,6 +10,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")func init() {@@ -19,12 +20,6 @@ func init() {type ProcedureDisallowCreateOrAlterAdvisor struct{}func (*ProcedureDisallowCreateOrAlterAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -36,9 +31,16 @@ func (*ProcedureDisallowCreateOrAlterAdvisor) Check(_ context.Context, checkCtx// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_select_no_select_all.go b/backend/plugin/advisor/mssql/rule_select_no_select_all.goindex 4b1e4a5476..07ae2f829d 100644--- a/backend/plugin/advisor/mssql/rule_select_no_select_all.go+++ b/backend/plugin/advisor/mssql/rule_select_no_select_all.go@@ -10,6 +10,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -26,12 +27,6 @@ type SelectNoSelectAllAdvisor struct {// Check checks for no select all.func (*SelectNoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -43,9 +38,16 @@ func (*SelectNoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Conte// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_statement_disallow_cross_db_queries.go b/backend/plugin/advisor/mssql/rule_statement_disallow_cross_db_queries.goindex 8e55bf8cd8..46661f2f99 100644--- a/backend/plugin/advisor/mssql/rule_statement_disallow_cross_db_queries.go+++ b/backend/plugin/advisor/mssql/rule_statement_disallow_cross_db_queries.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")@@ -22,12 +23,6 @@ func init() {type DisallowCrossDBQueriesAdvisor struct{}func (*DisallowCrossDBQueriesAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -39,9 +34,16 @@ func (*DisallowCrossDBQueriesAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_statement_where_disallow_functions_and_calculations.go b/backend/plugin/advisor/mssql/rule_statement_where_disallow_functions_and_calculations.goindex 7ece075088..cc2fdb0208 100644--- a/backend/plugin/advisor/mssql/rule_statement_where_disallow_functions_and_calculations.go+++ b/backend/plugin/advisor/mssql/rule_statement_where_disallow_functions_and_calculations.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")func init() {@@ -22,12 +23,6 @@ type DisallowFuncAndCalculationsAdvisor struct{}var _ advisor.Advisor = (*DisallowFuncAndCalculationsAdvisor)(nil)func (*DisallowFuncAndCalculationsAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -39,9 +34,16 @@ func (*DisallowFuncAndCalculationsAdvisor) Check(_ context.Context, checkCtx adv// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_select.go b/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_select.goindex 0e76ea3cab..202cfc24ba 100644--- a/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_select.go+++ b/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_select.go@@ -10,6 +10,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -26,12 +27,6 @@ type WhereRequirementForSelectAdvisor struct {// Check checks for WHERE clause requirement.func (*WhereRequirementForSelectAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -43,9 +38,16 @@ func (*WhereRequirementForSelectAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_update_delete.go b/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_update_delete.goindex 5b2f8461a2..a154d2e99b 100644--- a/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_update_delete.go+++ b/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_update_delete.go@@ -10,6 +10,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -26,12 +27,6 @@ type WhereRequirementForUpdateDeleteAdvisor struct {// Check checks for WHERE clause requirement.func (*WhereRequirementForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -43,9 +38,16 @@ func (*WhereRequirementForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_table_disallow_ddl.go b/backend/plugin/advisor/mssql/rule_table_disallow_ddl.goindex b2f50e997d..3a1f8df3f1 100644--- a/backend/plugin/advisor/mssql/rule_table_disallow_ddl.go+++ b/backend/plugin/advisor/mssql/rule_table_disallow_ddl.go@@ -14,6 +14,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")@@ -30,12 +31,6 @@ type TableDisallowDDLAdvisor struct {}func (*TableDisallowDDLAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -51,9 +46,16 @@ func (*TableDisallowDDLAdvisor) Check(_ context.Context, checkCtx advisor.Contex// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_table_disallow_dml.go b/backend/plugin/advisor/mssql/rule_table_disallow_dml.goindex e8c1b80abf..23276234a1 100644--- a/backend/plugin/advisor/mssql/rule_table_disallow_dml.go+++ b/backend/plugin/advisor/mssql/rule_table_disallow_dml.go@@ -14,6 +14,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")@@ -30,12 +31,6 @@ type TableDisallowDMLAdvisor struct {}func (*TableDisallowDMLAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -51,9 +46,16 @@ func (*TableDisallowDMLAdvisor) Check(_ context.Context, checkCtx advisor.Contex// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_table_drop_naming_convention.go b/backend/plugin/advisor/mssql/rule_table_drop_naming_convention.goindex dc86f014f2..e95895b568 100644--- a/backend/plugin/advisor/mssql/rule_table_drop_naming_convention.go+++ b/backend/plugin/advisor/mssql/rule_table_drop_naming_convention.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")@@ -30,12 +31,6 @@ type TableDropNamingConventionAdvisor struct {// Check checks for table drop with naming convention.func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -57,9 +52,16 @@ func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mssql/rule_table_no_foreign_key.go b/backend/plugin/advisor/mssql/rule_table_no_foreign_key.goindex 6ff0833511..ebcb0e3253 100644--- a/backend/plugin/advisor/mssql/rule_table_no_foreign_key.go+++ b/backend/plugin/advisor/mssql/rule_table_no_foreign_key.go@@ -12,7 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"-+ "github.com/bytebase/bytebase/backend/plugin/parser/base"tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")@@ -30,12 +30,6 @@ type TableNoForeignKeyAdvisor struct {// Check checks for table disallow foreign key..func (*TableNoForeignKeyAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -47,9 +41,16 @@ func (*TableNoForeignKeyAdvisor) Check(_ context.Context, checkCtx advisor.Conte// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}// Process the final advice after walkingdiff --git a/backend/plugin/advisor/mssql/rule_table_require_pk.go b/backend/plugin/advisor/mssql/rule_table_require_pk.goindex 5e4553ddea..3625ec2657 100644--- a/backend/plugin/advisor/mssql/rule_table_require_pk.go+++ b/backend/plugin/advisor/mssql/rule_table_require_pk.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")@@ -28,12 +29,6 @@ type TableRequirePkAdvisor struct {// Check checks for table require primary key..func (*TableRequirePkAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -45,9 +40,16 @@ func (*TableRequirePkAdvisor) Check(_ context.Context, checkCtx advisor.Context)// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}// Process the final advice after walkingdiff --git a/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.goindex 19cbe5f6e7..16dd729e67 100644--- a/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.go@@ -32,12 +32,6 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx adv}var adviceList []*storepb.Advice- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -54,9 +48,16 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx adv})}- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {checker := &mysqlparser.StatementTypeChecker{}- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)if checker.IsDDL {adviceList = append(adviceList, &storepb.Advice{@@ -80,7 +81,7 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx adv})}- tableReferences, err := prepareTransformation(checkCtx.DBSchema.Name, stmtList)+ tableReferences, err := prepareTransformation(checkCtx.DBSchema.Name, checkCtx.ParsedStatements)if err != nil {return nil, errors.Wrap(err, "failed to prepare transformation")}@@ -112,10 +113,17 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx advreturn adviceList, nil}-func prepareTransformation(databaseName string, parseResult []*base.ParseResult) ([]*mysqlparser.TableReference, error) {+func prepareTransformation(databaseName string, parsedStatements []base.ParsedStatement) ([]*mysqlparser.TableReference, error) {var result []*mysqlparser.TableReference- for i, sql := range parseResult {- tables, err := mysqlparser.ExtractTables(databaseName, sql, i)+ for i, stmt := range parsedStatements {+ if stmt.AST == nil {+ continue+ }+ ast, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ tables, err := mysqlparser.ExtractTables(databaseName, ast, i)if err != nil {return nil, errors.Wrap(err, "failed to extract tables")}diff --git a/backend/plugin/advisor/mysql/rule_charset_allowlist.go b/backend/plugin/advisor/mysql/rule_charset_allowlist.goindex 635e31ecbf..ec3bf41385 100644--- a/backend/plugin/advisor/mysql/rule_charset_allowlist.go+++ b/backend/plugin/advisor/mysql/rule_charset_allowlist.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -31,11 +32,6 @@ type CharsetAllowlistAdvisor struct {// Check checks for charset allowlist.func (*CharsetAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -53,10 +49,17 @@ func (*CharsetAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Contex// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_collation_allowlist.go b/backend/plugin/advisor/mysql/rule_collation_allowlist.goindex 6d7558b113..dfe44c0a01 100644--- a/backend/plugin/advisor/mysql/rule_collation_allowlist.go+++ b/backend/plugin/advisor/mysql/rule_collation_allowlist.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -31,12 +32,6 @@ type CollationAllowlistAdvisor struct {// Check checks for collation allowlist.func (*CollationAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -49,11 +44,18 @@ func (*CollationAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Cont// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)// Set text will be handled in the Query node- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_auto_increment_initial_value.go b/backend/plugin/advisor/mysql/rule_column_auto_increment_initial_value.goindex 84e85eb28f..144fb76d0f 100644--- a/backend/plugin/advisor/mysql/rule_column_auto_increment_initial_value.go+++ b/backend/plugin/advisor/mysql/rule_column_auto_increment_initial_value.go@@ -5,17 +5,17 @@ import ("fmt""strconv"- "github.com/pkg/errors"-"github.com/bytebase/bytebase/backend/plugin/advisor/code""github.com/antlr4-go/antlr/v4"+ "github.com/pkg/errors""github.com/bytebase/parser/mysql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -36,12 +36,6 @@ type ColumnAutoIncrementInitialValueAdvisor struct {// Check checks for auto-increment column initial value.func (*ColumnAutoIncrementInitialValueAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -57,10 +51,17 @@ func (*ColumnAutoIncrementInitialValueAdvisor) Check(_ context.Context, checkCtx// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_auto_increment_must_integer.go b/backend/plugin/advisor/mysql/rule_column_auto_increment_must_integer.goindex 012d08cda2..4ccc4e89da 100644--- a/backend/plugin/advisor/mysql/rule_column_auto_increment_must_integer.go+++ b/backend/plugin/advisor/mysql/rule_column_auto_increment_must_integer.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -33,12 +34,6 @@ type ColumnAutoIncrementMustIntegerAdvisor struct {// Check checks for auto-increment column type.func (*ColumnAutoIncrementMustIntegerAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -50,10 +45,17 @@ func (*ColumnAutoIncrementMustIntegerAdvisor) Check(_ context.Context, checkCtx// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_auto_increment_must_unsigned.go b/backend/plugin/advisor/mysql/rule_column_auto_increment_must_unsigned.goindex 58e9f3118a..cdd4b275fb 100644--- a/backend/plugin/advisor/mysql/rule_column_auto_increment_must_unsigned.go+++ b/backend/plugin/advisor/mysql/rule_column_auto_increment_must_unsigned.go@@ -14,6 +14,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -33,12 +34,6 @@ type ColumnAutoIncrementMustUnsignedAdvisor struct {// Check checks for unsigned auto-increment column.func (*ColumnAutoIncrementMustUnsignedAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -50,10 +45,17 @@ func (*ColumnAutoIncrementMustUnsignedAdvisor) Check(_ context.Context, checkCtx// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_comment_convention.go b/backend/plugin/advisor/mysql/rule_column_comment_convention.goindex c64f94ae1b..f3a0a48d2f 100644--- a/backend/plugin/advisor/mysql/rule_column_comment_convention.go+++ b/backend/plugin/advisor/mysql/rule_column_comment_convention.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -30,12 +31,6 @@ type ColumnCommentConventionAdvisor struct {// Check checks for column comment convention.func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -48,10 +43,17 @@ func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_current_time_count_limit.go b/backend/plugin/advisor/mysql/rule_column_current_time_count_limit.goindex ef157de461..970733d88e 100644--- a/backend/plugin/advisor/mysql/rule_column_current_time_count_limit.go+++ b/backend/plugin/advisor/mysql/rule_column_current_time_count_limit.go@@ -14,6 +14,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -38,12 +39,6 @@ type ColumnCurrentTimeCountLimitAdvisor struct {// Check checks for current time column count limit.func (*ColumnCurrentTimeCountLimitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -55,10 +50,17 @@ func (*ColumnCurrentTimeCountLimitAdvisor) Check(_ context.Context, checkCtx adv// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}// Generate advice after walkingdiff --git a/backend/plugin/advisor/mysql/rule_column_disallow_changing.go b/backend/plugin/advisor/mysql/rule_column_disallow_changing.goindex b841aa8500..d47339e082 100644--- a/backend/plugin/advisor/mysql/rule_column_disallow_changing.go+++ b/backend/plugin/advisor/mysql/rule_column_disallow_changing.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -32,12 +33,6 @@ type ColumnDisallowChangingAdvisor struct {// Check checks for disallow CHANGE COLUMN statement.func (*ColumnDisallowChangingAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -49,10 +44,17 @@ func (*ColumnDisallowChangingAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_disallow_changing_order.go b/backend/plugin/advisor/mysql/rule_column_disallow_changing_order.goindex 0c858d5b7f..578949993d 100644--- a/backend/plugin/advisor/mysql/rule_column_disallow_changing_order.go+++ b/backend/plugin/advisor/mysql/rule_column_disallow_changing_order.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -32,12 +33,6 @@ type ColumnDisallowChangingOrderAdvisor struct {// Check checks for disallow changing column order.func (*ColumnDisallowChangingOrderAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -49,10 +44,17 @@ func (*ColumnDisallowChangingOrderAdvisor) Check(_ context.Context, checkCtx adv// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go b/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.goindex 27bec2814a..2dbdf81740 100644--- a/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go+++ b/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go@@ -14,6 +14,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/store/model")@@ -34,12 +35,6 @@ type ColumnDisallowChangingTypeAdvisor struct {// Check checks for disallow changing column type.func (*ColumnDisallowChangingTypeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -51,10 +46,17 @@ func (*ColumnDisallowChangingTypeAdvisor) Check(_ context.Context, checkCtx advi// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_disallow_drop.go b/backend/plugin/advisor/mysql/rule_column_disallow_drop.goindex 2cceaa17f4..62f6c48619 100644--- a/backend/plugin/advisor/mysql/rule_column_disallow_drop.go+++ b/backend/plugin/advisor/mysql/rule_column_disallow_drop.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -30,12 +31,6 @@ type ColumnDisallowDropAdvisor struct {// Check checks for disallow DROP COLUMN statement.func (*ColumnDisallowDropAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -47,10 +42,17 @@ func (*ColumnDisallowDropAdvisor) Check(_ context.Context, checkCtx advisor.Cont// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go b/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.goindex c0f4445c88..7af4cda42a 100644--- a/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go+++ b/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/store/model")@@ -32,12 +33,6 @@ type ColumnDisallowDropInIndexAdvisor struct {// Check checks for disallow Drop COLUMN in index statement.func (*ColumnDisallowDropInIndexAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -49,10 +44,17 @@ func (*ColumnDisallowDropInIndexAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_disallow_set_charset.go b/backend/plugin/advisor/mysql/rule_column_disallow_set_charset.goindex ba5fa1087e..64a8ea10f3 100644--- a/backend/plugin/advisor/mysql/rule_column_disallow_set_charset.go+++ b/backend/plugin/advisor/mysql/rule_column_disallow_set_charset.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -31,12 +32,6 @@ type ColumnDisallowSetCharsetAdvisor struct {// Check checks for disallow set column charset.func (*ColumnDisallowSetCharsetAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -48,10 +43,17 @@ func (*ColumnDisallowSetCharsetAdvisor) Check(_ context.Context, checkCtx adviso// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_maximum_character_length.go b/backend/plugin/advisor/mysql/rule_column_maximum_character_length.goindex 9012a50770..7df509ca06 100644--- a/backend/plugin/advisor/mysql/rule_column_maximum_character_length.go+++ b/backend/plugin/advisor/mysql/rule_column_maximum_character_length.go@@ -5,17 +5,17 @@ import ("fmt""strconv"- "github.com/pkg/errors"-"github.com/bytebase/bytebase/backend/plugin/advisor/code""github.com/antlr4-go/antlr/v4"+ "github.com/pkg/errors""github.com/bytebase/parser/mysql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -35,12 +35,6 @@ type ColumnMaximumCharacterLengthAdvisor struct {// Check checks for maximum character length.func (*ColumnMaximumCharacterLengthAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -56,10 +50,17 @@ func (*ColumnMaximumCharacterLengthAdvisor) Check(_ context.Context, checkCtx ad// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_maximum_varchar_length.go b/backend/plugin/advisor/mysql/rule_column_maximum_varchar_length.goindex 3dcfbb72bc..b9b5d8950c 100644--- a/backend/plugin/advisor/mysql/rule_column_maximum_varchar_length.go+++ b/backend/plugin/advisor/mysql/rule_column_maximum_varchar_length.go@@ -5,16 +5,16 @@ import ("fmt""strconv"- "github.com/pkg/errors"-"github.com/bytebase/bytebase/backend/plugin/advisor/code""github.com/antlr4-go/antlr/v4""github.com/bytebase/parser/mysql"+ "github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -34,12 +34,6 @@ type ColumnMaximumVarcharLengthAdvisor struct {// Check checks for maximum varchar length.func (*ColumnMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -55,10 +49,17 @@ func (*ColumnMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advi// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_no_null.go b/backend/plugin/advisor/mysql/rule_column_no_null.goindex 42daab8c23..ad53f8f94e 100644--- a/backend/plugin/advisor/mysql/rule_column_no_null.go+++ b/backend/plugin/advisor/mysql/rule_column_no_null.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/store/model")@@ -32,12 +33,6 @@ type ColumnNoNullAdvisor struct {// Check checks for column no NULL value.func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- root, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -49,10 +44,17 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range root {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}// Generate advice after walkingdiff --git a/backend/plugin/advisor/mysql/rule_column_require_charset.go b/backend/plugin/advisor/mysql/rule_column_require_charset.goindex b1b8edab80..5ca7ba8fed 100644--- a/backend/plugin/advisor/mysql/rule_column_require_charset.go+++ b/backend/plugin/advisor/mysql/rule_column_require_charset.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -29,12 +30,6 @@ type ColumnRequireCharsetAdvisor struct {}func (*ColumnRequireCharsetAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,10 +41,17 @@ func (*ColumnRequireCharsetAdvisor) Check(_ context.Context, checkCtx advisor.Co// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_require_collation.go b/backend/plugin/advisor/mysql/rule_column_require_collation.goindex 8c9184c376..169ad6ef51 100644--- a/backend/plugin/advisor/mysql/rule_column_require_collation.go+++ b/backend/plugin/advisor/mysql/rule_column_require_collation.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -28,12 +29,6 @@ type ColumnRequireCollationAdvisor struct {}func (*ColumnRequireCollationAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -45,10 +40,17 @@ func (*ColumnRequireCollationAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_require_default.go b/backend/plugin/advisor/mysql/rule_column_require_default.goindex 6339b2d61e..5a4517fb72 100644--- a/backend/plugin/advisor/mysql/rule_column_require_default.go+++ b/backend/plugin/advisor/mysql/rule_column_require_default.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -31,12 +32,6 @@ type ColumnRequireDefaultAdvisor struct {// Check checks for column default requirement.func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -48,10 +43,17 @@ func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Co// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_required.go b/backend/plugin/advisor/mysql/rule_column_required.goindex 0d227354d0..841e4a93c2 100644--- a/backend/plugin/advisor/mysql/rule_column_required.go+++ b/backend/plugin/advisor/mysql/rule_column_required.go@@ -6,16 +6,16 @@ import ("slices""strings"- "github.com/pkg/errors"-"github.com/bytebase/bytebase/backend/plugin/advisor/code""github.com/antlr4-go/antlr/v4""github.com/bytebase/parser/mysql"+ "github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -35,12 +35,6 @@ type ColumnRequirementAdvisor struct {// Check checks for the column requirement.func (*ColumnRequirementAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- list, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -61,10 +55,17 @@ func (*ColumnRequirementAdvisor) Check(_ context.Context, checkCtx advisor.Conte// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range list {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return rule.generateAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_set_default_for_not_null.go b/backend/plugin/advisor/mysql/rule_column_set_default_for_not_null.goindex d017bf3f71..b3177460c2 100644--- a/backend/plugin/advisor/mysql/rule_column_set_default_for_not_null.go+++ b/backend/plugin/advisor/mysql/rule_column_set_default_for_not_null.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -32,12 +33,6 @@ type ColumnSetDefaultForNotNullAdvisor struct {// Check checks for set default value for not null column.func (*ColumnSetDefaultForNotNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -49,10 +44,17 @@ func (*ColumnSetDefaultForNotNullAdvisor) Check(_ context.Context, checkCtx advi// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_column_type_disallow_list.go b/backend/plugin/advisor/mysql/rule_column_type_disallow_list.goindex 5552a6feec..c86f640423 100644--- a/backend/plugin/advisor/mysql/rule_column_type_disallow_list.go+++ b/backend/plugin/advisor/mysql/rule_column_type_disallow_list.go@@ -14,6 +14,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -33,12 +34,6 @@ type ColumnTypeDisallowListAdvisor struct {// Check checks for column type restriction.func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -56,10 +51,17 @@ func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_database_drop_empty_db.go b/backend/plugin/advisor/mysql/rule_database_drop_empty_db.goindex d24569063f..5de0590297 100644--- a/backend/plugin/advisor/mysql/rule_database_drop_empty_db.go+++ b/backend/plugin/advisor/mysql/rule_database_drop_empty_db.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/store/model")@@ -32,11 +33,6 @@ type DatabaseAllowDropIfEmptyAdvisor struct {// Check checks for drop table naming convention.func (*DatabaseAllowDropIfEmptyAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- list, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -48,10 +44,17 @@ func (*DatabaseAllowDropIfEmptyAdvisor) Check(_ context.Context, checkCtx adviso// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range list {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_disallow_procedure.go b/backend/plugin/advisor/mysql/rule_disallow_procedure.goindex ff134e53a6..8d21e8855d 100644--- a/backend/plugin/advisor/mysql/rule_disallow_procedure.go+++ b/backend/plugin/advisor/mysql/rule_disallow_procedure.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"advisorcode "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -29,12 +30,6 @@ type ProcedureDisallowCreateAdvisor struct {// Check checks for disallow create procedure.func (*ProcedureDisallowCreateAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,10 +41,17 @@ func (*ProcedureDisallowCreateAdvisor) Check(_ context.Context, checkCtx advisor// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_event_disallow_create.go b/backend/plugin/advisor/mysql/rule_event_disallow_create.goindex 773e9dcb97..9a78e573f3 100644--- a/backend/plugin/advisor/mysql/rule_event_disallow_create.go+++ b/backend/plugin/advisor/mysql/rule_event_disallow_create.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"advisorcode "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -29,12 +30,6 @@ type EventDisallowCreateAdvisor struct {// Check checks for disallow creating event.func (*EventDisallowCreateAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,10 +41,17 @@ func (*EventDisallowCreateAdvisor) Check(_ context.Context, checkCtx advisor.Con// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_function_disallow_create.go b/backend/plugin/advisor/mysql/rule_function_disallow_create.goindex 25817513da..5601f0d51b 100644--- a/backend/plugin/advisor/mysql/rule_function_disallow_create.go+++ b/backend/plugin/advisor/mysql/rule_function_disallow_create.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"advisorcode "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -29,12 +30,6 @@ type FunctionDisallowCreateAdvisor struct {// Check checks for disallow creating function.func (*FunctionDisallowCreateAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,10 +41,17 @@ func (*FunctionDisallowCreateAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_function_disallowed_list.go b/backend/plugin/advisor/mysql/rule_function_disallowed_list.goindex c97e8da0f2..161d4aa1b5 100644--- a/backend/plugin/advisor/mysql/rule_function_disallowed_list.go+++ b/backend/plugin/advisor/mysql/rule_function_disallowed_list.go@@ -14,6 +14,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -30,12 +31,6 @@ type FunctionDisallowedListAdvisor struct {}func (*FunctionDisallowedListAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -53,10 +48,17 @@ func (*FunctionDisallowedListAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_index_key_number_limit.go b/backend/plugin/advisor/mysql/rule_index_key_number_limit.goindex 98120f5c17..91595c85cf 100644--- a/backend/plugin/advisor/mysql/rule_index_key_number_limit.go+++ b/backend/plugin/advisor/mysql/rule_index_key_number_limit.go@@ -4,16 +4,16 @@ import ("context""fmt"- "github.com/pkg/errors"-"github.com/bytebase/bytebase/backend/plugin/advisor/code""github.com/antlr4-go/antlr/v4""github.com/bytebase/parser/mysql"+ "github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -33,12 +33,6 @@ type IndexKeyNumberLimitAdvisor struct {// Check checks for index key number limit.func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -54,10 +48,17 @@ func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Con// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_index_no_duplicate_column.go b/backend/plugin/advisor/mysql/rule_index_no_duplicate_column.goindex 2d64faa78c..120886b4b4 100644--- a/backend/plugin/advisor/mysql/rule_index_no_duplicate_column.go+++ b/backend/plugin/advisor/mysql/rule_index_no_duplicate_column.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -32,12 +33,6 @@ type IndexNoDuplicateColumnAdvisor struct {// Check checks for no duplicate columns in index.func (*IndexNoDuplicateColumnAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -49,10 +44,17 @@ func (*IndexNoDuplicateColumnAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_index_pk_type.go b/backend/plugin/advisor/mysql/rule_index_pk_type.goindex aa7d4c6e26..8749fbe90d 100644--- a/backend/plugin/advisor/mysql/rule_index_pk_type.go+++ b/backend/plugin/advisor/mysql/rule_index_pk_type.go@@ -14,6 +14,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/store/model")@@ -34,12 +35,6 @@ type IndexPkTypeAdvisor struct {// Check checks for correct type of PK.func (*IndexPkTypeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -51,10 +46,17 @@ func (*IndexPkTypeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_index_primary_key_type_allowlist.go b/backend/plugin/advisor/mysql/rule_index_primary_key_type_allowlist.goindex 0666522af4..0adf973672 100644--- a/backend/plugin/advisor/mysql/rule_index_primary_key_type_allowlist.go+++ b/backend/plugin/advisor/mysql/rule_index_primary_key_type_allowlist.go@@ -14,6 +14,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/store/model")@@ -33,12 +34,6 @@ type IndexPrimaryKeyTypeAllowlistAdvisor struct {// Check checks for primary key type allowlist.func (*IndexPrimaryKeyTypeAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -55,10 +50,17 @@ func (*IndexPrimaryKeyTypeAllowlistAdvisor) Check(_ context.Context, checkCtx ad// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_index_total_number_limit.go b/backend/plugin/advisor/mysql/rule_index_total_number_limit.goindex 43967d9980..9f41ed6a07 100644--- a/backend/plugin/advisor/mysql/rule_index_total_number_limit.go+++ b/backend/plugin/advisor/mysql/rule_index_total_number_limit.go@@ -5,16 +5,16 @@ import ("fmt""slices"- "github.com/pkg/errors"-"github.com/bytebase/bytebase/backend/plugin/advisor/code""github.com/antlr4-go/antlr/v4""github.com/bytebase/parser/mysql"+ "github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/store/model")@@ -35,12 +35,6 @@ type IndexTotalNumberLimitAdvisor struct {// Check checks for index total number limit.func (*IndexTotalNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -56,10 +50,17 @@ func (*IndexTotalNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.C// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return rule.generateAdvice(), nildiff --git a/backend/plugin/advisor/mysql/rule_index_type_allow_list.go b/backend/plugin/advisor/mysql/rule_index_type_allow_list.goindex f65daf0619..4fdf68dc27 100644--- a/backend/plugin/advisor/mysql/rule_index_type_allow_list.go+++ b/backend/plugin/advisor/mysql/rule_index_type_allow_list.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -29,12 +30,6 @@ type IndexTypeAllowListAdvisor struct {}func (*IndexTypeAllowListAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -48,10 +43,17 @@ func (*IndexTypeAllowListAdvisor) Check(_ context.Context, checkCtx advisor.Cont// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_index_type_no_blob.go b/backend/plugin/advisor/mysql/rule_index_type_no_blob.goindex 772f812125..a27bbcc365 100644--- a/backend/plugin/advisor/mysql/rule_index_type_no_blob.go+++ b/backend/plugin/advisor/mysql/rule_index_type_no_blob.go@@ -14,6 +14,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/store/model")@@ -34,12 +35,6 @@ type IndexTypeNoBlobAdvisor struct {// Check checks for index type no blob.func (*IndexTypeNoBlobAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -51,10 +46,17 @@ func (*IndexTypeNoBlobAdvisor) Check(_ context.Context, checkCtx advisor.Context// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_insert_disallow_order_by_rand.go b/backend/plugin/advisor/mysql/rule_insert_disallow_order_by_rand.goindex 7a95567402..e38f8184e5 100644--- a/backend/plugin/advisor/mysql/rule_insert_disallow_order_by_rand.go+++ b/backend/plugin/advisor/mysql/rule_insert_disallow_order_by_rand.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -33,12 +34,6 @@ 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) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -50,10 +45,17 @@ func (*InsertDisallowOrderByRandAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_insert_must_specify_column.go b/backend/plugin/advisor/mysql/rule_insert_must_specify_column.goindex a66e9d0cd9..3df2ef99af 100644--- a/backend/plugin/advisor/mysql/rule_insert_must_specify_column.go+++ b/backend/plugin/advisor/mysql/rule_insert_must_specify_column.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -30,12 +31,6 @@ type InsertMustSpecifyColumnAdvisor struct {// Check checks for to enforce column specified.func (*InsertMustSpecifyColumnAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -47,10 +42,17 @@ func (*InsertMustSpecifyColumnAdvisor) Check(_ context.Context, checkCtx advisor// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_insert_row_limit.go b/backend/plugin/advisor/mysql/rule_insert_row_limit.goindex 8066b6a3f5..fd9d0739a6 100644--- a/backend/plugin/advisor/mysql/rule_insert_row_limit.go+++ b/backend/plugin/advisor/mysql/rule_insert_row_limit.go@@ -14,6 +14,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -32,12 +33,6 @@ type InsertRowLimitAdvisor struct {// Check checks for insert row limit.func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- list, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -54,10 +49,17 @@ func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Contex// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range list {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)if rule.GetExplainCount() >= common.MaximumLintExplainSize {break}diff --git a/backend/plugin/advisor/mysql/rule_migration_compatibility.go b/backend/plugin/advisor/mysql/rule_migration_compatibility.goindex e32ed1db05..1c2493071c 100644--- a/backend/plugin/advisor/mysql/rule_migration_compatibility.go+++ b/backend/plugin/advisor/mysql/rule_migration_compatibility.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -31,12 +32,6 @@ type CompatibilityAdvisor struct {// Check checks schema backward compatibility.func (*CompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -48,10 +43,17 @@ func (*CompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.Context)// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_naming_auto_increment_column.go b/backend/plugin/advisor/mysql/rule_naming_auto_increment_column.goindex 2ecbf24bfc..eb2a181a47 100644--- a/backend/plugin/advisor/mysql/rule_naming_auto_increment_column.go+++ b/backend/plugin/advisor/mysql/rule_naming_auto_increment_column.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -32,12 +33,6 @@ type NamingAutoIncrementColumnAdvisor struct {// Check checks for auto-increment naming convention.func (*NamingAutoIncrementColumnAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -63,10 +58,17 @@ func (*NamingAutoIncrementColumnAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_naming_column.go b/backend/plugin/advisor/mysql/rule_naming_column.goindex 440d7e28a6..a72e9cbc0c 100644--- a/backend/plugin/advisor/mysql/rule_naming_column.go+++ b/backend/plugin/advisor/mysql/rule_naming_column.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -30,11 +31,6 @@ type NamingColumnConventionAdvisor struct {// Check checks for column naming convention.func (*NamingColumnConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- list, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -61,10 +57,17 @@ func (*NamingColumnConventionAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range list {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_naming_foreign_key_convention.go b/backend/plugin/advisor/mysql/rule_naming_foreign_key_convention.goindex 6100e59d82..b89ba57f74 100644--- a/backend/plugin/advisor/mysql/rule_naming_foreign_key_convention.go+++ b/backend/plugin/advisor/mysql/rule_naming_foreign_key_convention.go@@ -5,15 +5,15 @@ import ("fmt""strings"- "github.com/pkg/errors"-"github.com/antlr4-go/antlr/v4""github.com/bytebase/parser/mysql"+ "github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -33,12 +33,6 @@ type NamingFKConventionAdvisor struct {// Check checks for foreign key naming convention.func (*NamingFKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- root, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -69,10 +63,17 @@ func (*NamingFKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Cont// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range root {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_naming_identifier_no_keyword.go b/backend/plugin/advisor/mysql/rule_naming_identifier_no_keyword.goindex 4bcf1b200d..430aba3bbf 100644--- a/backend/plugin/advisor/mysql/rule_naming_identifier_no_keyword.go+++ b/backend/plugin/advisor/mysql/rule_naming_identifier_no_keyword.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -28,12 +29,6 @@ type NamingIdentifierNoKeywordAdvisor struct {// Check checks for identifier naming convention without keyword.func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -45,10 +40,17 @@ func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_naming_index_convention.go b/backend/plugin/advisor/mysql/rule_naming_index_convention.goindex 3fa31ef77e..c4176fc8e5 100644--- a/backend/plugin/advisor/mysql/rule_naming_index_convention.go+++ b/backend/plugin/advisor/mysql/rule_naming_index_convention.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/store/model")@@ -41,12 +42,6 @@ type NamingIndexConventionAdvisor struct {// Check checks for index naming convention.func (*NamingIndexConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- root, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -77,10 +72,17 @@ func (*NamingIndexConventionAdvisor) Check(_ context.Context, checkCtx advisor.C// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range root {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_naming_table.go b/backend/plugin/advisor/mysql/rule_naming_table.goindex b6f9e870bb..98b52e7519 100644--- a/backend/plugin/advisor/mysql/rule_naming_table.go+++ b/backend/plugin/advisor/mysql/rule_naming_table.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -32,11 +33,6 @@ type NamingTableConventionAdvisor struct {// Check checks for table naming convention.func (*NamingTableConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- list, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, errors.Errorf("failed to convert to Tree")- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -63,10 +59,17 @@ func (*NamingTableConventionAdvisor) Check(_ context.Context, checkCtx advisor.C// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range list {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.go b/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.goindex bfb526075e..c8dbd36676 100644--- a/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.go+++ b/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/store/model")@@ -33,12 +34,6 @@ type NamingUKConventionAdvisor struct {// Check checks for index naming convention.func (*NamingUKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- root, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -69,10 +64,17 @@ func (*NamingUKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Cont// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range root {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_online_migration.go b/backend/plugin/advisor/mysql/rule_online_migration.goindex 6edda9cc5a..f9cc955fed 100644--- a/backend/plugin/advisor/mysql/rule_online_migration.go+++ b/backend/plugin/advisor/mysql/rule_online_migration.go@@ -35,11 +35,6 @@ type OnlineMigrationAdvisor struct {// Check checks for using gh-ost to migrate large tables.func (*OnlineMigrationAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, errors.Errorf("failed to convert to StmtNode")- }-numberPayload := checkCtx.Rule.GetNumberPayload()if numberPayload == nil {return nil, errors.New("number_payload is required for this rule")@@ -75,10 +70,17 @@ func (*OnlineMigrationAdvisor) Check(ctx context.Context, checkCtx advisor.Conte// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}adviceList := rule.GetAdviceList()@@ -90,14 +92,14 @@ func (*OnlineMigrationAdvisor) Check(ctx context.Context, checkCtx advisor.Conte}// One statement needs online migration, others don't.// Advise running the statement in another issue.- if len(adviceList) == 1 && len(stmtList) > 1 {+ if len(adviceList) == 1 && len(checkCtx.ParsedStatements) > 1 {return adviceList, nil}// We have only one statement, and the statement// needs online migration.// Advise to enable online migration for the issue, or return OK if it's already enabled.- if len(adviceList) == 1 && len(stmtList) == 1 {+ if len(adviceList) == 1 && len(checkCtx.ParsedStatements) == 1 {if checkCtx.EnableGhost {return nil, nil}diff --git a/backend/plugin/advisor/mysql/rule_statement_add_column_without_position.go b/backend/plugin/advisor/mysql/rule_statement_add_column_without_position.goindex 066b510533..76b833b463 100644--- a/backend/plugin/advisor/mysql/rule_statement_add_column_without_position.go+++ b/backend/plugin/advisor/mysql/rule_statement_add_column_without_position.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -28,12 +29,6 @@ type StatementAddColumnWithoutPositionAdvisor struct {// Check checks for checking no position in ADD COLUMN clause.func (*StatementAddColumnWithoutPositionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -45,10 +40,17 @@ func (*StatementAddColumnWithoutPositionAdvisor) Check(_ context.Context, checkC// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_statement_affected_row_limit.go b/backend/plugin/advisor/mysql/rule_statement_affected_row_limit.goindex 268c5367af..e9b1f09e1e 100644--- a/backend/plugin/advisor/mysql/rule_statement_affected_row_limit.go+++ b/backend/plugin/advisor/mysql/rule_statement_affected_row_limit.go@@ -14,6 +14,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -32,12 +33,6 @@ type StatementAffectedRowLimitAdvisor struct {// Check checks for UPDATE/DELETE affected row limit.func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -54,10 +49,17 @@ func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx advchecker := NewGenericChecker([]Rule{rule})if checkCtx.Driver != nil {- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)if rule.explainCount >= common.MaximumLintExplainSize {break}diff --git a/backend/plugin/advisor/mysql/rule_statement_disallow_using_filesort.go b/backend/plugin/advisor/mysql/rule_statement_disallow_using_filesort.goindex 787d03c0d7..57caac1553 100644--- a/backend/plugin/advisor/mysql/rule_statement_disallow_using_filesort.go+++ b/backend/plugin/advisor/mysql/rule_statement_disallow_using_filesort.go@@ -14,6 +14,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -30,12 +31,6 @@ type StatementDisallowUsingFilesortAdvisor struct {}func (*StatementDisallowUsingFilesortAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -48,10 +43,17 @@ func (*StatementDisallowUsingFilesortAdvisor) Check(ctx context.Context, checkCtchecker := NewGenericChecker([]Rule{rule})if rule.driver != nil {- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)if rule.GetExplainCount() >= common.MaximumLintExplainSize {break}diff --git a/backend/plugin/advisor/mysql/rule_statement_disallow_using_temporary.go b/backend/plugin/advisor/mysql/rule_statement_disallow_using_temporary.goindex f3e0d8b69a..09048e98f2 100644--- a/backend/plugin/advisor/mysql/rule_statement_disallow_using_temporary.go+++ b/backend/plugin/advisor/mysql/rule_statement_disallow_using_temporary.go@@ -14,6 +14,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -30,12 +31,6 @@ type StatementDisallowUsingTemporaryAdvisor struct {}func (*StatementDisallowUsingTemporaryAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -48,10 +43,17 @@ func (*StatementDisallowUsingTemporaryAdvisor) Check(ctx context.Context, checkCchecker := NewGenericChecker([]Rule{rule})if rule.driver != nil {- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)if rule.GetExplainCount() >= common.MaximumLintExplainSize {break}diff --git a/backend/plugin/advisor/mysql/rule_statement_dml_dry_run.go b/backend/plugin/advisor/mysql/rule_statement_dml_dry_run.goindex e1793a6b2c..b6e71b78d6 100644--- a/backend/plugin/advisor/mysql/rule_statement_dml_dry_run.go+++ b/backend/plugin/advisor/mysql/rule_statement_dml_dry_run.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -31,12 +32,6 @@ type StatementDmlDryRunAdvisor struct {// Check checks for DML dry run.func (*StatementDmlDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -49,10 +44,17 @@ func (*StatementDmlDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Cochecker := NewGenericChecker([]Rule{rule})if checkCtx.Driver != nil {- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)if rule.explainCount >= common.MaximumLintExplainSize {break}diff --git a/backend/plugin/advisor/mysql/rule_statement_join_strict_column_attrs.go b/backend/plugin/advisor/mysql/rule_statement_join_strict_column_attrs.goindex 52ee5d94e6..aeb0b054eb 100644--- a/backend/plugin/advisor/mysql/rule_statement_join_strict_column_attrs.go+++ b/backend/plugin/advisor/mysql/rule_statement_join_strict_column_attrs.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/store/model")@@ -28,12 +29,6 @@ type StatementJoinStrictColumnAttrsAdvisor struct {}func (*StatementJoinStrictColumnAttrsAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -49,10 +44,17 @@ func (*StatementJoinStrictColumnAttrsAdvisor) Check(_ context.Context, checkCtx// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_statement_maximum_join_table_count.go b/backend/plugin/advisor/mysql/rule_statement_maximum_join_table_count.goindex 51e66ddd33..90ad63724d 100644--- a/backend/plugin/advisor/mysql/rule_statement_maximum_join_table_count.go+++ b/backend/plugin/advisor/mysql/rule_statement_maximum_join_table_count.go@@ -4,15 +4,15 @@ import ("context""fmt"- "github.com/pkg/errors"-"github.com/antlr4-go/antlr/v4""github.com/bytebase/parser/mysql"+ "github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,12 +27,6 @@ type StatementMaximumJoinTableCountAdvisor struct {}func (*StatementMaximumJoinTableCountAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -48,10 +42,17 @@ func (*StatementMaximumJoinTableCountAdvisor) Check(_ context.Context, checkCtx// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_statement_maximum_limit_value.go b/backend/plugin/advisor/mysql/rule_statement_maximum_limit_value.goindex 0952e81453..bf0c3d0a63 100644--- a/backend/plugin/advisor/mysql/rule_statement_maximum_limit_value.go+++ b/backend/plugin/advisor/mysql/rule_statement_maximum_limit_value.go@@ -5,15 +5,15 @@ import ("fmt""strconv"- "github.com/pkg/errors"-"github.com/antlr4-go/antlr/v4""github.com/bytebase/parser/mysql"+ "github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -31,12 +31,6 @@ type StatementMaximumLimitValueAdvisor struct {}func (*StatementMaximumLimitValueAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -52,10 +46,17 @@ func (*StatementMaximumLimitValueAdvisor) Check(_ context.Context, checkCtx advi// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_statement_maximum_statements_in_transaction.go b/backend/plugin/advisor/mysql/rule_statement_maximum_statements_in_transaction.goindex a7b93da033..65821f37fc 100644--- a/backend/plugin/advisor/mysql/rule_statement_maximum_statements_in_transaction.go+++ b/backend/plugin/advisor/mysql/rule_statement_maximum_statements_in_transaction.go@@ -3,13 +3,13 @@ package mysqlimport ("context"- "github.com/pkg/errors"-"github.com/antlr4-go/antlr/v4""github.com/bytebase/parser/mysql"+ "github.com/pkg/errors"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -24,12 +24,6 @@ type StatementMaximumStatementsInTransactionAdvisor struct {}func (*StatementMaximumStatementsInTransactionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -45,10 +39,17 @@ func (*StatementMaximumStatementsInTransactionAdvisor) Check(_ context.Context,// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_statement_merge_alter_table.go b/backend/plugin/advisor/mysql/rule_statement_merge_alter_table.goindex 1d6b2dfa36..70934ff23a 100644--- a/backend/plugin/advisor/mysql/rule_statement_merge_alter_table.go+++ b/backend/plugin/advisor/mysql/rule_statement_merge_alter_table.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -31,12 +32,6 @@ type StatementMergeAlterTableAdvisor struct {// Check checks for merging ALTER TABLE statements.func (*StatementMergeAlterTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -48,10 +43,17 @@ func (*StatementMergeAlterTableAdvisor) Check(_ context.Context, checkCtx adviso// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}// Generate advice based on collected table informationdiff --git a/backend/plugin/advisor/mysql/rule_statement_query_minimum_plan_level.go b/backend/plugin/advisor/mysql/rule_statement_query_minimum_plan_level.goindex 91c0041ea7..9ebeada7d8 100644--- a/backend/plugin/advisor/mysql/rule_statement_query_minimum_plan_level.go+++ b/backend/plugin/advisor/mysql/rule_statement_query_minimum_plan_level.go@@ -15,6 +15,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -30,12 +31,6 @@ type StatementQueryMinumumPlanLevelAdvisor struct {}func (*StatementQueryMinumumPlanLevelAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -52,10 +47,17 @@ func (*StatementQueryMinumumPlanLevelAdvisor) Check(ctx context.Context, checkCtchecker := NewGenericChecker([]Rule{rule})if rule.driver != nil {- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)if rule.GetExplainCount() >= common.MaximumLintExplainSize {break}diff --git a/backend/plugin/advisor/mysql/rule_statement_select_full_table_scan.go b/backend/plugin/advisor/mysql/rule_statement_select_full_table_scan.goindex 9b5e9e5f49..130db44379 100644--- a/backend/plugin/advisor/mysql/rule_statement_select_full_table_scan.go+++ b/backend/plugin/advisor/mysql/rule_statement_select_full_table_scan.go@@ -15,6 +15,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -32,12 +33,6 @@ type StatementSelectFullTableScanAdvisor struct {}func (*StatementSelectFullTableScanAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -50,10 +45,17 @@ func (*StatementSelectFullTableScanAdvisor) Check(ctx context.Context, checkCtxchecker := NewGenericChecker([]Rule{rule})if rule.driver != nil {- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)if rule.GetExplainCount() >= common.MaximumLintExplainSize {break}diff --git a/backend/plugin/advisor/mysql/rule_statement_where_disallow_using_function.go b/backend/plugin/advisor/mysql/rule_statement_where_disallow_using_function.goindex 5772ac2765..cf9d4a07a7 100644--- a/backend/plugin/advisor/mysql/rule_statement_where_disallow_using_function.go+++ b/backend/plugin/advisor/mysql/rule_statement_where_disallow_using_function.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -26,12 +27,6 @@ type StatementWhereDisallowUsingFunctionAdvisor struct {}func (*StatementWhereDisallowUsingFunctionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -43,10 +38,17 @@ func (*StatementWhereDisallowUsingFunctionAdvisor) Check(_ context.Context, chec// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_statement_where_maximum_logical_operator_count.go b/backend/plugin/advisor/mysql/rule_statement_where_maximum_logical_operator_count.goindex 2d4c72bdd5..3ad6f1aa2c 100644--- a/backend/plugin/advisor/mysql/rule_statement_where_maximum_logical_operator_count.go+++ b/backend/plugin/advisor/mysql/rule_statement_where_maximum_logical_operator_count.go@@ -4,15 +4,15 @@ import ("context""fmt"- "github.com/pkg/errors"-"github.com/antlr4-go/antlr/v4""github.com/bytebase/parser/mysql"+ "github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,12 +27,6 @@ type StatementWhereMaximumLogicalOperatorCountAdvisor struct {}func (*StatementWhereMaximumLogicalOperatorCountAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -43,7 +37,7 @@ func (*StatementWhereMaximumLogicalOperatorCountAdvisor) Check(_ context.Context}var allAdvice []*storepb.Advice- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {// Create the rule for each statementrule := NewStatementWhereMaximumLogicalOperatorCountRule(level, checkCtx.Rule.Type.String(), int(numberPayload.Number))@@ -53,7 +47,14 @@ func (*StatementWhereMaximumLogicalOperatorCountAdvisor) Check(_ context.Contextrule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)rule.resetForStatement()- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)// Check OR conditions after walking the treerule.checkOrConditions()diff --git a/backend/plugin/advisor/mysql/rule_statement_where_no_equal_null.go b/backend/plugin/advisor/mysql/rule_statement_where_no_equal_null.goindex e40dc7167d..582409b195 100644--- a/backend/plugin/advisor/mysql/rule_statement_where_no_equal_null.go+++ b/backend/plugin/advisor/mysql/rule_statement_where_no_equal_null.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -25,12 +26,6 @@ type StatementWhereNoEqualNullAdvisor struct {}func (*StatementWhereNoEqualNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -42,10 +37,17 @@ func (*StatementWhereNoEqualNullAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_stmt_disallow_commit.go b/backend/plugin/advisor/mysql/rule_stmt_disallow_commit.goindex 367510f044..56875a5f4b 100644--- a/backend/plugin/advisor/mysql/rule_stmt_disallow_commit.go+++ b/backend/plugin/advisor/mysql/rule_stmt_disallow_commit.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -30,12 +31,6 @@ type StatementDisallowCommitAdvisor struct {// Check checks for disallowing commit.func (*StatementDisallowCommitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -47,10 +42,17 @@ func (*StatementDisallowCommitAdvisor) Check(_ context.Context, checkCtx advisor// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_stmt_disallow_limit.go b/backend/plugin/advisor/mysql/rule_stmt_disallow_limit.goindex 5a7258962b..c02ee42a21 100644--- a/backend/plugin/advisor/mysql/rule_stmt_disallow_limit.go+++ b/backend/plugin/advisor/mysql/rule_stmt_disallow_limit.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -29,12 +30,6 @@ type StatementDisallowLimitAdvisor struct {// Check checks for no LIMIT clause in INSERT/UPDATE statement.func (*StatementDisallowLimitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,10 +41,17 @@ func (*StatementDisallowLimitAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_stmt_disallow_order_by.go b/backend/plugin/advisor/mysql/rule_stmt_disallow_order_by.goindex 6fbfecb868..33d783c062 100644--- a/backend/plugin/advisor/mysql/rule_stmt_disallow_order_by.go+++ b/backend/plugin/advisor/mysql/rule_stmt_disallow_order_by.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -29,12 +30,6 @@ type DisallowOrderByAdvisor struct {// Check checks for no ORDER BY clause in DELETE/UPDATE statements.func (*DisallowOrderByAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,10 +41,17 @@ func (*DisallowOrderByAdvisor) Check(_ context.Context, checkCtx advisor.Context// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_stmt_max_execution_time.go b/backend/plugin/advisor/mysql/rule_stmt_max_execution_time.goindex a40aa93668..cc40dd3598 100644--- a/backend/plugin/advisor/mysql/rule_stmt_max_execution_time.go+++ b/backend/plugin/advisor/mysql/rule_stmt_max_execution_time.go@@ -8,11 +8,11 @@ import ("github.com/antlr4-go/antlr/v4""github.com/bytebase/parser/mysql"- "github.com/pkg/errors"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -29,11 +29,6 @@ type MaxExecutionTimeAdvisor struct {}func (*MaxExecutionTimeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, errors.Errorf("failed to convert to stmt list")- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -51,10 +46,17 @@ func (*MaxExecutionTimeAdvisor) Check(_ context.Context, checkCtx advisor.Contex// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_stmt_no_leading_wildcard_like.go b/backend/plugin/advisor/mysql/rule_stmt_no_leading_wildcard_like.goindex 09c02081ae..3511e9e807 100644--- a/backend/plugin/advisor/mysql/rule_stmt_no_leading_wildcard_like.go+++ b/backend/plugin/advisor/mysql/rule_stmt_no_leading_wildcard_like.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -30,12 +31,6 @@ type NoLeadingWildcardLikeAdvisor struct {// Check checks for no leading wildcard LIKE.func (*NoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- root, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -47,10 +42,17 @@ func (*NoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx advisor.C// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range root {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_stmt_no_select_all.go b/backend/plugin/advisor/mysql/rule_stmt_no_select_all.goindex f51a825554..11f127bab9 100644--- a/backend/plugin/advisor/mysql/rule_stmt_no_select_all.go+++ b/backend/plugin/advisor/mysql/rule_stmt_no_select_all.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -29,12 +30,6 @@ type NoSelectAllAdvisor struct {// Check checks for no "select *".func (*NoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- root, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,10 +41,17 @@ func (*NoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range root {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_stmt_require_algorithm_or_lock_options.go b/backend/plugin/advisor/mysql/rule_stmt_require_algorithm_or_lock_options.goindex ff78058f83..2a42ddb0b0 100644--- a/backend/plugin/advisor/mysql/rule_stmt_require_algorithm_or_lock_options.go+++ b/backend/plugin/advisor/mysql/rule_stmt_require_algorithm_or_lock_options.go@@ -5,12 +5,12 @@ import ("github.com/antlr4-go/antlr/v4""github.com/bytebase/parser/mysql"- "github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -31,11 +31,6 @@ type RequireAlgorithmOrLockOptionAdvisor struct {}func (*RequireAlgorithmOrLockOptionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, errors.Errorf("failed to convert to stmt list")- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -52,10 +47,17 @@ func (*RequireAlgorithmOrLockOptionAdvisor) Check(_ context.Context, checkCtx ad// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_select.go b/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_select.goindex 05e694323a..0ef454358c 100644--- a/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_select.go+++ b/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_select.go@@ -6,12 +6,12 @@ import ("github.com/antlr4-go/antlr/v4""github.com/bytebase/parser/mysql"- "github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -30,11 +30,6 @@ type WhereRequirementForSelectAdvisor struct {// Check checks for the WHERE clause requirement.func (*WhereRequirementForSelectAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- root, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, errors.Errorf("failed to convert to StmtNode")- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,10 +41,17 @@ func (*WhereRequirementForSelectAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range root {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_update_delete.go b/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_update_delete.goindex d4a60e1ede..5be78b659d 100644--- a/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_update_delete.go+++ b/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_update_delete.go@@ -6,12 +6,12 @@ import ("github.com/antlr4-go/antlr/v4""github.com/bytebase/parser/mysql"- "github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -31,11 +31,6 @@ type WhereRequirementForUpdateDeleteAdvisor struct {// Check checks for the WHERE clause requirement.func (*WhereRequirementForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, errors.Errorf("failed to convert to StmtNode")- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -47,10 +42,17 @@ func (*WhereRequirementForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_table_comment_convention.go b/backend/plugin/advisor/mysql/rule_table_comment_convention.goindex 1e090f55f9..5908aef55b 100644--- a/backend/plugin/advisor/mysql/rule_table_comment_convention.go+++ b/backend/plugin/advisor/mysql/rule_table_comment_convention.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -30,12 +31,6 @@ type TableCommentConventionAdvisor struct {// Check checks for table comment convention.func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- list, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -48,10 +43,17 @@ func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range list {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_table_disallow_ddl.go b/backend/plugin/advisor/mysql/rule_table_disallow_ddl.goindex aa633b4e40..7bbd5143bf 100644--- a/backend/plugin/advisor/mysql/rule_table_disallow_ddl.go+++ b/backend/plugin/advisor/mysql/rule_table_disallow_ddl.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -28,12 +29,6 @@ type TableDisallowDDLAdvisor struct {}func (*TableDisallowDDLAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- list, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,10 +41,17 @@ func (*TableDisallowDDLAdvisor) Check(_ context.Context, checkCtx advisor.Contex// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range list {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_table_disallow_dml.go b/backend/plugin/advisor/mysql/rule_table_disallow_dml.goindex fbc10e68eb..10c83f8fa2 100644--- a/backend/plugin/advisor/mysql/rule_table_disallow_dml.go+++ b/backend/plugin/advisor/mysql/rule_table_disallow_dml.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -28,12 +29,6 @@ type TableDisallowDMLAdvisor struct {}func (*TableDisallowDMLAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- list, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,10 +41,17 @@ func (*TableDisallowDMLAdvisor) Check(_ context.Context, checkCtx advisor.Contex// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range list {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_table_disallow_partition.go b/backend/plugin/advisor/mysql/rule_table_disallow_partition.goindex 72687a3c8b..623727b389 100644--- a/backend/plugin/advisor/mysql/rule_table_disallow_partition.go+++ b/backend/plugin/advisor/mysql/rule_table_disallow_partition.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -31,12 +32,6 @@ type TableDisallowPartitionAdvisor struct {// Check checks for disallow table partition.func (*TableDisallowPartitionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -48,10 +43,17 @@ func (*TableDisallowPartitionAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_table_disallow_set_charset.go b/backend/plugin/advisor/mysql/rule_table_disallow_set_charset.goindex 2e82c54c7a..ac5523efd7 100644--- a/backend/plugin/advisor/mysql/rule_table_disallow_set_charset.go+++ b/backend/plugin/advisor/mysql/rule_table_disallow_set_charset.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -27,12 +28,6 @@ type TableDisallowSetCharsetAdvisor struct {}func (*TableDisallowSetCharsetAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -44,10 +39,17 @@ func (*TableDisallowSetCharsetAdvisor) Check(_ context.Context, checkCtx advisor// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_table_disallow_trigger.go b/backend/plugin/advisor/mysql/rule_table_disallow_trigger.goindex f0501555c0..13ec95e0fb 100644--- a/backend/plugin/advisor/mysql/rule_table_disallow_trigger.go+++ b/backend/plugin/advisor/mysql/rule_table_disallow_trigger.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -29,12 +30,6 @@ type TableDisallowTriggerAdvisor struct {// Check checks for disallow table trigger.func (*TableDisallowTriggerAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,10 +41,17 @@ func (*TableDisallowTriggerAdvisor) Check(_ context.Context, checkCtx advisor.Co// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_table_drop_naming_convention.go b/backend/plugin/advisor/mysql/rule_table_drop_naming_convention.goindex 7d72b9ea54..a4e60ca3e1 100644--- a/backend/plugin/advisor/mysql/rule_table_drop_naming_convention.go+++ b/backend/plugin/advisor/mysql/rule_table_drop_naming_convention.go@@ -14,6 +14,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -33,11 +34,6 @@ type TableDropNamingConventionAdvisor struct {// Check checks for drop table naming convention.func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- list, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -58,10 +54,17 @@ func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range list {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_table_limit_size.go b/backend/plugin/advisor/mysql/rule_table_limit_size.goindex d6d7510d7c..ffe8d6f684 100644--- a/backend/plugin/advisor/mysql/rule_table_limit_size.go+++ b/backend/plugin/advisor/mysql/rule_table_limit_size.go@@ -4,11 +4,10 @@ import ("context""fmt"- "github.com/pkg/errors"-"github.com/bytebase/bytebase/backend/plugin/advisor/code""github.com/antlr4-go/antlr/v4"+ "github.com/pkg/errors""github.com/bytebase/parser/mysql"@@ -17,6 +16,7 @@ import (mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")func init() {@@ -37,12 +37,6 @@ func (*MaximumTableSizeAdvisor) Check(_ context.Context, checkCtx advisor.Contexreturn nil, errors.New("number_payload is required for this rule")}- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-// User defined rule level.status, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {@@ -51,9 +45,17 @@ func (*MaximumTableSizeAdvisor) Check(_ context.Context, checkCtx advisor.Contexvar adviceList []*storepb.Advice- for _, parsedResult := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+statTypeChecker := &mysqlparser.StatementTypeChecker{}- antlr.ParseTreeWalkerDefault.Walk(statTypeChecker, parsedResult.Tree)+ antlr.ParseTreeWalkerDefault.Walk(statTypeChecker, antlrAST.Tree)if statTypeChecker.IsDDL {// Create the rule@@ -62,9 +64,9 @@ func (*MaximumTableSizeAdvisor) Check(_ context.Context, checkCtx advisor.Contex// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- rule.SetBaseLine(parsedResult.BaseLine)- checker.SetBaseLine(parsedResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parsedResult.Tree)+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)// Generate advice based on collected table informationrule.generateAdvice()diff --git a/backend/plugin/advisor/mysql/rule_table_no_duplicate_index.go b/backend/plugin/advisor/mysql/rule_table_no_duplicate_index.goindex 5b3c0c45db..a2f8cfa8e0 100644--- a/backend/plugin/advisor/mysql/rule_table_no_duplicate_index.go+++ b/backend/plugin/advisor/mysql/rule_table_no_duplicate_index.go@@ -16,6 +16,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -33,12 +34,6 @@ type TableNoDuplicateIndexAdvisor struct {// Check checks for no duplicate index in table.func (*TableNoDuplicateIndexAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -50,10 +45,17 @@ func (*TableNoDuplicateIndexAdvisor) Check(_ context.Context, checkCtx advisor.C// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_table_no_fk.go b/backend/plugin/advisor/mysql/rule_table_no_fk.goindex f3f27ca949..c4c9b1a225 100644--- a/backend/plugin/advisor/mysql/rule_table_no_fk.go+++ b/backend/plugin/advisor/mysql/rule_table_no_fk.go@@ -14,6 +14,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -33,11 +34,6 @@ type TableNoFKAdvisor struct {// Check checks table disallow foreign key.func (*TableNoFKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- root, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -49,10 +45,17 @@ func (*TableNoFKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range root {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_table_require_charset.go b/backend/plugin/advisor/mysql/rule_table_require_charset.goindex dce2cd4c3c..10160086fe 100644--- a/backend/plugin/advisor/mysql/rule_table_require_charset.go+++ b/backend/plugin/advisor/mysql/rule_table_require_charset.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -28,12 +29,6 @@ type TableRequireCharsetAdvisor struct {}func (*TableRequireCharsetAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -45,10 +40,17 @@ func (*TableRequireCharsetAdvisor) Check(_ context.Context, checkCtx advisor.Con// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_table_require_collation.go b/backend/plugin/advisor/mysql/rule_table_require_collation.goindex f34c2df84a..232f0f0828 100644--- a/backend/plugin/advisor/mysql/rule_table_require_collation.go+++ b/backend/plugin/advisor/mysql/rule_table_require_collation.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -28,12 +29,6 @@ type TableRequireCollationAdvisor struct {}func (*TableRequireCollationAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -45,10 +40,17 @@ func (*TableRequireCollationAdvisor) Check(_ context.Context, checkCtx advisor.C// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_table_require_pk.go b/backend/plugin/advisor/mysql/rule_table_require_pk.goindex 3c95861f0e..923b99b28f 100644--- a/backend/plugin/advisor/mysql/rule_table_require_pk.go+++ b/backend/plugin/advisor/mysql/rule_table_require_pk.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/store/model")@@ -37,12 +38,6 @@ type TableRequirePKAdvisor struct {// Check checks table requires PK.func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- root, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -54,10 +49,17 @@ func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context)// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range root {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}// Generate advice after walkingdiff --git a/backend/plugin/advisor/mysql/rule_table_text_fields_total_length.go b/backend/plugin/advisor/mysql/rule_table_text_fields_total_length.goindex d444758225..26c4e8fd6a 100644--- a/backend/plugin/advisor/mysql/rule_table_text_fields_total_length.go+++ b/backend/plugin/advisor/mysql/rule_table_text_fields_total_length.go@@ -7,17 +7,17 @@ import ("strconv""strings"- "github.com/pkg/errors"-"github.com/bytebase/bytebase/backend/plugin/advisor/code""github.com/antlr4-go/antlr/v4"+ "github.com/pkg/errors""github.com/bytebase/parser/mysql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/store/model")@@ -34,12 +34,6 @@ type TableMaximumVarcharLengthAdvisor struct {}func (*TableMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -55,10 +49,17 @@ func (*TableMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_use_innodb.go b/backend/plugin/advisor/mysql/rule_use_innodb.goindex 5f58a851a5..9b1d757446 100644--- a/backend/plugin/advisor/mysql/rule_use_innodb.go+++ b/backend/plugin/advisor/mysql/rule_use_innodb.go@@ -6,7 +6,6 @@ import ("strings""github.com/antlr4-go/antlr/v4"- "github.com/pkg/errors""github.com/bytebase/parser/mysql"@@ -14,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"advisorcode "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -35,11 +35,6 @@ type UseInnoDBAdvisor struct {// Check checks for using InnoDB engine.func (*UseInnoDBAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- list, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, errors.Errorf("failed to convert to Tree")- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -51,10 +46,17 @@ func (*UseInnoDBAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range list {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/mysql/rule_view_disallow_create.go b/backend/plugin/advisor/mysql/rule_view_disallow_create.goindex 7170da122f..9960ecffdf 100644--- a/backend/plugin/advisor/mysql/rule_view_disallow_create.go+++ b/backend/plugin/advisor/mysql/rule_view_disallow_create.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"advisorcode "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -29,12 +30,6 @@ type ViewDisallowCreateAdvisor struct {// Check checks for disallow creating view.func (*ViewDisallowCreateAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,10 +41,17 @@ func (*ViewDisallowCreateAdvisor) Check(_ context.Context, checkCtx advisor.Cont// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {rule.SetBaseLine(stmt.BaseLine)checker.SetBaseLine(stmt.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/oceanbase/advisor_disallow_offline_ddl.go b/backend/plugin/advisor/oceanbase/advisor_disallow_offline_ddl.goindex efa118d77f..7c29bacb7a 100644--- a/backend/plugin/advisor/oceanbase/advisor_disallow_offline_ddl.go+++ b/backend/plugin/advisor/oceanbase/advisor_disallow_offline_ddl.go@@ -16,6 +16,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -33,12 +34,6 @@ type DisallowOfflineDdlAdvisor struct {// Check checks for disallow Offline DDL.func (*DisallowOfflineDdlAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -51,9 +46,16 @@ func (*DisallowOfflineDdlAdvisor) Check(_ context.Context, checkCtx advisor.ContcurrentDB: checkCtx.CurrentDatabase,}- for _, stmtNode := range stmtList {- checker.baseLine = stmtNode.BaseLine- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ checker.baseLine = stmt.BaseLine+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.adviceList, nildiff --git a/backend/plugin/advisor/oceanbase/advisor_insert_row_limit.go b/backend/plugin/advisor/oceanbase/advisor_insert_row_limit.goindex 0bcaa55fca..db2cf4b749 100644--- a/backend/plugin/advisor/oceanbase/advisor_insert_row_limit.go+++ b/backend/plugin/advisor/oceanbase/advisor_insert_row_limit.go@@ -14,6 +14,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -31,12 +32,6 @@ type InsertRowLimitAdvisor struct {// Check checks for insert row limit.func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- list, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -55,9 +50,16 @@ func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Contexctx: ctx,}- for _, stmt := range list {+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }checker.baseLine = stmt.BaseLine- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)if checker.explainCount >= common.MaximumLintExplainSize {break}diff --git a/backend/plugin/advisor/oceanbase/advisor_statement_affected_row_limit.go b/backend/plugin/advisor/oceanbase/advisor_statement_affected_row_limit.goindex 9b075092c6..2ebf623ab2 100644--- a/backend/plugin/advisor/oceanbase/advisor_statement_affected_row_limit.go+++ b/backend/plugin/advisor/oceanbase/advisor_statement_affected_row_limit.go@@ -15,6 +15,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -32,12 +33,6 @@ type StatementAffectedRowLimitAdvisor struct {// Check checks for UPDATE/DELETE affected row limit.func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -55,9 +50,16 @@ func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx adv}if checker.driver != nil {- for _, stmt := range stmtList {+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }checker.baseLine = stmt.BaseLine- antlr.ParseTreeWalkerDefault.Walk(checker, stmt.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)if checker.explainCount >= common.MaximumLintExplainSize {break}diff --git a/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.goindex d58bb453b1..6bcef4d016 100644--- a/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.go@@ -32,12 +32,6 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx advreturn nil, nil}- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,10 +40,17 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx advrule := NewStatementPriorBackupCheckRule(ctx, level, checkCtx.Rule.Type.String(), checkCtx)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()@@ -80,14 +81,21 @@ type statementInfo struct {table *TableReference}-func prepareTransformation(databaseName string, parseResults []*base.ParseResult) []statementInfo {+func prepareTransformation(databaseName string, parsedStatements []base.ParsedStatement) []statementInfo {extractor := &dmlExtractor{databaseName: databaseName,}// Walk each parse result tree to extract DML statements- for _, result := range parseResults {- antlr.ParseTreeWalkerDefault.Walk(extractor, result.Tree)+ for _, stmt := range parsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(extractor, antlrAST.Tree)}return extractor.dmls@@ -274,11 +282,7 @@ func (r *StatementPriorBackupCheckRule) handleSQLScriptExit() {})}- parseResults, err := advisor.GetANTLRParseResults(r.checkCtx)- if err != nil {- return- }- statementInfoList := prepareTransformation(r.checkCtx.DBSchema.Name, parseResults)+ statementInfoList := prepareTransformation(r.checkCtx.DBSchema.Name, r.checkCtx.ParsedStatements)groupByTable := make(map[string][]statementInfo)for _, item := range statementInfoList {diff --git a/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.go b/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.goindex c8a3a08241..a2f433c9a7 100644--- a/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.go+++ b/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.go@@ -5,14 +5,14 @@ import ("context""fmt"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-"github.com/antlr4-go/antlr/v4"parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -29,12 +29,6 @@ type ColumnAddNotNullColumnRequireDefaultAdvisor struct {// Check checks for adding not null column requires default.func (*ColumnAddNotNullColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -43,10 +37,17 @@ func (*ColumnAddNotNullColumnRequireDefaultAdvisor) Check(_ context.Context, cherule := NewColumnAddNotNullColumnRequireDefaultRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_column_comment_convention.go b/backend/plugin/advisor/oracle/rule_column_comment_convention.goindex ed7ebfdc13..17b60f23d0 100644--- a/backend/plugin/advisor/oracle/rule_column_comment_convention.go+++ b/backend/plugin/advisor/oracle/rule_column_comment_convention.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")@@ -28,12 +29,6 @@ type ColumnCommentConventionAdvisor struct {}func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -43,10 +38,17 @@ func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisorrule := NewColumnCommentConventionRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase, commentPayload)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_column_maximum_character_length.go b/backend/plugin/advisor/oracle/rule_column_maximum_character_length.goindex 71d78c12c7..6b25a5ebc9 100644--- a/backend/plugin/advisor/oracle/rule_column_maximum_character_length.go+++ b/backend/plugin/advisor/oracle/rule_column_maximum_character_length.go@@ -8,14 +8,14 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-"github.com/antlr4-go/antlr/v4"parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -32,12 +32,6 @@ type ColumnMaximumCharacterLengthAdvisor struct {// Check checks for maximum character length.func (*ColumnMaximumCharacterLengthAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -54,10 +48,17 @@ func (*ColumnMaximumCharacterLengthAdvisor) Check(_ context.Context, checkCtx adrule := NewColumnMaximumCharacterLengthRule(level, checkCtx.Rule.Type.String(), int(numberPayload.Number))checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.go b/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.goindex 8add5f019d..86f65dd5cc 100644--- a/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.go+++ b/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.go@@ -8,14 +8,14 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-"github.com/antlr4-go/antlr/v4"parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -32,12 +32,6 @@ type ColumnMaximumVarcharLengthAdvisor struct {// Check checks for maximum varchar length.func (*ColumnMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -54,10 +48,17 @@ func (*ColumnMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advirule := NewColumnMaximumVarcharLengthRule(level, checkCtx.Rule.Type.String(), int(numberPayload.Number))checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_column_no_null.go b/backend/plugin/advisor/oracle/rule_column_no_null.goindex e0e3ecba6b..e103abe823 100644--- a/backend/plugin/advisor/oracle/rule_column_no_null.go+++ b/backend/plugin/advisor/oracle/rule_column_no_null.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -31,12 +32,6 @@ type ColumnNoNullAdvisor struct {// Check checks for column no NULL value.func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -45,10 +40,17 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (rule := NewColumnNoNullRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_column_require.go b/backend/plugin/advisor/oracle/rule_column_require.goindex e229a1f22d..521e4af875 100644--- a/backend/plugin/advisor/oracle/rule_column_require.go+++ b/backend/plugin/advisor/oracle/rule_column_require.go@@ -9,14 +9,14 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-"github.com/antlr4-go/antlr/v4"parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -33,12 +33,6 @@ type ColumnRequireAdvisor struct {// Check checks for column requirement.func (*ColumnRequireAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -51,10 +45,17 @@ func (*ColumnRequireAdvisor) Check(_ context.Context, checkCtx advisor.Context)rule := NewColumnRequireRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase, stringArrayPayload.List)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_column_require_default.go b/backend/plugin/advisor/oracle/rule_column_require_default.goindex aa87996b0b..0dcc9160cb 100644--- a/backend/plugin/advisor/oracle/rule_column_require_default.go+++ b/backend/plugin/advisor/oracle/rule_column_require_default.go@@ -6,14 +6,14 @@ import ("fmt""slices"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-"github.com/antlr4-go/antlr/v4"parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -30,12 +30,6 @@ type ColumnRequireDefaultAdvisor struct {// Check checks for column default requirement.func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -44,10 +38,17 @@ func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Corule := NewColumnRequireDefaultRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_column_type_disallow_list.go b/backend/plugin/advisor/oracle/rule_column_type_disallow_list.goindex 33f6323ed1..8794072d70 100644--- a/backend/plugin/advisor/oracle/rule_column_type_disallow_list.go+++ b/backend/plugin/advisor/oracle/rule_column_type_disallow_list.go@@ -5,14 +5,14 @@ import ("context""fmt"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-"github.com/antlr4-go/antlr/v4"parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")@@ -30,12 +30,6 @@ type ColumnTypeDisallowListAdvisor struct {// Check checks for column type disallow list.func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,10 +40,17 @@ func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.rule := NewColumnTypeDisallowListRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase, stringArrayPayload.List)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_index_key_number_limit.go b/backend/plugin/advisor/oracle/rule_index_key_number_limit.goindex e35dcd7994..f664147901 100644--- a/backend/plugin/advisor/oracle/rule_index_key_number_limit.go+++ b/backend/plugin/advisor/oracle/rule_index_key_number_limit.go@@ -7,14 +7,14 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-"github.com/antlr4-go/antlr/v4"parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -31,12 +31,6 @@ type IndexKeyNumberLimitAdvisor struct {// Check checks for index key number limit.func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -53,10 +47,17 @@ func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Conrule := NewIndexKeyNumberLimitRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase, int(numberPayload.Number))checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_insert_must_specify_column.go b/backend/plugin/advisor/oracle/rule_insert_must_specify_column.goindex b6cc7f6605..30222d4d37 100644--- a/backend/plugin/advisor/oracle/rule_insert_must_specify_column.go+++ b/backend/plugin/advisor/oracle/rule_insert_must_specify_column.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,12 +28,6 @@ type InsertMustSpecifyColumnAdvisor struct {// Check checks for to enforce column specified.func (*InsertMustSpecifyColumnAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -41,10 +36,17 @@ func (*InsertMustSpecifyColumnAdvisor) Check(_ context.Context, checkCtx advisorrule := NewInsertMustSpecifyColumnRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_naming_identifier_case.go b/backend/plugin/advisor/oracle/rule_naming_identifier_case.goindex b649d9e04d..2c668b04c7 100644--- a/backend/plugin/advisor/oracle/rule_naming_identifier_case.go+++ b/backend/plugin/advisor/oracle/rule_naming_identifier_case.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -29,12 +30,6 @@ type NamingIdentifierCaseAdvisor struct {// Check checks for identifier case.func (*NamingIdentifierCaseAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -44,10 +39,17 @@ func (*NamingIdentifierCaseAdvisor) Check(_ context.Context, checkCtx advisor.Corule := NewNamingIdentifierCaseRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase, namingCasePayload.Upper)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.go b/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.goindex 03a8041f64..b8a3b21699 100644--- a/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.go+++ b/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.go@@ -5,14 +5,14 @@ import ("context""fmt"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-"github.com/antlr4-go/antlr/v4"parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")@@ -30,12 +30,6 @@ type NamingIdentifierNoKeywordAdvisor struct {// Check checks for identifier naming convention without keyword.func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -44,10 +38,17 @@ func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advisrule := NewNamingIdentifierNoKeywordRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_naming_table.go b/backend/plugin/advisor/oracle/rule_naming_table.goindex c99de6541a..dd14865f97 100644--- a/backend/plugin/advisor/oracle/rule_naming_table.go+++ b/backend/plugin/advisor/oracle/rule_naming_table.go@@ -14,6 +14,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -30,12 +31,6 @@ type NamingTableAdvisor struct {// Check checks for table naming convention.func (*NamingTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -58,10 +53,17 @@ func (*NamingTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([rule := NewNamingTableRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase, format, maxLength)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.go b/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.goindex ca62d5c6ce..d3183f6d9d 100644--- a/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.go+++ b/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.go@@ -5,14 +5,14 @@ import ("context""fmt"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-"github.com/antlr4-go/antlr/v4"parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")@@ -30,12 +30,6 @@ type NamingTableNoKeywordAdvisor struct {// Check checks for table naming convention without keyword.func (*NamingTableNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -44,10 +38,17 @@ func (*NamingTableNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Corule := NewNamingTableNoKeywordRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_select_no_select_all.go b/backend/plugin/advisor/oracle/rule_select_no_select_all.goindex ca26c9b12d..64ba6df3ca 100644--- a/backend/plugin/advisor/oracle/rule_select_no_select_all.go+++ b/backend/plugin/advisor/oracle/rule_select_no_select_all.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,12 +28,6 @@ type SelectNoSelectAllAdvisor struct {// Check checks for no select all.func (*SelectNoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -41,10 +36,17 @@ func (*SelectNoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Conterule := NewSelectNoSelectAllRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.go b/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.goindex 25ef8aaa04..2c9b455610 100644--- a/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.go+++ b/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/plugin/parser/plsql")@@ -28,12 +29,6 @@ type StatementDmlDryRunAdvisor struct {}func (*StatementDmlDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -43,10 +38,17 @@ func (*StatementDmlDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Cochecker := NewGenericChecker([]Rule{rule})if checkCtx.Driver != nil {- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}}diff --git a/backend/plugin/advisor/oracle/rule_table_comment_convention.go b/backend/plugin/advisor/oracle/rule_table_comment_convention.goindex 22f06f22f2..bfc63e7a29 100644--- a/backend/plugin/advisor/oracle/rule_table_comment_convention.go+++ b/backend/plugin/advisor/oracle/rule_table_comment_convention.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")@@ -28,12 +29,6 @@ type TableCommentConventionAdvisor struct {}func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -43,10 +38,17 @@ func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.rule := NewTableCommentConventionRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase, commentPayload)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_table_no_foreign_key.go b/backend/plugin/advisor/oracle/rule_table_no_foreign_key.goindex 784ea6ea8f..32283799ac 100644--- a/backend/plugin/advisor/oracle/rule_table_no_foreign_key.go+++ b/backend/plugin/advisor/oracle/rule_table_no_foreign_key.go@@ -5,14 +5,14 @@ import ("context""fmt"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-"github.com/antlr4-go/antlr/v4"parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -29,12 +29,6 @@ type TableNoForeignKeyAdvisor struct {// Check checks for table disallow foreign key.func (*TableNoForeignKeyAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -43,10 +37,17 @@ func (*TableNoForeignKeyAdvisor) Check(_ context.Context, checkCtx advisor.Conterule := NewTableNoForeignKeyRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_table_require_pk.go b/backend/plugin/advisor/oracle/rule_table_require_pk.goindex fe13f7c066..5a5a45bf8f 100644--- a/backend/plugin/advisor/oracle/rule_table_require_pk.go+++ b/backend/plugin/advisor/oracle/rule_table_require_pk.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -28,12 +29,6 @@ type TableRequirePKAdvisor struct {// Check checks table requires PK.func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -42,10 +37,17 @@ func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context)rule := NewTableRequirePKRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_where_no_leading_wildcard_like.go b/backend/plugin/advisor/oracle/rule_where_no_leading_wildcard_like.goindex 6d3333180f..6a46fe5548 100644--- a/backend/plugin/advisor/oracle/rule_where_no_leading_wildcard_like.go+++ b/backend/plugin/advisor/oracle/rule_where_no_leading_wildcard_like.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -28,12 +29,6 @@ type WhereNoLeadingWildcardLikeAdvisor struct {// Check checks for no leading wildcard LIKE.func (*WhereNoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -42,10 +37,17 @@ func (*WhereNoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx advirule := NewWhereNoLeadingWildcardLikeRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_where_require_for_select.go b/backend/plugin/advisor/oracle/rule_where_require_for_select.goindex e8de2147ac..a33a808af0 100644--- a/backend/plugin/advisor/oracle/rule_where_require_for_select.go+++ b/backend/plugin/advisor/oracle/rule_where_require_for_select.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -28,12 +29,6 @@ type WhereRequireForSelectAdvisor struct {// Check checks for WHERE clause requirement.func (*WhereRequireForSelectAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -42,10 +37,17 @@ func (*WhereRequireForSelectAdvisor) Check(_ context.Context, checkCtx advisor.Crule := NewWhereRequireForSelectRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_where_require_for_update_delete.go b/backend/plugin/advisor/oracle/rule_where_require_for_update_delete.goindex a59ab78702..086a1f9b7f 100644--- a/backend/plugin/advisor/oracle/rule_where_require_for_update_delete.go+++ b/backend/plugin/advisor/oracle/rule_where_require_for_update_delete.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,12 +28,6 @@ type WhereRequireForUpdateDeleteAdvisor struct {// Check checks for WHERE clause requirement.func (*WhereRequireForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtList, err := advisor.GetANTLRParseResults(checkCtx)-- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -41,10 +36,17 @@ func (*WhereRequireForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx advrule := NewWhereRequireForUpdateDeleteRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- for _, stmtNode := range stmtList {- rule.SetBaseLine(stmtNode.BaseLine)- checker.SetBaseLine(stmtNode.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtNode.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList()diff --git a/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go b/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.goindex cb7e905ee6..6813d3701f 100644--- a/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go@@ -41,11 +41,6 @@ func (*BuiltinPriorBackupCheckAdvisor) Check(_ context.Context, checkCtx advisorreturn nil, nil}- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -55,18 +50,25 @@ func (*BuiltinPriorBackupCheckAdvisor) Check(_ context.Context, checkCtx advisorvar adviceList []*storepb.Advice// Check for DDL statements in DML context- for _, stmtInfo := range stmtInfos {+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }rule := &ddlRule{BaseRule: BaseRule{level: level,title: title,},- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,}- rule.SetBaseLine(stmtInfo.BaseLine)+ rule.SetBaseLine(stmt.BaseLine)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}@@ -83,11 +85,7 @@ func (*BuiltinPriorBackupCheckAdvisor) Check(_ context.Context, checkCtx advisor}// Check statement type consistency for each table- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, errors.Wrapf(err, "failed to get parse results")- }- statementInfoList := prepareTransformation(parseResults)+ statementInfoList := prepareTransformation(checkCtx.ParsedStatements)groupByTable := make(map[string][]statementInfo)for _, item := range statementInfoList {@@ -284,10 +282,17 @@ type statementInfo struct {table *TableReference}-func prepareTransformation(parseResults []*base.ParseResult) []statementInfo {+func prepareTransformation(parsedStatements []base.ParsedStatement) []statementInfo {extractor := &dmlExtractor{}- for _, parseResult := range parseResults {- antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)+ for _, stmt := range parsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ antlr.ParseTreeWalkerDefault.Walk(extractor, antlrAST.Tree)}return extractor.dmls}diff --git a/backend/plugin/advisor/pg/advisor_collation_allowlist.go b/backend/plugin/advisor/pg/advisor_collation_allowlist.goindex 9c458d600c..1c29d8cea3 100644--- a/backend/plugin/advisor/pg/advisor_collation_allowlist.go+++ b/backend/plugin/advisor/pg/advisor_collation_allowlist.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,11 +28,6 @@ type CollationAllowlistAdvisor struct {// Check checks for collation allowlist.func (*CollationAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -53,11 +49,18 @@ func (*CollationAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Contchecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- rule.tokens = parseResult.Tokens- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ rule.tokens = antlrAST.Tokens+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_column_comment_convention.go b/backend/plugin/advisor/pg/advisor_column_comment_convention.goindex 378be881fa..04572ed12b 100644--- a/backend/plugin/advisor/pg/advisor_column_comment_convention.go+++ b/backend/plugin/advisor/pg/advisor_column_comment_convention.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -27,11 +28,6 @@ type ColumnCommentConventionAdvisor struct {}func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -46,10 +42,17 @@ func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisorchecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}// Now validate all collected columns against commentsdiff --git a/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go b/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.goindex 6695074ec3..7f40fac1cb 100644--- a/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go+++ b/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -30,11 +31,6 @@ type ColumnDefaultDisallowVolatileAdvisor struct {// Check checks for column default volatile functions.func (*ColumnDefaultDisallowVolatileAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -50,10 +46,17 @@ func (*ColumnDefaultDisallowVolatileAdvisor) Check(_ context.Context, checkCtx achecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go b/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.goindex bc7bc3e9db..fc603a8647 100644--- a/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go+++ b/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -28,11 +29,6 @@ type ColumnDisallowChangingTypeAdvisor struct {// Check checks for disallow changing column type.func (*ColumnDisallowChangingTypeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -47,11 +43,18 @@ func (*ColumnDisallowChangingTypeAdvisor) Check(_ context.Context, checkCtx advichecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- rule.tokens = parseResult.Tokens- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ rule.tokens = antlrAST.Tokens+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go b/backend/plugin/advisor/pg/advisor_column_maximum_character_length.goindex 40d5fa130d..c50414f8bc 100644--- a/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go+++ b/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go@@ -14,6 +14,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -31,11 +32,6 @@ type ColumnMaximumCharacterLengthAdvisor struct {// Check checks for maximum character length.func (*ColumnMaximumCharacterLengthAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -59,10 +55,17 @@ func (*ColumnMaximumCharacterLengthAdvisor) Check(_ context.Context, checkCtx adchecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_column_no_null.go b/backend/plugin/advisor/pg/advisor_column_no_null.goindex ee2a498773..853a97f334 100644--- a/backend/plugin/advisor/pg/advisor_column_no_null.go+++ b/backend/plugin/advisor/pg/advisor_column_no_null.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/plugin/parser/pg""github.com/bytebase/bytebase/backend/store/model")@@ -30,11 +31,6 @@ type ColumnNoNullAdvisor struct {// Check checks for column no NULL value.func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -51,10 +47,17 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}// Generate advice after all parse trees have been walkeddiff --git a/backend/plugin/advisor/pg/advisor_column_require_default.go b/backend/plugin/advisor/pg/advisor_column_require_default.goindex 93af1b79e4..a88f99f65c 100644--- a/backend/plugin/advisor/pg/advisor_column_require_default.go+++ b/backend/plugin/advisor/pg/advisor_column_require_default.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -30,11 +31,6 @@ type ColumnRequireDefaultAdvisor struct {// Check checks for column default requirement.func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -49,10 +45,17 @@ func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Cochecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_column_required.go b/backend/plugin/advisor/pg/advisor_column_required.goindex 38289c7c8e..fe4a88bce3 100644--- a/backend/plugin/advisor/pg/advisor_column_required.go+++ b/backend/plugin/advisor/pg/advisor_column_required.go@@ -16,6 +16,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -35,11 +36,6 @@ type ColumnRequirementAdvisor struct {// Check checks for the column requirement.func (*ColumnRequirementAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -66,10 +62,17 @@ func (*ColumnRequirementAdvisor) Check(_ context.Context, checkCtx advisor.Contechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go b/backend/plugin/advisor/pg/advisor_column_type_disallow_list.goindex c7ea636e0b..4f83f593bb 100644--- a/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go+++ b/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -30,11 +31,6 @@ type ColumnTypeDisallowListAdvisor struct {// Check checks for column type restriction.func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -58,10 +54,17 @@ func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_comment_convention.go b/backend/plugin/advisor/pg/advisor_comment_convention.goindex b6df82d7e5..1dca522976 100644--- a/backend/plugin/advisor/pg/advisor_comment_convention.go+++ b/backend/plugin/advisor/pg/advisor_comment_convention.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -29,11 +30,6 @@ type CommentConventionAdvisor struct {// Check checks for comment length.func (*CommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -54,10 +50,17 @@ func (*CommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Contechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_encoding_allowlist.go b/backend/plugin/advisor/pg/advisor_encoding_allowlist.goindex a988bfb36d..9f5c6c083e 100644--- a/backend/plugin/advisor/pg/advisor_encoding_allowlist.go+++ b/backend/plugin/advisor/pg/advisor_encoding_allowlist.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -28,11 +29,6 @@ type EncodingAllowlistAdvisor struct {// Check checks for encoding allowlist.func (*EncodingAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -56,10 +52,17 @@ func (*EncodingAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Contechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_index_create_concurrently.go b/backend/plugin/advisor/pg/advisor_index_create_concurrently.goindex 2a412756fd..3044a1bb00 100644--- a/backend/plugin/advisor/pg/advisor_index_create_concurrently.go+++ b/backend/plugin/advisor/pg/advisor_index_create_concurrently.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,11 +28,6 @@ type IndexConcurrentlyAdvisor struct {// Check checks for to create index concurrently.func (*IndexConcurrentlyAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -47,10 +43,17 @@ func (*IndexConcurrentlyAdvisor) Check(_ context.Context, checkCtx advisor.Contechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_index_key_number_limit.go b/backend/plugin/advisor/pg/advisor_index_key_number_limit.goindex 41e5c394f8..5754e3d9fb 100644--- a/backend/plugin/advisor/pg/advisor_index_key_number_limit.go+++ b/backend/plugin/advisor/pg/advisor_index_key_number_limit.go@@ -14,6 +14,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -31,11 +32,6 @@ type IndexKeyNumberLimitAdvisor struct {// Check checks for index key number limit.func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -56,10 +52,17 @@ func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Conchecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go b/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.goindex 0f363328b0..6c06228455 100644--- a/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go+++ b/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -29,11 +30,6 @@ type IndexNoDuplicateColumnAdvisor struct {// Check checks for no duplicate columns in index.func (*IndexNoDuplicateColumnAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -48,10 +44,17 @@ func (*IndexNoDuplicateColumnAdvisor) Check(_ context.Context, checkCtx advisor.checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --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 94011d134c..7b0b94ce14 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@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -29,11 +30,6 @@ type IndexPrimaryKeyTypeAllowlistAdvisor struct {// Check checks for primary key type allowlist.func (*IndexPrimaryKeyTypeAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -48,10 +44,17 @@ func (*IndexPrimaryKeyTypeAllowlistAdvisor) Check(_ context.Context, checkCtx adchecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_index_total_number_limit.go b/backend/plugin/advisor/pg/advisor_index_total_number_limit.goindex 86ed5c52e5..6c0bb71cdd 100644--- a/backend/plugin/advisor/pg/advisor_index_total_number_limit.go+++ b/backend/plugin/advisor/pg/advisor_index_total_number_limit.go@@ -15,6 +15,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/store/model")@@ -32,11 +33,6 @@ type IndexTotalNumberLimitAdvisor struct {// Check checks for index total number limit.func (*IndexTotalNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -55,10 +51,17 @@ func (*IndexTotalNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Cchecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}rule.generateAdvice()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 47e6a4d15b..97a9c53e3b 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@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -28,29 +29,31 @@ 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) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &insertDisallowOrderByRandRule{BaseRule: BaseRule{level: level,title: checkCtx.Rule.Type.String(),},- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,}rule.SetBaseLine(stmtInfo.BaseLine)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}diff --git a/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go b/backend/plugin/advisor/pg/advisor_insert_must_specify_column.goindex 3398fa2ccc..045ab731cb 100644--- a/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go+++ b/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,29 +28,31 @@ type InsertMustSpecifyColumnAdvisor struct {// Check checks for to enforce column specified.func (*InsertMustSpecifyColumnAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &insertMustSpecifyColumnRule{BaseRule: BaseRule{level: level,title: checkCtx.Rule.Type.String(),},- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,}rule.SetBaseLine(stmtInfo.BaseLine)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}diff --git a/backend/plugin/advisor/pg/advisor_insert_row_limit.go b/backend/plugin/advisor/pg/advisor_insert_row_limit.goindex ae5ae6347d..06294cf6b8 100644--- a/backend/plugin/advisor/pg/advisor_insert_row_limit.go+++ b/backend/plugin/advisor/pg/advisor_insert_row_limit.go@@ -16,6 +16,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"advisorcode "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -32,11 +33,6 @@ type InsertRowLimitAdvisor struct {// Check checks for the INSERT row limit.func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -51,7 +47,14 @@ func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Contex}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &insertRowLimitRule{BaseRule: BaseRule{level: level,@@ -60,13 +63,13 @@ func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.ContexmaxRow: int(numberPayload.Number),driver: checkCtx.Driver,ctx: ctx,- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,UsePostgresDatabaseOwner: checkCtx.UsePostgresDatabaseOwner,}rule.SetBaseLine(stmtInfo.BaseLine)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}diff --git a/backend/plugin/advisor/pg/advisor_migration_compatibility.go b/backend/plugin/advisor/pg/advisor_migration_compatibility.goindex 5f18a0551d..76e90dae91 100644--- a/backend/plugin/advisor/pg/advisor_migration_compatibility.go+++ b/backend/plugin/advisor/pg/advisor_migration_compatibility.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"advisorcode "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,11 +28,6 @@ type CompatibilityAdvisor struct {// Check checks schema backward compatibility.func (*CompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -40,20 +36,27 @@ func (*CompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.Context)var adviceList []*storepb.AdvicelastCreateTable := ""- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &compatibilityRule{BaseRule: BaseRule{level: level,title: checkCtx.Rule.Type.String(),},- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,lastCreateTable: lastCreateTable,}checker := NewGenericChecker([]Rule{rule})rule.SetBaseLine(stmtInfo.BaseLine)checker.SetBaseLine(stmtInfo.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)lastCreateTable = rule.lastCreateTablediff --git a/backend/plugin/advisor/pg/advisor_naming_column.go b/backend/plugin/advisor/pg/advisor_naming_column.goindex 68ed5398a7..6fe1ee4465 100644--- a/backend/plugin/advisor/pg/advisor_naming_column.go+++ b/backend/plugin/advisor/pg/advisor_naming_column.go@@ -14,6 +14,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -31,11 +32,6 @@ type NamingColumnConventionAdvisor struct {// Check checks for column naming convention.func (*NamingColumnConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -67,10 +63,17 @@ func (*NamingColumnConventionAdvisor) Check(_ context.Context, checkCtx advisor.checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.goindex e1331e8b87..6f2765b36c 100644--- a/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go@@ -15,6 +15,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -32,11 +33,6 @@ type NamingFKConventionAdvisor struct {// Check checks for foreign key naming convention.func (*NamingFKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -73,10 +69,17 @@ func (*NamingFKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Contchecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go b/backend/plugin/advisor/pg/advisor_naming_fully_qualified.goindex 34e8a1c79f..be844c5db1 100644--- a/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go+++ b/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go@@ -30,30 +30,32 @@ type FullyQualifiedObjectNameAdvisor struct {// Check checks for fully qualified object names.func (*FullyQualifiedObjectNameAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &fullyQualifiedObjectNameRule{BaseRule: BaseRule{level: level,title: checkCtx.Rule.Type.String(),},dbMetadata: checkCtx.DBSchema,- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,}rule.SetBaseLine(stmtInfo.BaseLine)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}@@ -336,7 +338,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- parseResults, err := pgparser.ParsePostgreSQL(statement)+ parsedStatements, err := pgparser.ParsePostgreSQL(statement)if err != nil {return nil}@@ -346,9 +348,9 @@ func (r *fullyQualifiedObjectNameRule) findAllTablesInSelect(statement string) [schemaNameMap: r.getSchemaNameMapFromPublic(),}- for _, parseResult := range parseResults {- if parseResult.Tree != nil {- antlr.ParseTreeWalkerDefault.Walk(collector, parseResult.Tree)+ for _, antlrAST := range parsedStatements {+ if antlrAST != nil && antlrAST.Tree != nil {+ antlr.ParseTreeWalkerDefault.Walk(collector, antlrAST.Tree)}}diff --git a/backend/plugin/advisor/pg/advisor_naming_index_convention.go b/backend/plugin/advisor/pg/advisor_naming_index_convention.goindex 827aa496f7..5ef7bd65ad 100644--- a/backend/plugin/advisor/pg/advisor_naming_index_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_index_convention.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg""github.com/bytebase/bytebase/backend/store/model")@@ -30,11 +31,6 @@ type NamingIndexConventionAdvisor struct {// Check checks for index naming convention.func (*NamingIndexConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -72,10 +68,17 @@ func (*NamingIndexConventionAdvisor) Check(_ context.Context, checkCtx advisor.Cchecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.goindex d33eb3ddd7..03b623754a 100644--- a/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg""github.com/bytebase/bytebase/backend/store/model")@@ -30,11 +31,6 @@ type NamingPKConventionAdvisor struct {// Check checks for primary key naming convention.func (*NamingPKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -60,7 +56,14 @@ func (*NamingPKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Cont}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &namingPKConventionRule{BaseRule: BaseRule{level: level,@@ -75,7 +78,7 @@ func (*NamingPKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Contchecker := NewGenericChecker([]Rule{rule})rule.SetBaseLine(stmtInfo.BaseLine)checker.SetBaseLine(stmtInfo.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}diff --git a/backend/plugin/advisor/pg/advisor_naming_table.go b/backend/plugin/advisor/pg/advisor_naming_table.goindex b7b9942778..19d82c1c75 100644--- a/backend/plugin/advisor/pg/advisor_naming_table.go+++ b/backend/plugin/advisor/pg/advisor_naming_table.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -30,11 +31,6 @@ type NamingTableConventionAdvisor struct {// Check checks for table naming convention.func (*NamingTableConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -66,10 +62,17 @@ func (*NamingTableConventionAdvisor) Check(_ context.Context, checkCtx advisor.Cchecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.goindex b6dec21d7f..eed57d589a 100644--- a/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg""github.com/bytebase/bytebase/backend/store/model")@@ -31,11 +32,6 @@ type NamingUKConventionAdvisor struct {// Check checks for unique key naming convention.func (*NamingUKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -73,10 +69,17 @@ func (*NamingUKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Contchecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --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 d9c4ae810e..7fd46a9e4a 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@@ -10,6 +10,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -26,11 +27,6 @@ type StatementAddCheckNotValidAdvisor struct {// Check checks for to add check not valid.func (*StatementAddCheckNotValidAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -45,10 +41,17 @@ func (*StatementAddCheckNotValidAdvisor) Check(_ context.Context, checkCtx advischecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --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 aa7478ac5c..1409925940 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@@ -10,6 +10,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -26,11 +27,6 @@ type StatementAddFKNotValidAdvisor struct {// Check checks for adding foreign key constraints without NOT VALID.func (*StatementAddFKNotValidAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -45,10 +41,17 @@ func (*StatementAddFKNotValidAdvisor) Check(_ context.Context, checkCtx advisor.checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go b/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.goindex f94f563e93..1481f53012 100644--- a/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go+++ b/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go@@ -15,6 +15,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -31,11 +32,6 @@ type StatementAffectedRowLimitAdvisor struct {// Check checks for UPDATE/DELETE affected row limit.func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -51,7 +47,14 @@ func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx adv}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &statementAffectedRowLimitRule{BaseRule: BaseRule{level: level,@@ -61,12 +64,12 @@ func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx advctx: ctx,driver: checkCtx.Driver,usePostgresDatabaseOwner: checkCtx.UsePostgresDatabaseOwner,- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,}rule.SetBaseLine(stmtInfo.BaseLine)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}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 e46886b5c4..4d08d7aeb7 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@@ -10,6 +10,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -24,11 +25,6 @@ type StatementCheckSetRoleVariable struct {}func (*StatementCheckSetRoleVariable) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -43,10 +39,17 @@ func (*StatementCheckSetRoleVariable) Check(_ context.Context, checkCtx advisor.checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}if !rule.hasSetRole {diff --git a/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go b/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.goindex 65b9d9393f..412e8c88a0 100644--- a/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go+++ b/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go@@ -10,6 +10,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -24,11 +25,6 @@ type StatementCreateSpecifySchema struct {}func (*StatementCreateSpecifySchema) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -43,10 +39,17 @@ func (*StatementCreateSpecifySchema) Check(_ context.Context, checkCtx advisor.Cchecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --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 e1228c9717..37b6c32eae 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@@ -10,6 +10,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -26,11 +27,6 @@ type StatementDisallowAddColumnWithDefaultAdvisor struct {// Check checks for to disallow add column with default.func (*StatementDisallowAddColumnWithDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -45,10 +41,17 @@ func (*StatementDisallowAddColumnWithDefaultAdvisor) Check(_ context.Context, chchecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --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 7addd04e23..8ffd9a1a51 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@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -28,11 +29,6 @@ type StatementDisallowAddNotNullAdvisor struct {// Check checks for to disallow add not null.func (*StatementDisallowAddNotNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -47,10 +43,17 @@ func (*StatementDisallowAddNotNullAdvisor) Check(_ context.Context, checkCtx advchecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go b/backend/plugin/advisor/pg/advisor_statement_disallow_commit.goindex 2634cc6d5c..1ca2c3bffd 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,26 +28,28 @@ type StatementDisallowCommitAdvisor struct {// Check checks for disallowing COMMIT statements.func (*StatementDisallowCommitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &statementDisallowCommitRule{BaseRule: BaseRule{level: level, title: checkCtx.Rule.Type.String()},- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,}rule.SetBaseLine(stmtInfo.BaseLine)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}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 98042d895c..7f8f15faa0 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@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,30 +28,32 @@ type StatementDisallowOnDelCascadeAdvisor struct {// Check checks for ON DELETE CASCADE.func (*StatementDisallowOnDelCascadeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &statementDisallowOnDelCascadeRule{BaseRule: BaseRule{level: level,title: checkCtx.Rule.Type.String(),},- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,}checker := NewGenericChecker([]Rule{rule})rule.SetBaseLine(stmtInfo.BaseLine)checker.SetBaseLine(stmtInfo.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}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 8d9549b581..75f3a64c27 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@@ -10,6 +10,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -26,11 +27,6 @@ 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) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -45,10 +41,17 @@ func (*StatementDisallowRemoveTblCascadeAdvisor) Check(_ context.Context, checkCchecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go b/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.goindex 963cfdb24c..77159b4579 100644--- a/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go+++ b/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -28,11 +29,6 @@ type StatementDMLDryRunAdvisor struct {// Check checks for DML dry run.func (*StatementDMLDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -44,7 +40,14 @@ func (*StatementDMLDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Co}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &statementDMLDryRunRule{BaseRule: BaseRule{level: level,@@ -53,12 +56,12 @@ func (*StatementDMLDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Coctx: ctx,driver: checkCtx.Driver,usePostgresDatabaseOwner: checkCtx.UsePostgresDatabaseOwner,- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,}rule.SetBaseLine(stmtInfo.BaseLine)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}diff --git a/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.go b/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.goindex fa07514ae7..36765d97c1 100644--- a/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.go+++ b/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.go@@ -14,6 +14,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -30,11 +31,6 @@ type StatementMaximumLimitValueAdvisor struct {// Check checks for maximum LIMIT value.func (*StatementMaximumLimitValueAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -54,10 +50,17 @@ func (*StatementMaximumLimitValueAdvisor) Check(_ context.Context, checkCtx advichecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go b/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.goindex bf64d21e72..abb44418f7 100644--- a/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go+++ b/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,11 +28,6 @@ type StatementMergeAlterTableAdvisor struct {// Check checks for no redundant ALTER TABLE statements.func (*StatementMergeAlterTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -47,10 +43,17 @@ func (*StatementMergeAlterTableAdvisor) Check(_ context.Context, checkCtx advisochecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return rule.generateAdvice(), nildiff --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 012d5e1743..0498cf0c72 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@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")// Note: strings import is still needed for pattern checking (HasPrefix)@@ -29,30 +30,32 @@ type StatementNoLeadingWildcardLikeAdvisor struct {// Check checks for no leading wildcard LIKE.func (*StatementNoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &statementNoLeadingWildcardLikeRule{BaseRule: BaseRule{level: level,title: checkCtx.Rule.Type.String(),},- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,reportedStatements: make(map[antlr.ParserRuleContext]bool),}rule.SetBaseLine(stmtInfo.BaseLine)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}diff --git a/backend/plugin/advisor/pg/advisor_statement_no_select_all.go b/backend/plugin/advisor/pg/advisor_statement_no_select_all.goindex ad35ba60b6..f6b63cecb4 100644--- a/backend/plugin/advisor/pg/advisor_statement_no_select_all.go+++ b/backend/plugin/advisor/pg/advisor_statement_no_select_all.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,29 +28,31 @@ type NoSelectAllAdvisor struct {// Check checks for no "select *".func (*NoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &noSelectAllRule{BaseRule: BaseRule{level: level,title: checkCtx.Rule.Type.String(),},- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,}rule.SetBaseLine(stmtInfo.BaseLine)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}diff --git a/backend/plugin/advisor/pg/advisor_statement_non_transactional.go b/backend/plugin/advisor/pg/advisor_statement_non_transactional.goindex cfc1ad8aaa..4b9ffe6bd8 100644--- a/backend/plugin/advisor/pg/advisor_statement_non_transactional.go+++ b/backend/plugin/advisor/pg/advisor_statement_non_transactional.go@@ -11,6 +11,7 @@ import ("github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code""github.com/bytebase/bytebase/backend/plugin/db/pg"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,29 +28,31 @@ type NonTransactionalAdvisor struct {// Check checks for non-transactional statements.func (*NonTransactionalAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &nonTransactionalRule{BaseRule: BaseRule{level: level,title: checkCtx.Rule.Type.String(),},- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,}checker := NewGenericChecker([]Rule{rule})rule.SetBaseLine(stmtInfo.BaseLine)checker.SetBaseLine(stmtInfo.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}diff --git a/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go b/backend/plugin/advisor/pg/advisor_statement_object_owner_check.goindex 2fa302db11..5e35db9cd6 100644--- a/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go+++ b/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/plugin/parser/pg""github.com/bytebase/bytebase/backend/store/model")@@ -33,11 +34,6 @@ type StatementObjectOwnerCheckAdvisor struct {}func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -64,10 +60,17 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advchecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_statement_where_required_select.go b/backend/plugin/advisor/pg/advisor_statement_where_required_select.goindex dbdf30a6dc..a3a5ebbeac 100644--- a/backend/plugin/advisor/pg/advisor_statement_where_required_select.go+++ b/backend/plugin/advisor/pg/advisor_statement_where_required_select.go@@ -10,6 +10,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -26,29 +27,31 @@ type StatementWhereRequiredSelectAdvisor struct {// Check checks for WHERE clause requirement in SELECT statements.func (*StatementWhereRequiredSelectAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &statementWhereRequiredSelectRule{BaseRule: BaseRule{level: level,title: checkCtx.Rule.Type.String(),},- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,}rule.SetBaseLine(stmtInfo.BaseLine)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}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 3dfa41478e..d6152771fa 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@@ -10,6 +10,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -26,29 +27,31 @@ type StatementWhereRequiredUpdateDeleteAdvisor struct {// Check checks for WHERE clause requirement in UPDATE/DELETE statements.func (*StatementWhereRequiredUpdateDeleteAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &statementWhereRequiredRule{BaseRule: BaseRule{level: level,title: checkCtx.Rule.Type.String(),},- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,}rule.SetBaseLine(stmtInfo.BaseLine)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}diff --git a/backend/plugin/advisor/pg/advisor_table_comment_convention.go b/backend/plugin/advisor/pg/advisor_table_comment_convention.goindex b1924dfccf..803a75094f 100644--- a/backend/plugin/advisor/pg/advisor_table_comment_convention.go+++ b/backend/plugin/advisor/pg/advisor_table_comment_convention.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -27,11 +28,6 @@ type TableCommentConventionAdvisor struct {}func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -51,10 +47,17 @@ func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.checker := NewGenericChecker([]Rule{rule})- for _, stmtInfo := range stmtInfos {- rule.SetBaseLine(stmtInfo.BaseLine)- checker.SetBaseLine(stmtInfo.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}// Check each created table for comment requirementsdiff --git a/backend/plugin/advisor/pg/advisor_table_disallow_partition.go b/backend/plugin/advisor/pg/advisor_table_disallow_partition.goindex d30e3d2c69..b4da6a9c71 100644--- a/backend/plugin/advisor/pg/advisor_table_disallow_partition.go+++ b/backend/plugin/advisor/pg/advisor_table_disallow_partition.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -28,29 +29,31 @@ type TableDisallowPartitionAdvisor struct {// Check checks for partitioned tables.func (*TableDisallowPartitionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &tableDisallowPartitionRule{BaseRule: BaseRule{level: level,title: checkCtx.Rule.Type.String(),},- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,}rule.SetBaseLine(stmtInfo.BaseLine)checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}diff --git a/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go b/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.goindex 7d03c79c85..4b1ef3e255 100644--- a/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go+++ b/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go@@ -15,6 +15,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -32,11 +33,6 @@ type TableDropNamingConventionAdvisor struct {// Check checks for table drop with naming convention.func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -62,10 +58,17 @@ func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advischecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/pg/advisor_table_no_fk.go b/backend/plugin/advisor/pg/advisor_table_no_fk.goindex 9537621d96..fc442a4faa 100644--- a/backend/plugin/advisor/pg/advisor_table_no_fk.go+++ b/backend/plugin/advisor/pg/advisor_table_no_fk.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -28,29 +29,31 @@ type TableNoFKAdvisor struct {// Check checks table disallow foreign key.func (*TableNoFKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err}var adviceList []*storepb.Advice- for _, stmtInfo := range stmtInfos {+ for _, stmtInfo := range checkCtx.ParsedStatements {+ if stmtInfo.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)+ if !ok {+ continue+ }rule := &tableNoFKRule{BaseRule: BaseRule{level: level,title: checkCtx.Rule.Type.String(),},- tokens: stmtInfo.Tokens,+ tokens: antlrAST.Tokens,}checker := NewGenericChecker([]Rule{rule})checker.SetBaseLine(stmtInfo.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)adviceList = append(adviceList, checker.GetAdviceList()...)}diff --git a/backend/plugin/advisor/pg/advisor_table_require_pk.go b/backend/plugin/advisor/pg/advisor_table_require_pk.goindex 936f1de51e..0449dcc59e 100644--- a/backend/plugin/advisor/pg/advisor_table_require_pk.go+++ b/backend/plugin/advisor/pg/advisor_table_require_pk.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg""github.com/bytebase/bytebase/backend/store/model")@@ -29,11 +30,6 @@ type TableRequirePKAdvisor struct {// Check parses the given statement and checks for errors.func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- stmtInfos, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -50,11 +46,18 @@ func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context)checker := NewGenericChecker([]Rule{rule})- for _, stmtInfo := range stmtInfos {- rule.SetBaseLine(stmtInfo.BaseLine)- rule.tokens = stmtInfo.Tokens- checker.SetBaseLine(stmtInfo.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, stmtInfo.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ rule.tokens = antlrAST.Tokens+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}// Simple Solution: Validate final state after walking all statementsdiff --git a/backend/plugin/advisor/snowflake/rule_column_maximum_varchar_length.go b/backend/plugin/advisor/snowflake/rule_column_maximum_varchar_length.goindex dc49c6a29e..85abffc78b 100644--- a/backend/plugin/advisor/snowflake/rule_column_maximum_varchar_length.go+++ b/backend/plugin/advisor/snowflake/rule_column_maximum_varchar_length.go@@ -15,6 +15,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")const (@@ -37,11 +38,6 @@ type ColumnMaximumVarcharLengthAdvisor struct {// Check checks for maximum varchar length.func (*ColumnMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -61,10 +57,17 @@ func (*ColumnMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advi// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/snowflake/rule_column_no_null.go b/backend/plugin/advisor/snowflake/rule_column_no_null.goindex 4271da4840..06121c1b49 100644--- a/backend/plugin/advisor/snowflake/rule_column_no_null.go+++ b/backend/plugin/advisor/snowflake/rule_column_no_null.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"snowsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/snowflake")@@ -28,11 +29,6 @@ type ColumnNoNullAdvisor struct {// Check checks for column no NULL value.func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -44,10 +40,17 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/snowflake/rule_column_require.go b/backend/plugin/advisor/snowflake/rule_column_require.goindex 277417720b..8880e32fc6 100644--- a/backend/plugin/advisor/snowflake/rule_column_require.go+++ b/backend/plugin/advisor/snowflake/rule_column_require.go@@ -16,6 +16,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"snowsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/snowflake")@@ -33,11 +34,6 @@ type ColumnRequireAdvisor struct {// Check checks for column requirement.func (*ColumnRequireAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -55,10 +51,17 @@ func (*ColumnRequireAdvisor) Check(_ context.Context, checkCtx advisor.Context)rule := NewColumnRequireRule(level, checkCtx.Rule.Type.String(), requireColumns)checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/snowflake/rule_migration_compatibility.go b/backend/plugin/advisor/snowflake/rule_migration_compatibility.goindex 388922c9e0..4bf9e51a75 100644--- a/backend/plugin/advisor/snowflake/rule_migration_compatibility.go+++ b/backend/plugin/advisor/snowflake/rule_migration_compatibility.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"snowsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/snowflake")@@ -30,11 +31,6 @@ type MigrationCompatibilityAdvisor struct {// Check checks for migration compatibility.func (*MigrationCompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -43,10 +39,17 @@ func (*MigrationCompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.rule := NewMigrationCompatibilityRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/snowflake/rule_naming_identifier_case.go b/backend/plugin/advisor/snowflake/rule_naming_identifier_case.goindex e815f92738..38f4fb492f 100644--- a/backend/plugin/advisor/snowflake/rule_naming_identifier_case.go+++ b/backend/plugin/advisor/snowflake/rule_naming_identifier_case.go@@ -13,6 +13,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"snowsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/snowflake")@@ -30,11 +31,6 @@ type NamingIdentifierCaseAdvisor struct {// Check checks for identifier case.func (*NamingIdentifierCaseAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -43,10 +39,17 @@ func (*NamingIdentifierCaseAdvisor) Check(_ context.Context, checkCtx advisor.Corule := NewNamingIdentifierCaseRule(level, checkCtx.Rule.Type.String())checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/snowflake/rule_naming_identifier_no_keyword.go b/backend/plugin/advisor/snowflake/rule_naming_identifier_no_keyword.goindex 16b87c9bd7..d5382f637d 100644--- a/backend/plugin/advisor/snowflake/rule_naming_identifier_no_keyword.go+++ b/backend/plugin/advisor/snowflake/rule_naming_identifier_no_keyword.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"snowsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/snowflake")@@ -30,11 +31,6 @@ type NamingIdentifierNoKeywordAdvisor struct {// Check checks for identifier naming convention without keyword.func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -43,10 +39,17 @@ func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advisrule := NewNamingIdentifierNoKeywordRule(level, checkCtx.Rule.Type.String())checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/snowflake/rule_naming_table.go b/backend/plugin/advisor/snowflake/rule_naming_table.goindex 475a8a084c..e99f55fb7e 100644--- a/backend/plugin/advisor/snowflake/rule_naming_table.go+++ b/backend/plugin/advisor/snowflake/rule_naming_table.go@@ -16,6 +16,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -32,11 +33,6 @@ type NamingTableAdvisor struct {// Check checks for table naming convention.func (*NamingTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -59,10 +55,17 @@ func (*NamingTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([rule := NewNamingTableRule(level, checkCtx.Rule.Type.String(), format, maxLength)checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/snowflake/rule_naming_table_no_keyword.go b/backend/plugin/advisor/snowflake/rule_naming_table_no_keyword.goindex a57c91e1b1..0ec1878512 100644--- a/backend/plugin/advisor/snowflake/rule_naming_table_no_keyword.go+++ b/backend/plugin/advisor/snowflake/rule_naming_table_no_keyword.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"snowsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/snowflake")@@ -29,11 +30,6 @@ type NamingTableNoKeywordAdvisor struct {// Check checks for table naming convention without keyword.func (*NamingTableNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -42,10 +38,17 @@ func (*NamingTableNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Corule := NewNamingTableNoKeywordRule(level, checkCtx.Rule.Type.String())checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/snowflake/rule_select_no_select_all.go b/backend/plugin/advisor/snowflake/rule_select_no_select_all.goindex 872aa908a0..e7477de12a 100644--- a/backend/plugin/advisor/snowflake/rule_select_no_select_all.go+++ b/backend/plugin/advisor/snowflake/rule_select_no_select_all.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,11 +28,6 @@ type SelectNoSelectAllAdvisor struct {// Check checks for no select all.func (*SelectNoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -40,10 +36,17 @@ func (*SelectNoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Conterule := NewSelectNoSelectAllRule(level, checkCtx.Rule.Type.String())checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/snowflake/rule_table_drop_naming_convention.go b/backend/plugin/advisor/snowflake/rule_table_drop_naming_convention.goindex 5da33b13b0..03a143261a 100644--- a/backend/plugin/advisor/snowflake/rule_table_drop_naming_convention.go+++ b/backend/plugin/advisor/snowflake/rule_table_drop_naming_convention.go@@ -14,6 +14,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"snowsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/snowflake")@@ -31,11 +32,6 @@ type TableDropNamingConventionAdvisor struct {// Check checks for table drop with naming convention.func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -54,10 +50,17 @@ func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advisrule := NewTableDropNamingConventionRule(level, checkCtx.Rule.Type.String(), format)checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/snowflake/rule_table_no_foreign_key.go b/backend/plugin/advisor/snowflake/rule_table_no_foreign_key.goindex 32b28c2ce6..c7a1a7e7b5 100644--- a/backend/plugin/advisor/snowflake/rule_table_no_foreign_key.go+++ b/backend/plugin/advisor/snowflake/rule_table_no_foreign_key.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"snowsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/snowflake")@@ -29,11 +30,6 @@ type TableNoForeignKeyAdvisor struct {// Check checks for table disallow foreign key.func (*TableNoForeignKeyAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -42,10 +38,17 @@ func (*TableNoForeignKeyAdvisor) Check(_ context.Context, checkCtx advisor.Conterule := NewTableNoForeignKeyRule(level, checkCtx.Rule.Type.String())checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/snowflake/rule_table_require_pk.go b/backend/plugin/advisor/snowflake/rule_table_require_pk.goindex e64152429d..edcb8db57e 100644--- a/backend/plugin/advisor/snowflake/rule_table_require_pk.go+++ b/backend/plugin/advisor/snowflake/rule_table_require_pk.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"snowsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/snowflake")@@ -29,11 +30,6 @@ type TableRequirePkAdvisor struct {// Check checks for table require primary key.func (*TableRequirePkAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -42,10 +38,17 @@ func (*TableRequirePkAdvisor) Check(_ context.Context, checkCtx advisor.Context)rule := NewTableRequirePkRule(level, checkCtx.Rule.Type.String())checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/snowflake/rule_where_require_select.go b/backend/plugin/advisor/snowflake/rule_where_require_select.goindex 0098012f88..3d25b268e3 100644--- a/backend/plugin/advisor/snowflake/rule_where_require_select.go+++ b/backend/plugin/advisor/snowflake/rule_where_require_select.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,11 +28,6 @@ type WhereRequireForSelectAdvisor struct {// Check checks for WHERE clause requirement.func (*WhereRequireForSelectAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -40,10 +36,17 @@ func (*WhereRequireForSelectAdvisor) Check(_ context.Context, checkCtx advisor.Crule := NewWhereRequireForSelectRule(level, checkCtx.Rule.Type.String())checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/advisor/snowflake/rule_where_require_update_delete.go b/backend/plugin/advisor/snowflake/rule_where_require_update_delete.goindex e56bacfeaf..9ec217433a 100644--- a/backend/plugin/advisor/snowflake/rule_where_require_update_delete.go+++ b/backend/plugin/advisor/snowflake/rule_where_require_update_delete.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -27,11 +28,6 @@ type WhereRequireForUpdateDeleteAdvisor struct {// Check checks for WHERE clause requirement.func (*WhereRequireForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- parseResults, err := advisor.GetANTLRParseResults(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -40,10 +36,17 @@ func (*WhereRequireForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx advrule := NewWhereRequireForUpdateDeleteRule(level, checkCtx.Rule.Type.String())checker := NewGenericChecker([]Rule{rule})- for _, parseResult := range parseResults {- rule.SetBaseLine(parseResult.BaseLine)- checker.SetBaseLine(parseResult.BaseLine)- antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ for _, stmt := range checkCtx.ParsedStatements {+ if stmt.AST == nil {+ continue+ }+ antlrAST, ok := base.GetANTLRAST(stmt.AST)+ if !ok {+ continue+ }+ rule.SetBaseLine(stmt.BaseLine)+ checker.SetBaseLine(stmt.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}return checker.GetAdviceList(), nildiff --git a/backend/plugin/parser/base/base.go b/backend/plugin/parser/base/base.goindex 6c1a5c6e8c..1af93e1e4b 100644--- a/backend/plugin/parser/base/base.go+++ b/backend/plugin/parser/base/base.go@@ -113,18 +113,6 @@ func GetOffsetLength(total int) int {}}-// ParseResult is the result of parsing SQL statements.-type ParseResult struct {- Tree antlr.Tree- Tokens *antlr.CommonTokenStream- // BaseLine stores the zero-based line offset where this SQL statement starts in the original multi-statement input.- // When splitting a multi-statement SQL script (e.g., "SELECT 1;\nSELECT 2;"), each statement is parsed separately.- // BaseLine tracks the original line number (minus 1) of the first token in this statement, allowing error messages- // and positions to be correctly reported relative to the original script rather than the isolated statement.- // Calculated from StartPosition.Line - 1 (since StartPosition uses 1-based line numbers, but BaseLine is 0-based for offset arithmetic).- BaseLine int-}-// GetLineOffset returns the 0-based line offset from a StartPosition.// This is useful for converting from the 1-based StartPosition to the 0-based offset// needed for some calculations.diff --git a/backend/plugin/parser/bigquery/bigquery.go b/backend/plugin/parser/bigquery/bigquery.goindex 3f9973c9a6..9f14f8f3f7 100644--- a/backend/plugin/parser/bigquery/bigquery.go+++ b/backend/plugin/parser/bigquery/bigquery.go@@ -13,29 +13,29 @@ import ()// ParseBigQuerySQL parses the given SQL statement by using antlr4. Returns a list of AST and token stream if no error.-func ParseBigQuerySQL(statement string) ([]*base.ParseResult, error) {+func ParseBigQuerySQL(statement string) ([]*base.ANTLRAST, error) {stmts, err := SplitSQL(statement)if err != nil {return nil, err}- var result []*base.ParseResult+ var result []*base.ANTLRASTfor _, stmt := range stmts {if stmt.Empty {continue}- parseResult, err := parseSingleBigQuerySQL(stmt.Text, stmt.BaseLine)+ ast, err := parseSingleBigQuerySQL(stmt.Text, stmt.BaseLine)if err != nil {return nil, err}- result = append(result, parseResult)+ result = append(result, ast)}return result, nil}-func parseSingleBigQuerySQL(statement string, baseLine int) (*base.ParseResult, error) {+func parseSingleBigQuerySQL(statement string, baseLine int) (*base.ANTLRAST, error) {statement = strings.TrimRightFunc(statement, utils.IsSpaceOrSemicolon) + "\n;"inputStream := antlr.NewInputStream(statement)lexer := parser.NewGoogleSQLLexer(inputStream)@@ -70,11 +70,11 @@ func parseSingleBigQuerySQL(statement string, baseLine int) (*base.ParseResult,return nil, parserErrorListener.Err}- result := &base.ParseResult{- Tree: tree,- Tokens: stream,- BaseLine: baseLine,+ ast := &base.ANTLRAST{+ StartPosition: startPosition,+ Tree: tree,+ Tokens: stream,}- return result, nil+ return ast, nil}diff --git a/backend/plugin/parser/cassandra/cassandra.go b/backend/plugin/parser/cassandra/cassandra.goindex ca1348f486..cac46d92b2 100644--- a/backend/plugin/parser/cassandra/cassandra.go+++ b/backend/plugin/parser/cassandra/cassandra.go@@ -23,20 +23,11 @@ func parseCassandraForRegistry(statement string) ([]base.AST, error) {if err != nil {return nil, err}- return toAST(parseResults), nil-}--// toAST converts []*ParseResult to []base.AST.-func toAST(results []*base.ParseResult) []base.AST {- var asts []base.AST- for _, r := range results {- asts = append(asts, &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(r.BaseLine) + 1},- Tree: r.Tree,- Tokens: r.Tokens,- })+ asts := make([]base.AST, len(parseResults))+ for i, r := range parseResults {+ asts[i] = r}- return asts+ return asts, nil}// parseCassandraStatements is the ParseStatementsFunc for Cassandra.@@ -62,11 +53,7 @@ func parseCassandraStatements(statement string) ([]base.ParsedStatement, error)Statement: stmt,}if !stmt.Empty && astIndex < len(parseResults) {- ps.AST = &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},- Tree: parseResults[astIndex].Tree,- Tokens: parseResults[astIndex].Tokens,- }+ ps.AST = parseResults[astIndex]astIndex++}result = append(result, ps)@@ -76,13 +63,13 @@ func parseCassandraStatements(statement string) ([]base.ParsedStatement, error)}// ParseCassandraSQL parses the given CQL statement by using antlr4. Returns a list of AST and token stream if no error.-func ParseCassandraSQL(statement string) ([]*base.ParseResult, error) {+func ParseCassandraSQL(statement string) ([]*base.ANTLRAST, error) {stmts, err := SplitSQL(statement)if err != nil {return nil, err}- var result []*base.ParseResult+ var result []*base.ANTLRASTfor _, stmt := range stmts {if stmt.Empty {continue@@ -98,7 +85,7 @@ func ParseCassandraSQL(statement string) ([]*base.ParseResult, error) {return result, nil}-func parseSingleCassandraSQL(statement string, baseLine int) (*base.ParseResult, error) {+func parseSingleCassandraSQL(statement string, baseLine int) (*base.ANTLRAST, error) {statement = strings.TrimRightFunc(statement, utils.IsSpaceOrSemicolon) + "\n;"inputStream := antlr.NewInputStream(statement)lexer := cql.NewCqlLexer(inputStream)@@ -133,10 +120,10 @@ func parseSingleCassandraSQL(statement string, baseLine int) (*base.ParseResult,return nil, parserErrorListener.Err}- result := &base.ParseResult{- Tree: tree,- Tokens: stream,- BaseLine: baseLine,+ result := &base.ANTLRAST{+ StartPosition: &storepb.Position{Line: int32(baseLine) + 1},+ Tree: tree,+ Tokens: stream,}return result, nildiff --git a/backend/plugin/parser/cassandra/cassandra_test.go b/backend/plugin/parser/cassandra/cassandra_test.goindex e6ae1787f2..443c13d3ed 100644--- a/backend/plugin/parser/cassandra/cassandra_test.go+++ b/backend/plugin/parser/cassandra/cassandra_test.go@@ -5,6 +5,8 @@ import ("github.com/stretchr/testify/assert""github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/plugin/parser/base")func TestParseCassandraSQL(t *testing.T) {@@ -93,12 +95,12 @@ func TestParseCassandraSQLBaseLine(t *testing.T) {// BaseLine follows the pattern from SplitSQL based on token positions// First statement: line 0- assert.Equal(t, 0, results[0].BaseLine)+ assert.Equal(t, 0, base.GetLineOffset(results[0].StartPosition))// Second statement: includes newline+tab prefix, but first token is on line 2 (BaseLine = line - 1 = 1-1 = 0)// Actually the newline is part of the previous statement's text, so first real token is on line 2- assert.Equal(t, 0, results[1].BaseLine) // First token after semicolon is still on line 1 (0-indexed)+ assert.Equal(t, 0, base.GetLineOffset(results[1].StartPosition)) // First token after semicolon is still on line 1 (0-indexed)// Third statement- assert.Equal(t, 1, results[2].BaseLine)+ assert.Equal(t, 1, base.GetLineOffset(results[2].StartPosition))}func TestParseCassandraSQLErrors(t *testing.T) {diff --git a/backend/plugin/parser/cosmosdb/cosmosdb.go b/backend/plugin/parser/cosmosdb/cosmosdb.goindex 9c1001cdca..db0a1e18f3 100644--- a/backend/plugin/parser/cosmosdb/cosmosdb.go+++ b/backend/plugin/parser/cosmosdb/cosmosdb.go@@ -13,13 +13,13 @@ import (// ParseCosmosDBQuery parses the given CosmosDB SQL statement by using antlr4. Returns a list of AST and token stream if no error.// Note: CosmosDB only supports single SELECT statements, so this will typically return a list with one element.-func ParseCosmosDBQuery(statement string) ([]*base.ParseResult, error) {+func ParseCosmosDBQuery(statement string) ([]*base.ANTLRAST, error) {stmts, err := SplitSQL(statement)if err != nil {return nil, err}- var result []*base.ParseResult+ var result []*base.ANTLRASTfor _, stmt := range stmts {if stmt.Empty {continue@@ -35,7 +35,7 @@ func ParseCosmosDBQuery(statement string) ([]*base.ParseResult, error) {return result, nil}-func parseSingleCosmosDBQuery(statement string, baseLine int) (*base.ParseResult, error) {+func parseSingleCosmosDBQuery(statement string, baseLine int) (*base.ANTLRAST, error) {statement = strings.TrimRightFunc(statement, utils.IsSpaceOrSemicolon)inputStream := antlr.NewInputStream(statement)lexer := parser.NewCosmosDBLexer(inputStream)@@ -70,10 +70,10 @@ func parseSingleCosmosDBQuery(statement string, baseLine int) (*base.ParseResultreturn nil, parserErrorListener.Err}- result := &base.ParseResult{- Tree: tree,- Tokens: stream,- BaseLine: baseLine,+ result := &base.ANTLRAST{+ StartPosition: startPosition,+ Tree: tree,+ Tokens: stream,}return result, nildiff --git a/backend/plugin/parser/cosmosdb/cosmosdb_test.go b/backend/plugin/parser/cosmosdb/cosmosdb_test.goindex 67168d0791..4c073d6c51 100644--- a/backend/plugin/parser/cosmosdb/cosmosdb_test.go+++ b/backend/plugin/parser/cosmosdb/cosmosdb_test.go@@ -60,7 +60,8 @@ func TestParseCosmosDBQuery(t *testing.T) {for i, result := range results {assert.NotNil(t, result.Tree, "Result %d should have a Tree", i)assert.NotNil(t, result.Tokens, "Result %d should have Tokens", i)- assert.Equal(t, 0, result.BaseLine, "Result %d should have BaseLine 0", i)+ assert.NotNil(t, result.StartPosition, "Result %d should have StartPosition", i)+ assert.Equal(t, int32(1), result.StartPosition.Line, "Result %d should have StartPosition.Line 1", i)}})}diff --git a/backend/plugin/parser/doris/doris.go b/backend/plugin/parser/doris/doris.goindex 7a8a9e0561..6bcd91c21b 100644--- a/backend/plugin/parser/doris/doris.go+++ b/backend/plugin/parser/doris/doris.go@@ -16,24 +16,15 @@ func init() {// parseDorisForRegistry is the ParseFunc for Doris.// Returns []base.AST with *ANTLRAST instances.func parseDorisForRegistry(statement string) ([]base.AST, error) {- parseResults, err := ParseDorisSQL(statement)+ antlrASTs, err := ParseDorisSQL(statement)if err != nil {return nil, err}- return toAST(parseResults), nil-}--// toAST converts []*ParseResult to []base.AST.-func toAST(results []*base.ParseResult) []base.AST {var asts []base.AST- for _, r := range results {- asts = append(asts, &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(r.BaseLine) + 1},- Tree: r.Tree,- Tokens: r.Tokens,- })+ for _, ast := range antlrASTs {+ asts = append(asts, ast)}- return asts+ return asts, nil}// parseDorisStatements is the ParseStatementsFunc for Doris.@@ -46,24 +37,20 @@ func parseDorisStatements(statement string) ([]base.ParsedStatement, error) {}// Then parse to get ASTs- parseResults, err := ParseDorisSQL(statement)+ antlrASTs, err := ParseDorisSQL(statement)if err != nil {return nil, err}- // Combine: Statement provides text/positions, ParseResult provides AST+ // Combine: Statement provides text/positions, ANTLRAST provides ASTvar result []base.ParsedStatementastIndex := 0for _, stmt := range stmts {ps := base.ParsedStatement{Statement: stmt,}- if !stmt.Empty && astIndex < len(parseResults) {- ps.AST = &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},- Tree: parseResults[astIndex].Tree,- Tokens: parseResults[astIndex].Tokens,- }+ if !stmt.Empty && astIndex < len(antlrASTs) {+ ps.AST = antlrASTs[astIndex]astIndex++}result = append(result, ps)@@ -73,29 +60,29 @@ func parseDorisStatements(statement string) ([]base.ParsedStatement, error) {}// ParseDorisSQL parses the given SQL statement by using antlr4. Returns a list of AST and token stream if no error.-func ParseDorisSQL(statement string) ([]*base.ParseResult, error) {+func ParseDorisSQL(statement string) ([]*base.ANTLRAST, error) {stmts, err := SplitSQL(statement)if err != nil {return nil, err}- var result []*base.ParseResult+ var result []*base.ANTLRASTfor _, stmt := range stmts {if stmt.Empty {continue}- parseResult, err := parseSingleDorisSQL(stmt.Text, stmt.BaseLine)+ antlrAST, err := parseSingleDorisSQL(stmt.Text, stmt.BaseLine)if err != nil {return nil, err}- result = append(result, parseResult)+ result = append(result, antlrAST)}return result, nil}-func parseSingleDorisSQL(statement string, baseLine int) (*base.ParseResult, error) {+func parseSingleDorisSQL(statement string, baseLine int) (*base.ANTLRAST, error) {lexer := parser.NewDorisLexer(antlr.NewInputStream(statement))stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)p := parser.NewDorisParser(stream)@@ -125,10 +112,10 @@ func parseSingleDorisSQL(statement string, baseLine int) (*base.ParseResult, errreturn nil, parserErrorListener.Err}- result := &base.ParseResult{- Tree: tree,- Tokens: stream,- BaseLine: baseLine,+ result := &base.ANTLRAST{+ StartPosition: startPosition,+ Tree: tree,+ Tokens: stream,}return result, nildiff --git a/backend/plugin/parser/doris/query_span_extractor.go b/backend/plugin/parser/doris/query_span_extractor.goindex df45e5446e..192f9a92e9 100644--- a/backend/plugin/parser/doris/query_span_extractor.go+++ b/backend/plugin/parser/doris/query_span_extractor.go@@ -31,23 +31,23 @@ func newQuerySpanExtractor(database string, gCtx base.GetQuerySpanContext, ignorfunc (q *querySpanExtractor) getQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {q.ctx = ctx- parseResults, err := ParseDorisSQL(statement)+ antlrASTs, err := ParseDorisSQL(statement)if err != nil {return nil, err}- if len(parseResults) == 0 {+ if len(antlrASTs) == 0 {return &base.QuerySpan{SourceColumns: base.SourceColumnSet{},Results: []base.QuerySpanResult{},}, nil}- if len(parseResults) != 1 {- return nil, errors.Errorf("expecting only one statement to get query span, but got %d", len(parseResults))+ if len(antlrASTs) != 1 {+ return nil, errors.Errorf("expecting only one statement to get query span, but got %d", len(antlrASTs))}- parseResult := parseResults[0]- accessTables := getAccessTables(q.defaultDatabase, parseResult, q.ctes, q.gCtx, q.ignoreCaseSensitive)+ antlrAST := antlrASTs[0]+ accessTables := getAccessTables(q.defaultDatabase, antlrAST, q.ctes, q.gCtx, q.ignoreCaseSensitive)// We do not support simultaneous access to the system table and the user table// because we do not synchronize the schema of the system table.@@ -62,7 +62,7 @@ func (q *querySpanExtractor) getQuerySpan(ctx context.Context, statement string)allSystems: allSystems,result: base.QueryTypeUnknown,}- antlr.ParseTreeWalkerDefault.Walk(queryTypeListener, parseResult.Tree)+ antlr.ParseTreeWalkerDefault.Walk(queryTypeListener, antlrAST.Tree)return &base.QuerySpan{Type: queryTypeListener.result,@@ -71,10 +71,10 @@ func (q *querySpanExtractor) getQuerySpan(ctx context.Context, statement string)}, nil}-func getAccessTables(database string, parseResult *base.ParseResult, ctes map[string]bool, gCtx base.GetQuerySpanContext, ignoreCaseSensitive bool) base.SourceColumnSet {+func getAccessTables(database string, antlrAST *base.ANTLRAST, ctes map[string]bool, gCtx base.GetQuerySpanContext, ignoreCaseSensitive bool) base.SourceColumnSet {// First, extract CTEs from the querycteListener := newCTEListener()- antlr.ParseTreeWalkerDefault.Walk(cteListener, parseResult.Tree)+ antlr.ParseTreeWalkerDefault.Walk(cteListener, antlrAST.Tree)// Merge extracted CTEs with any existing onesfor cte := range cteListener.ctes {@@ -82,7 +82,7 @@ func getAccessTables(database string, parseResult *base.ParseResult, ctes map[st}accessTableListener := newAccessTableListener(database, ctes, gCtx, ignoreCaseSensitive)- antlr.ParseTreeWalkerDefault.Walk(accessTableListener, parseResult.Tree)+ antlr.ParseTreeWalkerDefault.Walk(accessTableListener, antlrAST.Tree)return accessTableListener.sourceColumnSet}diff --git a/backend/plugin/parser/mysql/backup.go b/backend/plugin/parser/mysql/backup.goindex dc8bfbd86b..35328a0743 100644--- a/backend/plugin/parser/mysql/backup.go+++ b/backend/plugin/parser/mysql/backup.go@@ -423,13 +423,13 @@ func (l *suffixSelectStatementListener) EnterUpdateStatement(ctx *parser.UpdateS}}-func ExtractTables(databaseName string, parseResult *base.ParseResult, offset int) ([]StatementInfo, error) {+func ExtractTables(databaseName string, ast *base.ANTLRAST, offset int) ([]StatementInfo, error) {listener := &tableReferenceListener{databaseName: databaseName,offset: offset,}- antlr.ParseTreeWalkerDefault.Walk(listener, parseResult.Tree)+ antlr.ParseTreeWalkerDefault.Walk(listener, ast.Tree)return listener.tables, listener.err}diff --git a/backend/plugin/parser/mysql/mysql.go b/backend/plugin/parser/mysql/mysql.goindex be0210d3be..e1f534d6a4 100644--- a/backend/plugin/parser/mysql/mysql.go+++ b/backend/plugin/parser/mysql/mysql.go@@ -35,20 +35,11 @@ func parseMySQLForRegistry(statement string) ([]base.AST, error) {if err != nil {return nil, err}- return toAST(parseResults), nil-}--// toAST converts []*ParseResult to []base.AST.-func toAST(results []*base.ParseResult) []base.AST {- var asts []base.AST- for _, r := range results {- asts = append(asts, &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(r.BaseLine) + 1},- Tree: r.Tree,- Tokens: r.Tokens,- })+ asts := make([]base.AST, len(parseResults))+ for i, r := range parseResults {+ asts[i] = r}- return asts+ return asts, nil}// parseMySQLStatements is the ParseStatementsFunc for MySQL, MariaDB, and OceanBase.@@ -66,8 +57,7 @@ func parseMySQLStatements(statement string) ([]base.ParsedStatement, error) {return nil, err}- // Combine: Statement provides text/positions, ParseResult provides AST- // Note: parseResults may have fewer items if some statements are empty+ // Combine: Statement provides text/positions, ANTLRAST provides ASTvar result []base.ParsedStatementastIndex := 0for _, stmt := range stmts {@@ -75,11 +65,7 @@ func parseMySQLStatements(statement string) ([]base.ParsedStatement, error) {Statement: stmt,}if !stmt.Empty && astIndex < len(parseResults) {- ps.AST = &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},- Tree: parseResults[astIndex].Tree,- Tokens: parseResults[astIndex].Tokens,- }+ ps.AST = parseResults[astIndex]astIndex++}result = append(result, ps)@@ -89,7 +75,7 @@ func parseMySQLStatements(statement string) ([]base.ParsedStatement, error) {}// ParseMySQL parses the given SQL statement and returns the AST.-func ParseMySQL(statement string) ([]*base.ParseResult, error) {+func ParseMySQL(statement string) ([]*base.ANTLRAST, error) {statement, err := DealWithDelimiter(statement)if err != nil {return nil, err@@ -278,8 +264,8 @@ func mysqlAddSemicolonIfNeeded(sql string) string {return sql}-func parseInputStream(input *antlr.InputStream, statement string) ([]*base.ParseResult, error) {- var result []*base.ParseResult+func parseInputStream(input *antlr.InputStream, statement string) ([]*base.ANTLRAST, error) {+ var result []*base.ANTLRASTlexer := parser.NewMySQLLexer(input)stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)@@ -303,10 +289,10 @@ func parseInputStream(input *antlr.InputStream, statement string) ([]*base.Parsecontinue}- result = append(result, &base.ParseResult{- Tree: tree,- Tokens: tokens,- BaseLine: s.BaseLine,+ result = append(result, &base.ANTLRAST{+ StartPosition: &storepb.Position{Line: int32(s.BaseLine) + 1},+ Tree: tree,+ Tokens: tokens,})// s.End.Line is 1-based, but baseLine should be 0-basedbaseLine = int(s.End.Line) - 1diff --git a/backend/plugin/parser/mysql/restore.go b/backend/plugin/parser/mysql/restore.goindex e5e772fba8..352d75f053 100644--- a/backend/plugin/parser/mysql/restore.go+++ b/backend/plugin/parser/mysql/restore.go@@ -49,7 +49,7 @@ func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statementreturn doGenerate(ctx, rCtx, sqlForComment, parseResult[0], backupItem)}-func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment string, parseResult *base.ParseResult, backupItem *storepb.PriorBackupDetail_Item) (string, error) {+func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment string, ast *base.ANTLRAST, backupItem *storepb.PriorBackupDetail_Item) (string, error) {_, sourceDatabase, err := common.GetInstanceDatabaseID(backupItem.SourceTable.Database)if err != nil {return "", errors.Wrapf(err, "failed to get source database ID for %s", backupItem.SourceTable.Database)@@ -77,7 +77,7 @@ func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment strnormalColumns: normalColumns,}var buf strings.Builder- antlr.ParseTreeWalkerDefault.Walk(g, parseResult.Tree)+ antlr.ParseTreeWalkerDefault.Walk(g, ast.Tree)if g.err != nil {return "", g.err}diff --git a/backend/plugin/parser/partiql/partiql.go b/backend/plugin/parser/partiql/partiql.goindex db2f113bdb..88e9bdfd85 100644--- a/backend/plugin/parser/partiql/partiql.go+++ b/backend/plugin/parser/partiql/partiql.go@@ -24,20 +24,11 @@ func parsePartiQLForRegistry(statement string) ([]base.AST, error) {if err != nil {return nil, err}- return toAST(parseResults), nil-}--// toAST converts []*ParseResult to []base.AST.-func toAST(results []*base.ParseResult) []base.AST {- var asts []base.AST- for _, r := range results {- asts = append(asts, &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(r.BaseLine) + 1},- Tree: r.Tree,- Tokens: r.Tokens,- })+ asts := make([]base.AST, len(parseResults))+ for i, r := range parseResults {+ asts[i] = r}- return asts+ return asts, nil}// parsePartiQLStatements is the ParseStatementsFunc for PartiQL (DynamoDB).@@ -55,7 +46,7 @@ func parsePartiQLStatements(statement string) ([]base.ParsedStatement, error) {return nil, err}- // Combine: Statement provides text/positions, ParseResult provides AST+ // Combine: Statement provides text/positions, ANTLRAST provides ASTvar result []base.ParsedStatementastIndex := 0for _, stmt := range stmts {@@ -63,11 +54,7 @@ func parsePartiQLStatements(statement string) ([]base.ParsedStatement, error) {Statement: stmt,}if !stmt.Empty && astIndex < len(parseResults) {- ps.AST = &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},- Tree: parseResults[astIndex].Tree,- Tokens: parseResults[astIndex].Tokens,- }+ ps.AST = parseResults[astIndex]astIndex++}result = append(result, ps)@@ -77,13 +64,13 @@ func parsePartiQLStatements(statement string) ([]base.ParsedStatement, error) {}// ParsePartiQL parses the given PartiQL statement by using antlr4. Returns a list of AST and token stream if no error.-func ParsePartiQL(statement string) ([]*base.ParseResult, error) {+func ParsePartiQL(statement string) ([]*base.ANTLRAST, error) {stmts, err := SplitSQL(statement)if err != nil {return nil, err}- var result []*base.ParseResult+ var result []*base.ANTLRASTfor _, stmt := range stmts {if stmt.Empty {continue@@ -99,7 +86,7 @@ func ParsePartiQL(statement string) ([]*base.ParseResult, error) {return result, nil}-func parseSinglePartiQL(statement string, baseLine int) (*base.ParseResult, error) {+func parseSinglePartiQL(statement string, baseLine int) (*base.ANTLRAST, error) {statement = strings.TrimRightFunc(statement, utils.IsSpaceOrSemicolon) + "\n;"inputStream := antlr.NewInputStream(statement)lexer := parser.NewPartiQLLexer(inputStream)@@ -134,10 +121,10 @@ func parseSinglePartiQL(statement string, baseLine int) (*base.ParseResult, erroreturn nil, parserErrorListener.Err}- result := &base.ParseResult{- Tree: tree,- Tokens: stream,- BaseLine: baseLine,+ result := &base.ANTLRAST{+ StartPosition: &storepb.Position{Line: int32(baseLine) + 1},+ Tree: tree,+ Tokens: stream,}return result, nildiff --git a/backend/plugin/parser/pg/backup.go b/backend/plugin/parser/pg/backup.goindex d98962ce8c..9ab48abbcf 100644--- a/backend/plugin/parser/pg/backup.go+++ b/backend/plugin/parser/pg/backup.go@@ -257,7 +257,7 @@ func prepareTransformation(ctx context.Context, tCtx base.TransformContext, stat// Walk all parse results to extract DML statementsfor _, parseResult := range parseResults {- extractor.currentBaseLine = parseResult.BaseLine+ extractor.currentBaseLine = base.GetLineOffset(parseResult.StartPosition)antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)if extractor.err != nil {return nil, extractor.errdiff --git a/backend/plugin/parser/pg/pg.go b/backend/plugin/parser/pg/pg.goindex c692f0fe1c..14be256e4a 100644--- a/backend/plugin/parser/pg/pg.go+++ b/backend/plugin/parser/pg/pg.go@@ -23,20 +23,11 @@ func parsePostgreSQLForRegistry(statement string) ([]base.AST, error) {if err != nil {return nil, err}- return toAST(parseResults), nil-}--// toAST converts []*ParseResult to []base.AST.-func toAST(results []*base.ParseResult) []base.AST {- var asts []base.AST- for _, r := range results {- asts = append(asts, &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(r.BaseLine) + 1},- Tree: r.Tree,- Tokens: r.Tokens,- })- }- return asts+ asts := make([]base.AST, len(parseResults))+ for i, r := range parseResults {+ asts[i] = r+ }+ return asts, nil}// parsePgStatements is the ParseStatementsFunc for PostgreSQL.@@ -54,7 +45,7 @@ func parsePgStatements(statement string) ([]base.ParsedStatement, error) {return nil, err}- // Combine: Statement provides text/positions, ParseResult provides AST+ // Combine: Statement provides text/positions, ANTLRAST provides ASTvar result []base.ParsedStatementastIndex := 0for _, stmt := range stmts {@@ -62,11 +53,7 @@ func parsePgStatements(statement string) ([]base.ParsedStatement, error) {Statement: stmt,}if !stmt.Empty && astIndex < len(parseResults) {- ps.AST = &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},- Tree: parseResults[astIndex].Tree,- Tokens: parseResults[astIndex].Tokens,- }+ ps.AST = parseResults[astIndex]astIndex++}result = append(result, ps)@@ -75,15 +62,15 @@ func parsePgStatements(statement string) ([]base.ParsedStatement, error) {return result, nil}-// ParsePostgreSQL parses the given SQL and returns a list of ParseResult (one per statement).+// ParsePostgreSQL parses the given SQL and returns a list of ANTLRAST (one per statement).// Use the PostgreSQL parser based on antlr4.-func ParsePostgreSQL(sql string) ([]*base.ParseResult, error) {+func ParsePostgreSQL(sql string) ([]*base.ANTLRAST, error) {stmts, err := SplitSQL(sql)if err != nil {return nil, err}- var results []*base.ParseResult+ var results []*base.ANTLRASTfor _, stmt := range stmts {if stmt.Empty {continue@@ -99,8 +86,8 @@ func ParsePostgreSQL(sql string) ([]*base.ParseResult, error) {return results, nil}-// parseSinglePostgreSQL parses a single PostgreSQL statement and returns the ParseResult.-func parseSinglePostgreSQL(sql string, baseLine int) (*base.ParseResult, error) {+// parseSinglePostgreSQL parses a single PostgreSQL statement and returns the ANTLRAST.+func parseSinglePostgreSQL(sql string, baseLine int) (*base.ANTLRAST, error) {lexer := parser.NewPostgreSQLLexer(antlr.NewInputStream(sql))stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)p := parser.NewPostgreSQLParser(stream)@@ -130,18 +117,18 @@ func parseSinglePostgreSQL(sql string, baseLine int) (*base.ParseResult, error)return nil, parserErrorListener.Err}- result := &base.ParseResult{- Tree: tree,- Tokens: stream,- BaseLine: baseLine,+ result := &base.ANTLRAST{+ StartPosition: &storepb.Position{Line: int32(baseLine) + 1},+ Tree: tree,+ Tokens: stream,}return result, nil}-// ParsePostgreSQLPLBlock parses the given PL/pgSQL block (BEGIN...END) and returns the ParseResult.+// ParsePostgreSQLPLBlock parses the given PL/pgSQL block (BEGIN...END) and returns the ANTLRAST.// Use the PostgreSQL parser based on antlr4, starting from pl_block rule.-func ParsePostgreSQLPLBlock(plBlock string) (*base.ParseResult, error) {+func ParsePostgreSQLPLBlock(plBlock string) (*base.ANTLRAST, error) {lexer := parser.NewPostgreSQLLexer(antlr.NewInputStream(plBlock))stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)p := parser.NewPostgreSQLParser(stream)@@ -171,9 +158,10 @@ func ParsePostgreSQLPLBlock(plBlock string) (*base.ParseResult, error) {return nil, parserErrorListener.Err}- result := &base.ParseResult{- Tree: tree,- Tokens: stream,+ result := &base.ANTLRAST{+ StartPosition: &storepb.Position{Line: 1},+ Tree: tree,+ Tokens: stream,}return result, nildiff --git a/backend/plugin/parser/pg/restore.go b/backend/plugin/parser/pg/restore.goindex 1f2ea66681..dac46bed52 100644--- a/backend/plugin/parser/pg/restore.go+++ b/backend/plugin/parser/pg/restore.go@@ -40,13 +40,13 @@ func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statement}// Find the parse result that contains the statement at the backup position- var targetResult *base.ParseResult+ var targetResult *base.ANTLRASTfor _, parseResult := range parseResults {// Walk the tree to find if this parse result contains the target statementfinder := &statementAtPositionFinder{startPos: backupItem.StartPosition,endPos: backupItem.EndPosition,- baseLine: parseResult.BaseLine,+ baseLine: base.GetLineOffset(parseResult.StartPosition),}antlr.ParseTreeWalkerDefault.Walk(finder, parseResult.Tree)if finder.found {@@ -74,7 +74,7 @@ func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statementreturn doGenerate(ctx, rCtx, sqlForComment, targetResult, backupItem, prependStatements)}-func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment string, tree *base.ParseResult, backupItem *storepb.PriorBackupDetail_Item, prependStatements string) (string, error) {+func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment string, tree *base.ANTLRAST, backupItem *storepb.PriorBackupDetail_Item, prependStatements string) (string, error) {_, sourceDatabase, err := common.GetInstanceDatabaseID(backupItem.SourceTable.Database)if err != nil {return "", errors.Wrapf(err, "failed to get source database ID for %s", backupItem.SourceTable.Database)@@ -257,7 +257,7 @@ func extractStatement(statement string, backupItem *storepb.PriorBackupDetail_It// Walk all parse results to find statements within the specified position rangefor _, parseResult := range parseResults {- l.baseLine = parseResult.BaseLine+ l.baseLine = base.GetLineOffset(parseResult.StartPosition)antlr.ParseTreeWalkerDefault.Walk(l, parseResult.Tree)}diff --git a/backend/plugin/parser/plsql/backup.go b/backend/plugin/parser/plsql/backup.goindex 16bcc133c6..81069716ce 100644--- a/backend/plugin/parser/plsql/backup.go+++ b/backend/plugin/parser/plsql/backup.go@@ -258,9 +258,9 @@ func prepareTransformation(databaseName, statement string) ([]statementInfo, errdatabaseName: databaseName,}- // Walk each parse result tree to extract DML statements+ // Walk each ANTLRAST tree to extract DML statementsfor _, result := range results {- extractor.baseLine = result.BaseLine+ extractor.baseLine = base.GetLineOffset(result.StartPosition)antlr.ParseTreeWalkerDefault.Walk(extractor, result.Tree)}diff --git a/backend/plugin/parser/plsql/plsql.go b/backend/plugin/parser/plsql/plsql.goindex c42b7a9cd3..882f9ceb05 100644--- a/backend/plugin/parser/plsql/plsql.go+++ b/backend/plugin/parser/plsql/plsql.go@@ -27,20 +27,11 @@ func parsePLSQLForRegistry(statement string) ([]base.AST, error) {if err != nil {return nil, err}- return toAST(parseResults), nil-}--// toAST converts []*ParseResult to []base.AST.-func toAST(results []*base.ParseResult) []base.AST {- var asts []base.AST- for _, r := range results {- asts = append(asts, &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(r.BaseLine) + 1},- Tree: r.Tree,- Tokens: r.Tokens,- })+ asts := make([]base.AST, len(parseResults))+ for i, r := range parseResults {+ asts[i] = r}- return asts+ return asts, nil}// parsePLSQLStatements is the ParseStatementsFunc for Oracle (PL/SQL).@@ -58,7 +49,7 @@ func parsePLSQLStatements(statement string) ([]base.ParsedStatement, error) {return nil, err}- // Combine: Statement provides text/positions, ParseResult provides AST+ // Combine: Statement provides text/positions, ANTLRAST provides ASTvar result []base.ParsedStatementastIndex := 0for _, stmt := range stmts {@@ -66,11 +57,7 @@ func parsePLSQLStatements(statement string) ([]base.ParsedStatement, error) {Statement: stmt,}if !stmt.Empty && astIndex < len(parseResults) {- ps.AST = &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},- Tree: parseResults[astIndex].Tree,- Tokens: parseResults[astIndex].Tokens,- }+ ps.AST = parseResults[astIndex]astIndex++}result = append(result, ps)@@ -112,10 +99,10 @@ func ParseVersion(banner string) (*Version, error) {return nil, errors.Errorf("failed to parse version from banner: %s", banner)}-// ParsePLSQL parses the given PLSQL and returns a list of parse results.+// ParsePLSQL parses the given PLSQL and returns a list of ANTLR ASTs.// It first parses the whole statement to get the AST, then splits by unit_statement// and sql_plus_command nodes, and re-parses each individual statement.-func ParsePLSQL(sql string) ([]*base.ParseResult, error) {+func ParsePLSQL(sql string) ([]*base.ANTLRAST, error) {sql = addSemicolonIfNeeded(sql)// First pass: parse the whole statement to get the AST for splitting@@ -131,7 +118,7 @@ func ParsePLSQL(sql string) ([]*base.ParseResult, error) {}// Iterate through children in order to preserve statement ordering and re-parse each one- var result []*base.ParseResult+ var result []*base.ANTLRASTfor _, child := range sqlScript.GetChildren() {var stmtText stringvar stmtBaseLine int@@ -159,10 +146,10 @@ func ParsePLSQL(sql string) ([]*base.ParseResult, error) {return nil, err}- result = append(result, &base.ParseResult{- Tree: stmtTree,- Tokens: stmtTokens,- BaseLine: stmtBaseLine,+ result = append(result, &base.ANTLRAST{+ StartPosition: &storepb.Position{Line: int32(stmtBaseLine) + 1},+ Tree: stmtTree,+ Tokens: stmtTokens,})}diff --git a/backend/plugin/parser/plsql/plsql_test.go b/backend/plugin/parser/plsql/plsql_test.goindex 1c1445c267..6c17bbd58f 100644--- a/backend/plugin/parser/plsql/plsql_test.go+++ b/backend/plugin/parser/plsql/plsql_test.go@@ -5,6 +5,8 @@ import (parser "github.com/bytebase/parser/plsql""github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/plugin/parser/base")func TestPLSQLParser(t *testing.T) {@@ -87,7 +89,7 @@ INSERT INTO t3 VALUES (1, 2);`,require.Equal(t, test.expectedCount, len(results), "Statement: %s", test.statement)for i, result := range results {- require.Equal(t, test.expectedLines[i], result.BaseLine, "Statement %d", i+1)+ require.Equal(t, test.expectedLines[i], base.GetLineOffset(result.StartPosition), "Statement %d", i+1)}}}diff --git a/backend/plugin/parser/redshift/diagnose.go b/backend/plugin/parser/redshift/diagnose.goindex 4376363e75..19030c1759 100644--- a/backend/plugin/parser/redshift/diagnose.go+++ b/backend/plugin/parser/redshift/diagnose.go@@ -26,7 +26,7 @@ func Diagnose(_ context.Context, _ base.DiagnoseContext, statement string) ([]bareturn diagnostics, nil}-// parseRedshiftStatement parses the given SQL and returns the ParseResult.+// parseRedshiftStatement parses the given SQL and returns syntax errors if any.// Use the Redshift parser based on antlr4.func parseRedshiftStatement(statement string) *base.SyntaxError {trimmedStatement := strings.TrimRightFunc(statement, unicode.IsSpace)diff --git a/backend/plugin/parser/redshift/redshift.go b/backend/plugin/parser/redshift/redshift.goindex 16139a67d9..2b079f2bf2 100644--- a/backend/plugin/parser/redshift/redshift.go+++ b/backend/plugin/parser/redshift/redshift.go@@ -25,20 +25,11 @@ func parseRedshiftForRegistry(statement string) ([]base.AST, error) {if err != nil {return nil, err}- return toAST(parseResults), nil-}--// toAST converts []*ParseResult to []base.AST.-func toAST(results []*base.ParseResult) []base.AST {- var asts []base.AST- for _, r := range results {- asts = append(asts, &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(r.BaseLine) + 1},- Tree: r.Tree,- Tokens: r.Tokens,- })+ asts := make([]base.AST, len(parseResults))+ for i, r := range parseResults {+ asts[i] = r}- return asts+ return asts, nil}// parseRedshiftStatements is the ParseStatementsFunc for Redshift.@@ -56,7 +47,7 @@ func parseRedshiftStatements(statement string) ([]base.ParsedStatement, error) {return nil, err}- // Combine: Statement provides text/positions, ParseResult provides AST+ // Combine: Statement provides text/positions, ANTLRAST provides ASTvar result []base.ParsedStatementastIndex := 0for _, stmt := range stmts {@@ -64,11 +55,7 @@ func parseRedshiftStatements(statement string) ([]base.ParsedStatement, error) {Statement: stmt,}if !stmt.Empty && astIndex < len(parseResults) {- ps.AST = &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},- Tree: parseResults[astIndex].Tree,- Tokens: parseResults[astIndex].Tokens,- }+ ps.AST = parseResults[astIndex]astIndex++}result = append(result, ps)@@ -77,15 +64,15 @@ func parseRedshiftStatements(statement string) ([]base.ParsedStatement, error) {return result, nil}-// ParseRedshift parses the given SQL statement and returns a list of ParseResults.-// Each ParseResult represents one statement with its AST, tokens, and base line offset.-func ParseRedshift(sql string) ([]*base.ParseResult, error) {+// ParseRedshift parses the given SQL and returns a list of ANTLRAST (one per statement).+// Use the Redshift parser based on antlr4.+func ParseRedshift(sql string) ([]*base.ANTLRAST, error) {stmts, err := SplitSQL(sql)if err != nil {return nil, errors.Wrap(err, "failed to split SQL")}- var results []*base.ParseResult+ var results []*base.ANTLRASTfor _, stmt := range stmts {if stmt.Empty {continue@@ -101,8 +88,8 @@ func ParseRedshift(sql string) ([]*base.ParseResult, error) {return results, nil}-// parseSingleRedshift parses a single Redshift statement by using antlr4. Returns the AST and token stream if no error.-func parseSingleRedshift(statement string, baseLine int) (*base.ParseResult, error) {+// parseSingleRedshift parses a single Redshift statement and returns the ANTLRAST.+func parseSingleRedshift(statement string, baseLine int) (*base.ANTLRAST, error) {statement = strings.TrimRightFunc(statement, utils.IsSpaceOrSemicolon) + ";"inputStream := antlr.NewInputStream(statement)lexer := parser.NewRedshiftLexer(inputStream)@@ -139,10 +126,10 @@ func parseSingleRedshift(statement string, baseLine int) (*base.ParseResult, errreturn nil, parserErrorListener.Err}- result := &base.ParseResult{- Tree: tree,- Tokens: stream,- BaseLine: baseLine,+ result := &base.ANTLRAST{+ StartPosition: &storepb.Position{Line: int32(baseLine) + 1},+ Tree: tree,+ Tokens: stream,}return result, nildiff --git a/backend/plugin/parser/snowflake/snowflake.go b/backend/plugin/parser/snowflake/snowflake.goindex 2a17097025..6ae572d84e 100644--- a/backend/plugin/parser/snowflake/snowflake.go+++ b/backend/plugin/parser/snowflake/snowflake.go@@ -24,20 +24,11 @@ func parseSnowflakeForRegistry(statement string) ([]base.AST, error) {if err != nil {return nil, err}- return toAST(parseResults), nil-}--// toAST converts []*ParseResult to []base.AST.-func toAST(results []*base.ParseResult) []base.AST {- var asts []base.AST- for _, r := range results {- asts = append(asts, &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(r.BaseLine) + 1},- Tree: r.Tree,- Tokens: r.Tokens,- })- }- return asts+ asts := make([]base.AST, len(parseResults))+ for i, r := range parseResults {+ asts[i] = r+ }+ return asts, nil}// parseSnowflakeStatements is the ParseStatementsFunc for Snowflake.@@ -55,7 +46,7 @@ func parseSnowflakeStatements(statement string) ([]base.ParsedStatement, error)return nil, err}- // Combine: Statement provides text/positions, ParseResult provides AST+ // Combine: Statement provides text/positions, ANTLRAST provides ASTvar result []base.ParsedStatementastIndex := 0for _, stmt := range stmts {@@ -63,11 +54,7 @@ func parseSnowflakeStatements(statement string) ([]base.ParsedStatement, error)Statement: stmt,}if !stmt.Empty && astIndex < len(parseResults) {- ps.AST = &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},- Tree: parseResults[astIndex].Tree,- Tokens: parseResults[astIndex].Tokens,- }+ ps.AST = parseResults[astIndex]astIndex++}result = append(result, ps)@@ -76,15 +63,15 @@ func parseSnowflakeStatements(statement string) ([]base.ParsedStatement, error)return result, nil}-// ParseSnowSQL parses the given SQL and returns a list of ParseResult (one per statement).+// ParseSnowSQL parses the given SQL and returns a list of ANTLRAST (one per statement).// Use the Snowflake parser based on antlr4.-func ParseSnowSQL(sql string) ([]*base.ParseResult, error) {+func ParseSnowSQL(sql string) ([]*base.ANTLRAST, error) {stmts, err := SplitSQL(sql)if err != nil {return nil, err}- var results []*base.ParseResult+ var results []*base.ANTLRASTfor _, stmt := range stmts {if stmt.Empty {continue@@ -100,8 +87,8 @@ func ParseSnowSQL(sql string) ([]*base.ParseResult, error) {return results, nil}-// parseSingleSnowSQL parses a single Snowflake statement and returns the ParseResult.-func parseSingleSnowSQL(statement string, baseLine int) (*base.ParseResult, error) {+// parseSingleSnowSQL parses a single Snowflake statement and returns the ANTLRAST.+func parseSingleSnowSQL(statement string, baseLine int) (*base.ANTLRAST, error) {statement = strings.TrimRightFunc(statement, utils.IsSpaceOrSemicolon) + "\n;"inputStream := antlr.NewInputStream(statement)lexer := parser.NewSnowflakeLexer(inputStream)@@ -136,10 +123,10 @@ func parseSingleSnowSQL(statement string, baseLine int) (*base.ParseResult, erroreturn nil, parserErrorListener.Err}- result := &base.ParseResult{- Tree: tree,- Tokens: stream,- BaseLine: baseLine,+ result := &base.ANTLRAST{+ StartPosition: &storepb.Position{Line: int32(baseLine) + 1},+ Tree: tree,+ Tokens: stream,}return result, nildiff --git a/backend/plugin/parser/spanner/spanner.go b/backend/plugin/parser/spanner/spanner.goindex 4a6770ac3f..ca40533584 100644--- a/backend/plugin/parser/spanner/spanner.go+++ b/backend/plugin/parser/spanner/spanner.go@@ -12,15 +12,15 @@ import ("github.com/bytebase/bytebase/backend/utils")-// ParseSpannerGoogleSQL parses the given SQL and returns a list of ParseResult (one per statement).+// ParseSpannerGoogleSQL parses the given SQL and returns a list of ANTLRAST (one per statement).// Use the GoogleSQL parser based on antlr4.-func ParseSpannerGoogleSQL(sql string) ([]*base.ParseResult, error) {+func ParseSpannerGoogleSQL(sql string) ([]*base.ANTLRAST, error) {stmts, err := SplitSQL(sql)if err != nil {return nil, err}- var results []*base.ParseResult+ var results []*base.ANTLRASTfor _, stmt := range stmts {if stmt.Empty {continue@@ -36,8 +36,8 @@ func ParseSpannerGoogleSQL(sql string) ([]*base.ParseResult, error) {return results, nil}-// parseSingleSpannerGoogleSQL parses a single Spanner statement and returns the ParseResult.-func parseSingleSpannerGoogleSQL(statement string, baseLine int) (*base.ParseResult, error) {+// parseSingleSpannerGoogleSQL parses a single Spanner statement and returns the ANTLRAST.+func parseSingleSpannerGoogleSQL(statement string, baseLine int) (*base.ANTLRAST, error) {statement = strings.TrimRightFunc(statement, utils.IsSpaceOrSemicolon) + "\n;"inputStream := antlr.NewInputStream(statement)lexer := parser.NewGoogleSQLLexer(inputStream)@@ -72,10 +72,10 @@ func parseSingleSpannerGoogleSQL(statement string, baseLine int) (*base.ParseResreturn nil, parserErrorListener.Err}- result := &base.ParseResult{- Tree: tree,- Tokens: stream,- BaseLine: baseLine,+ result := &base.ANTLRAST{+ StartPosition: startPosition,+ Tree: tree,+ Tokens: stream,}return result, nildiff --git a/backend/plugin/parser/tidb/backup.go b/backend/plugin/parser/tidb/backup.goindex 70a7e24510..0290c07400 100644--- a/backend/plugin/parser/tidb/backup.go+++ b/backend/plugin/parser/tidb/backup.go@@ -424,13 +424,13 @@ type TableReference struct {Alias string}-func extractTables(databaseName string, parseResult *base.ParseResult, offset int) ([]statementInfo, error) {+func extractTables(databaseName string, ast *base.ANTLRAST, offset int) ([]statementInfo, error) {listener := &tableReferenceListener{databaseName: databaseName,offset: offset,}- antlr.ParseTreeWalkerDefault.Walk(listener, parseResult.Tree)+ antlr.ParseTreeWalkerDefault.Walk(listener, ast.Tree)return listener.tables, listener.err}diff --git a/backend/plugin/parser/tidb/tidb.go b/backend/plugin/parser/tidb/tidb.goindex 6813cfca9f..33db577b2c 100644--- a/backend/plugin/parser/tidb/tidb.go+++ b/backend/plugin/parser/tidb/tidb.go@@ -142,7 +142,7 @@ func ParseTiDB(sql string, charset string, collation string) ([]ast.StmtNode, erreturn nodes, nil}-func ANTLRParseTiDB(statement string) ([]*base.ParseResult, error) {+func ANTLRParseTiDB(statement string) ([]*base.ANTLRAST, error) {statement, err := DealWithDelimiter(statement)if err != nil {return nil, err@@ -192,8 +192,8 @@ func parseSingleStatement(baseLine int, statement string) (antlr.Tree, *antlr.Coreturn tree, stream, nil}-func parseInputStream(input *antlr.InputStream, statement string) ([]*base.ParseResult, error) {- var result []*base.ParseResult+func parseInputStream(input *antlr.InputStream, statement string) ([]*base.ANTLRAST, error) {+ var result []*base.ANTLRASTlexer := parser.NewTiDBLexer(input)stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)@@ -217,10 +217,10 @@ func parseInputStream(input *antlr.InputStream, statement string) ([]*base.Parsecontinue}- result = append(result, &base.ParseResult{- Tree: tree,- Tokens: tokens,- BaseLine: s.BaseLine,+ result = append(result, &base.ANTLRAST{+ StartPosition: &storepb.Position{Line: int32(s.BaseLine) + 1},+ Tree: tree,+ Tokens: tokens,})baseLine = int(s.End.GetLine())}diff --git a/backend/plugin/parser/trino/trino.go b/backend/plugin/parser/trino/trino.goindex 9117947caa..be3e6748ae 100644--- a/backend/plugin/parser/trino/trino.go+++ b/backend/plugin/parser/trino/trino.go@@ -13,17 +13,15 @@ import ("github.com/bytebase/bytebase/backend/plugin/parser/base")-// ParseResult is the result of parsing a Trino statement.--// ParseTrino parses the given SQL statement and returns a list of ParseResults.-// Each ParseResult represents one statement with its AST, tokens, and base line offset.-func ParseTrino(sql string) ([]*base.ParseResult, error) {+// ParseTrino parses the given SQL statement and returns a list of ANTLRAST.+// Each ANTLRAST represents one statement with its AST, tokens, and start position.+func ParseTrino(sql string) ([]*base.ANTLRAST, error) {stmts, err := SplitSQL(sql)if err != nil {return nil, errors.Wrap(err, "failed to split SQL")}- var results []*base.ParseResult+ var results []*base.ANTLRASTfor _, stmt := range stmts {if stmt.Empty {continue@@ -39,8 +37,8 @@ func ParseTrino(sql string) ([]*base.ParseResult, error) {return results, nil}-// parseSingleTrino parses a single Trino statement and returns the ParseResult.-func parseSingleTrino(sql string, baseLine int) (*base.ParseResult, error) {+// parseSingleTrino parses a single Trino statement and returns the ANTLRAST.+func parseSingleTrino(sql string, baseLine int) (*base.ANTLRAST, error) {// Add a semicolon if it's missing to allow users to omit the semicolontrimmedSQL := strings.TrimRightFunc(sql, unicode.IsSpace)if len(trimmedSQL) > 0 && !strings.HasSuffix(trimmedSQL, ";") {@@ -82,11 +80,11 @@ func parseSingleTrino(sql string, baseLine int) (*base.ParseResult, error) {return nil, parserErrorListener.Err}- // Return the parse result- return &base.ParseResult{- Tree: tree,- Tokens: stream,- BaseLine: baseLine,+ // Return the ANTLR AST+ return &base.ANTLRAST{+ StartPosition: startPosition,+ Tree: tree,+ Tokens: stream,}, nil}diff --git a/backend/plugin/parser/tsql/backup.go b/backend/plugin/parser/tsql/backup.goindex 0bb7005977..308deb3c65 100644--- a/backend/plugin/parser/tsql/backup.go+++ b/backend/plugin/parser/tsql/backup.go@@ -327,7 +327,7 @@ func (e *suffixSelectStatementExtractor) EnterDelete_statement(ctx *parser.Delet}func prepareTransformation(databaseName, statement string) ([]statementInfo, error) {- parseResults, err := ParseTSQL(statement)+ antlrASTs, err := ParseTSQL(statement)if err != nil {return nil, errors.Wrap(err, "failed to parse statement")}@@ -336,9 +336,9 @@ func prepareTransformation(databaseName, statement string) ([]statementInfo, errdatabaseName: databaseName,}- for _, parseResult := range parseResults {- extractor.baseLine = parseResult.BaseLine- antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)+ for _, ast := range antlrASTs {+ extractor.baseLine = base.GetLineOffset(ast.StartPosition)+ antlr.ParseTreeWalkerDefault.Walk(extractor, ast.Tree)}return extractor.dmls, nildiff --git a/backend/plugin/parser/tsql/query.go b/backend/plugin/parser/tsql/query.goindex 5e7787551b..1b3d54a034 100644--- a/backend/plugin/parser/tsql/query.go+++ b/backend/plugin/parser/tsql/query.go@@ -13,11 +13,11 @@ func init() {}func ValidateSQLForEditor(statement string) (bool, bool, error) {- parseResults, err := ParseTSQL(statement)+ antlrASTs, err := ParseTSQL(statement)if err != nil {return false, false, err}- if len(parseResults) == 0 {+ if len(antlrASTs) == 0 {return false, false, nil}@@ -25,8 +25,8 @@ func ValidateSQLForEditor(statement string) (bool, bool, error) {valid: true,}- for _, parseResult := range parseResults {- antlr.ParseTreeWalkerDefault.Walk(l, parseResult.Tree)+ for _, ast := range antlrASTs {+ antlr.ParseTreeWalkerDefault.Walk(l, ast.Tree)if !l.valid {break}diff --git a/backend/plugin/parser/tsql/query_span_extractor.go b/backend/plugin/parser/tsql/query_span_extractor.goindex efc3122f52..8ce543fcf3 100644--- a/backend/plugin/parser/tsql/query_span_extractor.go+++ b/backend/plugin/parser/tsql/query_span_extractor.go@@ -57,17 +57,17 @@ func newQuerySpanExtractor(defaultDatabase string, defaultSchema string, gCtx bafunc (q *querySpanExtractor) getQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {q.ctx = ctx- parseResults, err := ParseTSQL(statement)+ antlrASTs, err := ParseTSQL(statement)if err != nil {return nil, err}- if len(parseResults) != 1 {- return nil, errors.Errorf("expected exactly 1 statement, got %d", len(parseResults))+ if len(antlrASTs) != 1 {+ return nil, errors.Errorf("expected exactly 1 statement, got %d", len(antlrASTs))}- parseResult := parseResults[0]- tree := parseResult.Tree+ ast := antlrASTs[0]+ tree := ast.Treeif tree == nil {return nil, nil}@@ -105,10 +105,10 @@ func (q *querySpanExtractor) getQuerySpan(ctx context.Context, statement string)listener := &tsqlSelectOnlyListener{extractor: q,}- // Walk all parse results to collect temp table declarations from earlier statements- for _, parseResult := range parseResults {- if parseResult.Tree != nil {- antlr.ParseTreeWalkerDefault.Walk(listener, parseResult.Tree)+ // Walk all ASTs to collect temp table declarations from earlier statements+ for _, a := range antlrASTs {+ if a.Tree != nil {+ antlr.ParseTreeWalkerDefault.Walk(listener, a.Tree)}}err = listener.err@@ -3665,17 +3665,17 @@ func unquote(name string) string {}func getSelectBodyFromCreateView(createView string) (string, error) {- parseResults, err := ParseTSQL(createView)+ antlrASTs, err := ParseTSQL(createView)if err != nil {return "", err}- if len(parseResults) != 1 {- return "", errors.Errorf("expected exactly 1 statement, got %d", len(parseResults))+ if len(antlrASTs) != 1 {+ return "", errors.Errorf("expected exactly 1 statement, got %d", len(antlrASTs))}- parseResult := parseResults[0]- tree := parseResult.Tree+ ast := antlrASTs[0]+ tree := ast.Treeif tree == nil {return "", errors.Errorf("parse tree is nil")}diff --git a/backend/plugin/parser/tsql/restore.go b/backend/plugin/parser/tsql/restore.goindex 8a3568ddb3..0f00859ec1 100644--- a/backend/plugin/parser/tsql/restore.go+++ b/backend/plugin/parser/tsql/restore.go@@ -34,23 +34,23 @@ func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statementreturn "", errors.Errorf("no original SQL")}- parseResults, err := ParseTSQL(statement)+ antlrASTs, err := ParseTSQL(statement)if err != nil {return "", err}- // Find the parse result that contains the statement at the backup position- var targetResult *base.ParseResult- for _, parseResult := range parseResults {- // Walk the tree to find if this parse result contains the target statement+ // Find the AST that contains the statement at the backup position+ var targetResult *base.ANTLRAST+ for _, ast := range antlrASTs {+ // Walk the tree to find if this AST contains the target statementfinder := &statementAtPositionFinder{startPos: backupItem.StartPosition,endPos: backupItem.EndPosition,- baseLine: parseResult.BaseLine,+ baseLine: base.GetLineOffset(ast.StartPosition),}- antlr.ParseTreeWalkerDefault.Walk(finder, parseResult.Tree)+ antlr.ParseTreeWalkerDefault.Walk(finder, ast.Tree)if finder.found {- targetResult = parseResult+ targetResult = astbreak}}@@ -68,7 +68,7 @@ func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statementreturn doGenerate(ctx, rCtx, sqlForComment, targetResult, backupItem)}-func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment string, tree *base.ParseResult, backupItem *storepb.PriorBackupDetail_Item) (string, error) {+func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment string, ast *base.ANTLRAST, backupItem *storepb.PriorBackupDetail_Item) (string, error) {_, sourceDatabase, err := common.GetInstanceDatabaseID(backupItem.SourceTable.Database)if err != nil {return "", errors.Wrapf(err, "failed to get source database ID for %s", backupItem.SourceTable.Database)@@ -117,7 +117,7 @@ func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment strpk: tableMetadata.GetPrimaryKey(),table: tableMetadata,}- antlr.ParseTreeWalkerDefault.Walk(g, tree.Tree)+ antlr.ParseTreeWalkerDefault.Walk(g, ast.Tree)if g.err != nil {return "", g.err}@@ -382,10 +382,10 @@ func extractStatement(statement string, backupItem *storepb.PriorBackupDetail_ItendPos: backupItem.EndPosition,}- // 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)+ // Walk all ASTs to find statements within the specified position range+ for _, ast := range parseResults {+ l.baseLine = base.GetLineOffset(ast.StartPosition)+ antlr.ParseTreeWalkerDefault.Walk(l, ast.Tree)}if len(l.originalSQL) == 0 {diff --git a/backend/plugin/parser/tsql/tsql.go b/backend/plugin/parser/tsql/tsql.goindex 9b606d0d4a..4e40f2da69 100644--- a/backend/plugin/parser/tsql/tsql.go+++ b/backend/plugin/parser/tsql/tsql.go@@ -22,24 +22,15 @@ func init() {// parseTSQLForRegistry is the ParseFunc for T-SQL.// Returns []base.AST with *ANTLRAST instances.func parseTSQLForRegistry(statement string) ([]base.AST, error) {- parseResults, err := ParseTSQL(statement)+ antlrASTs, err := ParseTSQL(statement)if err != nil {return nil, err}- return toAST(parseResults), nil-}--// toAST converts []*ParseResult to []base.AST.-func toAST(results []*base.ParseResult) []base.AST {var asts []base.AST- for _, r := range results {- asts = append(asts, &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(r.BaseLine) + 1},- Tree: r.Tree,- Tokens: r.Tokens,- })+ for _, a := range antlrASTs {+ asts = append(asts, a)}- return asts+ return asts, nil}// parseTSQLStatements is the ParseStatementsFunc for T-SQL (MSSQL).@@ -52,24 +43,20 @@ func parseTSQLStatements(statement string) ([]base.ParsedStatement, error) {}// Then parse to get ASTs- parseResults, err := ParseTSQL(statement)+ antlrASTs, err := ParseTSQL(statement)if err != nil {return nil, err}- // Combine: Statement provides text/positions, ParseResult provides AST+ // Combine: Statement provides text/positions, ANTLRAST provides ASTvar result []base.ParsedStatementastIndex := 0for _, stmt := range stmts {ps := base.ParsedStatement{Statement: stmt,}- if !stmt.Empty && astIndex < len(parseResults) {- ps.AST = &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},- Tree: parseResults[astIndex].Tree,- Tokens: parseResults[astIndex].Tokens,- }+ if !stmt.Empty && astIndex < len(antlrASTs) {+ ps.AST = antlrASTs[astIndex]astIndex++}result = append(result, ps)@@ -78,32 +65,32 @@ func parseTSQLStatements(statement string) ([]base.ParsedStatement, error) {return result, nil}-// ParseTSQL parses the given SQL and returns a list of ParseResult (one per statement).+// ParseTSQL parses the given SQL and returns a list of ANTLRAST (one per statement).// Use the T-SQL parser based on antlr4.-func ParseTSQL(sql string) ([]*base.ParseResult, error) {+func ParseTSQL(sql string) ([]*base.ANTLRAST, error) {stmts, err := SplitSQL(sql)if err != nil {return nil, err}- var results []*base.ParseResult+ var results []*base.ANTLRASTfor _, stmt := range stmts {if stmt.Empty {continue}- parseResult, err := parseSingleTSQL(stmt.Text, stmt.BaseLine)+ antlrAST, err := parseSingleTSQL(stmt.Text, stmt.BaseLine)if err != nil {return nil, err}- results = append(results, parseResult)+ results = append(results, antlrAST)}return results, nil}-// parseSingleTSQL parses a single T-SQL statement and returns the ParseResult.-func parseSingleTSQL(statement string, baseLine int) (*base.ParseResult, error) {+// parseSingleTSQL parses a single T-SQL statement and returns the ANTLRAST.+func parseSingleTSQL(statement string, baseLine int) (*base.ANTLRAST, error) {inputStream := antlr.NewInputStream(statement)lexer := parser.NewTSqlLexer(inputStream)stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)@@ -137,10 +124,10 @@ func parseSingleTSQL(statement string, baseLine int) (*base.ParseResult, error)return nil, parserErrorListener.Err}- result := &base.ParseResult{- Tree: tree,- Tokens: stream,- BaseLine: baseLine,+ result := &base.ANTLRAST{+ StartPosition: startPosition,+ Tree: tree,+ Tokens: stream,}return result, nildiff --git a/backend/plugin/schema/mysql/walk_through.go b/backend/plugin/schema/mysql/walk_through.goindex 6634b20a5c..efee9982e1 100644--- a/backend/plugin/schema/mysql/walk_through.go+++ b/backend/plugin/schema/mysql/walk_through.go@@ -44,8 +44,8 @@ func WalkThrough(d *model.DatabaseMetadata, ast []base.AST) *storepb.Advice {d.CreateSchema("")}- // Extract ParseResult from AST- var nodeList []*base.ParseResult+ // Extract ANTLRAST from AST+ var nodeList []*base.ANTLRASTfor _, unifiedAST := range ast {antlrAST, ok := base.GetANTLRAST(unifiedAST)if !ok {@@ -59,11 +59,7 @@ func WalkThrough(d *model.DatabaseMetadata, ast []base.AST) *storepb.Advice {},}}- nodeList = append(nodeList, &base.ParseResult{- Tree: antlrAST.Tree,- Tokens: antlrAST.Tokens,- BaseLine: base.GetLineOffset(antlrAST.StartPosition),- })+ nodeList = append(nodeList, antlrAST)}for _, node := range nodeList {@@ -90,9 +86,9 @@ func (l *mysqlListener) EnterQuery(ctx *mysql.QueryContext) {l.lineNumber = l.baseLine + ctx.GetStart().GetLine()}-func mysqlChangeState(d *model.DatabaseMetadata, in *base.ParseResult) *storepb.Advice {+func mysqlChangeState(d *model.DatabaseMetadata, in *base.ANTLRAST) *storepb.Advice {listener := &mysqlListener{- baseLine: in.BaseLine,+ baseLine: base.GetLineOffset(in.StartPosition),databaseMetadata: d,}antlr.ParseTreeWalkerDefault.Walk(listener, in.Tree)diff --git a/backend/plugin/schema/pg/walk_through.go b/backend/plugin/schema/pg/walk_through.goindex 2e2f70e36d..e226b31896 100644--- a/backend/plugin/schema/pg/walk_through.go+++ b/backend/plugin/schema/pg/walk_through.go@@ -26,8 +26,8 @@ func init() {// WalkThrough walks through the PostgreSQL ANTLR parse tree and builds catalog metadata.func WalkThrough(d *model.DatabaseMetadata, ast []base.AST) *storepb.Advice {- // Extract ParseResult from AST- var parseResults []*base.ParseResult+ // Extract ANTLRAST from AST+ var antlrASTList []*base.ANTLRASTfor _, unifiedAST := range ast {antlrAST, ok := base.GetANTLRAST(unifiedAST)if !ok {@@ -41,11 +41,7 @@ func WalkThrough(d *model.DatabaseMetadata, ast []base.AST) *storepb.Advice {},}}- parseResults = append(parseResults, &base.ParseResult{- Tree: antlrAST.Tree,- Tokens: antlrAST.Tokens,- BaseLine: base.GetLineOffset(antlrAST.StartPosition),- })+ antlrASTList = append(antlrASTList, antlrAST)}// Build listener with database state@@ -55,14 +51,14 @@ func WalkThrough(d *model.DatabaseMetadata, ast []base.AST) *storepb.Advice {}// Walk through all parse results- for _, parseResult := range parseResults {- root, ok := parseResult.Tree.(parser.IRootContext)+ for _, antlrAST := range antlrASTList {+ root, ok := antlrAST.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("invalid ANTLR tree type %T", antlrAST.Tree),+ Content: fmt.Sprintf("invalid ANTLR tree type %T", antlrAST.Tree),StartPosition: &storepb.Position{Line: 0,},