Skip to content

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

refactor: standardize Snowflake parser to return list of ParseResults (#18155)

h3n4l27b19f817d04
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 78b674fef4..9c9744964d 100644
--- a/backend/plugin/advisor/snowflake/rule_column_maximum_varchar_length.go
+++ b/backend/plugin/advisor/snowflake/rule_column_maximum_varchar_length.go
@@ -9,7 +9,6 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/snowflake"
- "github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -36,9 +35,9 @@ type ColumnMaximumVarcharLengthAdvisor struct {
// Check checks for maximum varchar length.
func (*ColumnMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, ok := checkCtx.AST.(antlr.Tree)
- if !ok {
- return nil, errors.Errorf("failed to convert to Tree")
+ parseResults, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -60,7 +59,11 @@ func (*ColumnMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advi
// Create the generic checker with the rule
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/snowflake/rule_column_no_null.go b/backend/plugin/advisor/snowflake/rule_column_no_null.go
index a993058760..ab50183bfa 100644
--- a/backend/plugin/advisor/snowflake/rule_column_no_null.go
+++ b/backend/plugin/advisor/snowflake/rule_column_no_null.go
@@ -6,7 +6,6 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/snowflake"
- "github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -29,9 +28,9 @@ type ColumnNoNullAdvisor struct {
// Check checks for column no NULL value.
func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, ok := checkCtx.AST.(antlr.Tree)
- if !ok {
- return nil, errors.Errorf("failed to convert to Tree")
+ parseResults, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -45,7 +44,11 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (
// Create the generic checker with the rule
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/snowflake/rule_column_require.go b/backend/plugin/advisor/snowflake/rule_column_require.go
index 3ec117df9d..58c3fb31d0 100644
--- a/backend/plugin/advisor/snowflake/rule_column_require.go
+++ b/backend/plugin/advisor/snowflake/rule_column_require.go
@@ -10,7 +10,6 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/snowflake"
- "github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -32,9 +31,9 @@ type ColumnRequireAdvisor struct {
// Check checks for column requirement.
func (*ColumnRequireAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, ok := checkCtx.AST.(antlr.Tree)
- if !ok {
- return nil, errors.Errorf("failed to convert to Tree")
+ parseResults, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -54,7 +53,11 @@ func (*ColumnRequireAdvisor) Check(_ context.Context, checkCtx advisor.Context)
rule := NewColumnRequireRule(level, string(checkCtx.Rule.Type), requireColumns)
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
@@ -156,7 +159,7 @@ func (r *ColumnRequireRule) exitCreateTable(ctx *parser.Create_tableContext) {
Code: code.NoRequiredColumn.Int32(),
Title: r.title,
Content: fmt.Sprintf("Table %s missing required column %q", r.currentOriginalTableName, column),
- StartPosition: common.ConvertANTLRLineToPosition(ctx.Column_decl_item_list().GetStop().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.Column_decl_item_list().GetStop().GetLine()),
})
}
r.currentOriginalTableName = ""
@@ -198,7 +201,7 @@ func (r *ColumnRequireRule) exitAlterTable(ctx *parser.Alter_tableContext) {
Code: code.NoRequiredColumn.Int32(),
Title: r.title,
Content: fmt.Sprintf("Table %s missing required column %q", r.currentOriginalTableName, column),
- StartPosition: common.ConvertANTLRLineToPosition(ctx.Table_column_action().GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.Table_column_action().GetStart().GetLine()),
})
}
r.currentOriginalTableName = ""
diff --git a/backend/plugin/advisor/snowflake/rule_migration_compatibility.go b/backend/plugin/advisor/snowflake/rule_migration_compatibility.go
index cca8f926ab..b510943d2c 100644
--- a/backend/plugin/advisor/snowflake/rule_migration_compatibility.go
+++ b/backend/plugin/advisor/snowflake/rule_migration_compatibility.go
@@ -8,7 +8,6 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/snowflake"
- "github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -31,9 +30,9 @@ type MigrationCompatibilityAdvisor struct {
// Check checks for migration compatibility.
func (*MigrationCompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, ok := checkCtx.AST.(antlr.Tree)
- if !ok {
- return nil, errors.Errorf("failed to convert to Tree")
+ parseResults, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -44,7 +43,11 @@ func (*MigrationCompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.
rule := NewMigrationCompatibilityRule(level, string(checkCtx.Rule.Type), checkCtx.CurrentDatabase)
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
@@ -148,7 +151,7 @@ func (r *MigrationCompatibilityRule) enterDropTable(ctx *parser.Drop_tableContex
Code: code.CompatibilityDropTable.Int32(),
Title: r.title,
Content: fmt.Sprintf("Drop table %q may cause incompatibility with the existing data and code", normalizedFullDropTableName),
- StartPosition: common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),
})
}
@@ -167,7 +170,7 @@ func (r *MigrationCompatibilityRule) enterDropSchema(ctx *parser.Drop_schemaCont
Code: code.CompatibilityDropSchema.Int32(),
Title: r.title,
Content: fmt.Sprintf("Drop schema %q may cause incompatibility with the existing data and code", normalizedFullDropSchemaName),
- StartPosition: common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),
})
}
@@ -186,7 +189,7 @@ func (r *MigrationCompatibilityRule) enterDropDatabase(ctx *parser.Drop_database
Code: code.CompatibilityDropDatabase.Int32(),
Title: r.title,
Content: fmt.Sprintf("Drop database %q may cause incompatibility with the existing data and code", normalizedFullDropDatabaseName),
- StartPosition: common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),
})
}
@@ -209,6 +212,6 @@ func (r *MigrationCompatibilityRule) enterAlterTable(ctx *parser.Alter_tableCont
Code: code.CompatibilityDropColumn.Int32(),
Title: r.title,
Content: fmt.Sprintf("Drop column %s may cause incompatibility with the existing data and code", strings.Join(normalizedAllColumnNames, ",")),
- StartPosition: common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),
})
}
diff --git a/backend/plugin/advisor/snowflake/rule_naming_identifier_case.go b/backend/plugin/advisor/snowflake/rule_naming_identifier_case.go
index 71e88188e4..12ea04c123 100644
--- a/backend/plugin/advisor/snowflake/rule_naming_identifier_case.go
+++ b/backend/plugin/advisor/snowflake/rule_naming_identifier_case.go
@@ -8,7 +8,6 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/snowflake"
- "github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -31,9 +30,9 @@ type NamingIdentifierCaseAdvisor struct {
// Check checks for identifier case.
func (*NamingIdentifierCaseAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, ok := checkCtx.AST.(antlr.Tree)
- if !ok {
- return nil, errors.Errorf("failed to convert to Tree")
+ parseResults, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -44,7 +43,11 @@ func (*NamingIdentifierCaseAdvisor) Check(_ context.Context, checkCtx advisor.Co
rule := NewNamingIdentifierCaseRule(level, string(checkCtx.Rule.Type))
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
@@ -119,7 +122,7 @@ func (r *NamingIdentifierCaseRule) enterColumnDeclItemList(ctx *parser.Column_de
Code: code.NamingCaseMismatch.Int32(),
Title: r.title,
Content: fmt.Sprintf("Identifier %q should be upper case", originalColName),
- StartPosition: common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),
})
}
}
@@ -139,7 +142,7 @@ func (r *NamingIdentifierCaseRule) enterAlterTable(ctx *parser.Alter_tableContex
Code: code.NamingCaseMismatch.Int32(),
Title: r.title,
Content: fmt.Sprintf("Identifier %q should be upper case", renameToColName),
- StartPosition: common.ConvertANTLRLineToPosition(renameToID.GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + renameToID.GetStart().GetLine()),
})
}
}
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 05cd35bf7c..fd04fd1de5 100644
--- a/backend/plugin/advisor/snowflake/rule_naming_identifier_no_keyword.go
+++ b/backend/plugin/advisor/snowflake/rule_naming_identifier_no_keyword.go
@@ -9,7 +9,6 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/snowflake"
- "github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -31,9 +30,9 @@ type NamingIdentifierNoKeywordAdvisor struct {
// Check checks for identifier naming convention without keyword.
func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, ok := checkCtx.AST.(antlr.Tree)
- if !ok {
- return nil, errors.Errorf("failed to convert to Tree")
+ parseResults, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -44,7 +43,11 @@ func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advis
rule := NewNamingIdentifierNoKeywordRule(level, string(checkCtx.Rule.Type))
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
@@ -119,7 +122,7 @@ func (r *NamingIdentifierNoKeywordRule) enterColumnDeclItemList(ctx *parser.Colu
Code: code.NameIsKeywordIdentifier.Int32(),
Title: r.title,
Content: fmt.Sprintf("Identifier %s is a keyword and should be avoided", originalID.GetText()),
- StartPosition: common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),
})
}
}
@@ -139,7 +142,7 @@ func (r *NamingIdentifierNoKeywordRule) enterAlterTable(ctx *parser.Alter_tableC
Code: code.NameIsKeywordIdentifier.Int32(),
Title: r.title,
Content: fmt.Sprintf("Identifier %s is a keyword and should be avoided", renameToID.GetText()),
- StartPosition: common.ConvertANTLRLineToPosition(renameToID.GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + renameToID.GetStart().GetLine()),
})
}
}
diff --git a/backend/plugin/advisor/snowflake/rule_naming_table.go b/backend/plugin/advisor/snowflake/rule_naming_table.go
index c1a9f81628..6205b318c0 100644
--- a/backend/plugin/advisor/snowflake/rule_naming_table.go
+++ b/backend/plugin/advisor/snowflake/rule_naming_table.go
@@ -10,7 +10,6 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/snowflake"
- "github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -32,9 +31,9 @@ type NamingTableAdvisor struct {
// Check checks for table naming convention.
func (*NamingTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, ok := checkCtx.AST.(antlr.Tree)
- if !ok {
- return nil, errors.Errorf("failed to convert to Tree")
+ parseResults, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -49,7 +48,11 @@ func (*NamingTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([
rule := NewNamingTableRule(level, string(checkCtx.Rule.Type), format, maxLength)
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
@@ -107,7 +110,7 @@ func (r *NamingTableRule) enterCreateTable(ctx *parser.Create_tableContext) {
Code: code.NamingTableConventionMismatch.Int32(),
Title: r.title,
Content: fmt.Sprintf(`"%s" mismatches table naming convention, naming format should be %q`, tableName, r.format),
- StartPosition: common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),
})
}
if r.maxLength > 0 && len(tableName) > r.maxLength {
@@ -116,7 +119,7 @@ func (r *NamingTableRule) enterCreateTable(ctx *parser.Create_tableContext) {
Code: code.NamingTableConventionMismatch.Int32(),
Title: r.title,
Content: fmt.Sprintf("\"%s\" mismatches table naming convention, its length should be within %d characters", tableName, r.maxLength),
- StartPosition: common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),
})
}
}
@@ -141,7 +144,7 @@ func (r *NamingTableRule) enterAlterTable(ctx *parser.Alter_tableContext) {
Code: code.NamingTableConventionMismatch.Int32(),
Title: r.title,
Content: fmt.Sprintf(`"%s" mismatches table naming convention, naming format should be %q`, tableName, r.format),
- StartPosition: common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),
})
}
if r.maxLength > 0 && len(tableName) > r.maxLength {
@@ -150,7 +153,7 @@ func (r *NamingTableRule) enterAlterTable(ctx *parser.Alter_tableContext) {
Code: code.NamingTableConventionMismatch.Int32(),
Title: r.title,
Content: fmt.Sprintf("\"%s\" mismatches table naming convention, its length should be within %d characters", tableName, r.maxLength),
- StartPosition: common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),
})
}
}
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 b15517b9be..0088434aad 100644
--- a/backend/plugin/advisor/snowflake/rule_naming_table_no_keyword.go
+++ b/backend/plugin/advisor/snowflake/rule_naming_table_no_keyword.go
@@ -9,7 +9,6 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/snowflake"
- "github.com/pkg/errors"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/advisor"
@@ -30,9 +29,9 @@ type NamingTableNoKeywordAdvisor struct {
// Check checks for table naming convention without keyword.
func (*NamingTableNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, ok := checkCtx.AST.(antlr.Tree)
- if !ok {
- return nil, errors.Errorf("failed to convert to Tree")
+ parseResults, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -43,7 +42,11 @@ func (*NamingTableNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Co
rule := NewNamingTableNoKeywordRule(level, string(checkCtx.Rule.Type))
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
diff --git a/backend/plugin/advisor/snowflake/rule_select_no_select_all.go b/backend/plugin/advisor/snowflake/rule_select_no_select_all.go
index 91dfbf967a..b2598a9d00 100644
--- a/backend/plugin/advisor/snowflake/rule_select_no_select_all.go
+++ b/backend/plugin/advisor/snowflake/rule_select_no_select_all.go
@@ -6,7 +6,6 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/snowflake"
- "github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -28,9 +27,9 @@ type SelectNoSelectAllAdvisor struct {
// Check checks for no select all.
func (*SelectNoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, ok := checkCtx.AST.(antlr.Tree)
- if !ok {
- return nil, errors.Errorf("failed to convert to Tree")
+ parseResults, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -41,7 +40,11 @@ func (*SelectNoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Conte
rule := NewSelectNoSelectAllRule(level, string(checkCtx.Rule.Type))
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
@@ -88,7 +91,7 @@ func (r *SelectNoSelectAllRule) enterSelectListElem(ctx *parser.Select_list_elem
Code: code.StatementSelectAll.Int32(),
Title: r.title,
Content: "Avoid using SELECT *.",
- StartPosition: common.ConvertANTLRLineToPosition(v.STAR().GetSymbol().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + v.STAR().GetSymbol().GetLine()),
})
}
}
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 fa42d420dc..1f58b2780b 100644
--- a/backend/plugin/advisor/snowflake/rule_table_drop_naming_convention.go
+++ b/backend/plugin/advisor/snowflake/rule_table_drop_naming_convention.go
@@ -10,7 +10,6 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/snowflake"
- "github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -32,9 +31,9 @@ type TableDropNamingConventionAdvisor struct {
// Check checks for table drop with naming convention.
func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, ok := checkCtx.AST.(antlr.Tree)
- if !ok {
- return nil, errors.Errorf("failed to convert to Tree")
+ parseResults, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -50,7 +49,11 @@ func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advis
rule := NewTableDropNamingConventionRule(level, string(checkCtx.Rule.Type), format)
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
@@ -99,7 +102,7 @@ func (r *TableDropNamingConventionRule) enterDropTable(ctx *parser.Drop_tableCon
Code: code.TableDropNamingConventionMismatch.Int32(),
Title: r.title,
Content: fmt.Sprintf("%q mismatches drop table naming convention, naming format should be %q", normalizedObjectName, r.format),
- StartPosition: common.ConvertANTLRLineToPosition(ctx.Object_name().GetO().GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.Object_name().GetO().GetStart().GetLine()),
})
}
}
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 7a922941c8..e8b1dcb6bf 100644
--- a/backend/plugin/advisor/snowflake/rule_table_no_foreign_key.go
+++ b/backend/plugin/advisor/snowflake/rule_table_no_foreign_key.go
@@ -5,15 +5,13 @@ import (
"context"
"fmt"
- "github.com/bytebase/bytebase/backend/plugin/advisor/code"
-
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/snowflake"
- "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"
snowsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/snowflake"
)
@@ -31,9 +29,9 @@ type TableNoForeignKeyAdvisor struct {
// Check checks for table disallow foreign key.
func (*TableNoForeignKeyAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, ok := checkCtx.AST.(antlr.Tree)
- if !ok {
- return nil, errors.Errorf("failed to convert to Tree")
+ parseResults, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -44,7 +42,11 @@ func (*TableNoForeignKeyAdvisor) Check(_ context.Context, checkCtx advisor.Conte
rule := NewTableNoForeignKeyRule(level, string(checkCtx.Rule.Type))
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
@@ -142,7 +144,7 @@ func (r *TableNoForeignKeyRule) enterCreateTable(ctx *parser.Create_tableContext
r.tableForeignKeyTimes[normalizedTableName] = 0
r.tableOriginalName[normalizedTableName] = originalTableName.GetText()
- r.tableLine[normalizedTableName] = ctx.GetStart().GetLine()
+ r.tableLine[normalizedTableName] = r.baseLine + ctx.GetStart().GetLine()
r.currentNormalizedTableName = normalizedTableName
r.currentConstraintAction = currentConstraintActionAdd
}
@@ -166,7 +168,7 @@ func (r *TableNoForeignKeyRule) enterOutOfLineConstraint(ctx *parser.Out_of_line
switch r.currentConstraintAction {
case currentConstraintActionAdd:
r.tableForeignKeyTimes[r.currentNormalizedTableName]++
- r.tableLine[r.currentNormalizedTableName] = ctx.GetStart().GetLine()
+ r.tableLine[r.currentNormalizedTableName] = r.baseLine + ctx.GetStart().GetLine()
case currentConstraintActionDrop:
if times, ok := r.tableForeignKeyTimes[r.currentNormalizedTableName]; ok && times > 0 {
r.tableForeignKeyTimes[r.currentNormalizedTableName]--
diff --git a/backend/plugin/advisor/snowflake/rule_table_require_pk.go b/backend/plugin/advisor/snowflake/rule_table_require_pk.go
index 66e1bd636d..6a6d50e62e 100644
--- a/backend/plugin/advisor/snowflake/rule_table_require_pk.go
+++ b/backend/plugin/advisor/snowflake/rule_table_require_pk.go
@@ -7,7 +7,6 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/snowflake"
- "github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -30,9 +29,9 @@ type TableRequirePkAdvisor struct {
// Check checks for table require primary key.
func (*TableRequirePkAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, ok := checkCtx.AST.(antlr.Tree)
- if !ok {
- return nil, errors.Errorf("failed to convert to Tree")
+ parseResults, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -43,7 +42,11 @@ func (*TableRequirePkAdvisor) Check(_ context.Context, checkCtx advisor.Context)
rule := NewTableRequirePkRule(level, string(checkCtx.Rule.Type))
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
@@ -130,7 +133,7 @@ func (r *TableRequirePkRule) GetAdviceList() []*storepb.Advice {
Code: code.TableNoPK.Int32(),
Title: r.title,
Content: fmt.Sprintf("Table %s requires PRIMARY KEY.", r.tableOriginalName[tableName]),
- StartPosition: common.ConvertANTLRLineToPosition(r.tableLine[tableName]),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + r.tableLine[tableName]),
})
}
}
diff --git a/backend/plugin/advisor/snowflake/rule_where_require_select.go b/backend/plugin/advisor/snowflake/rule_where_require_select.go
index cb2251e0fd..47e7c92958 100644
--- a/backend/plugin/advisor/snowflake/rule_where_require_select.go
+++ b/backend/plugin/advisor/snowflake/rule_where_require_select.go
@@ -6,7 +6,6 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/snowflake"
- "github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -28,9 +27,9 @@ type WhereRequireForSelectAdvisor struct {
// Check checks for WHERE clause requirement.
func (*WhereRequireForSelectAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, ok := checkCtx.AST.(antlr.Tree)
- if !ok {
- return nil, errors.Errorf("failed to convert to Tree")
+ parseResults, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -41,7 +40,11 @@ func (*WhereRequireForSelectAdvisor) Check(_ context.Context, checkCtx advisor.C
rule := NewWhereRequireForSelectRule(level, string(checkCtx.Rule.Type))
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
@@ -95,7 +98,7 @@ func (r *WhereRequireForSelectRule) enterQueryStatement(ctx *parser.Query_statem
Code: code.StatementNoWhere.Int32(),
Title: r.title,
Content: "WHERE clause is required for SELECT statement.",
- StartPosition: common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),
})
}
}
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 2ffada5bf9..b8ec741f7b 100644
--- a/backend/plugin/advisor/snowflake/rule_where_require_update_delete.go
+++ b/backend/plugin/advisor/snowflake/rule_where_require_update_delete.go
@@ -6,7 +6,6 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/snowflake"
- "github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -28,9 +27,9 @@ type WhereRequireForUpdateDeleteAdvisor struct {
// Check checks for WHERE clause requirement.
func (*WhereRequireForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, ok := checkCtx.AST.(antlr.Tree)
- if !ok {
- return nil, errors.Errorf("failed to convert to Tree")
+ parseResults, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -41,7 +40,11 @@ func (*WhereRequireForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx adv
rule := NewWhereRequireForUpdateDeleteRule(level, string(checkCtx.Rule.Type))
checker := NewGenericChecker([]Rule{rule})
- antlr.ParseTreeWalkerDefault.Walk(checker, tree)
+ for _, parseResult := range parseResults {
+ rule.SetBaseLine(parseResult.BaseLine)
+ checker.SetBaseLine(parseResult.BaseLine)
+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)
+ }
return checker.GetAdviceList(), nil
}
@@ -92,7 +95,7 @@ func (r *WhereRequireForUpdateDeleteRule) enterUpdateStatement(ctx *parser.Updat
Code: code.StatementNoWhere.Int32(),
Title: r.title,
Content: "WHERE clause is required for UPDATE statement.",
- StartPosition: common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),
})
}
}
@@ -104,7 +107,7 @@ func (r *WhereRequireForUpdateDeleteRule) enterDeleteStatement(ctx *parser.Delet
Code: code.StatementNoWhere.Int32(),
Title: r.title,
Content: "WHERE clause is required for DELETE statement.",
- StartPosition: common.ConvertANTLRLineToPosition(ctx.GetStart().GetLine()),
+ StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),
})
}
}
diff --git a/backend/plugin/advisor/snowflake/test/table_require_pk.yaml b/backend/plugin/advisor/snowflake/test/table_require_pk.yaml
index bd0729e038..16d3c3f19c 100644
--- a/backend/plugin/advisor/snowflake/test/table_require_pk.yaml
+++ b/backend/plugin/advisor/snowflake/test/table_require_pk.yaml
@@ -126,7 +126,7 @@
title: table.require-pk
content: Table CUSTOMER requires PRIMARY KEY.
startposition:
- line: 24
+ line: 25
column: 0
endposition: null
- status: 2
diff --git a/backend/plugin/advisor/snowflake/utils.go b/backend/plugin/advisor/snowflake/utils.go
new file mode 100644
index 0000000000..cad7a95be5
--- /dev/null
+++ b/backend/plugin/advisor/snowflake/utils.go
@@ -0,0 +1,25 @@
+package snowflake
+
+import (
+ "github.com/pkg/errors"
+
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ snowsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/snowflake"
+)
+
+// getANTLRTree extracts the ANTLR parse trees from the advisor context.
+// The AST must be pre-parsed and passed via checkCtx.AST (e.g., in tests or by the framework).
+// This enforces proper AST caching and makes any missing cache obvious.
+// Returns all parse results for multi-statement SQL review.
+func getANTLRTree(checkCtx advisor.Context) ([]*snowsqlparser.ParseResult, error) {
+ if checkCtx.AST == nil {
+ return nil, errors.New("AST is not provided in context - must be parsed before calling advisor")
+ }
+
+ parseResults, ok := checkCtx.AST.([]*snowsqlparser.ParseResult)
+ if !ok {
+ return nil, errors.Errorf("AST type mismatch: expected []*snowsqlparser.ParseResult, got %T", checkCtx.AST)
+ }
+
+ return parseResults, nil
+}
diff --git a/backend/plugin/db/snowflake/query.go b/backend/plugin/db/snowflake/query.go
index 86be4594bf..dbdbf8020c 100644
--- a/backend/plugin/db/snowflake/query.go
+++ b/backend/plugin/db/snowflake/query.go
@@ -25,11 +25,17 @@ func getStatementWithResultLimit(statement string, limit int) string {
}
func getStatementWithResultLimitInline(singleStatement string, limitCount int) (string, error) {
- result, err := snowparser.ParseSnowSQL(singleStatement)
+ results, err := snowparser.ParseSnowSQL(singleStatement)
if err != nil {
return "", err
}
+ if len(results) != 1 {
+ return "", errors.Errorf("expected exactly 1 statement, got %d", len(results))
+ }
+
+ result := results[0]
+
listener := &snowsqlRewriter{
limitCount: limitCount,
outerMostQuery: true,
diff --git a/backend/plugin/parser/base/interface.go b/backend/plugin/parser/base/interface.go
index 36e1f0b3f6..4b5f9e72fc 100644
--- a/backend/plugin/parser/base/interface.go
+++ b/backend/plugin/parser/base/interface.go
@@ -271,7 +271,7 @@ func RegisterParseFunc(engine storepb.Engine, f ParseFunc) {
// - CockroachDB: statements.Statements (github.com/cockroachdb/cockroachdb-parser/pkg/sql/parser/statements)
// - Redshift: antlr.Tree
// - Oracle: antlr.Tree
-// - Snowflake: antlr.Tree
+// - Snowflake: []*ParseResult (github.com/bytebase/bytebase/backend/plugin/parser/snowflake) - ANTLR-based
// - MSSQL: antlr.Tree
// - DynamoDB (PartiQL): antlr.Tree
// - Doris: *ParseResult (github.com/bytebase/bytebase/backend/plugin/parser/doris)
diff --git a/backend/plugin/parser/snowflake/query.go b/backend/plugin/parser/snowflake/query.go
index ff95dbb543..55b9b782b2 100644
--- a/backend/plugin/parser/snowflake/query.go
+++ b/backend/plugin/parser/snowflake/query.go
@@ -14,16 +14,18 @@ func init() {
// validateQuery validates the SQL statement for SQL editor.
func validateQuery(statement string) (bool, bool, error) {
- parseResult, err := ParseSnowSQL(statement)
+ parseResults, err := ParseSnowSQL(statement)
if err != nil {
return false, false, err
}
l := &queryValidateListener{
valid: true,
}
- antlr.ParseTreeWalkerDefault.Walk(l, parseResult.Tree)
- if !l.valid {
- return false, false, nil
+ for _, parseResult := range parseResults {
+ antlr.ParseTreeWalkerDefault.Walk(l, parseResult.Tree)
+ if !l.valid {
+ return false, false, nil
+ }
}
return true, !l.hasExecute, nil
}
diff --git a/backend/plugin/parser/snowflake/query_span_extractor.go b/backend/plugin/parser/snowflake/query_span_extractor.go
index 924d0f9966..c829150204 100644
--- a/backend/plugin/parser/snowflake/query_span_extractor.go
+++ b/backend/plugin/parser/snowflake/query_span_extractor.go
@@ -48,13 +48,16 @@ func newQuerySpanExtractor(defaultDatabase, defaultSchema string, gCtx base.GetQ
func (q *querySpanExtractor) getQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {
q.ctx = ctx
- parseResult, err := ParseSnowSQL(statement)
+ parseResults, err := ParseSnowSQL(statement)
if err != nil {
return nil, err
}
- if parseResult == nil {
- return nil, nil
+
+ if len(parseResults) != 1 {
+ return nil, errors.Errorf("expected exactly 1 statement, got %d", len(parseResults))
}
+
+ parseResult := parseResults[0]
tree := parseResult.Tree
if tree == nil {
return nil, nil
diff --git a/backend/plugin/parser/snowflake/snowflake.go b/backend/plugin/parser/snowflake/snowflake.go
index 1eaa1a9f07..9d3387a2c9 100644
--- a/backend/plugin/parser/snowflake/snowflake.go
+++ b/backend/plugin/parser/snowflake/snowflake.go
@@ -17,25 +17,48 @@ func init() {
}
// parseSnowflakeForRegistry is the ParseFunc for Snowflake.
-// Returns antlr.Tree on success.
+// Returns []*ParseResult on success.
func parseSnowflakeForRegistry(statement string) (any, error) {
- result, err := ParseSnowSQL(statement + ";")
+ return ParseSnowSQL(statement)
+}
+
+type ParseResult struct {
+ Tree antlr.Tree
+ Tokens *antlr.CommonTokenStream
+ BaseLine int
+}
+
+// ParseSnowSQL parses the given SQL and returns a list of ParseResult (one per statement).
+// Use the Snowflake parser based on antlr4.
+func ParseSnowSQL(sql string) ([]*ParseResult, error) {
+ stmts, err := SplitSQL(sql)
if err != nil {
return nil, err
}
- if result == nil {
- return nil, nil
+
+ var results []*ParseResult
+ for _, stmt := range stmts {
+ if stmt.Empty {
+ continue
+ }
+
+ parseResult, err := parseSingleSnowSQL(stmt.Text, stmt.BaseLine)
+ if err != nil {
+ return nil, err
+ }
+ results = append(results, parseResult)
}
- return result.Tree, nil
-}
-type ParseResult struct {
- Tree antlr.Tree
- Tokens *antlr.CommonTokenStream
+ return results, nil
}
-// ParseSnowSQL parses the given SQL statement by using antlr4. Returns the AST and token stream if no error.
-func ParseSnowSQL(statement string) (*ParseResult, error) {
+// parseSingleSnowSQL parses a single Snowflake statement and returns the ParseResult.
+func parseSingleSnowSQL(statement string, baseLine int) (*ParseResult, error) {
+ // Trim leading newlines to ensure the first token starts at line 1 in ANTLR
+ // This makes baseLine calculations simpler: baseLine + line = original line
+ statement = strings.TrimLeftFunc(statement, func(r rune) bool {
+ return r == '\n' || r == '\r'
+ })
statement = strings.TrimRightFunc(statement, utils.IsSpaceOrSemicolon) + "\n;"
inputStream := antlr.NewInputStream(statement)
lexer := parser.NewSnowflakeLexer(inputStream)
@@ -46,12 +69,14 @@ func ParseSnowSQL(statement string) (*ParseResult, error) {
lexer.RemoveErrorListeners()
lexerErrorListener := &base.ParseErrorListener{
Statement: statement,
+ BaseLine: baseLine,
}
lexer.AddErrorListener(lexerErrorListener)
p.RemoveErrorListeners()
parserErrorListener := &base.ParseErrorListener{
Statement: statement,
+ BaseLine: baseLine,
}
p.AddErrorListener(parserErrorListener)
@@ -68,8 +93,9 @@ func ParseSnowSQL(statement string) (*ParseResult, error) {
}
result := &ParseResult{
- Tree: tree,
- Tokens: stream,
+ Tree: tree,
+ Tokens: stream,
+ BaseLine: baseLine,
}
return result, nil
diff --git a/backend/plugin/parser/snowflake/snowflake_test.go b/backend/plugin/parser/snowflake/snowflake_test.go
index 9f6a2f4300..a7292aa611 100644
--- a/backend/plugin/parser/snowflake/snowflake_test.go
+++ b/backend/plugin/parser/snowflake/snowflake_test.go
@@ -52,7 +52,10 @@ func TestParseSnowSQL(t *testing.T) {
},
{
sql: "SELECT 1;\n SELEC 5;\nSELECT 6;",
- err: "Syntax error at line 2:4 \nrelated text: SELECT 1;\n SELEC",
+ // After standardization, each statement is parsed separately, so the error context
+ // only includes the current statement being parsed (not previous statements).
+ // Leading newlines are trimmed, so the error context shows the trimmed text.
+ err: "Syntax error at line 2:4 \nrelated text: SELEC",
},
}
diff --git a/backend/plugin/parser/snowflake/split.go b/backend/plugin/parser/snowflake/split.go
index 68aca14d44..bdd13c2e21 100644
--- a/backend/plugin/parser/snowflake/split.go
+++ b/backend/plugin/parser/snowflake/split.go
@@ -1,21 +1,70 @@
package snowflake
import (
+ "strings"
+
+ "github.com/antlr4-go/antlr/v4"
+ parser "github.com/bytebase/parser/snowflake"
+
+ "github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
- "github.com/bytebase/bytebase/backend/plugin/parser/tokenizer"
)
func init() {
base.RegisterSplitterFunc(storepb.Engine_SNOWFLAKE, SplitSQL)
}
-// SplitSQL splits the given SQL statement into multiple SQL statements.
+// calculateBaseLine calculates the base line offset for a split statement.
+// Since we trim leading newlines before parsing, the first token will be on line 1
+// in the parsed result. Therefore, baseLine = original line - 1.
+func calculateBaseLine(_ []antlr.Token, antlrPosition *common.ANTLRPosition) int {
+ return int(antlrPosition.Line) - 1
+}
+
+// SplitSQL splits the given SQL statement into multiple SQL statements using ANTLR lexer.
func SplitSQL(statement string) ([]base.SingleSQL, error) {
- t := tokenizer.NewTokenizer(statement)
- list, err := t.SplitStandardMultiSQL()
- if err != nil {
- return nil, err
+ lexer := parser.NewSnowflakeLexer(antlr.NewInputStream(statement))
+ stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
+ stream.Fill()
+
+ tokens := stream.GetAllTokens()
+ var buf []antlr.Token
+ var sqls []base.SingleSQL
+
+ for i, token := range tokens {
+ if i < len(tokens)-1 {
+ buf = append(buf, token)
+ }
+ if (token.GetTokenType() == parser.SnowflakeLexerSEMI || i == len(tokens)-1) && len(buf) > 0 {
+ bufStr := new(strings.Builder)
+ empty := true
+
+ for _, b := range buf {
+ if _, err := bufStr.WriteString(b.GetText()); err != nil {
+ return nil, err
+ }
+ if b.GetChannel() != antlr.TokenHiddenChannel {
+ empty = false
+ }
+ }
+ antlrPosition := base.FirstDefaultChannelTokenPosition(buf)
+
+ // For the End position, use the current token (semicolon or EOF)
+ // instead of the last token in buf
+ sqls = append(sqls, base.SingleSQL{
+ Text: bufStr.String(),
+ BaseLine: calculateBaseLine(buf, antlrPosition),
+ End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
+ Line: int32(token.GetLine()),
+ Column: int32(token.GetColumn()),
+ }, statement),
+ Start: common.ConvertANTLRPositionToPosition(antlrPosition, statement),
+ Empty: empty,
+ })
+ buf = nil
+ continue
+ }
}
- return list, nil
+ return sqls, nil
}
diff --git a/backend/plugin/parser/snowflake/split_test.go b/backend/plugin/parser/snowflake/split_test.go
new file mode 100644
index 0000000000..1beac3a5d6
--- /dev/null
+++ b/backend/plugin/parser/snowflake/split_test.go
@@ -0,0 +1,142 @@
+package snowflake
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func TestSplitSQL(t *testing.T) {
+ statement := `SELECT * FROM users;
+ SELECT * FROM orders;
+ SELECT * FROM products;`
+ want := []base.SingleSQL{
+ {
+ Text: "SELECT * FROM users;",
+ BaseLine: 0,
+ Start: &storepb.Position{Line: 1, Column: 1},
+ End: &storepb.Position{Line: 1, Column: 20},
+ Empty: false,
+ },
+ {
+ Text: "\n\tSELECT * FROM orders;",
+ BaseLine: 1, // Corrected: first token is on line 2 of original SQL
+ Start: &storepb.Position{Line: 2, Column: 2},
+ End: &storepb.Position{Line: 2, Column: 22},
+ Empty: false,
+ },
+ {
+ Text: "\n\tSELECT * FROM products;",
+ BaseLine: 2, // Corrected: first token is on line 3 of original SQL
+ Start: &storepb.Position{Line: 3, Column: 2},
+ End: &storepb.Position{Line: 3, Column: 24},
+ Empty: false,
+ },
+ }
+
+ list, err := SplitSQL(statement)
+ require.NoError(t, err)
+ require.Equal(t, want, list)
+}
+
+func TestSplitSQLSingleStatement(t *testing.T) {
+ statement := "SELECT * FROM users;"
+ list, err := SplitSQL(statement)
+ require.NoError(t, err)
+ require.Equal(t, 1, len(list))
+ require.Equal(t, "SELECT * FROM users;", list[0].Text)
+ require.Equal(t, 0, list[0].BaseLine)
+ require.False(t, list[0].Empty)
+}
+
+func TestSplitSQLEmpty(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ wantCount int
+ }{
+ {
+ name: "Empty string",
+ statement: "",
+ wantCount: 0,
+ },
+ {
+ name: "Only whitespace",
+ statement: " \n \t ",
+ wantCount: 0,
+ },
+ {
+ name: "Only semicolon",
+ statement: ";",
+ wantCount: 1,
+ },
+ {
+ name: "Only comments and semicolon",
+ statement: "-- comment\n;",
+ wantCount: 1,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ list, err := SplitSQL(tt.statement)
+ require.NoError(t, err)
+ nonEmpty := 0
+ for _, sql := range list {
+ if !sql.Empty {
+ nonEmpty++
+ }
+ }
+ require.Equal(t, tt.wantCount, nonEmpty)
+ })
+ }
+}
+
+func TestSplitSQLWithComments(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ wantCount int
+ }{
+ {
+ name: "Statement with trailing comment",
+ statement: "SELECT * FROM users; -- This is a comment\nSELECT * FROM orders;",
+ wantCount: 2,
+ },
+ {
+ name: "Statement with leading comment",
+ statement: "-- Comment at start\nSELECT * FROM users;",
+ wantCount: 1,
+ },
+ {
+ name: "Only comment with semicolon",
+ statement: "-- comment only\n;",
+ wantCount: 1,
+ },
+ {
+ name: "Multiple statements with comments",
+ statement: "-- First query\nSELECT * FROM users;\n-- Second query\nSELECT * FROM orders;",
+ wantCount: 2,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ list, err := SplitSQL(tt.statement)
+ require.NoError(t, err)
+ require.Equal(t, tt.wantCount, len(list))
+ })
+ }
+}
+
+func TestSplitSQLWithoutSemicolon(t *testing.T) {
+ statement := "SELECT * FROM users"
+ list, err := SplitSQL(statement)
+ require.NoError(t, err)
+ require.Equal(t, 1, len(list))
+ require.Equal(t, "SELECT * FROM users", list[0].Text)
+ require.False(t, list[0].Empty)
+}