Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor: standardize 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.goindex 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 rulechecker := 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.goindex 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 rulechecker := 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.goindex 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.goindex 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_tableContexCode: 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_schemaContCode: 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_databaseCode: 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_tableContCode: 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.goindex 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.Corule := 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_deCode: 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_tableContexCode: 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.goindex 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 advisrule := 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.ColuCode: 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_tableCCode: 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.goindex 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.goindex 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.Corule := 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.goindex 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.Conterule := 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_elemCode: 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.goindex 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 advisrule := 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_tableConCode: 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.goindex 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.Conterule := 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_tableContextr.tableForeignKeyTimes[normalizedTableName] = 0r.tableOriginalName[normalizedTableName] = originalTableName.GetText()- r.tableLine[normalizedTableName] = ctx.GetStart().GetLine()+ r.tableLine[normalizedTableName] = r.baseLine + ctx.GetStart().GetLine()r.currentNormalizedTableName = normalizedTableNamer.currentConstraintAction = currentConstraintActionAdd}@@ -166,7 +168,7 @@ func (r *TableNoForeignKeyRule) enterOutOfLineConstraint(ctx *parser.Out_of_lineswitch 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.goindex 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.goindex 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.Crule := 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_statemCode: 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.goindex 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 advrule := 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.UpdatCode: 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.DeletCode: 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.yamlindex 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-pkcontent: Table CUSTOMER requires PRIMARY KEY.startposition:- line: 24+ line: 25column: 0endposition: null- status: 2diff --git a/backend/plugin/advisor/snowflake/utils.go b/backend/plugin/advisor/snowflake/utils.gonew file mode 100644index 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.goindex 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.goindex 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.goindex 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.goindex 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.GetQfunc (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.Treeif tree == nil {return nil, nildiff --git a/backend/plugin/parser/snowflake/snowflake.go b/backend/plugin/parser/snowflake/snowflake.goindex 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, nildiff --git a/backend/plugin/parser/snowflake/snowflake_test.go b/backend/plugin/parser/snowflake/snowflake_test.goindex 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.goindex 68aca14d44..bdd13c2e21 100644--- a/backend/plugin/parser/snowflake/split.go+++ b/backend/plugin/parser/snowflake/split.go@@ -1,21 +1,70 @@package snowflakeimport (+ "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.gonew file mode 100644index 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)+}