Skip to content

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

refactor(parser): introduce unified Statement type and migrate main dataflow (#18307)

h3n4l39948a712462
diff --git a/backend/api/v1/release_service_check.go b/backend/api/v1/release_service_check.go
index 64e33412b5..c59a152489 100644
--- a/backend/api/v1/release_service_check.go
+++ b/backend/api/v1/release_service_check.go
@@ -257,7 +257,7 @@ loop:
statement := string(file.Statement)
// Check if any syntax error in the statement.
if common.EngineSupportSyntaxCheck(engine) {
- _, syntaxAdvices := s.sheetManager.GetASTsForChecks(engine, statement)
+ _, syntaxAdvices := s.sheetManager.GetStatementsForChecks(engine, statement)
if len(syntaxAdvices) > 0 {
for _, advice := range syntaxAdvices {
checkResult.Advices = append(checkResult.Advices, convertToV1Advice(advice))
@@ -505,13 +505,14 @@ func (s *ReleaseService) checkReleaseDeclarative(ctx context.Context, files []*v
// Check if any syntax error in the statement.
if common.EngineSupportSyntaxCheck(engine) {
- asts, syntaxAdvices := s.sheetManager.GetASTsForChecks(engine, statement)
+ stmts, syntaxAdvices := s.sheetManager.GetStatementsForChecks(engine, statement)
if len(syntaxAdvices) > 0 {
for _, advice := range syntaxAdvices {
checkResult.Advices = append(checkResult.Advices, convertToV1Advice(advice))
}
} else {
// Only check statement types if there are no syntax errors
+ asts := base.ExtractASTs(stmts)
statementsWithPos, err := getStatementTypesWithPositionsForEngine(engine, asts)
if err != nil {
checkResult.Advices = append(checkResult.Advices, &v1pb.Advice{
diff --git a/backend/component/sheet/sheet.go b/backend/component/sheet/sheet.go
index ef17f9df0d..06dc96962f 100644
--- a/backend/component/sheet/sheet.go
+++ b/backend/component/sheet/sheet.go
@@ -41,8 +41,8 @@ const (
type Manager struct {
sync.Mutex
- store *store.Store
- astCache *lru.LRU[astHashKey, *Result]
+ store *store.Store
+ statementCache *lru.LRU[astHashKey, *StatementResult]
}
type astHashKey struct {
@@ -53,8 +53,8 @@ type astHashKey struct {
// NewManager creates a new sheet manager.
func NewManager(store *store.Store) *Manager {
return &Manager{
- store: store,
- astCache: lru.NewLRU[astHashKey, *Result](8, nil, 3*time.Minute),
+ store: store,
+ statementCache: lru.NewLRU[astHashKey, *StatementResult](8, nil, 3*time.Minute),
}
}
@@ -101,21 +101,21 @@ func getSheetCommands(engine storepb.Engine, statement string) []*storepb.Range
}
func getSheetCommandsGeneral(engine storepb.Engine, statement string) []*storepb.Range {
- singleSQLs, err := base.SplitMultiSQL(engine, statement)
+ statements, err := base.ParseStatements(engine, statement)
if err != nil {
if !strings.Contains(err.Error(), "not supported") {
- slog.Warn("failed to split multi sql", "engine", engine.String(), "statement", statement)
+ slog.Warn("failed to parse statements", "engine", engine.String(), "statement", statement)
}
return nil
}
// HACK(p0ny): always split for pg
- if len(singleSQLs) > common.MaximumCommands && engine != storepb.Engine_POSTGRES {
+ if len(statements) > common.MaximumCommands && engine != storepb.Engine_POSTGRES {
return nil
}
var sheetCommands []*storepb.Range
p := 0
- for _, s := range singleSQLs {
+ for _, s := range statements {
np := p + len(s.Text)
sheetCommands = append(sheetCommands, &storepb.Range{
Start: int32(p),
@@ -127,19 +127,19 @@ func getSheetCommandsGeneral(engine storepb.Engine, statement string) []*storepb
}
func getSheetCommandsFromByteOffset(engine storepb.Engine, statement string) []*storepb.Range {
- singleSQLs, err := base.SplitMultiSQL(engine, statement)
+ statements, err := base.ParseStatements(engine, statement)
if err != nil {
if !strings.Contains(err.Error(), "not supported") {
- slog.Warn("failed to get sheet command from byte offset", "engine", engine.String(), "statement", statement)
+ slog.Warn("failed to parse statements", "engine", engine.String(), "statement", statement)
}
return nil
}
- if len(singleSQLs) > common.MaximumCommands {
+ if len(statements) > common.MaximumCommands {
return nil
}
var sheetCommands []*storepb.Range
- for _, s := range singleSQLs {
+ for _, s := range statements {
sheetCommands = append(sheetCommands, &storepb.Range{
Start: int32(s.ByteOffsetStart),
End: int32(s.ByteOffsetEnd),
@@ -186,39 +186,41 @@ func getSheetCommandsForMSSQL(statement string) []*storepb.Range {
return sheetCommands
}
-type Result struct {
+// StatementResult holds the cached parsing results with the unified Statement type.
+type StatementResult struct {
sync.Mutex
- ast []base.AST
- advices []*storepb.Advice
+ statements []base.Statement
+ advices []*storepb.Advice
}
-// GetASTsForChecks gets the ASTs of statement with caching, and it should only be used
-// for plan checks because it involves some truncating.
-func (sm *Manager) GetASTsForChecks(dbType storepb.Engine, statement string) ([]base.AST, []*storepb.Advice) {
- var result *Result
+// GetStatementsForChecks gets the unified Statements (with both text and AST) with caching.
+// This is the new unified API that returns complete Statement objects.
+// Use this for new code that needs both text and AST information.
+func (sm *Manager) GetStatementsForChecks(dbType storepb.Engine, statement string) ([]base.Statement, []*storepb.Advice) {
+ var result *StatementResult
h := xxh3.HashString(statement)
key := astHashKey{hash: h, engine: dbType}
sm.Lock()
- if v, ok := sm.astCache.Get(key); ok {
+ if v, ok := sm.statementCache.Get(key); ok {
result = v
} else {
- result = &Result{}
- sm.astCache.Add(key, result)
+ result = &StatementResult{}
+ sm.statementCache.Add(key, result)
}
sm.Unlock()
result.Lock()
defer result.Unlock()
- if result.ast != nil || result.advices != nil {
- return result.ast, result.advices
+ if result.statements != nil || result.advices != nil {
+ return result.statements, result.advices
}
- ast, err := base.Parse(dbType, statement)
+ statements, err := base.ParseStatements(dbType, statement)
if err != nil {
result.advices = convertErrorToAdvice(err)
} else {
- result.ast = ast
+ result.statements = statements
}
- return result.ast, result.advices
+ return result.statements, result.advices
}
func convertErrorToAdvice(err error) []*storepb.Advice {
diff --git a/backend/plugin/advisor/sql_review.go b/backend/plugin/advisor/sql_review.go
index e73e74615b..fc4aa2d28f 100644
--- a/backend/plugin/advisor/sql_review.go
+++ b/backend/plugin/advisor/sql_review.go
@@ -10,6 +10,7 @@ import (
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/component/sheet"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
"github.com/bytebase/bytebase/backend/plugin/schema"
// Register walk-through implementations
@@ -489,7 +490,8 @@ func SQLReviewCheck(
ruleList []*storepb.SQLReviewRule,
checkContext Context,
) ([]*storepb.Advice, error) {
- asts, parseResult := sm.GetASTsForChecks(checkContext.DBType, statements)
+ stmts, parseResult := sm.GetStatementsForChecks(checkContext.DBType, statements)
+ asts := base.ExtractASTs(stmts)
builtinOnly := len(ruleList) == 0
diff --git a/backend/plugin/db/tidb/tidb.go b/backend/plugin/db/tidb/tidb.go
index b8931f6d16..16598a382b 100644
--- a/backend/plugin/db/tidb/tidb.go
+++ b/backend/plugin/db/tidb/tidb.go
@@ -413,7 +413,7 @@ func isNonTransactionStatement(stmt string) bool {
// QueryConn queries a SQL statement in a given connection.
func (d *Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement string, queryContext db.QueryContext) ([]*v1pb.QueryResult, error) {
- singleSQLs, err := base.SplitMultiSQL(storepb.Engine_MYSQL, statement)
+ singleSQLs, err := base.SplitMultiSQL(storepb.Engine_TIDB, statement)
if err != nil {
return nil, err
}
diff --git a/backend/plugin/parser/base/interface.go b/backend/plugin/parser/base/interface.go
index 483e17240d..04813ba433 100644
--- a/backend/plugin/parser/base/interface.go
+++ b/backend/plugin/parser/base/interface.go
@@ -29,6 +29,7 @@ var (
transformDMLToSelect = make(map[storepb.Engine]TransformDMLToSelectFunc)
generateRestoreSQL = make(map[storepb.Engine]GenerateRestoreSQLFunc)
parsers = make(map[storepb.Engine]ParseFunc)
+ statementParsers = make(map[storepb.Engine]ParseStatementsFunc)
statementTypeGetters = make(map[storepb.Engine]GetStatementTypesFunc)
)
@@ -52,6 +53,10 @@ type GenerateRestoreSQLFunc func(ctx context.Context, rCtx RestoreContext, state
// Parser packages can return *ANTLRAST for ANTLR-based parsers or their own concrete types.
type ParseFunc func(statement string) ([]AST, error)
+// ParseStatementsFunc is the interface for parsing SQL statements and returning []Statement.
+// This is the new unified parsing function that returns complete Statement objects.
+type ParseStatementsFunc func(statement string) ([]Statement, error)
+
// GetStatementTypesFunc returns the types of statements in the ASTs.
// Statement types include: INSERT, UPDATE, DELETE (DML), CREATE_TABLE, ALTER_TABLE, DROP_TABLE, etc. (DDL).
type GetStatementTypesFunc func([]AST) ([]string, error)
@@ -278,6 +283,25 @@ func Parse(engine storepb.Engine, statement string) ([]AST, error) {
return f(statement)
}
+func RegisterParseStatementsFunc(engine storepb.Engine, f ParseStatementsFunc) {
+ mux.Lock()
+ defer mux.Unlock()
+ if _, dup := statementParsers[engine]; dup {
+ panic(fmt.Sprintf("RegisterParseStatementsFunc called twice %s", engine))
+ }
+ statementParsers[engine] = f
+}
+
+// ParseStatements parses the SQL statement and returns Statement objects with both text and AST.
+// This is the new unified parsing function.
+func ParseStatements(engine storepb.Engine, statement string) ([]Statement, error) {
+ f, ok := statementParsers[engine]
+ if !ok {
+ return nil, errors.Errorf("engine %s is not supported for ParseStatements", engine)
+ }
+ return f(statement)
+}
+
func RegisterGetStatementTypes(engine storepb.Engine, f GetStatementTypesFunc) {
mux.Lock()
defer mux.Unlock()
diff --git a/backend/plugin/parser/base/statement.go b/backend/plugin/parser/base/statement.go
new file mode 100644
index 0000000000..6faa850abc
--- /dev/null
+++ b/backend/plugin/parser/base/statement.go
@@ -0,0 +1,97 @@
+package base
+
+import (
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+)
+
+// Statement represents a single SQL statement with both text and parsed AST.
+// This is the unified type that combines SingleSQL (text-based) and AST (tree-based).
+type Statement struct {
+ // Text content
+ Text string
+ Empty bool
+
+ // Position tracking (1-based)
+ StartPosition *storepb.Position
+ EndPosition *storepb.Position
+
+ // Byte offsets for execution tracking
+ ByteOffsetStart int
+ ByteOffsetEnd int
+
+ // Parsed tree (always present after Parse)
+ AST AST
+}
+
+// FilterEmptyStatements removes empty statements from the list.
+func FilterEmptyStatements(list []Statement) []Statement {
+ var result []Statement
+ for _, stmt := range list {
+ if !stmt.Empty {
+ result = append(result, stmt)
+ }
+ }
+ return result
+}
+
+// FilterEmptyStatementsWithIndexes removes empty statements and returns original indexes.
+func FilterEmptyStatementsWithIndexes(list []Statement) ([]Statement, []int32) {
+ var result []Statement
+ var originalIndex []int32
+ for i, stmt := range list {
+ if !stmt.Empty {
+ result = append(result, stmt)
+ originalIndex = append(originalIndex, int32(i))
+ }
+ }
+ return result, originalIndex
+}
+
+// SingleSQLToStatement converts a SingleSQL to a Statement without AST.
+// The AST field will be nil. Use this for incremental migration.
+func SingleSQLToStatement(sql SingleSQL) Statement {
+ return Statement{
+ Text: sql.Text,
+ Empty: sql.Empty,
+ StartPosition: sql.Start,
+ EndPosition: sql.End,
+ ByteOffsetStart: sql.ByteOffsetStart,
+ ByteOffsetEnd: sql.ByteOffsetEnd,
+ AST: nil,
+ }
+}
+
+// SingleSQLsToStatements converts a slice of SingleSQL to Statements without AST.
+func SingleSQLsToStatements(sqls []SingleSQL) []Statement {
+ result := make([]Statement, len(sqls))
+ for i, sql := range sqls {
+ result[i] = SingleSQLToStatement(sql)
+ }
+ return result
+}
+
+// StatementToSingleSQL converts a Statement back to SingleSQL.
+// The AST is discarded. Use this for backward compatibility.
+func StatementToSingleSQL(stmt Statement) SingleSQL {
+ return SingleSQL{
+ Text: stmt.Text,
+ Empty: stmt.Empty,
+ Start: stmt.StartPosition,
+ End: stmt.EndPosition,
+ ByteOffsetStart: stmt.ByteOffsetStart,
+ ByteOffsetEnd: stmt.ByteOffsetEnd,
+ // Note: BaseLine is not preserved as Statement uses 1-based StartPosition
+ }
+}
+
+// ExtractASTs extracts ASTs from a slice of Statements.
+// This is useful for backward compatibility when migrating from []AST to []Statement.
+func ExtractASTs(stmts []Statement) []AST {
+ var asts []AST
+ for _, stmt := range stmts {
+ if stmt.AST != nil {
+ asts = append(asts, stmt.AST)
+ }
+ }
+ return asts
+}
diff --git a/backend/plugin/parser/base/statement_test.go b/backend/plugin/parser/base/statement_test.go
new file mode 100644
index 0000000000..5bb3be8bf2
--- /dev/null
+++ b/backend/plugin/parser/base/statement_test.go
@@ -0,0 +1,78 @@
+package base
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+)
+
+func TestFilterEmptyStatements(t *testing.T) {
+ statements := []Statement{
+ {Text: "SELECT 1", Empty: false},
+ {Text: "", Empty: true},
+ {Text: "SELECT 2", Empty: false},
+ {Text: "-- comment", Empty: true},
+ }
+
+ result := FilterEmptyStatements(statements)
+
+ require.Len(t, result, 2)
+ require.Equal(t, "SELECT 1", result[0].Text)
+ require.Equal(t, "SELECT 2", result[1].Text)
+}
+
+func TestFilterEmptyStatementsWithIndexes(t *testing.T) {
+ statements := []Statement{
+ {Text: "SELECT 1", Empty: false},
+ {Text: "", Empty: true},
+ {Text: "SELECT 2", Empty: false},
+ }
+
+ result, indexes := FilterEmptyStatementsWithIndexes(statements)
+
+ require.Len(t, result, 2)
+ require.Equal(t, []int32{0, 2}, indexes)
+}
+
+func TestSingleSQLToStatement(t *testing.T) {
+ sql := SingleSQL{
+ Text: "SELECT 1",
+ Empty: false,
+ Start: &storepb.Position{Line: 1, Column: 1},
+ End: &storepb.Position{Line: 1, Column: 9},
+ ByteOffsetStart: 0,
+ ByteOffsetEnd: 8,
+ }
+
+ stmt := SingleSQLToStatement(sql)
+
+ require.Equal(t, sql.Text, stmt.Text)
+ require.Equal(t, sql.Empty, stmt.Empty)
+ require.Equal(t, sql.Start, stmt.StartPosition)
+ require.Equal(t, sql.End, stmt.EndPosition)
+ require.Equal(t, sql.ByteOffsetStart, stmt.ByteOffsetStart)
+ require.Equal(t, sql.ByteOffsetEnd, stmt.ByteOffsetEnd)
+ require.Nil(t, stmt.AST)
+}
+
+func TestStatementToSingleSQL(t *testing.T) {
+ stmt := Statement{
+ Text: "SELECT 1",
+ Empty: false,
+ StartPosition: &storepb.Position{Line: 1, Column: 1},
+ EndPosition: &storepb.Position{Line: 1, Column: 9},
+ ByteOffsetStart: 0,
+ ByteOffsetEnd: 8,
+ }
+
+ sql := StatementToSingleSQL(stmt)
+
+ require.Equal(t, stmt.Text, sql.Text)
+ require.Equal(t, stmt.Empty, sql.Empty)
+ require.Equal(t, stmt.StartPosition, sql.Start)
+ require.Equal(t, stmt.EndPosition, sql.End)
+ require.Equal(t, stmt.ByteOffsetStart, sql.ByteOffsetStart)
+ require.Equal(t, stmt.ByteOffsetEnd, sql.ByteOffsetEnd)
+}
diff --git a/backend/plugin/parser/cassandra/cassandra.go b/backend/plugin/parser/cassandra/cassandra.go
index 612c0358a3..641887dcef 100644
--- a/backend/plugin/parser/cassandra/cassandra.go
+++ b/backend/plugin/parser/cassandra/cassandra.go
@@ -13,6 +13,7 @@ import (
func init() {
base.RegisterParseFunc(storepb.Engine_CASSANDRA, parseCassandraForRegistry)
+ base.RegisterParseStatementsFunc(storepb.Engine_CASSANDRA, parseCassandraStatements)
}
// parseCassandraForRegistry is the ParseFunc for Cassandra.
@@ -38,6 +39,47 @@ func toAST(results []*base.ParseResult) []base.AST {
return asts
}
+// parseCassandraStatements is the ParseStatementsFunc for Cassandra.
+// Returns []Statement with both text and AST populated.
+func parseCassandraStatements(statement string) ([]base.Statement, error) {
+ // First split to get SingleSQL with text and positions
+ singleSQLs, err := SplitSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Then parse to get ASTs
+ parseResults, err := ParseCassandraSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Combine: SingleSQL provides text/positions, ParseResult provides AST
+ var statements []base.Statement
+ astIndex := 0
+ for _, sql := range singleSQLs {
+ stmt := base.Statement{
+ Text: sql.Text,
+ Empty: sql.Empty,
+ StartPosition: sql.Start,
+ EndPosition: sql.End,
+ ByteOffsetStart: sql.ByteOffsetStart,
+ ByteOffsetEnd: sql.ByteOffsetEnd,
+ }
+ if !sql.Empty && astIndex < len(parseResults) {
+ stmt.AST = &base.ANTLRAST{
+ StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
+ Tree: parseResults[astIndex].Tree,
+ Tokens: parseResults[astIndex].Tokens,
+ }
+ astIndex++
+ }
+ statements = append(statements, stmt)
+ }
+
+ return statements, nil
+}
+
// ParseCassandraSQL parses the given CQL statement by using antlr4. Returns a list of AST and token stream if no error.
func ParseCassandraSQL(statement string) ([]*base.ParseResult, error) {
stmts, err := SplitSQL(statement)
diff --git a/backend/plugin/parser/cockroachdb/cockroachdb.go b/backend/plugin/parser/cockroachdb/cockroachdb.go
index 1c8984fbda..bc75ae308b 100644
--- a/backend/plugin/parser/cockroachdb/cockroachdb.go
+++ b/backend/plugin/parser/cockroachdb/cockroachdb.go
@@ -13,6 +13,7 @@ import (
func init() {
base.RegisterParseFunc(storepb.Engine_COCKROACHDB, parseCockroachDBForRegistry)
+ base.RegisterParseStatementsFunc(storepb.Engine_COCKROACHDB, parseCockroachDBStatements)
}
// parseCockroachDBForRegistry is the ParseFunc for CockroachDB.
@@ -35,6 +36,43 @@ func parseCockroachDBForRegistry(statement string) ([]base.AST, error) {
return asts, nil
}
+// parseCockroachDBStatements is the ParseStatementsFunc for CockroachDB.
+// Returns []Statement with both text and AST populated.
+func parseCockroachDBStatements(statement string) ([]base.Statement, error) {
+ // First split to get SingleSQL with text and positions (uses PostgreSQL splitter)
+ singleSQLs, err := base.SplitMultiSQL(storepb.Engine_COCKROACHDB, statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Then parse to get ASTs
+ asts, err := parseCockroachDBForRegistry(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Combine: SingleSQL provides text/positions, AST provides parsed tree
+ var statements []base.Statement
+ astIndex := 0
+ for _, sql := range singleSQLs {
+ stmt := base.Statement{
+ Text: sql.Text,
+ Empty: sql.Empty,
+ StartPosition: sql.Start,
+ EndPosition: sql.End,
+ ByteOffsetStart: sql.ByteOffsetStart,
+ ByteOffsetEnd: sql.ByteOffsetEnd,
+ }
+ if !sql.Empty && astIndex < len(asts) {
+ stmt.AST = asts[astIndex]
+ astIndex++
+ }
+ statements = append(statements, stmt)
+ }
+
+ return statements, nil
+}
+
type ParseResult struct {
Stmts statements.Statements
}
diff --git a/backend/plugin/parser/doris/doris.go b/backend/plugin/parser/doris/doris.go
index db5cfa93ed..87fa11db86 100644
--- a/backend/plugin/parser/doris/doris.go
+++ b/backend/plugin/parser/doris/doris.go
@@ -10,6 +10,7 @@ import (
func init() {
base.RegisterParseFunc(storepb.Engine_DORIS, parseDorisForRegistry)
+ base.RegisterParseStatementsFunc(storepb.Engine_DORIS, parseDorisStatements)
}
// parseDorisForRegistry is the ParseFunc for Doris.
@@ -35,6 +36,47 @@ func toAST(results []*base.ParseResult) []base.AST {
return asts
}
+// parseDorisStatements is the ParseStatementsFunc for Doris.
+// Returns []Statement with both text and AST populated.
+func parseDorisStatements(statement string) ([]base.Statement, error) {
+ // First split to get SingleSQL with text and positions
+ singleSQLs, err := SplitSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Then parse to get ASTs
+ parseResults, err := ParseDorisSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Combine: SingleSQL provides text/positions, ParseResult provides AST
+ var statements []base.Statement
+ astIndex := 0
+ for _, sql := range singleSQLs {
+ stmt := base.Statement{
+ Text: sql.Text,
+ Empty: sql.Empty,
+ StartPosition: sql.Start,
+ EndPosition: sql.End,
+ ByteOffsetStart: sql.ByteOffsetStart,
+ ByteOffsetEnd: sql.ByteOffsetEnd,
+ }
+ if !sql.Empty && astIndex < len(parseResults) {
+ stmt.AST = &base.ANTLRAST{
+ StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
+ Tree: parseResults[astIndex].Tree,
+ Tokens: parseResults[astIndex].Tokens,
+ }
+ astIndex++
+ }
+ statements = append(statements, stmt)
+ }
+
+ return statements, nil
+}
+
// ParseDorisSQL parses the given SQL statement by using antlr4. Returns a list of AST and token stream if no error.
func ParseDorisSQL(statement string) ([]*base.ParseResult, error) {
stmts, err := SplitSQL(statement)
diff --git a/backend/plugin/parser/mysql/mysql.go b/backend/plugin/parser/mysql/mysql.go
index dc8b15ee33..9ed58b00e1 100644
--- a/backend/plugin/parser/mysql/mysql.go
+++ b/backend/plugin/parser/mysql/mysql.go
@@ -20,6 +20,9 @@ func init() {
base.RegisterParseFunc(storepb.Engine_MYSQL, parseMySQLForRegistry)
base.RegisterParseFunc(storepb.Engine_MARIADB, parseMySQLForRegistry)
base.RegisterParseFunc(storepb.Engine_OCEANBASE, parseMySQLForRegistry)
+ base.RegisterParseStatementsFunc(storepb.Engine_MYSQL, parseMySQLStatements)
+ base.RegisterParseStatementsFunc(storepb.Engine_MARIADB, parseMySQLStatements)
+ base.RegisterParseStatementsFunc(storepb.Engine_OCEANBASE, parseMySQLStatements)
base.RegisterGetStatementTypes(storepb.Engine_MYSQL, GetStatementTypes)
base.RegisterGetStatementTypes(storepb.Engine_MARIADB, GetStatementTypes)
base.RegisterGetStatementTypes(storepb.Engine_OCEANBASE, GetStatementTypes)
@@ -48,6 +51,48 @@ func toAST(results []*base.ParseResult) []base.AST {
return asts
}
+// parseMySQLStatements is the ParseStatementsFunc for MySQL, MariaDB, and OceanBase.
+// Returns []Statement with both text and AST populated.
+func parseMySQLStatements(statement string) ([]base.Statement, error) {
+ // First split to get SingleSQL with text and positions
+ singleSQLs, err := SplitSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Then parse to get ASTs
+ parseResults, err := ParseMySQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Combine: SingleSQL provides text/positions, ParseResult provides AST
+ // Note: parseResults may have fewer items if some statements are empty
+ var statements []base.Statement
+ astIndex := 0
+ for _, sql := range singleSQLs {
+ stmt := base.Statement{
+ Text: sql.Text,
+ Empty: sql.Empty,
+ StartPosition: sql.Start,
+ EndPosition: sql.End,
+ ByteOffsetStart: sql.ByteOffsetStart,
+ ByteOffsetEnd: sql.ByteOffsetEnd,
+ }
+ if !sql.Empty && astIndex < len(parseResults) {
+ stmt.AST = &base.ANTLRAST{
+ StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
+ Tree: parseResults[astIndex].Tree,
+ Tokens: parseResults[astIndex].Tokens,
+ }
+ astIndex++
+ }
+ statements = append(statements, stmt)
+ }
+
+ return statements, nil
+}
+
// ParseMySQL parses the given SQL statement and returns the AST.
func ParseMySQL(statement string) ([]*base.ParseResult, error) {
statement, err := DealWithDelimiter(statement)
diff --git a/backend/plugin/parser/mysql/mysql_test.go b/backend/plugin/parser/mysql/mysql_test.go
index b4f85d8ceb..1e5f5bf070 100644
--- a/backend/plugin/parser/mysql/mysql_test.go
+++ b/backend/plugin/parser/mysql/mysql_test.go
@@ -4,6 +4,9 @@ import (
"testing"
"github.com/stretchr/testify/require"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
)
func TestExtractDelimiter(t *testing.T) {
@@ -445,3 +448,26 @@ DELIMITER ;
require.Equalf(t, tc.want, got, "test cases: %d", i)
}
}
+
+func TestParseMySQLStatements(t *testing.T) {
+ statement := "SELECT 1; SELECT 2;"
+
+ statements, err := base.ParseStatements(storepb.Engine_MYSQL, statement)
+ require.NoError(t, err)
+
+ // Filter empty statements for assertion
+ statements = base.FilterEmptyStatements(statements)
+
+ require.Len(t, statements, 2)
+
+ // Check first statement
+ require.Equal(t, "SELECT 1;", statements[0].Text)
+ require.False(t, statements[0].Empty)
+ require.NotNil(t, statements[0].AST)
+ require.NotNil(t, statements[0].StartPosition)
+
+ // Check second statement
+ require.Contains(t, statements[1].Text, "SELECT 2")
+ require.False(t, statements[1].Empty)
+ require.NotNil(t, statements[1].AST)
+}
diff --git a/backend/plugin/parser/partiql/partiql.go b/backend/plugin/parser/partiql/partiql.go
index bbdbafc833..36baa9d503 100644
--- a/backend/plugin/parser/partiql/partiql.go
+++ b/backend/plugin/parser/partiql/partiql.go
@@ -14,6 +14,7 @@ import (
func init() {
base.RegisterParseFunc(storepb.Engine_DYNAMODB, parsePartiQLForRegistry)
+ base.RegisterParseStatementsFunc(storepb.Engine_DYNAMODB, parsePartiQLStatements)
}
// parsePartiQLForRegistry is the ParseFunc for PartiQL.
@@ -39,6 +40,47 @@ func toAST(results []*base.ParseResult) []base.AST {
return asts
}
+// parsePartiQLStatements is the ParseStatementsFunc for PartiQL (DynamoDB).
+// Returns []Statement with both text and AST populated.
+func parsePartiQLStatements(statement string) ([]base.Statement, error) {
+ // First split to get SingleSQL with text and positions
+ singleSQLs, err := SplitSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Then parse to get ASTs
+ parseResults, err := ParsePartiQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Combine: SingleSQL provides text/positions, ParseResult provides AST
+ var statements []base.Statement
+ astIndex := 0
+ for _, sql := range singleSQLs {
+ stmt := base.Statement{
+ Text: sql.Text,
+ Empty: sql.Empty,
+ StartPosition: sql.Start,
+ EndPosition: sql.End,
+ ByteOffsetStart: sql.ByteOffsetStart,
+ ByteOffsetEnd: sql.ByteOffsetEnd,
+ }
+ if !sql.Empty && astIndex < len(parseResults) {
+ stmt.AST = &base.ANTLRAST{
+ StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
+ Tree: parseResults[astIndex].Tree,
+ Tokens: parseResults[astIndex].Tokens,
+ }
+ astIndex++
+ }
+ statements = append(statements, stmt)
+ }
+
+ return statements, nil
+}
+
// ParsePartiQL parses the given PartiQL statement by using antlr4. Returns a list of AST and token stream if no error.
func ParsePartiQL(statement string) ([]*base.ParseResult, error) {
stmts, err := SplitSQL(statement)
diff --git a/backend/plugin/parser/pg/pg.go b/backend/plugin/parser/pg/pg.go
index de3a2540a4..116e0e0383 100644
--- a/backend/plugin/parser/pg/pg.go
+++ b/backend/plugin/parser/pg/pg.go
@@ -12,6 +12,7 @@ import (
func init() {
base.RegisterParseFunc(storepb.Engine_POSTGRES, parsePostgreSQLForRegistry)
+ base.RegisterParseStatementsFunc(storepb.Engine_POSTGRES, parsePgStatements)
base.RegisterGetStatementTypes(storepb.Engine_POSTGRES, GetStatementTypesForRegistry)
}
@@ -38,6 +39,47 @@ func toAST(results []*base.ParseResult) []base.AST {
return asts
}
+// parsePgStatements is the ParseStatementsFunc for PostgreSQL.
+// Returns []Statement with both text and AST populated.
+func parsePgStatements(statement string) ([]base.Statement, error) {
+ // First split to get SingleSQL with text and positions
+ singleSQLs, err := SplitSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Then parse to get ASTs
+ parseResults, err := ParsePostgreSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Combine: SingleSQL provides text/positions, ParseResult provides AST
+ var statements []base.Statement
+ astIndex := 0
+ for _, sql := range singleSQLs {
+ stmt := base.Statement{
+ Text: sql.Text,
+ Empty: sql.Empty,
+ StartPosition: sql.Start,
+ EndPosition: sql.End,
+ ByteOffsetStart: sql.ByteOffsetStart,
+ ByteOffsetEnd: sql.ByteOffsetEnd,
+ }
+ if !sql.Empty && astIndex < len(parseResults) {
+ stmt.AST = &base.ANTLRAST{
+ StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
+ Tree: parseResults[astIndex].Tree,
+ Tokens: parseResults[astIndex].Tokens,
+ }
+ astIndex++
+ }
+ statements = append(statements, stmt)
+ }
+
+ return statements, nil
+}
+
// ParsePostgreSQL parses the given SQL and returns a list of ParseResult (one per statement).
// Use the PostgreSQL parser based on antlr4.
func ParsePostgreSQL(sql string) ([]*base.ParseResult, error) {
diff --git a/backend/plugin/parser/plsql/plsql.go b/backend/plugin/parser/plsql/plsql.go
index 90035372f7..1b5aa16699 100644
--- a/backend/plugin/parser/plsql/plsql.go
+++ b/backend/plugin/parser/plsql/plsql.go
@@ -16,6 +16,7 @@ import (
func init() {
base.RegisterParseFunc(storepb.Engine_ORACLE, parsePLSQLForRegistry)
+ base.RegisterParseStatementsFunc(storepb.Engine_ORACLE, parsePLSQLStatements)
base.RegisterGetStatementTypes(storepb.Engine_ORACLE, GetStatementTypes)
}
@@ -42,6 +43,47 @@ func toAST(results []*base.ParseResult) []base.AST {
return asts
}
+// parsePLSQLStatements is the ParseStatementsFunc for Oracle (PL/SQL).
+// Returns []Statement with both text and AST populated.
+func parsePLSQLStatements(statement string) ([]base.Statement, error) {
+ // First split to get SingleSQL with text and positions
+ singleSQLs, err := SplitSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Then parse to get ASTs (note: ParsePLSQL adds semicolon internally)
+ parseResults, err := ParsePLSQL(statement + ";")
+ if err != nil {
+ return nil, err
+ }
+
+ // Combine: SingleSQL provides text/positions, ParseResult provides AST
+ var statements []base.Statement
+ astIndex := 0
+ for _, sql := range singleSQLs {
+ stmt := base.Statement{
+ Text: sql.Text,
+ Empty: sql.Empty,
+ StartPosition: sql.Start,
+ EndPosition: sql.End,
+ ByteOffsetStart: sql.ByteOffsetStart,
+ ByteOffsetEnd: sql.ByteOffsetEnd,
+ }
+ if !sql.Empty && astIndex < len(parseResults) {
+ stmt.AST = &base.ANTLRAST{
+ StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
+ Tree: parseResults[astIndex].Tree,
+ Tokens: parseResults[astIndex].Tokens,
+ }
+ astIndex++
+ }
+ statements = append(statements, stmt)
+ }
+
+ return statements, nil
+}
+
type Version struct {
First int
Second int
diff --git a/backend/plugin/parser/redshift/redshift.go b/backend/plugin/parser/redshift/redshift.go
index ac81515ce1..dde86b3de4 100644
--- a/backend/plugin/parser/redshift/redshift.go
+++ b/backend/plugin/parser/redshift/redshift.go
@@ -14,6 +14,7 @@ import (
func init() {
base.RegisterParseFunc(storepb.Engine_REDSHIFT, parseRedshiftForRegistry)
+ base.RegisterParseStatementsFunc(storepb.Engine_REDSHIFT, parseRedshiftStatements)
base.RegisterGetStatementTypes(storepb.Engine_REDSHIFT, GetStatementTypes)
}
@@ -40,6 +41,47 @@ func toAST(results []*base.ParseResult) []base.AST {
return asts
}
+// parseRedshiftStatements is the ParseStatementsFunc for Redshift.
+// Returns []Statement with both text and AST populated.
+func parseRedshiftStatements(statement string) ([]base.Statement, error) {
+ // First split to get SingleSQL with text and positions
+ singleSQLs, err := SplitSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Then parse to get ASTs
+ parseResults, err := ParseRedshift(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Combine: SingleSQL provides text/positions, ParseResult provides AST
+ var statements []base.Statement
+ astIndex := 0
+ for _, sql := range singleSQLs {
+ stmt := base.Statement{
+ Text: sql.Text,
+ Empty: sql.Empty,
+ StartPosition: sql.Start,
+ EndPosition: sql.End,
+ ByteOffsetStart: sql.ByteOffsetStart,
+ ByteOffsetEnd: sql.ByteOffsetEnd,
+ }
+ if !sql.Empty && astIndex < len(parseResults) {
+ stmt.AST = &base.ANTLRAST{
+ StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
+ Tree: parseResults[astIndex].Tree,
+ Tokens: parseResults[astIndex].Tokens,
+ }
+ astIndex++
+ }
+ statements = append(statements, stmt)
+ }
+
+ return statements, nil
+}
+
// ParseRedshift parses the given SQL statement and returns a list of ParseResults.
// Each ParseResult represents one statement with its AST, tokens, and base line offset.
func ParseRedshift(sql string) ([]*base.ParseResult, error) {
diff --git a/backend/plugin/parser/snowflake/snowflake.go b/backend/plugin/parser/snowflake/snowflake.go
index 01e2911103..cf4a95d75e 100644
--- a/backend/plugin/parser/snowflake/snowflake.go
+++ b/backend/plugin/parser/snowflake/snowflake.go
@@ -14,6 +14,7 @@ import (
func init() {
base.RegisterParseFunc(storepb.Engine_SNOWFLAKE, parseSnowflakeForRegistry)
+ base.RegisterParseStatementsFunc(storepb.Engine_SNOWFLAKE, parseSnowflakeStatements)
}
// parseSnowflakeForRegistry is the ParseFunc for Snowflake.
@@ -39,6 +40,47 @@ func toAST(results []*base.ParseResult) []base.AST {
return asts
}
+// parseSnowflakeStatements is the ParseStatementsFunc for Snowflake.
+// Returns []Statement with both text and AST populated.
+func parseSnowflakeStatements(statement string) ([]base.Statement, error) {
+ // First split to get SingleSQL with text and positions
+ singleSQLs, err := SplitSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Then parse to get ASTs
+ parseResults, err := ParseSnowSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Combine: SingleSQL provides text/positions, ParseResult provides AST
+ var statements []base.Statement
+ astIndex := 0
+ for _, sql := range singleSQLs {
+ stmt := base.Statement{
+ Text: sql.Text,
+ Empty: sql.Empty,
+ StartPosition: sql.Start,
+ EndPosition: sql.End,
+ ByteOffsetStart: sql.ByteOffsetStart,
+ ByteOffsetEnd: sql.ByteOffsetEnd,
+ }
+ if !sql.Empty && astIndex < len(parseResults) {
+ stmt.AST = &base.ANTLRAST{
+ StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
+ Tree: parseResults[astIndex].Tree,
+ Tokens: parseResults[astIndex].Tokens,
+ }
+ astIndex++
+ }
+ statements = append(statements, stmt)
+ }
+
+ return statements, nil
+}
+
// ParseSnowSQL parses the given SQL and returns a list of ParseResult (one per statement).
// Use the Snowflake parser based on antlr4.
func ParseSnowSQL(sql string) ([]*base.ParseResult, error) {
diff --git a/backend/plugin/parser/tidb/tidb.go b/backend/plugin/parser/tidb/tidb.go
index a1de35d025..3b6ec75636 100644
--- a/backend/plugin/parser/tidb/tidb.go
+++ b/backend/plugin/parser/tidb/tidb.go
@@ -26,6 +26,7 @@ import (
func init() {
base.RegisterParseFunc(storepb.Engine_TIDB, ParseTiDBForSyntaxCheck)
+ base.RegisterParseStatementsFunc(storepb.Engine_TIDB, parseTiDBStatements)
base.RegisterGetStatementTypes(storepb.Engine_TIDB, GetStatementTypes)
}
@@ -77,6 +78,43 @@ func ParseTiDBForSyntaxCheck(statement string) ([]base.AST, error) {
return results, nil
}
+// parseTiDBStatements is the ParseStatementsFunc for TiDB.
+// Returns []Statement with both text and AST populated.
+func parseTiDBStatements(statement string) ([]base.Statement, error) {
+ // First split to get SingleSQL with text and positions
+ singleSQLs, err := base.SplitMultiSQL(storepb.Engine_TIDB, statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Then parse to get ASTs
+ asts, err := ParseTiDBForSyntaxCheck(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Combine: SingleSQL provides text/positions, AST provides parsed tree
+ var statements []base.Statement
+ astIndex := 0
+ for _, sql := range singleSQLs {
+ stmt := base.Statement{
+ Text: sql.Text,
+ Empty: sql.Empty,
+ StartPosition: sql.Start,
+ EndPosition: sql.End,
+ ByteOffsetStart: sql.ByteOffsetStart,
+ ByteOffsetEnd: sql.ByteOffsetEnd,
+ }
+ if !sql.Empty && astIndex < len(asts) {
+ stmt.AST = asts[astIndex]
+ astIndex++
+ }
+ statements = append(statements, stmt)
+ }
+
+ return statements, nil
+}
+
func newTiDBParser() *tidbparser.Parser {
p := tidbparser.New()
diff --git a/backend/plugin/parser/tsql/tsql.go b/backend/plugin/parser/tsql/tsql.go
index 83f6d70b9d..37d209b652 100644
--- a/backend/plugin/parser/tsql/tsql.go
+++ b/backend/plugin/parser/tsql/tsql.go
@@ -15,6 +15,7 @@ import (
func init() {
base.RegisterParseFunc(storepb.Engine_MSSQL, parseTSQLForRegistry)
+ base.RegisterParseStatementsFunc(storepb.Engine_MSSQL, parseTSQLStatements)
base.RegisterGetStatementTypes(storepb.Engine_MSSQL, GetStatementTypes)
}
@@ -41,6 +42,47 @@ func toAST(results []*base.ParseResult) []base.AST {
return asts
}
+// parseTSQLStatements is the ParseStatementsFunc for T-SQL (MSSQL).
+// Returns []Statement with both text and AST populated.
+func parseTSQLStatements(statement string) ([]base.Statement, error) {
+ // First split to get SingleSQL with text and positions
+ singleSQLs, err := SplitSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Then parse to get ASTs
+ parseResults, err := ParseTSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ // Combine: SingleSQL provides text/positions, ParseResult provides AST
+ var statements []base.Statement
+ astIndex := 0
+ for _, sql := range singleSQLs {
+ stmt := base.Statement{
+ Text: sql.Text,
+ Empty: sql.Empty,
+ StartPosition: sql.Start,
+ EndPosition: sql.End,
+ ByteOffsetStart: sql.ByteOffsetStart,
+ ByteOffsetEnd: sql.ByteOffsetEnd,
+ }
+ if !sql.Empty && astIndex < len(parseResults) {
+ stmt.AST = &base.ANTLRAST{
+ StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
+ Tree: parseResults[astIndex].Tree,
+ Tokens: parseResults[astIndex].Tokens,
+ }
+ astIndex++
+ }
+ statements = append(statements, stmt)
+ }
+
+ return statements, nil
+}
+
// 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) ([]*base.ParseResult, error) {
diff --git a/backend/plugin/schema/mysql/walk_through_test.go b/backend/plugin/schema/mysql/walk_through_test.go
index 36e4aefec7..67f063c71b 100644
--- a/backend/plugin/schema/mysql/walk_through_test.go
+++ b/backend/plugin/schema/mysql/walk_through_test.go
@@ -15,6 +15,7 @@ import (
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/component/sheet"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
"github.com/bytebase/bytebase/backend/store/model"
)
@@ -51,7 +52,8 @@ func TestWalkThrough(t *testing.T) {
// Create DatabaseMetadata for walk-through
state := model.NewDatabaseMetadata(protoData, nil, nil, storepb.Engine_MYSQL, !test.IgnoreCaseSensitive)
- asts, _ := sm.GetASTsForChecks(storepb.Engine_MYSQL, test.Statement)
+ stmts, _ := sm.GetStatementsForChecks(storepb.Engine_MYSQL, test.Statement)
+ asts := base.ExtractASTs(stmts)
advice := WalkThrough(state, asts)
if advice != nil {
// Compare the advice fields
diff --git a/backend/plugin/schema/pg/walk_through_test.go b/backend/plugin/schema/pg/walk_through_test.go
index 6def90d00b..54fb545791 100644
--- a/backend/plugin/schema/pg/walk_through_test.go
+++ b/backend/plugin/schema/pg/walk_through_test.go
@@ -94,7 +94,8 @@ func TestWalkThrough(t *testing.T) {
// Create DatabaseMetadata for walk-through
state := model.NewDatabaseMetadata(protoData, nil, nil, storepb.Engine_POSTGRES, !test.IgnoreCaseSensitive)
- asts, _ := sm.GetASTsForChecks(storepb.Engine_POSTGRES, test.Statement)
+ stmts, _ := sm.GetStatementsForChecks(storepb.Engine_POSTGRES, test.Statement)
+ asts := base.ExtractASTs(stmts)
advice := WalkThrough(state, asts)
if advice != nil {
// Compare the advice fields
diff --git a/backend/plugin/schema/tidb/walk_through_test.go b/backend/plugin/schema/tidb/walk_through_test.go
index 547589176c..0a4cc91811 100644
--- a/backend/plugin/schema/tidb/walk_through_test.go
+++ b/backend/plugin/schema/tidb/walk_through_test.go
@@ -15,6 +15,7 @@ import (
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/component/sheet"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
"github.com/bytebase/bytebase/backend/store/model"
)
@@ -51,7 +52,8 @@ func TestWalkThrough(t *testing.T) {
// Create DatabaseMetadata for walk-through
state := model.NewDatabaseMetadata(protoData, nil, nil, storepb.Engine_TIDB, !test.IgnoreCaseSensitive)
- asts, _ := sm.GetASTsForChecks(storepb.Engine_TIDB, test.Statement)
+ stmts, _ := sm.GetStatementsForChecks(storepb.Engine_TIDB, test.Statement)
+ asts := base.ExtractASTs(stmts)
advice := WalkThrough(state, asts)
if advice != nil {
// Compare the advice fields
diff --git a/backend/runner/plancheck/statement_report_executor.go b/backend/runner/plancheck/statement_report_executor.go
index 7b83950640..9a5e545495 100644
--- a/backend/runner/plancheck/statement_report_executor.go
+++ b/backend/runner/plancheck/statement_report_executor.go
@@ -98,7 +98,7 @@ func (e *StatementReportExecutor) Run(ctx context.Context, config *storepb.PlanC
}
// Check statement syntax error.
- _, syntaxAdvices := e.sheetManager.GetASTsForChecks(instance.Metadata.GetEngine(), statement)
+ _, syntaxAdvices := e.sheetManager.GetStatementsForChecks(instance.Metadata.GetEngine(), statement)
if len(syntaxAdvices) > 0 {
advice := syntaxAdvices[0]
return []*storepb.PlanCheckRunResult_Result{
@@ -157,11 +157,12 @@ func GetSQLSummaryReport(ctx context.Context, stores *store.Store, sheetManager
return nil, errors.Errorf("instance not found: %s", database.InstanceID)
}
- asts, syntaxAdvices := sheetManager.GetASTsForChecks(instance.Metadata.GetEngine(), statement)
+ stmts, syntaxAdvices := sheetManager.GetStatementsForChecks(instance.Metadata.GetEngine(), statement)
if len(syntaxAdvices) > 0 {
// Return nil as it should already be checked before running this function.
return nil, nil
}
+ asts := parserbase.ExtractASTs(stmts)
var explainCalculator getAffectedRowsFromExplain
var sqlTypes []string