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 T-SQL parser and fix baseLine calculation (#18173)
h3n4lf7f1091bdc36
diff --git a/backend/plugin/advisor/mssql/generic_checker.go b/backend/plugin/advisor/mssql/generic_checker.goindex cd69fc9f12..0e12abf8e9 100644--- a/backend/plugin/advisor/mssql/generic_checker.go+++ b/backend/plugin/advisor/mssql/generic_checker.go@@ -143,6 +143,7 @@ type BaseRule struct {level storepb.Advice_Statustitle stringadviceList []*storepb.Advice+ baseLine int}// GetAdviceList returns the accumulated advice.@@ -151,6 +152,16 @@ func (r *BaseRule) GetAdviceList() []*storepb.Advice {}// AddAdvice adds a new advice to the list.+// It automatically adjusts the StartPosition by adding the baseLine offset.func (r *BaseRule) AddAdvice(advice *storepb.Advice) {+ // Adjust the line number by adding baseLine offset+ if advice.StartPosition != nil && r.baseLine > 0 {+ advice.StartPosition.Line += int32(r.baseLine)+ }r.adviceList = append(r.adviceList, advice)}++// SetBaseLine sets the base line number for multi-statement SQL.+func (r *BaseRule) SetBaseLine(baseLine int) {+ r.baseLine = baseLine+}diff --git a/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.goindex 2e71e9d658..44f3b9c6f4 100644--- a/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.go@@ -206,7 +206,7 @@ type statementInfo struct {}func prepareTransformation(databaseName, statement string) ([]statementInfo, error) {- parseResult, err := tsqlparser.ParseTSQL(statement)+ parseResults, err := tsqlparser.ParseTSQL(statement)if err != nil {return nil, errors.Wrap(err, "failed to parse statement")}@@ -214,7 +214,11 @@ func prepareTransformation(databaseName, statement string) ([]statementInfo, errextractor := &dmlExtractor{databaseName: databaseName,}- antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)++ for _, parseResult := range parseResults {+ antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)+ }+return extractor.dmls, nil}diff --git a/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.go b/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.goindex 62693698ef..f5c3bdd05d 100644--- a/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.go+++ b/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.go@@ -34,9 +34,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)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -58,7 +58,10 @@ 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)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_column_no_null.go b/backend/plugin/advisor/mssql/rule_column_no_null.goindex cec549d8e8..5d0affab90 100644--- a/backend/plugin/advisor/mssql/rule_column_no_null.go+++ b/backend/plugin/advisor/mssql/rule_column_no_null.go@@ -29,9 +29,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)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -45,7 +45,10 @@ 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)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_column_require.go b/backend/plugin/advisor/mssql/rule_column_require.goindex 9b138a3311..19df566ccc 100644--- a/backend/plugin/advisor/mssql/rule_column_require.go+++ b/backend/plugin/advisor/mssql/rule_column_require.go@@ -31,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)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -52,7 +52,10 @@ func (*ColumnRequireAdvisor) 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)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_column_type_disallow_list.go b/backend/plugin/advisor/mssql/rule_column_type_disallow_list.goindex acafaf0ee4..f4779de191 100644--- a/backend/plugin/advisor/mssql/rule_column_type_disallow_list.go+++ b/backend/plugin/advisor/mssql/rule_column_type_disallow_list.go@@ -14,6 +14,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")var (@@ -29,9 +30,9 @@ type ColumnTypeDisallowListAdvisor struct {}func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -54,7 +55,10 @@ func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_function_disallow_create_or_alter.go b/backend/plugin/advisor/mssql/rule_function_disallow_create_or_alter.goindex 1e9e8ebf8f..51507bae00 100644--- a/backend/plugin/advisor/mssql/rule_function_disallow_create_or_alter.go+++ b/backend/plugin/advisor/mssql/rule_function_disallow_create_or_alter.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")func init() {@@ -21,9 +22,9 @@ type FunctionDisallowCreateOrAlterAdvisor struct{}// Check implements advisor.Advisor.func (*FunctionDisallowCreateOrAlterAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -37,7 +38,10 @@ func (*FunctionDisallowCreateOrAlterAdvisor) Check(_ context.Context, checkCtx a// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_index_not_redundant.go b/backend/plugin/advisor/mssql/rule_index_not_redundant.goindex 2f5a9a2cf9..9077b51caa 100644--- a/backend/plugin/advisor/mssql/rule_index_not_redundant.go+++ b/backend/plugin/advisor/mssql/rule_index_not_redundant.go@@ -8,11 +8,12 @@ import ("github.com/antlr4-go/antlr/v4"parser "github.com/bytebase/parser/tsql"+"github.com/pkg/errors""github.com/bytebase/bytebase/backend/common""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/tsql"+ tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql"storepb "github.com/bytebase/bytebase/backend/generated-go/store")@@ -31,7 +32,7 @@ type IndexNotRedundantAdvisor struct{}// TODO(zp): we currently don't have runtime checks for indexes created in the statements.func (IndexNotRedundantAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {return nil, errors.Errorf("failed to convert to AST tree")}@@ -47,7 +48,10 @@ func (IndexNotRedundantAdvisor) Check(_ context.Context, checkCtx advisor.Contex// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}@@ -99,18 +103,18 @@ func (r *IndexNotRedundantRule) enterCreateIndex(ctx *parser.Create_indexContext// TODO(zp): we only check indexes in the current database due to the lack of necessary metadata.// Case sensitive!if database := fullTblName.GetDatabase(); database != nil {- if oriName, _ := tsql.NormalizeTSQLIdentifier(database); oriName != r.curDB {+ if oriName, _ := tsqlparser.NormalizeTSQLIdentifier(database); oriName != r.curDB {return}}if schema := fullTblName.GetSchema(); schema != nil {- idxSchemaName, _ = tsql.NormalizeTSQLIdentifier(schema)+ idxSchemaName, _ = tsqlparser.NormalizeTSQLIdentifier(schema)}- idxTblName, _ = tsql.NormalizeTSQLIdentifier(fullTblName.GetTable())+ idxTblName, _ = tsqlparser.NormalizeTSQLIdentifier(fullTblName.GetTable())}// Get index name from statement.- statIdxName, _ := tsql.NormalizeTSQLIdentifier(ctx.AllId_()[0])+ statIdxName, _ := tsqlparser.NormalizeTSQLIdentifier(ctx.AllId_()[0])// Get ordered index list from metadata.findIdxKey := FindIndexesKey{@@ -148,7 +152,7 @@ type IndexMap = map[FindIndexesKey][]*storepb.IndexMetadatafunc containRedundantPrefix(metaIdxList []*storepb.IndexMetadata, statColumnList *parser.IColumn_name_list_with_orderContext) string {for _, metaIndex := range metaIdxList {if statColumnList != nil && len((*statColumnList).AllColumn_name_with_order()) != 0 && len(metaIdxList) != 0 {- statIdxCol, _ := tsql.NormalizeTSQLIdentifier((*statColumnList).AllColumn_name_with_order()[0].Id_())+ statIdxCol, _ := tsqlparser.NormalizeTSQLIdentifier((*statColumnList).AllColumn_name_with_order()[0].Id_())if metaIndex.Expressions[0] == statIdxCol {return metaIndex.Name}diff --git a/backend/plugin/advisor/mssql/rule_migration_compatibility.go b/backend/plugin/advisor/mssql/rule_migration_compatibility.goindex 1742d59d1f..d5a40e199e 100644--- a/backend/plugin/advisor/mssql/rule_migration_compatibility.go+++ b/backend/plugin/advisor/mssql/rule_migration_compatibility.go@@ -30,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)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -46,7 +46,10 @@ func (*MigrationCompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_naming_identifier_no_keyword.go b/backend/plugin/advisor/mssql/rule_naming_identifier_no_keyword.goindex 04483f9873..6c29450590 100644--- a/backend/plugin/advisor/mssql/rule_naming_identifier_no_keyword.go+++ b/backend/plugin/advisor/mssql/rule_naming_identifier_no_keyword.go@@ -30,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)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -46,7 +46,10 @@ func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_naming_table.go b/backend/plugin/advisor/mssql/rule_naming_table.goindex c9335da13a..bdcb5c7128 100644--- a/backend/plugin/advisor/mssql/rule_naming_table.go+++ b/backend/plugin/advisor/mssql/rule_naming_table.go@@ -32,9 +32,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)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -52,7 +52,10 @@ func (*NamingTableAdvisor) 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)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_naming_table_no_keyword.go b/backend/plugin/advisor/mssql/rule_naming_table_no_keyword.goindex a7d4b53cf2..bdbae1cf33 100644--- a/backend/plugin/advisor/mssql/rule_naming_table_no_keyword.go+++ b/backend/plugin/advisor/mssql/rule_naming_table_no_keyword.go@@ -30,9 +30,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)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -46,7 +46,10 @@ func (*NamingTableNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Co// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_procedure_disallow_create_or_alter.go b/backend/plugin/advisor/mssql/rule_procedure_disallow_create_or_alter.goindex 2dbb53fe15..f647f04dde 100644--- a/backend/plugin/advisor/mssql/rule_procedure_disallow_create_or_alter.go+++ b/backend/plugin/advisor/mssql/rule_procedure_disallow_create_or_alter.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")func init() {@@ -20,9 +21,9 @@ func init() {type ProcedureDisallowCreateOrAlterAdvisor struct{}func (*ProcedureDisallowCreateOrAlterAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -36,7 +37,10 @@ func (*ProcedureDisallowCreateOrAlterAdvisor) Check(_ context.Context, checkCtx// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_select_no_select_all.go b/backend/plugin/advisor/mssql/rule_select_no_select_all.goindex 912b29d681..90d1622bf6 100644--- a/backend/plugin/advisor/mssql/rule_select_no_select_all.go+++ b/backend/plugin/advisor/mssql/rule_select_no_select_all.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")var (@@ -27,9 +28,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)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -43,7 +44,10 @@ func (*SelectNoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Conte// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_statement_disallow_cross_db_queries.go b/backend/plugin/advisor/mssql/rule_statement_disallow_cross_db_queries.goindex 4401ad925a..2778fc9a66 100644--- a/backend/plugin/advisor/mssql/rule_statement_disallow_cross_db_queries.go+++ b/backend/plugin/advisor/mssql/rule_statement_disallow_cross_db_queries.go@@ -7,13 +7,14 @@ import ("github.com/antlr4-go/antlr/v4"parser "github.com/bytebase/parser/tsql"+"github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"- "github.com/bytebase/bytebase/backend/plugin/parser/tsql"+ tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")func init() {@@ -23,9 +24,9 @@ func init() {type DisallowCrossDBQueriesAdvisor struct{}func (*DisallowCrossDBQueriesAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -39,7 +40,10 @@ func (*DisallowCrossDBQueriesAdvisor) Check(_ context.Context, checkCtx advisor.// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}@@ -88,7 +92,7 @@ func (*DisallowCrossDBQueriesRule) OnExit(_ antlr.ParserRuleContext, _ string) efunc (r *DisallowCrossDBQueriesRule) enterTableSourceItem(ctx *parser.Table_source_itemContext) {if fullTblnameCtx := ctx.Full_table_name(); fullTblnameCtx != nil {// Case insensitive.- if fullTblName, err := tsql.NormalizeFullTableName(fullTblnameCtx); err == nil && fullTblName.Database != "" && !strings.EqualFold(fullTblName.Database, r.curDB) {+ if fullTblName, err := tsqlparser.NormalizeFullTableName(fullTblnameCtx); err == nil && fullTblName.Database != "" && !strings.EqualFold(fullTblName.Database, r.curDB) {r.AddAdvice(&storepb.Advice{Status: r.level,Code: code.StatementDisallowCrossDBQueries.Int32(),@@ -103,7 +107,7 @@ func (r *DisallowCrossDBQueriesRule) enterTableSourceItem(ctx *parser.Table_sourfunc (r *DisallowCrossDBQueriesRule) enterUseStatement(ctx *parser.Use_statementContext) {if newDB := ctx.GetDatabase(); newDB != nil {- _, lowercaceDBName := tsql.NormalizeTSQLIdentifier(newDB)+ _, lowercaceDBName := tsqlparser.NormalizeTSQLIdentifier(newDB)r.curDB = lowercaceDBName}}diff --git a/backend/plugin/advisor/mssql/rule_statement_disallow_mix_in_ddl.go b/backend/plugin/advisor/mssql/rule_statement_disallow_mix_in_ddl.goindex 40ff06971b..ea2e23e904 100644--- a/backend/plugin/advisor/mssql/rule_statement_disallow_mix_in_ddl.go+++ b/backend/plugin/advisor/mssql/rule_statement_disallow_mix_in_ddl.go@@ -32,9 +32,9 @@ func (*StatementDisallowMixInDDLAdvisor) Check(_ context.Context, checkCtx advisdefault:return nil, nil}- tree, ok := checkCtx.AST.(antlr.Tree)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -49,7 +49,10 @@ func (*StatementDisallowMixInDDLAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_statement_disallow_mix_in_dml.go b/backend/plugin/advisor/mssql/rule_statement_disallow_mix_in_dml.goindex a83bee5eb5..e3158de763 100644--- a/backend/plugin/advisor/mssql/rule_statement_disallow_mix_in_dml.go+++ b/backend/plugin/advisor/mssql/rule_statement_disallow_mix_in_dml.go@@ -32,9 +32,9 @@ func (*StatementDisallowMixInDMLAdvisor) Check(_ context.Context, checkCtx advisdefault:return nil, nil}- tree, ok := checkCtx.AST.(antlr.Tree)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -49,7 +49,10 @@ func (*StatementDisallowMixInDMLAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_statement_where_disallow_functions_and_calculations.go b/backend/plugin/advisor/mssql/rule_statement_where_disallow_functions_and_calculations.goindex 1848bbdf39..744c233793 100644--- a/backend/plugin/advisor/mssql/rule_statement_where_disallow_functions_and_calculations.go+++ b/backend/plugin/advisor/mssql/rule_statement_where_disallow_functions_and_calculations.go@@ -12,6 +12,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")func init() {@@ -23,7 +24,7 @@ type DisallowFuncAndCalculationsAdvisor struct{}var _ advisor.Advisor = (*DisallowFuncAndCalculationsAdvisor)(nil)func (*DisallowFuncAndCalculationsAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {return nil, errors.Errorf("failed to convert to AST tree")}@@ -39,7 +40,10 @@ func (*DisallowFuncAndCalculationsAdvisor) Check(_ context.Context, checkCtx adv// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_select.go b/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_select.goindex ca592f5237..8661127136 100644--- a/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_select.go+++ b/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_select.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")var (@@ -27,9 +28,9 @@ type WhereRequirementForSelectAdvisor struct {// Check checks for WHERE clause requirement.func (*WhereRequirementForSelectAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -43,7 +44,10 @@ func (*WhereRequirementForSelectAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_update_delete.go b/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_update_delete.goindex 0945050fea..55cd25dbf5 100644--- a/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_update_delete.go+++ b/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_update_delete.go@@ -11,6 +11,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql")var (@@ -27,9 +28,9 @@ type WhereRequirementForUpdateDeleteAdvisor struct {// Check checks for WHERE clause requirement.func (*WhereRequirementForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -43,7 +44,10 @@ func (*WhereRequirementForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_table_disallow_ddl.go b/backend/plugin/advisor/mssql/rule_table_disallow_ddl.goindex 56d1202c0c..b030e4ed81 100644--- a/backend/plugin/advisor/mssql/rule_table_disallow_ddl.go+++ b/backend/plugin/advisor/mssql/rule_table_disallow_ddl.go@@ -29,9 +29,9 @@ type TableDisallowDDLAdvisor struct {}func (*TableDisallowDDLAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -49,7 +49,10 @@ func (*TableDisallowDDLAdvisor) Check(_ context.Context, checkCtx advisor.Contex// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_table_disallow_dml.go b/backend/plugin/advisor/mssql/rule_table_disallow_dml.goindex 232624ff9c..ff508c2c72 100644--- a/backend/plugin/advisor/mssql/rule_table_disallow_dml.go+++ b/backend/plugin/advisor/mssql/rule_table_disallow_dml.go@@ -29,9 +29,9 @@ type TableDisallowDMLAdvisor struct {}func (*TableDisallowDMLAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, ok := checkCtx.AST.(antlr.Tree)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -49,7 +49,10 @@ func (*TableDisallowDMLAdvisor) Check(_ context.Context, checkCtx advisor.Contex// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_table_drop_naming_convention.go b/backend/plugin/advisor/mssql/rule_table_drop_naming_convention.goindex 4d244e76bf..9ea9d64072 100644--- a/backend/plugin/advisor/mssql/rule_table_drop_naming_convention.go+++ b/backend/plugin/advisor/mssql/rule_table_drop_naming_convention.go@@ -31,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)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -51,7 +51,10 @@ func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advis// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }return checker.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mssql/rule_table_no_foreign_key.go b/backend/plugin/advisor/mssql/rule_table_no_foreign_key.goindex a86f398610..dab5e760d1 100644--- a/backend/plugin/advisor/mssql/rule_table_no_foreign_key.go+++ b/backend/plugin/advisor/mssql/rule_table_no_foreign_key.go@@ -30,9 +30,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)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -46,7 +46,10 @@ func (*TableNoForeignKeyAdvisor) Check(_ context.Context, checkCtx advisor.Conte// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, tree)+ for _, parseResult := range parseResults {+ rule.SetBaseLine(parseResult.BaseLine)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }// Process the final advice after walkingrule.generateFinalAdvice()diff --git a/backend/plugin/advisor/mssql/rule_table_require_pk.go b/backend/plugin/advisor/mssql/rule_table_require_pk.goindex 17f366e88d..565f8085aa 100644--- a/backend/plugin/advisor/mssql/rule_table_require_pk.go+++ b/backend/plugin/advisor/mssql/rule_table_require_pk.go@@ -29,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)+ parseResults, ok := checkCtx.AST.([]*tsqlparser.ParseResult)if !ok {- return nil, errors.Errorf("failed to convert to Tree")+ return nil, errors.Errorf("failed to convert to ParseResult list")}level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)@@ -45,7 +45,10 @@ func (*TableRequirePkAdvisor) 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)+ antlr.ParseTreeWalkerDefault.Walk(checker, parseResult.Tree)+ }// Process the final advice after walkingrule.generateFinalAdvice()diff --git a/backend/plugin/db/mssql/query.go b/backend/plugin/db/mssql/query.goindex 3399f36e17..46c4754cbe 100644--- a/backend/plugin/db/mssql/query.go+++ b/backend/plugin/db/mssql/query.go@@ -171,11 +171,17 @@ func getStatementWithResultLimit(statement string, limit int) string {}func getStatementWithResultLimitInline(singleStatement string, limitCount int) (string, error) {- result, err := tsqlparser.ParseTSQL(singleStatement)+ results, err := tsqlparser.ParseTSQL(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 := &tsqlRewriter{limitCount: limitCount,hasFetch: false,diff --git a/backend/plugin/db/mssql/stmt_type.go b/backend/plugin/db/mssql/stmt_type.goindex f4ab8d2e68..7b0a5bb00e 100644--- a/backend/plugin/db/mssql/stmt_type.go+++ b/backend/plugin/db/mssql/stmt_type.go@@ -23,12 +23,17 @@ type stmtTypeListener struct {}func getStmtType(stmt string) (stmtType, error) {- parseResult, err := parser.ParseTSQL(stmt)+ parseResults, err := parser.ParseTSQL(stmt)if err != nil {return stmtTypeUnknown, err}++ if len(parseResults) != 1 {+ return stmtTypeUnknown, errors.Errorf("expected exactly 1 statement, got %d", len(parseResults))+ }+l := &stmtTypeListener{}- antlr.ParseTreeWalkerDefault.Walk(l, parseResult.Tree)+ antlr.ParseTreeWalkerDefault.Walk(l, parseResults[0].Tree)if l.err != nil {return stmtTypeUnknown, l.err}diff --git a/backend/plugin/parser/tsql/backup.go b/backend/plugin/parser/tsql/backup.goindex 2e58ebd481..0bb7005977 100644--- a/backend/plugin/parser/tsql/backup.go+++ b/backend/plugin/parser/tsql/backup.go@@ -50,6 +50,7 @@ type statementInfo struct {statement stringtree antlr.ParserRuleContexttable *TableReference+ baseLine int}func TransformDMLToSelect(_ context.Context, _ base.TransformContext, statement string, sourceDatabase string, targetDatabase string, tablePrefix string) ([]base.BackupStatement, error) {@@ -166,11 +167,11 @@ func generateSQLForTable(statementInfoList []statementInfo, targetDatabase strinSourceTableName: table.Table,TargetTableName: targetTable,StartPosition: &storepb.Position{- Line: int32(statementInfoList[0].tree.GetStart().GetLine()),+ Line: int32(statementInfoList[0].baseLine + statementInfoList[0].tree.GetStart().GetLine()),Column: int32(statementInfoList[0].tree.GetStart().GetColumn()),},EndPosition: &storepb.Position{- Line: int32(statementInfoList[len(statementInfoList)-1].tree.GetStop().GetLine()),+ Line: int32(statementInfoList[len(statementInfoList)-1].baseLine + statementInfoList[len(statementInfoList)-1].tree.GetStop().GetLine()),Column: int32(statementInfoList[len(statementInfoList)-1].tree.GetStop().GetColumn()),},}, nil@@ -326,7 +327,7 @@ func (e *suffixSelectStatementExtractor) EnterDelete_statement(ctx *parser.Delet}func prepareTransformation(databaseName, statement string) ([]statementInfo, error) {- parseResult, err := ParseTSQL(statement)+ parseResults, err := ParseTSQL(statement)if err != nil {return nil, errors.Wrap(err, "failed to parse statement")}@@ -334,7 +335,12 @@ func prepareTransformation(databaseName, statement string) ([]statementInfo, errextractor := &dmlExtractor{databaseName: databaseName,}- antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)++ for _, parseResult := range parseResults {+ extractor.baseLine = parseResult.BaseLine+ antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)+ }+return extractor.dmls, nil}@@ -344,6 +350,7 @@ type dmlExtractor struct {databaseName stringdmls []statementInfooffset int+ baseLine int}func IsTopLevel(ctx antlr.Tree) bool {@@ -391,6 +398,7 @@ func (e *dmlExtractor) EnterUpdate_statement(ctx *parser.Update_statementContextstatement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),tree: ctx,table: table,+ baseLine: e.baseLine,})}}@@ -412,6 +420,7 @@ func (e *dmlExtractor) EnterDelete_statement(ctx *parser.Delete_statementContextstatement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),tree: ctx,table: table,+ baseLine: e.baseLine,})}}diff --git a/backend/plugin/parser/tsql/query.go b/backend/plugin/parser/tsql/query.goindex 2ac5406749..5e7787551b 100644--- a/backend/plugin/parser/tsql/query.go+++ b/backend/plugin/parser/tsql/query.go@@ -13,18 +13,25 @@ func init() {}func ValidateSQLForEditor(statement string) (bool, bool, error) {- parseResult, err := ParseTSQL(statement)+ parseResults, err := ParseTSQL(statement)if err != nil {return false, false, err}- if parseResult == nil {+ if len(parseResults) == 0 {return false, false, nil}l := &queryValidateListener{valid: true,}- antlr.ParseTreeWalkerDefault.Walk(l, parseResult.Tree)++ for _, parseResult := range parseResults {+ antlr.ParseTreeWalkerDefault.Walk(l, parseResult.Tree)+ if !l.valid {+ break+ }+ }+return l.valid, l.valid, nil}diff --git a/backend/plugin/parser/tsql/query_span_extractor.go b/backend/plugin/parser/tsql/query_span_extractor.goindex 1c0da8cd04..b1271bb3dc 100644--- a/backend/plugin/parser/tsql/query_span_extractor.go+++ b/backend/plugin/parser/tsql/query_span_extractor.go@@ -59,13 +59,16 @@ func newQuerySpanExtractor(defaultDatabase string, defaultSchema string, gCtx bafunc (q *querySpanExtractor) getQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {q.ctx = ctx- parseResult, err := ParseTSQL(statement)+ parseResults, err := ParseTSQL(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, nil@@ -104,7 +107,12 @@ func (q *querySpanExtractor) getQuerySpan(ctx context.Context, statement string)listener := &tsqlSelectOnlyListener{extractor: q,}- antlr.ParseTreeWalkerDefault.Walk(listener, tree)+ // Walk all parse results to collect temp table declarations from earlier statements+ for _, parseResult := range parseResults {+ if parseResult.Tree != nil {+ antlr.ParseTreeWalkerDefault.Walk(listener, parseResult.Tree)+ }+ }err = listener.errif err != nil {var resourceNotFound *parsererror.ResourceNotFoundError@@ -3659,13 +3667,16 @@ func unquote(name string) string {}func getSelectBodyFromCreateView(createView string) (string, error) {- parseResult, err := ParseTSQL(createView)+ parseResults, err := ParseTSQL(createView)if err != nil {return "", err}- if parseResult == nil {- return "", errors.Errorf("failed to parse CREATE VIEW statement")++ if len(parseResults) != 1 {+ return "", errors.Errorf("expected exactly 1 statement, got %d", len(parseResults))}++ parseResult := parseResults[0]tree := parseResult.Treeif tree == nil {return "", errors.Errorf("parse tree is nil")diff --git a/backend/plugin/parser/tsql/resource_change.go b/backend/plugin/parser/tsql/resource_change.goindex 31b1e7291b..00a10b72e0 100644--- a/backend/plugin/parser/tsql/resource_change.go+++ b/backend/plugin/parser/tsql/resource_change.go@@ -20,9 +20,9 @@ func init() {}func extractChangedResources(currentDatabase string, currentSchema string, dbMetadata *model.DatabaseMetadata, asts any, statement string) (*base.ChangeSummary, error) {- tree, ok := asts.(antlr.Tree)+ parseResults, ok := asts.([]*ParseResult)if !ok {- return nil, errors.Errorf("failed to convert ast to antlr.Tree")+ return nil, errors.Errorf("failed to convert ast to ParseResult list")}changedResources := model.NewChangedResources(dbMetadata)@@ -34,7 +34,9 @@ func extractChangedResources(currentDatabase string, currentSchema string, dbMetstatement: statement,}- antlr.ParseTreeWalkerDefault.Walk(l, tree)+ for _, parseResult := range parseResults {+ antlr.ParseTreeWalkerDefault.Walk(l, parseResult.Tree)+ }return &base.ChangeSummary{ChangedResources: changedResources,diff --git a/backend/plugin/parser/tsql/resource_change_test.go b/backend/plugin/parser/tsql/resource_change_test.goindex 74657a172c..7386422257 100644--- a/backend/plugin/parser/tsql/resource_change_test.go+++ b/backend/plugin/parser/tsql/resource_change_test.go@@ -44,7 +44,8 @@ func TestExtractChangedResources(t *testing.T) {asts, err := ParseTSQL(statement)require.NoError(t, err)- got, err := extractChangedResources("DB", "dbo", nil /* dbMetadata */, asts.Tree, statement)+ require.Len(t, asts, 5)+ got, err := extractChangedResources("DB", "dbo", nil /* dbMetadata */, asts, statement)require.NoError(t, err)require.Equal(t, want, got)}diff --git a/backend/plugin/parser/tsql/restore.go b/backend/plugin/parser/tsql/restore.goindex d27f0f8786..7d694731e4 100644--- a/backend/plugin/parser/tsql/restore.go+++ b/backend/plugin/parser/tsql/restore.go@@ -30,20 +30,42 @@ func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statementreturn "", errors.Errorf("failed to extract single SQL: %v", err)}- parseResult, err := ParseTSQL(statement)+ if len(originalSQL) == 0 {+ return "", errors.Errorf("no original SQL")+ }++ parseResults, err := ParseTSQL(statement)if err != nil {return "", err}- if parseResult.Tree == nil {- return "", errors.Errorf("no parse result")+ // Find the parse result that contains the statement at the backup position+ var targetResult *ParseResult+ for _, parseResult := range parseResults {+ // Walk the tree to find if this parse result contains the target statement+ finder := &statementAtPositionFinder{+ startPos: backupItem.StartPosition,+ endPos: backupItem.EndPosition,+ baseLine: parseResult.BaseLine,+ }+ antlr.ParseTreeWalkerDefault.Walk(finder, parseResult.Tree)+ if finder.found {+ targetResult = parseResult+ break+ }+ }++ if targetResult == nil {+ return "", errors.Errorf("could not find statement at position (line %d:%d - %d:%d)",+ backupItem.StartPosition.Line, backupItem.StartPosition.Column,+ backupItem.EndPosition.Line, backupItem.EndPosition.Column)}sqlForComment, truncated := common.TruncateString(originalSQL, maxCommentLength)if truncated {sqlForComment += "..."}- return doGenerate(ctx, rCtx, sqlForComment, parseResult, backupItem)+ return doGenerate(ctx, rCtx, sqlForComment, targetResult, backupItem)}func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment string, tree *ParseResult, backupItem *storepb.PriorBackupDetail_Item) (string, error) {@@ -350,47 +372,114 @@ func extractSingleSQL(statement string, backupItem *storepb.PriorBackupDetail_Itreturn "", errors.Errorf("backup item is nil")}- list, err := SplitSQL(statement)+ parseResults, err := ParseTSQL(statement)if err != nil {- return "", errors.Wrap(err, "failed to split sql")+ return "", errors.Wrapf(err, "failed to parse statement")}- start := 0- end := len(list) - 1- for i, item := range list {- if equalOrLess(item.Start, backupItem.StartPosition) {- start = i- }+ l := &originalSQLExtractor{+ startPos: backupItem.StartPosition,+ endPos: backupItem.EndPosition,}- for i := len(list) - 1; i >= 0; i-- {- if equalOrGreater(list[i].Start, backupItem.EndPosition) {- end = i+ // Walk all parse results to find statements within the specified position range+ for _, parseResult := range parseResults {+ l.baseLine = parseResult.BaseLine+ antlr.ParseTreeWalkerDefault.Walk(l, parseResult.Tree)+ }++ if len(l.originalSQL) == 0 {+ return "", nil+ }++ // Join with semicolons and add a trailing semicolon+ return strings.Join(l.originalSQL, ";\n") + ";", nil+}++// originalSQLExtractor extracts original SQL statements within a position range.+type originalSQLExtractor struct {+ *parser.BaseTSqlParserListener++ originalSQL []string+ startPos *storepb.Position+ endPos *storepb.Position+ baseLine int+}++func (l *originalSQLExtractor) EnterUpdate_statement(ctx *parser.Update_statementContext) {+ if IsTopLevel(ctx.GetParent()) {+ if inRange(&storepb.Position{+ Line: int32(ctx.GetStart().GetLine()) + int32(l.baseLine),+ Column: int32(ctx.GetStart().GetColumn()),+ }, &storepb.Position{+ Line: int32(ctx.GetStop().GetLine()) + int32(l.baseLine),+ Column: int32(ctx.GetStop().GetColumn()),+ }, l.startPos, l.endPos) {+ sql := ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx)+ // Strip trailing semicolon to avoid double semicolons when joining+ sql = strings.TrimSuffix(sql, ";")+ l.originalSQL = append(l.originalSQL, sql)}}- var result []string- for i := start; i <= end; i++ {- result = append(result, list[i].Text)+}++func (l *originalSQLExtractor) EnterDelete_statement(ctx *parser.Delete_statementContext) {+ if IsTopLevel(ctx.GetParent()) {+ if inRange(&storepb.Position{+ Line: int32(ctx.GetStart().GetLine()) + int32(l.baseLine),+ Column: int32(ctx.GetStart().GetColumn()),+ }, &storepb.Position{+ Line: int32(ctx.GetStop().GetLine()) + int32(l.baseLine),+ Column: int32(ctx.GetStop().GetColumn()),+ }, l.startPos, l.endPos) {+ sql := ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx)+ // Strip trailing semicolon to avoid double semicolons when joining+ sql = strings.TrimSuffix(sql, ";")+ l.originalSQL = append(l.originalSQL, sql)+ }}- return strings.Join(result, ""), nil}-func equalOrLess(a, b *storepb.Position) bool {- if a.Line < b.Line {- return true+// statementAtPositionFinder finds if a parse tree contains a statement at the given position.+type statementAtPositionFinder struct {+ *parser.BaseTSqlParserListener+ startPos *storepb.Position+ endPos *storepb.Position+ baseLine int+ found bool+}++func (f *statementAtPositionFinder) EnterUpdate_statement(ctx *parser.Update_statementContext) {+ if IsTopLevel(ctx.GetParent()) && inRange(&storepb.Position{+ Line: int32(ctx.GetStart().GetLine()) + int32(f.baseLine),+ Column: int32(ctx.GetStart().GetColumn()),+ }, &storepb.Position{+ Line: int32(ctx.GetStop().GetLine()) + int32(f.baseLine),+ Column: int32(ctx.GetStop().GetColumn()),+ }, f.startPos, f.endPos) {+ f.found = true}- if a.Line == b.Line && a.Column <= b.Column {- return true+}++func (f *statementAtPositionFinder) EnterDelete_statement(ctx *parser.Delete_statementContext) {+ if IsTopLevel(ctx.GetParent()) && inRange(&storepb.Position{+ Line: int32(ctx.GetStart().GetLine()) + int32(f.baseLine),+ Column: int32(ctx.GetStart().GetColumn()),+ }, &storepb.Position{+ Line: int32(ctx.GetStop().GetLine()) + int32(f.baseLine),+ Column: int32(ctx.GetStop().GetColumn()),+ }, f.startPos, f.endPos) {+ f.found = true}- return false}-func equalOrGreater(a, b *storepb.Position) bool {- if a.Line > b.Line {- return true+// inRange checks if a statement's position range is within the target range.+func inRange(start, end, targetStart, targetEnd *storepb.Position) bool {+ if start.Line < targetStart.Line || (start.Line == targetStart.Line && start.Column < targetStart.Column) {+ return false}- if a.Line == b.Line && a.Column >= b.Column {- return true+ if end.Line > targetEnd.Line || (end.Line == targetEnd.Line && end.Column > targetEnd.Column) {+ return false}- return false+ return true}diff --git a/backend/plugin/parser/tsql/restore_test.go b/backend/plugin/parser/tsql/restore_test.goindex 227879ea21..0fec3b3806 100644--- a/backend/plugin/parser/tsql/restore_test.go+++ b/backend/plugin/parser/tsql/restore_test.go@@ -83,7 +83,7 @@ func TestRestoreIdentityHandling(t *testing.T) {Table: "backup_positions",},StartPosition: &store.Position{Line: 1, Column: 0},- EndPosition: &store.Position{Line: 1, Column: 40},+ EndPosition: &store.Position{Line: 1, Column: 43},})a.NoError(err)@@ -133,12 +133,12 @@ func TestRestore(t *testing.T) {Table: t.BackupTable,},StartPosition: &store.Position{- Line: 0,+ Line: 1,Column: 0,},EndPosition: &store.Position{Line: math.MaxInt32,- Column: 0,+ Column: 1,},})a.NoError(err)diff --git a/backend/plugin/parser/tsql/split_test.go b/backend/plugin/parser/tsql/split_test.goindex 6aa6cf8835..3b4eeb80ca 100644--- a/backend/plugin/parser/tsql/split_test.go+++ b/backend/plugin/parser/tsql/split_test.go@@ -75,6 +75,52 @@ go},},},+ {+ statement: `+++++++++UPDATE SalesLT.Address SET City = "Shanghai";++UPDATE SalesLT.Address SET PostalCode = 0;+++UPDATE SalesLT.ProductModelProductDescription SET Culture = "zh-cn";++++`,+ want: resData{+ res: []base.SingleSQL{+ {+ Text: "\n\n\n\n\n\n\n\n\nUPDATE SalesLT.Address SET City = \"Shanghai\";",+ BaseLine: 0,+ Start: &storepb.Position{Line: 10, Column: 1},+ End: &storepb.Position{Line: 10, Column: 45},+ Empty: false,+ },+ {+ Text: "\n\nUPDATE SalesLT.Address SET PostalCode = 0;",+ BaseLine: 9,+ Start: &storepb.Position{Line: 12, Column: 1},+ End: &storepb.Position{Line: 12, Column: 42},+ Empty: false,+ },+ {+ Text: "\n\n\nUPDATE SalesLT.ProductModelProductDescription SET Culture = \"zh-cn\";",+ BaseLine: 11,+ Start: &storepb.Position{Line: 15, Column: 1},+ End: &storepb.Position{Line: 15, Column: 68},+ Empty: false,+ },+ },+ },+ },}for _, test := range tests {diff --git a/backend/plugin/parser/tsql/statement_type_test.go b/backend/plugin/parser/tsql/statement_type_test.goindex f579bae1a9..e65da67565 100644--- a/backend/plugin/parser/tsql/statement_type_test.go+++ b/backend/plugin/parser/tsql/statement_type_test.go@@ -30,9 +30,10 @@ func TestGetStatementType(t *testing.T) {a.NoError(yaml.Unmarshal(byteValue, &tests))for _, test := range tests {- result, err := ParseTSQL(test.Statement)+ results, err := ParseTSQL(test.Statement)a.NoError(err)- sqlType, err := GetStatementTypes(result.Tree)+ a.Len(results, 1)+ sqlType, err := GetStatementTypes(results[0].Tree)a.NoError(err)a.Equal(test.Want, sqlType)}diff --git a/backend/plugin/parser/tsql/test-data/query-span/standard.yaml b/backend/plugin/parser/tsql/test-data/query-span/standard.yamlindex 5f59aa4a3d..81cde54f61 100644--- a/backend/plugin/parser/tsql/test-data/query-span/standard.yaml+++ b/backend/plugin/parser/tsql/test-data/query-span/standard.yaml@@ -1,54 +1,3 @@-- description: Test for declare temp table- statement: |-- declare @temp table (a int);- insert into @temp values(1);- select * from @temp where 1=1;- defaultDatabase: db- ignoreCaseSensitive: true- metadata:- - |-- {- "name": "db",- "schemas": [- {- "name": "dbo",- "tables": [- {- "name": "MyTable1",- "columns": [- {- "name": "a"- },- {- "name": "b"- }- ]- }- ],- "views": [- {- "name": "MyView1",- "definition": "CREATE VIEW [dbo].[MyView1] AS SELECT * FROM MyTable1"- }- ]- }- ]- }- querySpan:- type: 1- results:- - name: a- sourcecolumns:- - server: ""- database: ""- schema: ""- table: '@temp'- column: a- isplainfield: true- sourcefieldpaths: []- selectasterisk: false- sourcecolumns: []- predicatecolumns: []- description: Test for builtin functionsstatement: SELECT NEWID() as uuid;defaultDatabase: dbdiff --git a/backend/plugin/parser/tsql/tsql.go b/backend/plugin/parser/tsql/tsql.goindex 65367d6351..33a8b53a2e 100644--- a/backend/plugin/parser/tsql/tsql.go+++ b/backend/plugin/parser/tsql/tsql.go@@ -18,25 +18,43 @@ func init() {}// parseTSQLForRegistry is the ParseFunc for T-SQL.-// Returns antlr.Tree on success.+// Returns []*ParseResult on success.func parseTSQLForRegistry(statement string) (any, error) {- result, err := ParseTSQL(statement)+ return ParseTSQL(statement)+}++type ParseResult struct {+ Tree antlr.Tree+ Tokens *antlr.CommonTokenStream+ BaseLine int+}++// ParseTSQL parses the given SQL and returns a list of ParseResult (one per statement).+// Use the T-SQL parser based on antlr4.+func ParseTSQL(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 := parseSingleTSQL(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}-// ParseTSQL parses the given SQL statement by using antlr4. Returns the AST and token stream if no error.-func ParseTSQL(statement string) (*ParseResult, error) {+// parseSingleTSQL parses a single T-SQL statement and returns the ParseResult.+func parseSingleTSQL(statement string, baseLine int) (*ParseResult, error) {inputStream := antlr.NewInputStream(statement)lexer := parser.NewTSqlLexer(inputStream)stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)@@ -46,12 +64,14 @@ func ParseTSQL(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 +88,9 @@ func ParseTSQL(statement string) (*ParseResult, error) {}result := &ParseResult{- Tree: tree,- Tokens: stream,+ Tree: tree,+ Tokens: stream,+ BaseLine: baseLine,}return result, nildiff --git a/backend/plugin/schema/mssql/generate_migration.go b/backend/plugin/schema/mssql/generate_migration.goindex bdebd12bac..1b26f74207 100644--- a/backend/plugin/schema/mssql/generate_migration.go+++ b/backend/plugin/schema/mssql/generate_migration.go@@ -1082,16 +1082,20 @@ func getViewDependencies(viewDef string, schemaName string) ([]string, error) {// Parse the CREATE VIEW statement to extract the query properly// We need to find the AS keyword that's part of CREATE VIEW, not column aliases- parseResult, err := tsql.ParseTSQL(viewDef)+ parseResults, err := tsql.ParseTSQL(viewDef)if err != nil {return nil, errors.Wrapf(err, "failed to parse view definition")}+ if len(parseResults) != 1 {+ return nil, errors.Errorf("expected exactly 1 statement, got %d", len(parseResults))+ }+// Extract the query part after the CREATE VIEW statement// This assumes the viewDef is a valid CREATE VIEW statement// and that it contains a valid T-SQL query.l := &queryClauseListener{}- antlr.ParseTreeWalkerDefault.Walk(l, parseResult.Tree)+ antlr.ParseTreeWalkerDefault.Walk(l, parseResults[0].Tree)if l.result == "" {return []string{}, nil}diff --git a/backend/plugin/schema/mssql/get_database_metadata.go b/backend/plugin/schema/mssql/get_database_metadata.goindex 35026301eb..a957f599e3 100644--- a/backend/plugin/schema/mssql/get_database_metadata.go+++ b/backend/plugin/schema/mssql/get_database_metadata.go@@ -22,13 +22,22 @@ func init() {// GetDatabaseMetadata parses the SQL schema text and returns the database metadata.func GetDatabaseMetadata(schemaText string) (*storepb.DatabaseSchemaMetadata, error) {- parseResult, err := tsql.ParseTSQL(schemaText)+ parseResults, err := tsql.ParseTSQL(schemaText)if err != nil {return nil, errors.Wrapf(err, "failed to parse SQL schema")}- if parseResult.Tree == nil {- return nil, errors.Errorf("empty parse tree")+ // Handle empty schema (no statements) by returning empty metadata with default dbo schema+ if len(parseResults) == 0 {+ return &storepb.DatabaseSchemaMetadata{+ Name: "",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "dbo",+ Tables: []*storepb.TableMetadata{},+ },+ },+ }, nil}extractor := &metadataExtractor{@@ -38,7 +47,11 @@ func GetDatabaseMetadata(schemaText string) (*storepb.DatabaseSchemaMetadata, ertables: make(map[tableKey]*storepb.TableMetadata),}- antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)+ for _, parseResult := range parseResults {+ if parseResult.Tree != nil {+ antlr.ParseTreeWalkerDefault.Walk(extractor, parseResult.Tree)+ }+ }if extractor.err != nil {return nil, extractor.err