Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor(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.goindex 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.goindex 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.Rangep := 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 *StatementResulth := 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.goindex 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) == 0diff --git a/backend/plugin/db/tidb/tidb.go b/backend/plugin/db/tidb/tidb.goindex 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.goindex 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.gonew file mode 100644index 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.gonew file mode 100644index 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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 intSecond intdiff --git a/backend/plugin/parser/redshift/redshift.go b/backend/plugin/parser/redshift/redshift.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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-throughstate := 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 fieldsdiff --git a/backend/plugin/schema/pg/walk_through_test.go b/backend/plugin/schema/pg/walk_through_test.goindex 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-throughstate := 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 fieldsdiff --git a/backend/plugin/schema/tidb/walk_through_test.go b/backend/plugin/schema/tidb/walk_through_test.goindex 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-throughstate := 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 fieldsdiff --git a/backend/runner/plancheck/statement_report_executor.go b/backend/runner/plancheck/statement_report_executor.goindex 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, sheetManagerreturn 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 getAffectedRowsFromExplainvar sqlTypes []string