Skip to content

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

refactor: move IsAllDML to parser package with registration pattern (#18279)

p0ny78789df6694a
diff --git a/backend/plugin/parser/base/interface.go b/backend/plugin/parser/base/interface.go
index fd2a7cf277..483e17240d 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)
+ statementTypeGetters = make(map[storepb.Engine]GetStatementTypesFunc)
)
type ValidateSQLForEditorFunc func(string) (bool, bool, error)
@@ -51,6 +52,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)
+// 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)
+
func RegisterQueryValidator(engine storepb.Engine, f ValidateSQLForEditorFunc) {
mux.Lock()
defer mux.Unlock()
@@ -273,6 +278,52 @@ func Parse(engine storepb.Engine, statement string) ([]AST, error) {
return f(statement)
}
+func RegisterGetStatementTypes(engine storepb.Engine, f GetStatementTypesFunc) {
+ mux.Lock()
+ defer mux.Unlock()
+ if _, dup := statementTypeGetters[engine]; dup {
+ panic(fmt.Sprintf("Register called twice %s", engine))
+ }
+ statementTypeGetters[engine] = f
+}
+
+// GetStatementTypes returns the types of statements in the ASTs.
+func GetStatementTypes(engine storepb.Engine, asts []AST) ([]string, error) {
+ f, ok := statementTypeGetters[engine]
+ if !ok {
+ return nil, errors.Errorf("engine %s is not supported", engine)
+ }
+ return f(asts)
+}
+
+// IsAllDML checks if all statements are DML (INSERT, UPDATE, DELETE).
+// Returns false for unsupported engines or parse errors (conservative approach).
+func IsAllDML(engine storepb.Engine, statement string) bool {
+ asts, err := Parse(engine, statement)
+ if err != nil {
+ return false
+ }
+ if len(asts) == 0 {
+ return false
+ }
+ types, err := GetStatementTypes(engine, asts)
+ if err != nil {
+ return false
+ }
+ if len(types) == 0 {
+ return false
+ }
+ for _, t := range types {
+ switch t {
+ case "INSERT", "UPDATE", "DELETE":
+ // DML statement, continue
+ default:
+ return false
+ }
+ }
+ return true
+}
+
type ChangeSummary struct {
ChangedResources *model.ChangedResources
SampleDMLS []string
diff --git a/backend/plugin/parser/mysql/mysql.go b/backend/plugin/parser/mysql/mysql.go
index b76df1fb55..dc8b15ee33 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.RegisterGetStatementTypes(storepb.Engine_MYSQL, GetStatementTypes)
+ base.RegisterGetStatementTypes(storepb.Engine_MARIADB, GetStatementTypes)
+ base.RegisterGetStatementTypes(storepb.Engine_OCEANBASE, GetStatementTypes)
}
// parseMySQLForRegistry is the ParseFunc for MySQL, MariaDB, and OceanBase.
diff --git a/backend/plugin/parser/pg/pg.go b/backend/plugin/parser/pg/pg.go
index 21cd5904e7..de3a2540a4 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.RegisterGetStatementTypes(storepb.Engine_POSTGRES, GetStatementTypesForRegistry)
}
// parsePostgreSQLForRegistry is the ParseFunc for PostgreSQL.
diff --git a/backend/plugin/parser/pg/statement_type.go b/backend/plugin/parser/pg/statement_type.go
index c4c2641ab1..4dc6249947 100644
--- a/backend/plugin/parser/pg/statement_type.go
+++ b/backend/plugin/parser/pg/statement_type.go
@@ -43,3 +43,17 @@ func GetStatementTypes(asts []base.AST) ([]StatementTypeWithPosition, error) {
return allResults, nil
}
+
+// GetStatementTypesForRegistry returns only the statement types as strings.
+// This is used for registration with base.RegisterGetStatementTypes.
+func GetStatementTypesForRegistry(asts []base.AST) ([]string, error) {
+ results, err := GetStatementTypes(asts)
+ if err != nil {
+ return nil, err
+ }
+ types := make([]string, len(results))
+ for i, r := range results {
+ types[i] = r.Type
+ }
+ return types, nil
+}
diff --git a/backend/plugin/parser/plsql/plsql.go b/backend/plugin/parser/plsql/plsql.go
index 630a664568..90035372f7 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.RegisterGetStatementTypes(storepb.Engine_ORACLE, GetStatementTypes)
}
// parsePLSQLForRegistry is the ParseFunc for PL/SQL.
diff --git a/backend/plugin/parser/redshift/redshift.go b/backend/plugin/parser/redshift/redshift.go
index 51a676771e..ac81515ce1 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.RegisterGetStatementTypes(storepb.Engine_REDSHIFT, GetStatementTypes)
}
// parseRedshiftForRegistry is the ParseFunc for Redshift.
diff --git a/backend/plugin/parser/tidb/tidb.go b/backend/plugin/parser/tidb/tidb.go
index 6177b5b781..a1de35d025 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.RegisterGetStatementTypes(storepb.Engine_TIDB, GetStatementTypes)
}
// ParseTiDBForSyntaxCheck parses TiDB SQL for syntax checking purposes.
diff --git a/backend/plugin/parser/tsql/tsql.go b/backend/plugin/parser/tsql/tsql.go
index 494713c2e5..83f6d70b9d 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.RegisterGetStatementTypes(storepb.Engine_MSSQL, GetStatementTypes)
}
// parseTSQLForRegistry is the ParseFunc for T-SQL.
diff --git a/backend/runner/taskrun/executor.go b/backend/runner/taskrun/executor.go
index 08ac07a30e..b9ebbc8044 100644
--- a/backend/runner/taskrun/executor.go
+++ b/backend/runner/taskrun/executor.go
@@ -16,6 +16,7 @@ import (
"github.com/bytebase/bytebase/backend/component/state"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/db"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
"github.com/bytebase/bytebase/backend/runner/schemasync"
"github.com/bytebase/bytebase/backend/store"
"github.com/bytebase/bytebase/backend/store/model"
@@ -89,6 +90,10 @@ type migrateContext struct {
changelog int64
changeHistoryPayload *storepb.InstanceChangeHistoryPayload
+
+ // needDump indicates whether schema dump is needed before/after migration.
+ // False for pure DML (INSERT, UPDATE, DELETE) since they don't change schema.
+ needDump bool
}
func getCreateTaskRunLog(ctx context.Context, taskRunUID int, s *store.Store, profile *config.Profile) func(t time.Time, e *storepb.TaskRunLog) error {
@@ -139,6 +144,10 @@ func runMigrationWithFunc(
return true, nil, err
}
+ // Pre-compute whether schema dump is needed.
+ // Skip dump for pure DML statements (INSERT, UPDATE, DELETE) as they don't change schema.
+ mc.needDump = computeNeedDump(task.Type, mc.instance.Metadata.GetEngine(), statement)
+
skipped, err := doMigrationWithFunc(ctx, driverCtx, store, stateCfg, profile, statement, mc, execFunc)
if err != nil {
return true, nil, err
@@ -484,7 +493,7 @@ func beginMigration(ctx context.Context, stores *store.Store, mc *migrateContext
// sync history
var syncHistoryPrevUID *int64
- if needDump(mc.task, mc.instance) {
+ if mc.needDump {
opts.LogDatabaseSyncStart()
syncHistoryPrev, err := mc.syncer.SyncDatabaseSchemaToHistory(ctx, mc.database)
if err != nil {
@@ -527,7 +536,7 @@ func endMigration(ctx context.Context, storeInstance *store.Store, mc *migrateCo
UID: mc.changelog,
}
- if needDump(mc.task, mc.instance) {
+ if mc.needDump {
opts.LogDatabaseSyncStart()
syncHistory, err := mc.syncer.SyncDatabaseSchemaToHistory(ctx, mc.database)
if err != nil {
@@ -651,11 +660,15 @@ func isChangeDatabaseTask(task *store.TaskMessage) bool {
}
}
-func needDump(task *store.TaskMessage, _ *store.InstanceMessage) bool {
+// computeNeedDump determines if schema dump is needed based on task type and statements.
+func computeNeedDump(taskType storepb.Task_Type, engine storepb.Engine, statement string) bool {
//exhaustive:enforce
- switch task.Type {
- case storepb.Task_DATABASE_MIGRATE,
- storepb.Task_DATABASE_SDL,
+ switch taskType {
+ case storepb.Task_DATABASE_MIGRATE:
+ // For DATABASE_MIGRATE, skip dump if all statements are DML
+ // (INSERT, UPDATE, DELETE) since they don't change schema.
+ return !base.IsAllDML(engine, statement)
+ case storepb.Task_DATABASE_SDL,
storepb.Task_DATABASE_CREATE:
return true
case