Skip to content

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

refactor(parser): remove Parse function, use ParseStatements (#18856)

h3n4le5638353ce31
diff --git a/backend/plugin/parser/base/interface.go b/backend/plugin/parser/base/interface.go
index 58ae83a210..d956d7664f 100644
--- a/backend/plugin/parser/base/interface.go
+++ b/backend/plugin/parser/base/interface.go
@@ -50,7 +50,6 @@ var (
spans = make(map[storepb.Engine]GetQuerySpanFunc)
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)
)
@@ -70,11 +69,6 @@ type TransformDMLToSelectFunc func(ctx context.Context, tCtx TransformContext, s
type GenerateRestoreSQLFunc func(ctx context.Context, rCtx RestoreContext, statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error)
-// ParseFunc is the interface for parsing SQL statements and returning []AST.
-// Each parser package is responsible for creating AST instances with the appropriate data.
-// 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 []ParsedStatement.
// This is the new unified parsing function that returns complete ParsedStatement objects with AST.
type ParseStatementsFunc func(statement string) ([]ParsedStatement, error)
@@ -286,25 +280,6 @@ func GenerateRestoreSQL(ctx context.Context, engine storepb.Engine, rCtx Restore
return f(ctx, rCtx, statement, backupItem)
}
-func RegisterParseFunc(engine storepb.Engine, f ParseFunc) {
- mux.Lock()
- defer mux.Unlock()
- if _, dup := parsers[engine]; dup {
- panic(fmt.Sprintf("Register called twice %s", engine))
- }
- parsers[engine] = f
-}
-
-// Parse parses the SQL statement and returns an AST representation.
-// Each parser is responsible for creating []AST instances directly.
-func Parse(engine storepb.Engine, statement string) ([]AST, error) {
- f, ok := parsers[engine]
- if !ok {
- return nil, errors.Errorf("engine %s is not supported", engine)
- }
- return f(statement)
-}
-
func RegisterParseStatementsFunc(engine storepb.Engine, f ParseStatementsFunc) {
mux.Lock()
defer mux.Unlock()
@@ -368,10 +343,11 @@ func IsAllDML(engine storepb.Engine, statement string) bool {
}
func isAllDMLImpl(engine storepb.Engine, statement string) bool {
- asts, err := Parse(engine, statement)
+ stmts, err := ParseStatements(engine, statement)
if err != nil {
return false
}
+ asts := ExtractASTs(stmts)
if len(asts) == 0 {
return false
}
diff --git a/backend/plugin/parser/cassandra/cassandra.go b/backend/plugin/parser/cassandra/cassandra.go
index 12c04c59f7..ba41c26571 100644
--- a/backend/plugin/parser/cassandra/cassandra.go
+++ b/backend/plugin/parser/cassandra/cassandra.go
@@ -12,24 +12,9 @@ import (
)
func init() {
- base.RegisterParseFunc(storepb.Engine_CASSANDRA, parseCassandraForRegistry)
base.RegisterParseStatementsFunc(storepb.Engine_CASSANDRA, parseCassandraStatements)
}
-// parseCassandraForRegistry is the ParseFunc for Cassandra.
-// Returns []base.AST with *ANTLRAST instances.
-func parseCassandraForRegistry(statement string) ([]base.AST, error) {
- parseResults, err := ParseCassandraSQL(statement)
- if err != nil {
- return nil, err
- }
- asts := make([]base.AST, len(parseResults))
- for i, r := range parseResults {
- asts[i] = r
- }
- return asts, nil
-}
-
// parseCassandraStatements is the ParseStatementsFunc for Cassandra.
// Returns []ParsedStatement with both text and AST populated.
func parseCassandraStatements(statement string) ([]base.ParsedStatement, error) {
diff --git a/backend/plugin/parser/cockroachdb/cockroachdb.go b/backend/plugin/parser/cockroachdb/cockroachdb.go
index c691cf96bc..f04415964d 100644
--- a/backend/plugin/parser/cockroachdb/cockroachdb.go
+++ b/backend/plugin/parser/cockroachdb/cockroachdb.go
@@ -12,30 +12,9 @@ import (
)
func init() {
- base.RegisterParseFunc(storepb.Engine_COCKROACHDB, parseCockroachDBForRegistry)
base.RegisterParseStatementsFunc(storepb.Engine_COCKROACHDB, parseCockroachDBStatements)
}
-// parseCockroachDBForRegistry is the ParseFunc for CockroachDB.
-// Returns []base.AST with *CockroachDBAST instances.
-func parseCockroachDBForRegistry(statement string) ([]base.AST, error) {
- result, err := ParseCockroachDBSQL(statement)
- if err != nil {
- return nil, err
- }
- if result == nil {
- return nil, nil
- }
- var asts []base.AST
- for _, stmt := range result.Stmts {
- asts = append(asts, &AST{
- StartPosition: &storepb.Position{Line: 1},
- Stmt: stmt,
- })
- }
- return asts, nil
-}
-
// parseCockroachDBStatements is the ParseStatementsFunc for CockroachDB.
// Returns []ParsedStatement with both text and AST populated.
func parseCockroachDBStatements(statement string) ([]base.ParsedStatement, error) {
@@ -46,7 +25,7 @@ func parseCockroachDBStatements(statement string) ([]base.ParsedStatement, error
}
// Then parse to get ASTs
- asts, err := parseCockroachDBForRegistry(statement)
+ parseResult, err := ParseCockroachDBSQL(statement)
if err != nil {
return nil, err
}
@@ -58,8 +37,11 @@ func parseCockroachDBStatements(statement string) ([]base.ParsedStatement, error
ps := base.ParsedStatement{
Statement: stmt,
}
- if !stmt.Empty && astIndex < len(asts) {
- ps.AST = asts[astIndex]
+ if !stmt.Empty && parseResult != nil && astIndex < len(parseResult.Stmts) {
+ ps.AST = &AST{
+ StartPosition: &storepb.Position{Line: 1},
+ Stmt: parseResult.Stmts[astIndex],
+ }
astIndex++
}
result = append(result, ps)
diff --git a/backend/plugin/parser/doris/doris.go b/backend/plugin/parser/doris/doris.go
index bc55e25525..a199cab823 100644
--- a/backend/plugin/parser/doris/doris.go
+++ b/backend/plugin/parser/doris/doris.go
@@ -9,24 +9,9 @@ import (
)
func init() {
- base.RegisterParseFunc(storepb.Engine_DORIS, parseDorisForRegistry)
base.RegisterParseStatementsFunc(storepb.Engine_DORIS, parseDorisStatements)
}
-// parseDorisForRegistry is the ParseFunc for Doris.
-// Returns []base.AST with *ANTLRAST instances.
-func parseDorisForRegistry(statement string) ([]base.AST, error) {
- antlrASTs, err := ParseDorisSQL(statement)
- if err != nil {
- return nil, err
- }
- var asts []base.AST
- for _, ast := range antlrASTs {
- asts = append(asts, ast)
- }
- return asts, nil
-}
-
// parseDorisStatements is the ParseStatementsFunc for Doris.
// Returns []ParsedStatement with both text and AST populated.
func parseDorisStatements(statement string) ([]base.ParsedStatement, error) {
diff --git a/backend/plugin/parser/mysql/mysql.go b/backend/plugin/parser/mysql/mysql.go
index 4dcd6bf629..1e5d06476c 100644
--- a/backend/plugin/parser/mysql/mysql.go
+++ b/backend/plugin/parser/mysql/mysql.go
@@ -16,9 +16,6 @@ import (
)
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)
@@ -27,20 +24,6 @@ func init() {
base.RegisterGetStatementTypes(storepb.Engine_OCEANBASE, GetStatementTypes)
}
-// parseMySQLForRegistry is the ParseFunc for MySQL, MariaDB, and OceanBase.
-// Returns []base.AST with *ANTLRAST instances.
-func parseMySQLForRegistry(statement string) ([]base.AST, error) {
- parseResults, err := ParseMySQL(statement)
- if err != nil {
- return nil, err
- }
- asts := make([]base.AST, len(parseResults))
- for i, r := range parseResults {
- asts[i] = r
- }
- return asts, nil
-}
-
// parseMySQLStatements is the ParseStatementsFunc for MySQL, MariaDB, and OceanBase.
// Returns []ParsedStatement with both text and AST populated.
func parseMySQLStatements(statement string) ([]base.ParsedStatement, error) {
diff --git a/backend/plugin/parser/mysql/resource_change_test.go b/backend/plugin/parser/mysql/resource_change_test.go
index c2582806d8..a2a4590890 100644
--- a/backend/plugin/parser/mysql/resource_change_test.go
+++ b/backend/plugin/parser/mysql/resource_change_test.go
@@ -45,8 +45,9 @@ func TestExtractChangedResources(t *testing.T) {
InsertCount: 2,
}
- asts, err := base.Parse(storepb.Engine_MYSQL, statement)
+ stmts, err := base.ParseStatements(storepb.Engine_MYSQL, statement)
require.NoError(t, err)
+ asts := base.ExtractASTs(stmts)
got, err := extractChangedResources("db", "", nil /* dbMetadata */, asts, statement)
require.NoError(t, err)
require.Equal(t, want, got)
diff --git a/backend/plugin/parser/mysql/statement_type_test.go b/backend/plugin/parser/mysql/statement_type_test.go
index 188ecf38d0..b2780493ff 100644
--- a/backend/plugin/parser/mysql/statement_type_test.go
+++ b/backend/plugin/parser/mysql/statement_type_test.go
@@ -38,8 +38,9 @@ func TestGetStatementType(t *testing.T) {
a.NoError(yaml.Unmarshal(byteValue, &tests))
for i, test := range tests {
- asts, err := base.Parse(storepb.Engine_MYSQL, test.Statement)
+ stmts, err := base.ParseStatements(storepb.Engine_MYSQL, test.Statement)
a.NoError(err)
+ asts := base.ExtractASTs(stmts)
sqlType, err := GetStatementTypes(asts)
a.NoError(err)
diff --git a/backend/plugin/parser/partiql/partiql.go b/backend/plugin/parser/partiql/partiql.go
index 8d225cde40..d53347665c 100644
--- a/backend/plugin/parser/partiql/partiql.go
+++ b/backend/plugin/parser/partiql/partiql.go
@@ -13,24 +13,9 @@ import (
)
func init() {
- base.RegisterParseFunc(storepb.Engine_DYNAMODB, parsePartiQLForRegistry)
base.RegisterParseStatementsFunc(storepb.Engine_DYNAMODB, parsePartiQLStatements)
}
-// parsePartiQLForRegistry is the ParseFunc for PartiQL.
-// Returns []base.AST with *ANTLRAST instances.
-func parsePartiQLForRegistry(statement string) ([]base.AST, error) {
- parseResults, err := ParsePartiQL(statement)
- if err != nil {
- return nil, err
- }
- asts := make([]base.AST, len(parseResults))
- for i, r := range parseResults {
- asts[i] = r
- }
- return asts, nil
-}
-
// parsePartiQLStatements is the ParseStatementsFunc for PartiQL (DynamoDB).
// Returns []ParsedStatement with both text and AST populated.
func parsePartiQLStatements(statement string) ([]base.ParsedStatement, error) {
diff --git a/backend/plugin/parser/pg/parser_integration_test.go b/backend/plugin/parser/pg/parser_integration_test.go
index 111f50e3e5..933afb1f04 100644
--- a/backend/plugin/parser/pg/parser_integration_test.go
+++ b/backend/plugin/parser/pg/parser_integration_test.go
@@ -47,7 +47,7 @@ FRAM t1;`,
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
- _, err := base.Parse(storepb.Engine_POSTGRES, test.statement)
+ _, err := base.ParseStatements(storepb.Engine_POSTGRES, test.statement)
require.Error(t, err)
syntaxErr, ok := err.(*base.SyntaxError)
require.True(t, ok, "expected *base.SyntaxError, got %T", err)
diff --git a/backend/plugin/parser/pg/pg.go b/backend/plugin/parser/pg/pg.go
index 30aca14c5e..79fbd56c42 100644
--- a/backend/plugin/parser/pg/pg.go
+++ b/backend/plugin/parser/pg/pg.go
@@ -11,25 +11,10 @@ import (
)
func init() {
- base.RegisterParseFunc(storepb.Engine_POSTGRES, parsePostgreSQLForRegistry)
base.RegisterParseStatementsFunc(storepb.Engine_POSTGRES, parsePgStatements)
base.RegisterGetStatementTypes(storepb.Engine_POSTGRES, GetStatementTypesForRegistry)
}
-// parsePostgreSQLForRegistry is the ParseFunc for PostgreSQL.
-// Returns []base.AST with *ANTLRAST instances.
-func parsePostgreSQLForRegistry(statement string) ([]base.AST, error) {
- parseResults, err := ParsePostgreSQL(statement)
- if err != nil {
- return nil, err
- }
- asts := make([]base.AST, len(parseResults))
- for i, r := range parseResults {
- asts[i] = r
- }
- return asts, nil
-}
-
// parsePgStatements is the ParseStatementsFunc for PostgreSQL.
// Returns []ParsedStatement with both text and AST populated.
func parsePgStatements(statement string) ([]base.ParsedStatement, error) {
diff --git a/backend/plugin/parser/pg/resource_change_test.go b/backend/plugin/parser/pg/resource_change_test.go
index 56c6d166ac..bcbe78480e 100644
--- a/backend/plugin/parser/pg/resource_change_test.go
+++ b/backend/plugin/parser/pg/resource_change_test.go
@@ -54,8 +54,9 @@ func TestExtractChangedResources(t *testing.T) {
InsertCount: 2,
}
- asts, err := base.Parse(storepb.Engine_POSTGRES, statement)
+ stmts, err := base.ParseStatements(storepb.Engine_POSTGRES, statement)
require.NoError(t, err)
+ asts := base.ExtractASTs(stmts)
got, err := extractChangedResources("db", "public", dbMetadata, asts, statement)
require.NoError(t, err)
require.Equal(t, want, got)
diff --git a/backend/plugin/parser/pg/statement_type_antlr_test.go b/backend/plugin/parser/pg/statement_type_antlr_test.go
index 09a3bf921b..373156023a 100644
--- a/backend/plugin/parser/pg/statement_type_antlr_test.go
+++ b/backend/plugin/parser/pg/statement_type_antlr_test.go
@@ -10,6 +10,7 @@ import (
)
func TestGetStatementTypesANTLR(t *testing.T) {
+ a := require.New(t)
tests := []struct {
name string
sql string
@@ -220,24 +221,26 @@ func TestGetStatementTypesANTLR(t *testing.T) {
}
for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- asts, err := base.Parse(storepb.Engine_POSTGRES, tt.sql)
- require.NoError(t, err)
+ t.Run(tt.name, func(_ *testing.T) {
+ stmts, err := base.ParseStatements(storepb.Engine_POSTGRES, tt.sql)
+ a.NoError(err)
+ asts := base.ExtractASTs(stmts)
stmtsWithPos, err := GetStatementTypes(asts)
- require.NoError(t, err)
+ a.NoError(err)
// Extract types from statements with positions
types := make([]string, len(stmtsWithPos))
for i, stmt := range stmtsWithPos {
types[i] = stmt.Type
}
- require.ElementsMatch(t, tt.expectedTypes, types)
+ a.ElementsMatch(tt.expectedTypes, types)
})
}
}
func TestGetStatementTypesWithPositions(t *testing.T) {
+ a := require.New(t)
tests := []struct {
name string
sql string
@@ -277,20 +280,21 @@ INSERT INTO t1 VALUES (1);`,
}
for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- asts, err := base.Parse(storepb.Engine_POSTGRES, tt.sql)
- require.NoError(t, err)
+ t.Run(tt.name, func(_ *testing.T) {
+ stmts, err := base.ParseStatements(storepb.Engine_POSTGRES, tt.sql)
+ a.NoError(err)
+ asts := base.ExtractASTs(stmts)
results, err := GetStatementTypes(asts)
- require.NoError(t, err)
- require.Len(t, results, len(tt.expected))
+ a.NoError(err)
+ a.Len(results, len(tt.expected))
for i, expected := range tt.expected {
- require.Equal(t, expected.Type, results[i].Type, "Statement %d type mismatch", i)
- require.Equal(t, expected.Line, results[i].Line, "Statement %d line mismatch", i)
+ a.Equal(expected.Type, results[i].Type, "Statement %d type mismatch", i)
+ a.Equal(expected.Line, results[i].Line, "Statement %d line mismatch", i)
if expected.Text != "" {
// Check that text contains expected content (may not include semicolon)
- require.Contains(t, results[i].Text, "CREATE TABLE t1", "Statement %d text mismatch", i)
+ a.Contains(results[i].Text, "CREATE TABLE t1", "Statement %d text mismatch", i)
}
}
})
diff --git a/backend/plugin/parser/plsql/plsql.go b/backend/plugin/parser/plsql/plsql.go
index 27f839a21f..b5d40b0ce7 100644
--- a/backend/plugin/parser/plsql/plsql.go
+++ b/backend/plugin/parser/plsql/plsql.go
@@ -15,25 +15,10 @@ import (
)
func init() {
- base.RegisterParseFunc(storepb.Engine_ORACLE, parsePLSQLForRegistry)
base.RegisterParseStatementsFunc(storepb.Engine_ORACLE, parsePLSQLStatements)
base.RegisterGetStatementTypes(storepb.Engine_ORACLE, GetStatementTypes)
}
-// parsePLSQLForRegistry is the ParseFunc for PL/SQL.
-// Returns []base.AST with *ANTLRAST instances.
-func parsePLSQLForRegistry(statement string) ([]base.AST, error) {
- parseResults, err := ParsePLSQL(statement + ";")
- if err != nil {
- return nil, err
- }
- asts := make([]base.AST, len(parseResults))
- for i, r := range parseResults {
- asts[i] = r
- }
- return asts, nil
-}
-
// parsePLSQLStatements is the ParseStatementsFunc for Oracle (PL/SQL).
// Returns []ParsedStatement with both text and AST populated.
func parsePLSQLStatements(statement string) ([]base.ParsedStatement, error) {
diff --git a/backend/plugin/parser/plsql/resource_change_test.go b/backend/plugin/parser/plsql/resource_change_test.go
index 957c52ce24..87d767136d 100644
--- a/backend/plugin/parser/plsql/resource_change_test.go
+++ b/backend/plugin/parser/plsql/resource_change_test.go
@@ -29,8 +29,9 @@ func TestExtractChangedResources(t *testing.T) {
InsertCount: 1,
}
- asts, err := base.Parse(storepb.Engine_ORACLE, statement)
+ stmts, err := base.ParseStatements(storepb.Engine_ORACLE, statement)
require.NoError(t, err)
+ asts := base.ExtractASTs(stmts)
require.NotEmpty(t, asts)
// Pass the full asts array to extractChangedResources
diff --git a/backend/plugin/parser/plsql/statement_type_test.go b/backend/plugin/parser/plsql/statement_type_test.go
index fe03642ac0..2268b09f9d 100644
--- a/backend/plugin/parser/plsql/statement_type_test.go
+++ b/backend/plugin/parser/plsql/statement_type_test.go
@@ -33,8 +33,9 @@ func TestGetStatementType(t *testing.T) {
a.NoError(yaml.Unmarshal(byteValue, &tests))
for _, test := range tests {
- asts, err := base.Parse(storepb.Engine_ORACLE, test.Statement)
+ stmts, err := base.ParseStatements(storepb.Engine_ORACLE, test.Statement)
a.NoError(err)
+ asts := base.ExtractASTs(stmts)
a.NotEmpty(asts)
sqlType, err := GetStatementTypes(asts)
a.NoError(err)
diff --git a/backend/plugin/parser/redshift/redshift.go b/backend/plugin/parser/redshift/redshift.go
index 2c69efc0ae..b084d9c245 100644
--- a/backend/plugin/parser/redshift/redshift.go
+++ b/backend/plugin/parser/redshift/redshift.go
@@ -13,25 +13,10 @@ import (
)
func init() {
- base.RegisterParseFunc(storepb.Engine_REDSHIFT, parseRedshiftForRegistry)
base.RegisterParseStatementsFunc(storepb.Engine_REDSHIFT, parseRedshiftStatements)
base.RegisterGetStatementTypes(storepb.Engine_REDSHIFT, GetStatementTypes)
}
-// parseRedshiftForRegistry is the ParseFunc for Redshift.
-// Returns []base.AST with *ANTLRAST instances.
-func parseRedshiftForRegistry(statement string) ([]base.AST, error) {
- parseResults, err := ParseRedshift(statement)
- if err != nil {
- return nil, err
- }
- asts := make([]base.AST, len(parseResults))
- for i, r := range parseResults {
- asts[i] = r
- }
- return asts, nil
-}
-
// parseRedshiftStatements is the ParseStatementsFunc for Redshift.
// Returns []ParsedStatement with both text and AST populated.
func parseRedshiftStatements(statement string) ([]base.ParsedStatement, error) {
diff --git a/backend/plugin/parser/snowflake/snowflake.go b/backend/plugin/parser/snowflake/snowflake.go
index e4b76f6ff3..877102a558 100644
--- a/backend/plugin/parser/snowflake/snowflake.go
+++ b/backend/plugin/parser/snowflake/snowflake.go
@@ -13,24 +13,9 @@ import (
)
func init() {
- base.RegisterParseFunc(storepb.Engine_SNOWFLAKE, parseSnowflakeForRegistry)
base.RegisterParseStatementsFunc(storepb.Engine_SNOWFLAKE, parseSnowflakeStatements)
}
-// parseSnowflakeForRegistry is the ParseFunc for Snowflake.
-// Returns []base.AST with *ANTLRAST instances.
-func parseSnowflakeForRegistry(statement string) ([]base.AST, error) {
- parseResults, err := ParseSnowSQL(statement)
- if err != nil {
- return nil, err
- }
- asts := make([]base.AST, len(parseResults))
- for i, r := range parseResults {
- asts[i] = r
- }
- return asts, nil
-}
-
// parseSnowflakeStatements is the ParseStatementsFunc for Snowflake.
// Returns []ParsedStatement with both text and AST populated.
func parseSnowflakeStatements(statement string) ([]base.ParsedStatement, error) {
diff --git a/backend/plugin/parser/tidb/resource_change_test.go b/backend/plugin/parser/tidb/resource_change_test.go
index 289085ba1f..ac5515e9c3 100644
--- a/backend/plugin/parser/tidb/resource_change_test.go
+++ b/backend/plugin/parser/tidb/resource_change_test.go
@@ -44,8 +44,9 @@ func TestExtractChangedResources(t *testing.T) {
InsertCount: 2,
}
- asts, err := base.Parse(storepb.Engine_TIDB, statement)
+ stmts, err := base.ParseStatements(storepb.Engine_TIDB, statement)
require.NoError(t, err)
+ asts := base.ExtractASTs(stmts)
got, err := extractChangedResources("db", "", nil /* dbMetadata */, asts, statement)
require.NoError(t, err)
require.Equal(t, want, got)
diff --git a/backend/plugin/parser/tidb/statement_type_test.go b/backend/plugin/parser/tidb/statement_type_test.go
index 636310e8bc..64f6c81913 100644
--- a/backend/plugin/parser/tidb/statement_type_test.go
+++ b/backend/plugin/parser/tidb/statement_type_test.go
@@ -38,8 +38,9 @@ func TestGetStatementType(t *testing.T) {
a.NoError(yaml.Unmarshal(byteValue, &tests))
for i, test := range tests {
- asts, err := base.Parse(storepb.Engine_TIDB, test.Statement)
+ stmts, err := base.ParseStatements(storepb.Engine_TIDB, test.Statement)
a.NoError(err)
+ asts := base.ExtractASTs(stmts)
sqlType, err := GetStatementTypes(asts)
a.NoError(err)
diff --git a/backend/plugin/parser/tidb/tidb.go b/backend/plugin/parser/tidb/tidb.go
index 87b5c21163..8c2d1a0d2f 100644
--- a/backend/plugin/parser/tidb/tidb.go
+++ b/backend/plugin/parser/tidb/tidb.go
@@ -20,7 +20,6 @@ import (
)
func init() {
- base.RegisterParseFunc(storepb.Engine_TIDB, ParseTiDBForSyntaxCheck)
base.RegisterParseStatementsFunc(storepb.Engine_TIDB, parseTiDBStatements)
base.RegisterGetStatementTypes(storepb.Engine_TIDB, GetStatementTypes)
}
diff --git a/backend/plugin/parser/tsql/resource_change_test.go b/backend/plugin/parser/tsql/resource_change_test.go
index 6b9aa0e732..d43fbc160f 100644
--- a/backend/plugin/parser/tsql/resource_change_test.go
+++ b/backend/plugin/parser/tsql/resource_change_test.go
@@ -35,8 +35,9 @@ func TestExtractChangedResources(t *testing.T) {
InsertCount: 2,
}
- asts, err := base.Parse(storepb.Engine_MSSQL, statement)
+ stmts, err := base.ParseStatements(storepb.Engine_MSSQL, statement)
require.NoError(t, err)
+ asts := base.ExtractASTs(stmts)
require.Len(t, asts, 5)
got, err := extractChangedResources("DB", "dbo", nil /* dbMetadata */, asts, statement)
require.NoError(t, err)
diff --git a/backend/plugin/parser/tsql/statement_type_test.go b/backend/plugin/parser/tsql/statement_type_test.go
index 64309d19bd..5d039d69f5 100644
--- a/backend/plugin/parser/tsql/statement_type_test.go
+++ b/backend/plugin/parser/tsql/statement_type_test.go
@@ -33,8 +33,9 @@ func TestGetStatementType(t *testing.T) {
a.NoError(yaml.Unmarshal(byteValue, &tests))
for _, test := range tests {
- asts, err := base.Parse(storepb.Engine_MSSQL, test.Statement)
+ stmts, err := base.ParseStatements(storepb.Engine_MSSQL, test.Statement)
a.NoError(err)
+ asts := base.ExtractASTs(stmts)
a.NotEmpty(asts)
sqlType, err := GetStatementTypes(asts)
a.NoError(err)
diff --git a/backend/plugin/parser/tsql/tsql.go b/backend/plugin/parser/tsql/tsql.go
index c6cbdccb7f..8fdead36f1 100644
--- a/backend/plugin/parser/tsql/tsql.go
+++ b/backend/plugin/parser/tsql/tsql.go
@@ -14,25 +14,10 @@ import (
)
func init() {
- base.RegisterParseFunc(storepb.Engine_MSSQL, parseTSQLForRegistry)
base.RegisterParseStatementsFunc(storepb.Engine_MSSQL, parseTSQLStatements)
base.RegisterGetStatementTypes(storepb.Engine_MSSQL, GetStatementTypes)
}
-// parseTSQLForRegistry is the ParseFunc for T-SQL.
-// Returns []base.AST with *ANTLRAST instances.
-func parseTSQLForRegistry(statement string) ([]base.AST, error) {
- antlrASTs, err := ParseTSQL(statement)
- if err != nil {
- return nil, err
- }
- var asts []base.AST
- for _, a := range antlrASTs {
- asts = append(asts, a)
- }
- return asts, nil
-}
-
// parseTSQLStatements is the ParseStatementsFunc for T-SQL (MSSQL).
// Returns []ParsedStatement with both text and AST populated.
func parseTSQLStatements(statement string) ([]base.ParsedStatement, error) {
diff --git a/backend/plugin/schema/pg/walk_through_test.go b/backend/plugin/schema/pg/walk_through_test.go
index 09e394067b..7ae0c42aec 100644
--- a/backend/plugin/schema/pg/walk_through_test.go
+++ b/backend/plugin/schema/pg/walk_through_test.go
@@ -188,14 +188,14 @@ func TestWalkThroughANTLR(t *testing.T) {
// Create DatabaseMetadata for walk-through
state := model.NewDatabaseMetadata(protoData, nil, nil, storepb.Engine_POSTGRES, !test.IgnoreCaseSensitive)
- // Parse using base.Parse to get AST
- unifiedASTs, parseErr := base.Parse(storepb.Engine_POSTGRES, test.Statement)
+ // Parse using base.ParseStatements to get AST
+ stmts, parseErr := base.ParseStatements(storepb.Engine_POSTGRES, test.Statement)
if parseErr != nil {
t.Fatalf("Failed to parse SQL: %v\nSQL: %s", parseErr, test.Statement)
}
// Call WalkThrough with AST
- advice := WalkThrough(state, unifiedASTs)
+ advice := WalkThrough(state, base.ExtractASTs(stmts))
if advice != nil {
// Compare the advice fields
require.Equal(t, test.Advice.Code, advice.Code)