Skip to content

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

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.go
index 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_Status
title string
adviceList []*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.go
index 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, err
extractor := &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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.IndexMetadata
func 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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) e
func (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_sour
func (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.go
index 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 advis
default:
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 rule
checker := 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.go
index 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 advis
default:
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 rule
checker := 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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 walking
rule.generateFinalAdvice()
diff --git a/backend/plugin/advisor/mssql/rule_table_require_pk.go b/backend/plugin/advisor/mssql/rule_table_require_pk.go
index 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 rule
checker := 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 walking
rule.generateFinalAdvice()
diff --git a/backend/plugin/db/mssql/query.go b/backend/plugin/db/mssql/query.go
index 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.go
index 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.go
index 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 string
tree antlr.ParserRuleContext
table *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 strin
SourceTableName: 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, err
extractor := &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 string
dmls []statementInfo
offset int
+ baseLine int
}
func IsTopLevel(ctx antlr.Tree) bool {
@@ -391,6 +398,7 @@ func (e *dmlExtractor) EnterUpdate_statement(ctx *parser.Update_statementContext
statement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),
tree: ctx,
table: table,
+ baseLine: e.baseLine,
})
}
}
@@ -412,6 +420,7 @@ func (e *dmlExtractor) EnterDelete_statement(ctx *parser.Delete_statementContext
statement: 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.go
index 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.go
index 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 ba
func (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.Tree
if 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.err
if 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.Tree
if 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.go
index 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, dbMet
statement: 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.go
index 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.go
index 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, statement
return "", 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_It
return "", 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.go
index 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.go
index 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.go
index 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.yaml
index 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 functions
statement: SELECT NEWID() as uuid;
defaultDatabase: db
diff --git a/backend/plugin/parser/tsql/tsql.go b/backend/plugin/parser/tsql/tsql.go
index 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, nil
diff --git a/backend/plugin/schema/mssql/generate_migration.go b/backend/plugin/schema/mssql/generate_migration.go
index 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.go
index 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, er
tables: 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