Skip to content

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

refactor(parser): eliminate ParseResult type, return ANTLRAST directly (#18537)

h3n4la3dd854472ae
diff --git a/backend/plugin/advisor/advisor.go b/backend/plugin/advisor/advisor.go
index 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.go
index 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 checking
rule := 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.dmls
diff --git a/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.go b/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_column_no_null.go b/backend/plugin/advisor/mssql/rule_column_no_null.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_column_require.go b/backend/plugin/advisor/mssql/rule_column_require.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_column_type_disallow_list.go b/backend/plugin/advisor/mssql/rule_column_type_disallow_list.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_function_disallow_create_or_alter.go b/backend/plugin/advisor/mssql/rule_function_disallow_create_or_alter.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_index_not_redundant.go b/backend/plugin/advisor/mssql/rule_index_not_redundant.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_migration_compatibility.go b/backend/plugin/advisor/mssql/rule_migration_compatibility.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_naming_identifier_no_keyword.go b/backend/plugin/advisor/mssql/rule_naming_identifier_no_keyword.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_naming_table.go b/backend/plugin/advisor/mssql/rule_naming_table.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_naming_table_no_keyword.go b/backend/plugin/advisor/mssql/rule_naming_table_no_keyword.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_procedure_disallow_create_or_alter.go b/backend/plugin/advisor/mssql/rule_procedure_disallow_create_or_alter.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_select_no_select_all.go b/backend/plugin/advisor/mssql/rule_select_no_select_all.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_statement_disallow_cross_db_queries.go b/backend/plugin/advisor/mssql/rule_statement_disallow_cross_db_queries.go
index 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 rule
checker := 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(), nil
diff --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.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_select.go b/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_select.go
index 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 rule
checker := 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(), nil
diff --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.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_table_disallow_ddl.go b/backend/plugin/advisor/mssql/rule_table_disallow_ddl.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_table_disallow_dml.go b/backend/plugin/advisor/mssql/rule_table_disallow_dml.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_table_drop_naming_convention.go b/backend/plugin/advisor/mssql/rule_table_drop_naming_convention.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mssql/rule_table_no_foreign_key.go b/backend/plugin/advisor/mssql/rule_table_no_foreign_key.go
index 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 rule
checker := 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 walking
diff --git a/backend/plugin/advisor/mssql/rule_table_require_pk.go b/backend/plugin/advisor/mssql/rule_table_require_pk.go
index 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 rule
checker := 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 walking
diff --git a/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.go
index 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 adv
return 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.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_collation_allowlist.go b/backend/plugin/advisor/mysql/rule_collation_allowlist.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_auto_increment_initial_value.go b/backend/plugin/advisor/mysql/rule_column_auto_increment_initial_value.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_auto_increment_must_integer.go b/backend/plugin/advisor/mysql/rule_column_auto_increment_must_integer.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_auto_increment_must_unsigned.go b/backend/plugin/advisor/mysql/rule_column_auto_increment_must_unsigned.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_comment_convention.go b/backend/plugin/advisor/mysql/rule_column_comment_convention.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_current_time_count_limit.go b/backend/plugin/advisor/mysql/rule_column_current_time_count_limit.go
index 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 rule
checker := 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 walking
diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_changing.go b/backend/plugin/advisor/mysql/rule_column_disallow_changing.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_changing_order.go b/backend/plugin/advisor/mysql/rule_column_disallow_changing_order.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go b/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_drop.go b/backend/plugin/advisor/mysql/rule_column_disallow_drop.go
index 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 rule
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 {
+ 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go b/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go
index 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 rule
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 {
+ 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_set_charset.go b/backend/plugin/advisor/mysql/rule_column_disallow_set_charset.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_maximum_character_length.go b/backend/plugin/advisor/mysql/rule_column_maximum_character_length.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_maximum_varchar_length.go b/backend/plugin/advisor/mysql/rule_column_maximum_varchar_length.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_no_null.go b/backend/plugin/advisor/mysql/rule_column_no_null.go
index 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 rule
checker := 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 walking
diff --git a/backend/plugin/advisor/mysql/rule_column_require_charset.go b/backend/plugin/advisor/mysql/rule_column_require_charset.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_require_collation.go b/backend/plugin/advisor/mysql/rule_column_require_collation.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_require_default.go b/backend/plugin/advisor/mysql/rule_column_require_default.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_required.go b/backend/plugin/advisor/mysql/rule_column_required.go
index 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 rule
checker := 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(), nil
diff --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.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_column_type_disallow_list.go b/backend/plugin/advisor/mysql/rule_column_type_disallow_list.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_database_drop_empty_db.go b/backend/plugin/advisor/mysql/rule_database_drop_empty_db.go
index 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 rule
checker := 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_disallow_procedure.go b/backend/plugin/advisor/mysql/rule_disallow_procedure.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_event_disallow_create.go b/backend/plugin/advisor/mysql/rule_event_disallow_create.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_function_disallow_create.go b/backend/plugin/advisor/mysql/rule_function_disallow_create.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_function_disallowed_list.go b/backend/plugin/advisor/mysql/rule_function_disallowed_list.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_index_key_number_limit.go b/backend/plugin/advisor/mysql/rule_index_key_number_limit.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_index_no_duplicate_column.go b/backend/plugin/advisor/mysql/rule_index_no_duplicate_column.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_index_pk_type.go b/backend/plugin/advisor/mysql/rule_index_pk_type.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_index_primary_key_type_allowlist.go b/backend/plugin/advisor/mysql/rule_index_primary_key_type_allowlist.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_index_total_number_limit.go b/backend/plugin/advisor/mysql/rule_index_total_number_limit.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_index_type_allow_list.go b/backend/plugin/advisor/mysql/rule_index_type_allow_list.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_index_type_no_blob.go b/backend/plugin/advisor/mysql/rule_index_type_no_blob.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_insert_disallow_order_by_rand.go b/backend/plugin/advisor/mysql/rule_insert_disallow_order_by_rand.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_insert_must_specify_column.go b/backend/plugin/advisor/mysql/rule_insert_must_specify_column.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_insert_row_limit.go b/backend/plugin/advisor/mysql/rule_insert_row_limit.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_naming_auto_increment_column.go b/backend/plugin/advisor/mysql/rule_naming_auto_increment_column.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_naming_column.go b/backend/plugin/advisor/mysql/rule_naming_column.go
index 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 rule
checker := 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_foreign_key_convention.go b/backend/plugin/advisor/mysql/rule_naming_foreign_key_convention.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_naming_identifier_no_keyword.go b/backend/plugin/advisor/mysql/rule_naming_identifier_no_keyword.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_naming_index_convention.go b/backend/plugin/advisor/mysql/rule_naming_index_convention.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_naming_table.go b/backend/plugin/advisor/mysql/rule_naming_table.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_online_migration.go b/backend/plugin/advisor/mysql/rule_online_migration.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_statement_affected_row_limit.go b/backend/plugin/advisor/mysql/rule_statement_affected_row_limit.go
index 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 adv
checker := 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.go
index 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, checkCt
checker := 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.go
index 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, checkC
checker := 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.go
index 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.Co
checker := 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.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_statement_maximum_join_table_count.go b/backend/plugin/advisor/mysql/rule_statement_maximum_join_table_count.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_statement_maximum_limit_value.go b/backend/plugin/advisor/mysql/rule_statement_maximum_limit_value.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_statement_maximum_statements_in_transaction.go b/backend/plugin/advisor/mysql/rule_statement_maximum_statements_in_transaction.go
index 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 mysql
import (
"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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_statement_merge_alter_table.go b/backend/plugin/advisor/mysql/rule_statement_merge_alter_table.go
index 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 rule
checker := 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 information
diff --git a/backend/plugin/advisor/mysql/rule_statement_query_minimum_plan_level.go b/backend/plugin/advisor/mysql/rule_statement_query_minimum_plan_level.go
index 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, checkCt
checker := 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.go
index 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, checkCtx
checker := 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.go
index 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 rule
checker := 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(), nil
diff --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.go
index 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 statement
rule := NewStatementWhereMaximumLogicalOperatorCountRule(level, checkCtx.Rule.Type.String(), int(numberPayload.Number))
@@ -53,7 +47,14 @@ func (*StatementWhereMaximumLogicalOperatorCountAdvisor) Check(_ context.Context
rule.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 tree
rule.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.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_stmt_disallow_commit.go b/backend/plugin/advisor/mysql/rule_stmt_disallow_commit.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_stmt_disallow_limit.go b/backend/plugin/advisor/mysql/rule_stmt_disallow_limit.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_stmt_disallow_order_by.go b/backend/plugin/advisor/mysql/rule_stmt_disallow_order_by.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_stmt_max_execution_time.go b/backend/plugin/advisor/mysql/rule_stmt_max_execution_time.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_stmt_no_leading_wildcard_like.go b/backend/plugin/advisor/mysql/rule_stmt_no_leading_wildcard_like.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_stmt_no_select_all.go b/backend/plugin/advisor/mysql/rule_stmt_no_select_all.go
index 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 rule
checker := 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(), nil
diff --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.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_select.go b/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_select.go
index 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 rule
checker := 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(), nil
diff --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.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_table_comment_convention.go b/backend/plugin/advisor/mysql/rule_table_comment_convention.go
index 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 rule
checker := 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_table_disallow_ddl.go b/backend/plugin/advisor/mysql/rule_table_disallow_ddl.go
index 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 rule
checker := 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_table_disallow_dml.go b/backend/plugin/advisor/mysql/rule_table_disallow_dml.go
index 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 rule
checker := 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_table_disallow_partition.go b/backend/plugin/advisor/mysql/rule_table_disallow_partition.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_table_disallow_set_charset.go b/backend/plugin/advisor/mysql/rule_table_disallow_set_charset.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_table_disallow_trigger.go b/backend/plugin/advisor/mysql/rule_table_disallow_trigger.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_table_drop_naming_convention.go b/backend/plugin/advisor/mysql/rule_table_drop_naming_convention.go
index 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 rule
checker := 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_table_limit_size.go b/backend/plugin/advisor/mysql/rule_table_limit_size.go
index 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.Contex
return 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.Contex
var 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 rule
checker := 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 information
rule.generateAdvice()
diff --git a/backend/plugin/advisor/mysql/rule_table_no_duplicate_index.go b/backend/plugin/advisor/mysql/rule_table_no_duplicate_index.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_table_no_fk.go b/backend/plugin/advisor/mysql/rule_table_no_fk.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_table_require_charset.go b/backend/plugin/advisor/mysql/rule_table_require_charset.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_table_require_collation.go b/backend/plugin/advisor/mysql/rule_table_require_collation.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_table_require_pk.go b/backend/plugin/advisor/mysql/rule_table_require_pk.go
index 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 rule
checker := 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 walking
diff --git a/backend/plugin/advisor/mysql/rule_table_text_fields_total_length.go b/backend/plugin/advisor/mysql/rule_table_text_fields_total_length.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/mysql/rule_use_innodb.go b/backend/plugin/advisor/mysql/rule_use_innodb.go
index 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 rule
checker := 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_view_disallow_create.go b/backend/plugin/advisor/mysql/rule_view_disallow_create.go
index 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 rule
checker := 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(), nil
diff --git a/backend/plugin/advisor/oceanbase/advisor_disallow_offline_ddl.go b/backend/plugin/advisor/oceanbase/advisor_disallow_offline_ddl.go
index 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.Cont
currentDB: 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, nil
diff --git a/backend/plugin/advisor/oceanbase/advisor_insert_row_limit.go b/backend/plugin/advisor/oceanbase/advisor_insert_row_limit.go
index 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.Contex
ctx: 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.go
index 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.go
index 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 adv
return 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 adv
rule := 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.go
index 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, che
rule := 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.go
index 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 advisor
rule := 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.go
index 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 ad
rule := 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.go
index 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 advi
rule := 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.go
index 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.go
index 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.go
index 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.Co
rule := 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.go
index 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.go
index 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.Con
rule := 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.go
index 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 advisor
rule := 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.go
index 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.Co
rule := 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.go
index 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 advis
rule := 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.go
index 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.go
index 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.Co
rule := 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.go
index 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.Conte
rule := 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.go
index 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.Co
checker := 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.go
index 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.go
index 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.Conte
rule := 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.go
index 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.go
index 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 advi
rule := 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.go
index 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.C
rule := 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.go
index 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 adv
rule := 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.go
index 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 advisor
return 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 advisor
var 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.go
index 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.Cont
checker := 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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_column_comment_convention.go b/backend/plugin/advisor/pg/advisor_column_comment_convention.go
index 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 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)
}
// Now validate all collected columns against comments
diff --git a/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go b/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go
index 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 a
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go b/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go
index 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 advi
checker := 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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go b/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go
index 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 ad
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_column_no_null.go b/backend/plugin/advisor/pg/advisor_column_no_null.go
index 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 walked
diff --git a/backend/plugin/advisor/pg/advisor_column_require_default.go b/backend/plugin/advisor/pg/advisor_column_require_default.go
index 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.Co
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_column_required.go b/backend/plugin/advisor/pg/advisor_column_required.go
index 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.Conte
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go b/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go
index 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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_comment_convention.go b/backend/plugin/advisor/pg/advisor_comment_convention.go
index 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.Conte
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_encoding_allowlist.go b/backend/plugin/advisor/pg/advisor_encoding_allowlist.go
index 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.Conte
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_index_create_concurrently.go b/backend/plugin/advisor/pg/advisor_index_create_concurrently.go
index 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.Conte
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_index_key_number_limit.go b/backend/plugin/advisor/pg/advisor_index_key_number_limit.go
index 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.Con
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go b/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go
index 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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.go b/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.go
index 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 ad
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_index_total_number_limit.go b/backend/plugin/advisor/pg/advisor_index_total_number_limit.go
index 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.C
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)
}
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.go
index 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.go
index 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.go
index 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.Contex
maxRow: 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.go
index 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.Advice
lastCreateTable := ""
- 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.lastCreateTable
diff --git a/backend/plugin/advisor/pg/advisor_naming_column.go b/backend/plugin/advisor/pg/advisor_naming_column.go
index 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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go
index 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.Cont
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go b/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go
index 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 statement
func (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.go
index 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.C
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go
index 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.Cont
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_naming_table.go b/backend/plugin/advisor/pg/advisor_naming_table.go
index 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.C
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go
index 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.Cont
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.go b/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.go
index 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 advis
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.go b/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.go
index 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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go b/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go
index 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 adv
ctx: 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.go
index 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.go
index 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.C
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.go b/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.go
index 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, ch
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.go b/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.go
index 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 adv
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go b/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go
index 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.go
index 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.go
index 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, checkC
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go b/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go
index 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.Co
ctx: 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.go
index 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 advi
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go b/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go
index 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 adviso
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 rule.generateAdvice(), nil
diff --git a/backend/plugin/advisor/pg/advisor_statement_no_leading_wildcard_like.go b/backend/plugin/advisor/pg/advisor_statement_no_leading_wildcard_like.go
index 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.go
index 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.go
index 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.go
index 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 adv
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_statement_where_required_select.go b/backend/plugin/advisor/pg/advisor_statement_where_required_select.go
index 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.go
index 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.go
index 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 requirements
diff --git a/backend/plugin/advisor/pg/advisor_table_disallow_partition.go b/backend/plugin/advisor/pg/advisor_table_disallow_partition.go
index 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.go
index 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 advis
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(), nil
diff --git a/backend/plugin/advisor/pg/advisor_table_no_fk.go b/backend/plugin/advisor/pg/advisor_table_no_fk.go
index 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.go
index 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 statements
diff --git a/backend/plugin/advisor/snowflake/rule_column_maximum_varchar_length.go b/backend/plugin/advisor/snowflake/rule_column_maximum_varchar_length.go
index 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 rule
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(), nil
diff --git a/backend/plugin/advisor/snowflake/rule_column_no_null.go b/backend/plugin/advisor/snowflake/rule_column_no_null.go
index 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 rule
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(), nil
diff --git a/backend/plugin/advisor/snowflake/rule_column_require.go b/backend/plugin/advisor/snowflake/rule_column_require.go
index 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(), nil
diff --git a/backend/plugin/advisor/snowflake/rule_migration_compatibility.go b/backend/plugin/advisor/snowflake/rule_migration_compatibility.go
index 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(), nil
diff --git a/backend/plugin/advisor/snowflake/rule_naming_identifier_case.go b/backend/plugin/advisor/snowflake/rule_naming_identifier_case.go
index 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.Co
rule := 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(), nil
diff --git a/backend/plugin/advisor/snowflake/rule_naming_identifier_no_keyword.go b/backend/plugin/advisor/snowflake/rule_naming_identifier_no_keyword.go
index 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 advis
rule := 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(), nil
diff --git a/backend/plugin/advisor/snowflake/rule_naming_table.go b/backend/plugin/advisor/snowflake/rule_naming_table.go
index 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(), nil
diff --git a/backend/plugin/advisor/snowflake/rule_naming_table_no_keyword.go b/backend/plugin/advisor/snowflake/rule_naming_table_no_keyword.go
index 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.Co
rule := 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(), nil
diff --git a/backend/plugin/advisor/snowflake/rule_select_no_select_all.go b/backend/plugin/advisor/snowflake/rule_select_no_select_all.go
index 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.Conte
rule := 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(), nil
diff --git a/backend/plugin/advisor/snowflake/rule_table_drop_naming_convention.go b/backend/plugin/advisor/snowflake/rule_table_drop_naming_convention.go
index 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 advis
rule := 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(), nil
diff --git a/backend/plugin/advisor/snowflake/rule_table_no_foreign_key.go b/backend/plugin/advisor/snowflake/rule_table_no_foreign_key.go
index 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.Conte
rule := 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(), nil
diff --git a/backend/plugin/advisor/snowflake/rule_table_require_pk.go b/backend/plugin/advisor/snowflake/rule_table_require_pk.go
index 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(), nil
diff --git a/backend/plugin/advisor/snowflake/rule_where_require_select.go b/backend/plugin/advisor/snowflake/rule_where_require_select.go
index 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.C
rule := 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(), nil
diff --git a/backend/plugin/advisor/snowflake/rule_where_require_update_delete.go b/backend/plugin/advisor/snowflake/rule_where_require_update_delete.go
index 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 adv
rule := 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(), nil
diff --git a/backend/plugin/parser/base/base.go b/backend/plugin/parser/base/base.go
index 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.go
index 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.ANTLRAST
for _, 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.go
index 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.ANTLRAST
for _, 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, nil
diff --git a/backend/plugin/parser/cassandra/cassandra_test.go b/backend/plugin/parser/cassandra/cassandra_test.go
index 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.go
index 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.ANTLRAST
for _, 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.ParseResult
return nil, parserErrorListener.Err
}
- result := &base.ParseResult{
- Tree: tree,
- Tokens: stream,
- BaseLine: baseLine,
+ result := &base.ANTLRAST{
+ StartPosition: startPosition,
+ Tree: tree,
+ Tokens: stream,
}
return result, nil
diff --git a/backend/plugin/parser/cosmosdb/cosmosdb_test.go b/backend/plugin/parser/cosmosdb/cosmosdb_test.go
index 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.go
index 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 AST
var result []base.ParsedStatement
astIndex := 0
for _, 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.ANTLRAST
for _, 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, err
return nil, parserErrorListener.Err
}
- result := &base.ParseResult{
- Tree: tree,
- Tokens: stream,
- BaseLine: baseLine,
+ result := &base.ANTLRAST{
+ StartPosition: startPosition,
+ Tree: tree,
+ Tokens: stream,
}
return result, nil
diff --git a/backend/plugin/parser/doris/query_span_extractor.go b/backend/plugin/parser/doris/query_span_extractor.go
index 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, ignor
func (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 query
cteListener := newCTEListener()
- antlr.ParseTreeWalkerDefault.Walk(cteListener, parseResult.Tree)
+ antlr.ParseTreeWalkerDefault.Walk(cteListener, antlrAST.Tree)
// Merge extracted CTEs with any existing ones
for 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.go
index 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.go
index 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 AST
var result []base.ParsedStatement
astIndex := 0
for _, 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.ANTLRAST
lexer := parser.NewMySQLLexer(input)
stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
@@ -303,10 +289,10 @@ func parseInputStream(input *antlr.InputStream, statement string) ([]*base.Parse
continue
}
- 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-based
baseLine = int(s.End.Line) - 1
diff --git a/backend/plugin/parser/mysql/restore.go b/backend/plugin/parser/mysql/restore.go
index 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, statement
return 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 str
normalColumns: 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.go
index 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 AST
var result []base.ParsedStatement
astIndex := 0
for _, 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.ANTLRAST
for _, 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, erro
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
diff --git a/backend/plugin/parser/pg/backup.go b/backend/plugin/parser/pg/backup.go
index 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 statements
for _, 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.err
diff --git a/backend/plugin/parser/pg/pg.go b/backend/plugin/parser/pg/pg.go
index 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 AST
var result []base.ParsedStatement
astIndex := 0
for _, 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.ANTLRAST
for _, 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, nil
diff --git a/backend/plugin/parser/pg/restore.go b/backend/plugin/parser/pg/restore.go
index 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.ANTLRAST
for _, parseResult := range parseResults {
// Walk the tree to find if this parse result contains the target statement
finder := &statementAtPositionFinder{
startPos: backupItem.StartPosition,
endPos: backupItem.EndPosition,
- baseLine: parseResult.BaseLine,
+ 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, statement
return 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 range
for _, 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.go
index 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, err
databaseName: databaseName,
}
- // Walk each parse result tree to extract DML statements
+ // Walk each ANTLRAST tree to extract DML statements
for _, 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.go
index 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 AST
var result []base.ParsedStatement
astIndex := 0
for _, 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.ANTLRAST
for _, child := range sqlScript.GetChildren() {
var stmtText string
var 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.go
index 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.go
index 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) ([]ba
return 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.go
index 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 AST
var result []base.ParsedStatement
astIndex := 0
for _, 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.ANTLRAST
for _, 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, err
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
diff --git a/backend/plugin/parser/snowflake/snowflake.go b/backend/plugin/parser/snowflake/snowflake.go
index 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 AST
var result []base.ParsedStatement
astIndex := 0
for _, 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.ANTLRAST
for _, 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, erro
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
diff --git a/backend/plugin/parser/spanner/spanner.go b/backend/plugin/parser/spanner/spanner.go
index 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.ANTLRAST
for _, 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.ParseRes
return nil, parserErrorListener.Err
}
- result := &base.ParseResult{
- Tree: tree,
- Tokens: stream,
- BaseLine: baseLine,
+ result := &base.ANTLRAST{
+ StartPosition: startPosition,
+ Tree: tree,
+ Tokens: stream,
}
return result, nil
diff --git a/backend/plugin/parser/tidb/backup.go b/backend/plugin/parser/tidb/backup.go
index 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.go
index 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, er
return 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.Co
return 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.ANTLRAST
lexer := parser.NewTiDBLexer(input)
stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
@@ -217,10 +217,10 @@ func parseInputStream(input *antlr.InputStream, statement string) ([]*base.Parse
continue
}
- 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.go
index 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.ANTLRAST
for _, 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 semicolon
trimmedSQL := 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.go
index 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, err
databaseName: 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, nil
diff --git a/backend/plugin/parser/tsql/query.go b/backend/plugin/parser/tsql/query.go
index 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.go
index 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 ba
func (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.Tree
if 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.Tree
if tree == nil {
return "", errors.Errorf("parse tree is nil")
}
diff --git a/backend/plugin/parser/tsql/restore.go b/backend/plugin/parser/tsql/restore.go
index 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, statement
return "", 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 statement
finder := &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 = ast
break
}
}
@@ -68,7 +68,7 @@ func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statement
return 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 str
pk: 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_It
endPos: 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.go
index 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 AST
var result []base.ParsedStatement
astIndex := 0
for _, 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.ANTLRAST
for _, 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, nil
diff --git a/backend/plugin/schema/mysql/walk_through.go b/backend/plugin/schema/mysql/walk_through.go
index 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.ANTLRAST
for _, 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.go
index 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.ANTLRAST
for _, 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,
},