Skip to content

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

feat(tidb): migrate prior-backup TransformDMLToSelect off ANTLR to omni (BYT-9622) (#20480)

Vincent Huang6186bd83e9c6
diff --git a/backend/plugin/parser/tidb/backup.go b/backend/plugin/parser/tidb/backup.go
index 3f2ce44c70..6b2c15d2ce 100644
--- a/backend/plugin/parser/tidb/backup.go
+++ b/backend/plugin/parser/tidb/backup.go
@@ -6,15 +6,13 @@ import (
"log/slog"
"strings"
- "github.com/antlr4-go/antlr/v4"
"github.com/pkg/errors"
- parser "github.com/bytebase/parser/mysql"
+ "github.com/bytebase/omni/tidb/ast"
"github.com/bytebase/bytebase/backend/common"
- "github.com/bytebase/bytebase/backend/generated-go/store"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
- "github.com/bytebase/bytebase/backend/plugin/parser/mysql"
"github.com/bytebase/bytebase/backend/store/model"
)
@@ -24,7 +22,27 @@ const (
)
func init() {
- base.RegisterTransformDMLToSelect(store.Engine_TIDB, TransformDMLToSelect)
+ base.RegisterTransformDMLToSelect(storepb.Engine_TIDB, TransformDMLToSelect)
+}
+
+type TableReference struct {
+ Database string
+ Table string
+ Alias string
+ // ExplicitSchema is true when the reference carried an explicit schema
+ // qualifier (e.g. db.test). A CTE reference is always unqualified, so a
+ // schema-qualified table is never a CTE even if its name matches one.
+ ExplicitSchema bool
+}
+
+type statementInfo struct {
+ offset int
+ statement string
+ table *TableReference
+ node ast.Node
+ fullSQL string
+ startPosition *storepb.Position
+ endPosition *storepb.Position
}
func TransformDMLToSelect(ctx context.Context, tCtx base.TransformContext, statement string, sourceDatabase string, targetDatabase string, tablePrefix string) ([]base.BackupStatement, error) {
@@ -36,7 +54,7 @@ func TransformDMLToSelect(ctx context.Context, tCtx base.TransformContext, state
}
}
- statementInfoList, err := prepareTransformation(sourceDatabase, statement, dbMetadata)
+ statementInfoList, err := prepareTransformation(sourceDatabase, statement, dbMetadata, tCtx.IsCaseSensitive)
if err != nil {
return nil, errors.Wrap(err, "failed to prepare transformation")
}
@@ -44,19 +62,10 @@ func TransformDMLToSelect(ctx context.Context, tCtx base.TransformContext, state
return generateSQL(ctx, tCtx, statementInfoList, targetDatabase, tablePrefix)
}
-type statementInfo struct {
- offset int
- statement string
- table *TableReference
- tree antlr.ParserRuleContext
- startPosition *store.Position
- endPosition *store.Position
-}
-
-func prepareTransformation(databaseName, statement string, dbMetadata *model.DatabaseMetadata) ([]statementInfo, error) {
- list, err := mysql.SplitSQL(statement)
+func prepareTransformation(databaseName, statement string, dbMetadata *model.DatabaseMetadata, isCaseSensitive bool) ([]statementInfo, error) {
+ list, err := SplitSQL(statement)
if err != nil {
- return nil, errors.Wrapf(err, "failed to split sql")
+ return nil, errors.Wrap(err, "failed to split sql")
}
var result []statementInfo
@@ -64,35 +73,419 @@ func prepareTransformation(databaseName, statement string, dbMetadata *model.Dat
if len(item.Text) == 0 || item.Empty {
continue
}
- parseResult, err := mysql.ParseMySQL(item.Text)
+
+ parsed, err := ParseTiDBOmni(item.Text)
if err != nil {
return nil, errors.Wrap(err, "failed to parse sql")
}
+ if parsed == nil || len(parsed.Items) == 0 {
+ continue
+ }
- for _, sql := range parseResult {
- // After splitting the SQL, we should have only one statement in the list.
- // The FOR loop is just for safety.
- // So we can use the i as the offset.
- tables, err := extractTables(databaseName, sql, i, dbMetadata)
+ for _, node := range parsed.Items {
+ tables, err := extractTables(databaseName, node, item.Text, dbMetadata, isCaseSensitive)
if err != nil {
return nil, errors.Wrap(err, "failed to extract tables")
}
for _, table := range tables {
- result = append(result, statementInfo{
- offset: i,
- statement: table.statement,
- table: table.table,
- tree: table.tree,
- startPosition: item.Start,
- endPosition: item.End,
- })
+ // A BackupStatement carries no source database, and the executor
+ // records the task database for the backed-up table. Reject
+ // cross-database mutations (DELETE or UPDATE) so a rollback can't
+ // be written to the wrong database.
+ if !equalIdentifier(table.table.Database, databaseName, isCaseSensitive) {
+ return nil, errors.Errorf("prior backup does not support cross-database mutations: %s.%s (task database %q)", table.table.Database, table.table.Table, databaseName)
+ }
+ table.offset = i
+ table.startPosition = item.Start
+ table.endPosition = item.End
+ result = append(result, table)
+ }
+ }
+ }
+
+ return result, nil
+}
+
+// extractTables extracts the affected table references from a single DML node.
+func extractTables(databaseName string, node ast.Node, fullSQL string, dbMetadata *model.DatabaseMetadata, isCaseSensitive bool) ([]statementInfo, error) {
+ switch n := node.(type) {
+ case *ast.DeleteStmt:
+ infos, err := extractTablesFromDelete(databaseName, n, fullSQL, isCaseSensitive)
+ return requireTargets(infos, err, "DELETE")
+ case *ast.UpdateStmt:
+ infos, err := extractTablesFromUpdate(databaseName, n, fullSQL, dbMetadata, isCaseSensitive)
+ return requireTargets(infos, err, "UPDATE")
+ case *ast.BatchStmt:
+ // TiDB BATCH (non-transactional DML) is not supported by prior backup.
+ // Reject it explicitly rather than returning an empty list, which the
+ // task executor would treat as a successful no-op and then run the
+ // mutation with no backup.
+ return nil, errors.New("prior backup does not support TiDB BATCH (non-transactional DML) statements")
+ case *ast.ExplainStmt:
+ // EXPLAIN ANALYZE executes the wrapped statement (TiDB modifies data for
+ // a DML), but prior backup can't unwrap/restore it — reject the ANALYZE
+ // form of an UPDATE/DELETE/BATCH. Plain EXPLAIN does not execute, so it
+ // needs no backup and is skipped.
+ if n.Analyze {
+ switch s := n.Stmt.(type) {
+ case *ast.UpdateStmt, *ast.DeleteStmt, *ast.BatchStmt:
+ return nil, errors.New("prior backup does not support EXPLAIN ANALYZE of an UPDATE/DELETE/BATCH statement")
+ case *ast.InsertStmt:
+ if isOverwritingInsert(s) {
+ return nil, errors.New("prior backup does not support EXPLAIN ANALYZE of a REPLACE or INSERT ... ON DUPLICATE KEY UPDATE statement")
+ }
+ default:
+ }
+ }
+ return nil, nil
+ case *ast.InsertStmt:
+ // REPLACE and INSERT ... ON DUPLICATE KEY UPDATE can overwrite or delete
+ // existing rows, but prior backup cannot back them up. Reject them rather
+ // than returning an empty list, which the task executor would treat as a
+ // successful no-op and then run the mutation unprotected. A plain INSERT
+ // only adds rows (nothing to restore), so it needs no backup.
+ if isOverwritingInsert(n) {
+ return nil, errors.New("prior backup does not support REPLACE or INSERT ... ON DUPLICATE KEY UPDATE statements")
+ }
+ return nil, nil
+ default:
+ return nil, nil
+ }
+}
+
+// isOverwritingInsert reports whether an INSERT can overwrite or delete
+// existing rows (REPLACE, or INSERT ... ON DUPLICATE KEY UPDATE), which prior
+// backup cannot back up. A plain INSERT only adds rows.
+func isOverwritingInsert(n *ast.InsertStmt) bool {
+ return n.IsReplace || len(n.OnDuplicateKey) > 0
+}
+
+// identifierKey normalizes an identifier for use as a map key/lookup, honoring
+// the instance's case sensitivity. TiDB resolves table-name and alias
+// qualifiers case-insensitively by default, so a case-mismatched reference
+// (UPDATE test AS T SET t.c = ...) must still resolve to the same table.
+func identifierKey(name string, isCaseSensitive bool) string {
+ if isCaseSensitive {
+ return name
+ }
+ return strings.ToLower(name)
+}
+
+// requireTargets fails when a recognized DML statement yields no backup target.
+// Returning an empty list with no error would let the task executor treat the
+// backup as a successful no-op and run the mutation unprotected (e.g. when a
+// table alias collides with a CTE name, so the only target gets filtered out).
+func requireTargets(infos []statementInfo, err error, kind string) ([]statementInfo, error) {
+ if err != nil {
+ return nil, err
+ }
+ if len(infos) == 0 {
+ return nil, errors.Errorf("prior backup could not determine a backup target for the %s statement", kind)
+ }
+ return infos, nil
+}
+
+func extractTablesFromDelete(databaseName string, n *ast.DeleteStmt, fullSQL string, isCaseSensitive bool) ([]statementInfo, error) {
+ cteNames := collectCTENames(fullSQL, n.Loc)
+ stmtText := extractStatementText(fullSQL, n.Loc)
+
+ singleTables := collectSingleTables(databaseName, cteNames, n.Tables, isCaseSensitive)
+
+ if len(n.Using) == 0 {
+ // Single-table DELETE: DELETE FROM t WHERE ...
+ if len(singleTables) == 0 {
+ return nil, nil
+ }
+ first := singleTables[firstKey(singleTables)]
+ return []statementInfo{{
+ statement: stmtText,
+ table: first,
+ node: n,
+ fullSQL: fullSQL,
+ }}, nil
+ }
+
+ // Multi-table DELETE: DELETE t1, t2 FROM t1 JOIN t2 ... WHERE ...
+ // Tables = targets to delete from; Using = the referenced table list.
+ refTables := collectSingleTables(databaseName, cteNames, n.Using, isCaseSensitive)
+
+ var result []statementInfo
+ for _, target := range singleTables {
+ name := target.Table
+ if target.Alias != "" {
+ name = target.Alias
+ }
+ ref, ok := refTables[identifierKey(name, isCaseSensitive)]
+ if !ok {
+ return nil, errors.Errorf("cannot extract reference table: no matched table %q in referenced table list", name)
+ }
+ // Skip only if the target resolves to a CTE reference (you can't delete a
+ // CTE). A real table aliased with a CTE's name is still a delete target.
+ if isCTERef(cteNames, ref) {
+ continue
+ }
+ result = append(result, statementInfo{
+ statement: stmtText,
+ table: ref,
+ node: n,
+ fullSQL: fullSQL,
+ })
+ }
+ return result, nil
+}
+
+func extractTablesFromUpdate(databaseName string, n *ast.UpdateStmt, fullSQL string, dbMetadata *model.DatabaseMetadata, isCaseSensitive bool) ([]statementInfo, error) {
+ cteNames := collectCTENames(fullSQL, n.Loc)
+ stmtText := extractStatementText(fullSQL, n.Loc)
+
+ singleTables := collectSingleTables(databaseName, cteNames, n.Tables, isCaseSensitive)
+
+ // Determine which tables the SET clause writes, via column table prefixes.
+ updatedTables := make(map[string]bool)
+ var unqualifiedColumns []string
+ for _, assign := range n.SetList {
+ if assign == nil || assign.Column == nil {
+ continue
+ }
+ table := assign.Column.Table
+ if table == "" {
+ updatedTables[""] = true
+ unqualifiedColumns = append(unqualifiedColumns, assign.Column.Column)
+ continue
+ }
+ // Look up the qualifier case-insensitively (TiDB default): the alias/name
+ // resolves regardless of the case used in the SET clause.
+ key := identifierKey(table, isCaseSensitive)
+ // Skip only if the qualifier resolves to a CTE reference in the FROM — a
+ // CTE can't be a mutation target. A real table aliased with a CTE's name
+ // (its resolved table is real) is still an update target.
+ if ref, ok := singleTables[key]; ok && isCTERef(cteNames, ref) {
+ continue
+ }
+ updatedTables[key] = true
+ }
+
+ // Resolve unqualified SET columns to their owning table(s) via metadata.
+ // Exclude CTE refs from the candidates: a CTE can't be a mutation target,
+ // and resolveUnqualifiedColumns' metadata-unavailable/unresolved fallback
+ // would otherwise mark every candidate (CTEs included).
+ if updatedTables[""] {
+ delete(updatedTables, "")
+ candidates := make(map[string]*TableReference, len(singleTables))
+ for key, ref := range singleTables {
+ if isCTERef(cteNames, ref) {
+ continue
}
+ candidates[key] = ref
+ }
+ for t := range resolveUnqualifiedColumns(unqualifiedColumns, candidates, dbMetadata) {
+ updatedTables[t] = true
}
}
+ // Single-table UPDATE: no explicit qualification needed.
+ if len(updatedTables) == 0 && len(singleTables) == 1 {
+ for _, ref := range singleTables {
+ return []statementInfo{{
+ statement: stmtText,
+ table: ref,
+ node: n,
+ fullSQL: fullSQL,
+ }}, nil
+ }
+ }
+
+ var result []statementInfo
+ for table := range updatedTables {
+ ref, ok := singleTables[table]
+ if !ok {
+ return nil, errors.Errorf("cannot extract reference table: no matched updated table %q in referenced table list", table)
+ }
+ result = append(result, statementInfo{
+ statement: stmtText,
+ table: ref,
+ node: n,
+ fullSQL: fullSQL,
+ })
+ }
return result, nil
}
+// collectSingleTables walks TableExpr slices and collects TableReference entries
+// keyed by alias or table name. A table's database is its explicit schema, or
+// the statement's database when unqualified.
+func collectSingleTables(databaseName string, cteNames map[string]bool, exprs []ast.TableExpr, isCaseSensitive bool) map[string]*TableReference {
+ result := make(map[string]*TableReference)
+ for _, expr := range exprs {
+ collectSingleTablesFromExpr(databaseName, cteNames, expr, isCaseSensitive, result)
+ }
+ return result
+}
+
+func collectSingleTablesFromExpr(databaseName string, cteNames map[string]bool, expr ast.TableExpr, isCaseSensitive bool, out map[string]*TableReference) {
+ switch e := expr.(type) {
+ case *ast.TableRef:
+ db := e.Schema
+ if db == "" {
+ db = databaseName
+ }
+ ref := &TableReference{Database: db, Table: e.Name, Alias: e.Alias, ExplicitSchema: e.Schema != ""}
+ // Key by alias-or-name, normalized for case-insensitive instances (TiDB
+ // default) so a case-mismatched qualifier still resolves. The original
+ // Table/Alias on ref are preserved for the emitted SQL.
+ key := e.Name
+ if e.Alias != "" {
+ key = e.Alias
+ }
+ key = identifierKey(key, isCaseSensitive)
+ // A schema-qualified physical table and an unqualified same-named CTE can
+ // coexist in one FROM (TiDB keeps them distinct) but collapse to the same
+ // map key. Keep the real table: a CTE is never a backup target, and
+ // letting it shadow a physical target would drop that target's backup.
+ if existing, ok := out[key]; ok && !isCTERef(cteNames, existing) && isCTERef(cteNames, ref) {
+ return
+ }
+ out[key] = ref
+ case *ast.JoinClause:
+ if e.Left != nil {
+ collectSingleTablesFromExpr(databaseName, cteNames, e.Left, isCaseSensitive, out)
+ }
+ if e.Right != nil {
+ collectSingleTablesFromExpr(databaseName, cteNames, e.Right, isCaseSensitive, out)
+ }
+ default:
+ }
+}
+
+// resolveUnqualifiedColumns resolves unqualified SET column names to their
+// owning table(s) using metadata. Falls back to all referenced tables when
+// metadata is unavailable or a column cannot be located.
+func resolveUnqualifiedColumns(columns []string, singleTables map[string]*TableReference, dbMetadata *model.DatabaseMetadata) map[string]bool {
+ result := make(map[string]bool)
+
+ var schema *model.SchemaMetadata
+ if dbMetadata != nil {
+ schema = dbMetadata.GetSchemaMetadata("")
+ }
+ if schema == nil {
+ for t := range singleTables {
+ result[t] = true
+ }
+ return result
+ }
+
+ for _, col := range columns {
+ resolved := false
+ for aliasOrName, ref := range singleTables {
+ tableMetadata := schema.GetTable(ref.Table)
+ if tableMetadata == nil {
+ continue
+ }
+ if tableMetadata.GetColumn(col) != nil {
+ result[aliasOrName] = true
+ resolved = true
+ }
+ }
+ if !resolved {
+ for t := range singleTables {
+ result[t] = true
+ }
+ return result
+ }
+ }
+ return result
+}
+
+func firstKey(m map[string]*TableReference) string {
+ for k := range m {
+ return k
+ }
+ return ""
+}
+
+// collectCTENames returns the set of CTE (WITH clause) names that precede the
+// statement, lower-cased for case-insensitive matching. omni does not attach
+// UPDATE/DELETE CTEs to the statement node, so we parse the text before the
+// statement Loc as a WITH clause.
+func collectCTENames(fullSQL string, stmtLoc ast.Loc) map[string]bool {
+ result := make(map[string]bool)
+ for _, cte := range parseCTEPrefix(fullSQL, stmtLoc) {
+ result[strings.ToLower(cte.Name)] = true
+ }
+ return result
+}
+
+// isCTERef reports whether ref resolves to a CTE. A CTE reference is always
+// unqualified, so a schema-qualified physical table (db.test) is never a CTE
+// even if its name matches one. CTE names match case-insensitively (TiDB
+// resolves a case-mismatched reference to the CTE, which shadows a same-named
+// real table), consistent with the file's other identifier comparisons.
+func isCTERef(cteNames map[string]bool, ref *TableReference) bool {
+ return !ref.ExplicitSchema && cteNames[strings.ToLower(ref.Table)]
+}
+
+// writeCTEPrefix writes the statement's WITH (CTE) clause before the backup
+// SELECT, so a SELECT whose FROM references a CTE stays valid. omni does not
+// attach UPDATE/DELETE CTEs to the statement node, so the prefix is recovered
+// from the text before the statement Loc.
+func writeCTEPrefix(buf *strings.Builder, node ast.Node, fullSQL string) error {
+ cte := extractCTE(fullSQL, nodeStmtLoc(node))
+ if cte == "" {
+ return nil
+ }
+ _, err := fmt.Fprintf(buf, "%s ", cte)
+ return err
+}
+
+// extractCTE returns the WITH-clause text preceding the statement, or "".
+func extractCTE(fullSQL string, stmtLoc ast.Loc) string {
+ if stmtLoc.Start <= 0 || len(parseCTEPrefix(fullSQL, stmtLoc)) == 0 {
+ return ""
+ }
+ return strings.TrimSpace(fullSQL[:stmtLoc.Start])
+}
+
+// nodeStmtLoc returns the source Loc of a DML statement node.
+func nodeStmtLoc(node ast.Node) ast.Loc {
+ switch n := node.(type) {
+ case *ast.UpdateStmt:
+ return n.Loc
+ case *ast.DeleteStmt:
+ return n.Loc
+ }
+ return ast.Loc{}
+}
+
+func parseCTEPrefix(fullSQL string, stmtLoc ast.Loc) []*ast.CommonTableExpr {
+ if stmtLoc.Start <= 0 || stmtLoc.Start > len(fullSQL) {
+ return nil
+ }
+ prefix := strings.TrimSpace(fullSQL[:stmtLoc.Start])
+ if prefix == "" {
+ return nil
+ }
+ // Wrap the prefix with a dummy SELECT so it parses as a complete statement.
+ parsed, err := ParseTiDBOmni(prefix + " SELECT 1")
+ if err != nil || parsed == nil {
+ return nil
+ }
+ for _, item := range parsed.Items {
+ if sel, ok := item.(*ast.SelectStmt); ok && len(sel.CTEs) > 0 {
+ return sel.CTEs
+ }
+ }
+ return nil
+}
+
+func extractStatementText(fullSQL string, loc ast.Loc) string {
+ start := max(0, loc.Start)
+ end := loc.End
+ if end <= start || end > len(fullSQL) {
+ end = len(fullSQL)
+ }
+ return strings.TrimSpace(fullSQL[start:end])
+}
+
func generateSQL(ctx context.Context, tCtx base.TransformContext, statementInfoList []statementInfo, databaseName string, tablePrefix string) ([]base.BackupStatement, error) {
if len(statementInfoList) <= maxMixedDMLCount {
return generateSQLForMixedDML(ctx, tCtx, statementInfoList, databaseName, tablePrefix)
@@ -104,9 +497,16 @@ func generateSQLForSingleTable(ctx context.Context, tCtx base.TransformContext,
table := statementInfoList[0].table
for _, item := range statementInfoList {
- if !equalTable(table, item.table) {
+ if !equalTable(table, item.table, tCtx.IsCaseSensitive) {
return nil, errors.Errorf("prior backup cannot handle statements on different tables more than %d", maxMixedDMLCount)
}
+ // This path UNION ALLs the statements into one backup SELECT. A WITH
+ // (CTE) prefix can't be emitted per union arm (TiDB rejects WITH after
+ // UNION ALL), so reject CTE statements here. CTEs are still supported on
+ // the per-statement mixed-DML path (<= maxMixedDMLCount).
+ if extractCTE(item.fullSQL, nodeStmtLoc(item.node)) != "" {
+ return nil, errors.Errorf("prior backup does not support WITH (CTE) statements when more than %d DML statements target the same table", maxMixedDMLCount)
+ }
}
generatedColumns, normalColumns, err := classifyColumns(ctx, tCtx.GetDatabaseMetadataFunc, tCtx.ListDatabaseNamesFunc, tCtx.IsCaseSensitive, tCtx.InstanceID, table)
if err != nil {
@@ -159,8 +559,8 @@ func generateSQLForSingleTable(ctx context.Context, tCtx base.TransformContext,
if _, err := buf.WriteString(" SELECT "); err != nil {
return nil, errors.Wrap(err, "failed to write select statement")
}
- for i, column := range normalColumns {
- if i > 0 {
+ for j, column := range normalColumns {
+ if j > 0 {
if err := buf.WriteByte(','); err != nil {
return nil, errors.Wrap(err, "failed to write comma")
}
@@ -173,7 +573,7 @@ func generateSQLForSingleTable(ctx context.Context, tCtx base.TransformContext,
return nil, errors.Wrap(err, "failed to write from")
}
}
- if err := extractSuffixSelectStatement(item.tree, &buf); err != nil {
+ if err := writeSuffixSelectClause(&buf, item.node, item.fullSQL); err != nil {
return nil, errors.Wrap(err, "failed to extract suffix select statement")
}
}
@@ -193,15 +593,25 @@ func generateSQLForSingleTable(ctx context.Context, tCtx base.TransformContext,
}, nil
}
-func equalTable(a, b *TableReference) bool {
+// equalIdentifier compares two SQL identifiers honoring the instance's case
+// sensitivity. TiDB instances are case-insensitive today
+// (store.IsObjectCaseSensitive returns false for TiDB), but honoring the flag
+// keeps this consistent with classifyColumns and correct if that ever changes.
+func equalIdentifier(a, b string, caseSensitive bool) bool {
+ if caseSensitive {
+ return a == b
+ }
+ return strings.EqualFold(a, b)
+}
+
+func equalTable(a, b *TableReference, caseSensitive bool) bool {
if a == nil || b == nil {
return false
}
-
- if a.Database != "" && b.Database != "" && a.Database != b.Database {
+ if a.Database != "" && b.Database != "" && !equalIdentifier(a.Database, b.Database, caseSensitive) {
return false
}
- return a.Table == b.Table
+ return equalIdentifier(a.Table, b.Table, caseSensitive)
}
func generateSQLForMixedDML(ctx context.Context, tCtx base.TransformContext, statementInfoList []statementInfo, databaseName string, tablePrefix string) ([]base.BackupStatement, error) {
@@ -215,8 +625,8 @@ func generateSQLForMixedDML(ctx context.Context, tCtx base.TransformContext, sta
table := statementInfo.table
targetTable := fmt.Sprintf("%s_%0*d_%s", tablePrefix, offsetLength, statementInfo.offset, table.Table)
targetTable, _ = common.TruncateString(targetTable, maxTableNameLength)
- // If enforce_gtid_consistency = true on MySQL 5.6+, we cannot run CREATE TABLE .. AS SELECT.
- // So we need to create the table first and then run INSERT INTO .. SELECT.
+ // If enforce_gtid_consistency = true, we cannot run CREATE TABLE .. AS SELECT.
+ // So we create the table first and then run INSERT INTO .. SELECT.
var buf strings.Builder
if _, err := fmt.Fprintf(&buf, "CREATE TABLE `%s`.`%s` LIKE `%s`.`%s`;\n", databaseName, targetTable, table.Database, table.Table); err != nil {
return nil, errors.Wrap(err, "failed to write create table statement")
@@ -230,9 +640,15 @@ func generateSQLForMixedDML(ctx context.Context, tCtx base.TransformContext, sta
tableNameOrAlias = table.Alias
}
if len(generatedColumns) == 0 {
- if _, err := fmt.Fprintf(&buf, "INSERT INTO `%s`.`%s` SELECT `%s`.* FROM ", databaseName, targetTable, tableNameOrAlias); err != nil {
+ if _, err := fmt.Fprintf(&buf, "INSERT INTO `%s`.`%s` ", databaseName, targetTable); err != nil {
return nil, errors.Wrap(err, "failed to write insert into statement")
}
+ if err := writeCTEPrefix(&buf, statementInfo.node, statementInfo.fullSQL); err != nil {
+ return nil, errors.Wrap(err, "failed to write cte")
+ }
+ if _, err := fmt.Fprintf(&buf, "SELECT `%s`.* FROM ", tableNameOrAlias); err != nil {
+ return nil, errors.Wrap(err, "failed to write select statement")
+ }
} else {
if _, err := fmt.Fprintf(&buf, "INSERT INTO `%s`.`%s` (", databaseName, targetTable); err != nil {
return nil, errors.Wrap(err, "failed to write insert into statement")
@@ -247,7 +663,13 @@ func generateSQLForMixedDML(ctx context.Context, tCtx base.TransformContext, sta
return nil, errors.Wrap(err, "failed to write column")
}
}
- if _, err := buf.WriteString(") SELECT "); err != nil {
+ if _, err := buf.WriteString(") "); err != nil {
+ return nil, errors.Wrap(err, "failed to write select")
+ }
+ if err := writeCTEPrefix(&buf, statementInfo.node, statementInfo.fullSQL); err != nil {
+ return nil, errors.Wrap(err, "failed to write cte")
+ }
+ if _, err := buf.WriteString("SELECT "); err != nil {
return nil, errors.Wrap(err, "failed to write select")
}
for i, column := range normalColumns {
@@ -264,7 +686,7 @@ func generateSQLForMixedDML(ctx context.Context, tCtx base.TransformContext, sta
return nil, errors.Wrap(err, "failed to write from")
}
}
- if err := extractSuffixSelectStatement(statementInfo.tree, &buf); err != nil {
+ if err := writeSuffixSelectClause(&buf, statementInfo.node, statementInfo.fullSQL); err != nil {
return nil, errors.Wrap(err, "failed to extract suffix select statement")
}
if err := buf.WriteByte(';'); err != nil {
@@ -281,6 +703,197 @@ func generateSQLForMixedDML(ctx context.Context, tCtx base.TransformContext, sta
return result, nil
}
+// writeSuffixSelectClause writes the "<table refs> WHERE ... ORDER BY ... LIMIT ..."
+// suffix of a DML statement, sliced from the original SQL via the node's Loc.
+func writeSuffixSelectClause(buf *strings.Builder, node ast.Node, fullSQL string) error {
+ switch n := node.(type) {
+ case *ast.UpdateStmt:
+ return writeUpdateSuffix(buf, n, fullSQL)
+ case *ast.DeleteStmt:
+ return writeDeleteSuffix(buf, n, fullSQL)
+ }
+ return nil
+}
+
+func writeUpdateSuffix(buf *strings.Builder, n *ast.UpdateStmt, sql string) error {
+ // "table_refs": from the first table ref to the last table ref's end.
+ if len(n.Tables) > 0 {
+ start := nodeLocStart(n.Tables[0])
+ end := nodeLocEnd(n.Tables[len(n.Tables)-1])
+ if start >= 0 && end > start && end <= len(sql) {
+ // omni excludes parentheses wrapping the table-ref list, so a
+ // parenthesized join operand can leave the slice unbalanced.
+ if _, err := buf.WriteString(balancedTableRefs(sql[start:end])); err != nil {
+ return err
+ }
+ }
+ }
+
+ // Everything after the last SET assignment is WHERE + ORDER BY + LIMIT.
+ if len(n.SetList) > 0 {
+ lastAssign := n.SetList[len(n.SetList)-1]
+ afterSet := lastAssign.Loc.End
+ stmtEnd := n.Loc.End
+ if stmtEnd <= 0 || stmtEnd > len(sql) {
+ stmtEnd = len(sql)
+ }
+ if afterSet >= 0 && afterSet < stmtEnd {
+ suffix := strings.TrimSpace(sql[afterSet:stmtEnd])
+ if suffix != "" {
+ if _, err := fmt.Fprintf(buf, " %s", suffix); err != nil {
+ return err
+ }
+ }
+ }
+ }
+ return nil
+}
+
+func writeDeleteSuffix(buf *strings.Builder, n *ast.DeleteStmt, sql string) error {
+ // Single-table DELETE: from the table ref to statement end.
+ // Multi-table DELETE: from the USING/reference table list to statement end.
+ var start int
+ switch {
+ case len(n.Using) > 0:
+ start = nodeLocStart(n.Using[0])
+ case len(n.Tables) > 0:
+ start = nodeLocStart(n.Tables[0])
+ default:
+ return nil
+ }
+ end := n.Loc.End
+ if end <= 0 || end > len(sql) {
+ end = len(sql)
+ }
+ if start >= 0 && end > start {
+ // omni excludes parentheses wrapping the table-ref list, so the slice can
+ // carry an unmatched ")"; rebalance it before emitting.
+ if _, err := buf.WriteString(balancedTableRefs(sql[start:end])); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// balancedTableRefs returns s (trimmed) with parentheses balanced. omni's
+// JoinClause/TableRef Loc excludes a wrapping "(" or ")", so a sliced table-ref
+// list can carry an unmatched ")" (a parenthesized left join operand) and/or an
+// unmatched "(" (a right operand). The missing parentheses only group, so their
+// source position is irrelevant — prepend "(" and append ")" to balance.
+func balancedTableRefs(s string) string {
+ leading, trailing := parenDeficit(s)
+ s = strings.TrimSpace(s)
+ if leading > 0 {
+ s = strings.Repeat("(", leading) + s
+ }
+ if trailing > 0 {
+ s += strings.Repeat(")", trailing)
+ }
+ return s
+}
+
+// parenDeficit returns how many "(" must be prepended and ")" appended to
+// balance s, ignoring parentheses inside string/identifier literals ('...',
+// "...", `...`) and comments (/* */, -- , #).
+func parenDeficit(s string) (leading int, trailing int) {
+ open := 0
+ for i := 0; i < len(s); i++ {
+ switch c := s[i]; {
+ case c == '\'' || c == '"' || c == '`':
+ i = skipQuoted(s, i)
+ case c == '/' && i+1 < len(s) && s[i+1] == '*':
+ i = skipBlockComment(s, i)
+ case c == '-' && i+1 < len(s) && s[i+1] == '-' && (i+2 >= len(s) || isASCIISpace(s[i+2])):
+ i = skipLineComment(s, i)
+ case c == '#':
+ i = skipLineComment(s, i)
+ case c == '(':
+ open++
+ case c == ')':
+ if open > 0 {
+ open--
+ } else {
+ leading++
+ }
+ default:
+ }
+ }
+ return leading, open
+}
+
+// skipQuoted returns the index of the closing quote of the string/identifier
+// literal opened at i (s[i] is the opening quote), or len(s)-1 if unterminated.
+func skipQuoted(s string, i int) int {
+ quote := s[i]
+ for j := i + 1; j < len(s); {
+ switch {
+ case s[j] == '\\' && quote != '`':
+ j += 2 // backslash escape ('...'/"..." only)
+ case s[j] == quote && j+1 < len(s) && s[j+1] == quote:
+ j += 2 // doubled-quote escape ('' "" ``)
+ case s[j] == quote:
+ return j
+ default:
+ j++
+ }
+ }
+ return len(s) - 1
+}
+
+// skipBlockComment returns the index of the closing "/" of the /* */ comment
+// opened at i, or len(s)-1 if unterminated.
+func skipBlockComment(s string, i int) int {
+ for j := i + 2; j+1 < len(s); j++ {
+ if s[j] == '*' && s[j+1] == '/' {
+ return j + 1
+ }
+ }
+ return len(s) - 1
+}
+
+// skipLineComment returns the index of the newline ending the -- or # comment
+// opened at i, or len(s)-1 if it runs to the end.
+func skipLineComment(s string, i int) int {
+ for j := i; j < len(s); j++ {
+ if s[j] == '\n' {
+ return j
+ }
+ }
+ return len(s) - 1
+}
+
+func isASCIISpace(c byte) bool {
+ return c == ' ' || c == '\t' || c == '\n' || c == '\r'
+}
+
+func nodeLocStart(expr ast.TableExpr) int {
+ switch e := expr.(type) {
+ case *ast.TableRef:
+ return e.Loc.Start
+ case *ast.JoinClause:
+ return e.Loc.Start
+ case *ast.SubqueryExpr:
+ return e.Loc.Start
+ case *ast.JsonTableExpr:
+ return e.Loc.Start
+ }
+ return -1
+}
+
+func nodeLocEnd(expr ast.TableExpr) int {
+ switch e := expr.(type) {
+ case *ast.TableRef:
+ return e.Loc.End
+ case *ast.JoinClause:
+ return e.Loc.End
+ case *ast.SubqueryExpr:
+ return e.Loc.End
+ case *ast.JsonTableExpr:
+ return e.Loc.End
+ }
+ return -1
+}
+
func classifyColumns(ctx context.Context, getDatabaseMetadataFunc base.GetDatabaseMetadataFunc, listDatabaseNamesFunc base.ListDatabaseNamesFunc, isCaseSensitive bool, instanceID string, table *TableReference) ([]string, []string, error) {
if getDatabaseMetadataFunc == nil {
return nil, nil, errors.New("GetDatabaseMetadataFunc is not set")
@@ -317,8 +930,7 @@ func classifyColumns(ctx context.Context, getDatabaseMetadataFunc base.GetDataba
return nil, nil, errors.Errorf("failed to get database metadata for InstanceID %q, Database %q", instanceID, table.Database)
}
- emptySchema := ""
- schema := dbMetadata.GetSchemaMetadata(emptySchema)
+ schema := dbMetadata.GetSchemaMetadata("")
if schema == nil {
return nil, nil, errors.New("failed to get schema metadata")
}
@@ -339,337 +951,3 @@ func classifyColumns(ctx context.Context, getDatabaseMetadataFunc base.GetDataba
return generatedColumns, normalColumns, nil
}
-
-func extractSuffixSelectStatement(tree antlr.Tree, buf *strings.Builder) error {
- listener := &suffixSelectStatementListener{
- buf: buf,
- }
-
- antlr.ParseTreeWalkerDefault.Walk(listener, tree)
- return listener.err
-}
-
-type suffixSelectStatementListener struct {
- *parser.BaseMySQLParserListener
-
- buf *strings.Builder
- err error
-}
-
-func (l *suffixSelectStatementListener) EnterDeleteStatement(ctx *parser.DeleteStatementContext) {
- if !isTopLevel(ctx.GetParent()) {
- return
- }
- if ctx.TableRef() != nil {
- // Single table delete statement.
- if _, err := l.buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromTokens(
- ctx.TableRef().GetStart(),
- ctx.GetStop(),
- )); err != nil {
- l.err = errors.Wrap(err, "failed to write suffix select statement")
- return
- }
- }
-
- if ctx.TableAliasRefList() != nil {
- // Multi table delete statement.
- if _, err := l.buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromTokens(
- ctx.TableReferenceList().GetStart(),
- ctx.GetStop(),
- )); err != nil {
- l.err = errors.Wrap(err, "failed to write suffix select statement")
- return
- }
- }
-}
-
-func (l *suffixSelectStatementListener) EnterUpdateStatement(ctx *parser.UpdateStatementContext) {
- if !isTopLevel(ctx.GetParent()) {
- return
- }
- if _, err := l.buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx.TableReferenceList())); err != nil {
- l.err = errors.Wrap(err, "failed to write suffix select statement")
- return
- }
-
- if ctx.WhereClause() != nil {
- if err := l.buf.WriteByte(' '); err != nil {
- l.err = errors.Wrap(err, "failed to write suffix select statement")
- return
- }
- if _, err := l.buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx.WhereClause())); err != nil {
- l.err = errors.Wrap(err, "failed to write suffix select statement")
- return
- }
- }
-
- if ctx.OrderClause() != nil {
- if err := l.buf.WriteByte(' '); err != nil {
- l.err = errors.Wrap(err, "failed to write suffix select statement")
- return
- }
- if _, err := l.buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx.OrderClause())); err != nil {
- l.err = errors.Wrap(err, "failed to write suffix select statement")
- return
- }
- }
-
- if ctx.SimpleLimitClause() != nil {
- if err := l.buf.WriteByte(' '); err != nil {
- l.err = errors.Wrap(err, "failed to write suffix select statement")
- return
- }
- if _, err := l.buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx.SimpleLimitClause())); err != nil {
- l.err = errors.Wrap(err, "failed to write suffix select statement")
- return
- }
- }
-}
-
-type TableReference struct {
- Database string
- Table string
- Alias string
-}
-
-func extractTables(databaseName string, ast *base.ANTLRAST, offset int, dbMetadata *model.DatabaseMetadata) ([]statementInfo, error) {
- listener := &tableReferenceListener{
- databaseName: databaseName,
- dbMetadata: dbMetadata,
- offset: offset,
- }
-
- antlr.ParseTreeWalkerDefault.Walk(listener, ast.Tree)
-
- return listener.tables, listener.err
-}
-
-type tableReferenceListener struct {
- *parser.BaseMySQLParserListener
-
- databaseName string
- dbMetadata *model.DatabaseMetadata
- offset int
- tables []statementInfo
- err error
-}
-
-func isTopLevel(ctx antlr.Tree) bool {
- if ctx == nil {
- return true
- }
- switch ctx := ctx.(type) {
- case *parser.SimpleStatementContext:
- return isTopLevel(ctx.GetParent())
- case *parser.QueryContext, *parser.ScriptContext:
- return true
- default:
- return false
- }
-}
-
-func (l *tableReferenceListener) EnterDeleteStatement(ctx *parser.DeleteStatementContext) {
- if !isTopLevel(ctx.GetParent()) {
- return
- }
-
- if ctx.TableRef() != nil {
- // Single table delete statement.
- database, table := mysql.NormalizeMySQLTableRef(ctx.TableRef())
- if len(database) > 0 && database != l.databaseName {
- l.err = errors.Errorf("database is not matched: %s != %s", database, l.databaseName)
- return
- }
-
- alias := ""
-
- if ctx.TableAlias() != nil {
- alias = mysql.NormalizeMySQLIdentifier(ctx.TableAlias().Identifier())
- }
-
- if len(database) == 0 {
- database = l.databaseName
- }
-
- l.tables = append(l.tables, statementInfo{
- offset: l.offset,
- statement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),
- tree: ctx,
- table: &TableReference{
- Database: database,
- Table: table,
- Alias: alias,
- },
- })
- return
- }
-
- if ctx.TableAliasRefList() != nil {
- // Multi table delete statement.
- singleTables := &singleTableListener{
- databaseName: l.databaseName,
- singleTables: make(map[string]*TableReference),
- }
-
- antlr.ParseTreeWalkerDefault.Walk(singleTables, ctx.TableReferenceList())
-
- for _, tableRef := range ctx.TableAliasRefList().AllTableRefWithWildcard() {
- database, table := mysql.NormalizeMySQLTableRefWithWildcard(tableRef)
- if len(database) > 0 && database != l.databaseName {
- l.err = errors.Errorf("database is not matched: %s != %s", database, l.databaseName)
- return
- }
-
- singleTable, ok := singleTables.singleTables[table]
- if !ok {
- l.err = errors.Errorf("cannot extract reference table: no matched table %q in referenced table list", table)
- return
- }
-
- l.tables = append(l.tables, statementInfo{
- offset: l.offset,
- statement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),
- tree: ctx,
- table: singleTable,
- })
- }
- }
-}
-
-// resolveUnqualifiedColumns resolves unqualified column names to their owning
-// table(s) using database metadata. Falls back to all tables if metadata is
-// unavailable or column cannot be resolved.
-func (l *tableReferenceListener) resolveUnqualifiedColumns(columns []string, singleTables map[string]*TableReference) map[string]bool {
- result := make(map[string]bool)
-
- schema := l.getSchemaMetadata()
- if schema == nil {
- // No metadata available, fall back to all tables.
- for tableName := range singleTables {
- result[tableName] = true
- }
- return result
- }
-
- for _, col := range columns {
- resolved := false
- for aliasOrName, ref := range singleTables {
- tableMetadata := schema.GetTable(ref.Table)
- if tableMetadata == nil {
- continue
- }
- if tableMetadata.GetColumn(col) != nil {
- result[aliasOrName] = true
- resolved = true
- }
- }
- if !resolved {
- // Column not found in any table metadata, fall back to all tables.
- for tableName := range singleTables {
- result[tableName] = true
- }
- return result
- }
- }
-
- return result
-}
-
-func (l *tableReferenceListener) getSchemaMetadata() *model.SchemaMetadata {
- if l.dbMetadata == nil {
- return nil
- }
- return l.dbMetadata.GetSchemaMetadata("")
-}
-
-func (l *tableReferenceListener) EnterUpdateStatement(ctx *parser.UpdateStatementContext) {
- if !isTopLevel(ctx.GetParent()) {
- return
- }
-
- listener := &updateTableListener{
- tables: make(map[string]bool),
- }
-
- antlr.ParseTreeWalkerDefault.Walk(listener, ctx.UpdateList())
-
- singleTables := &singleTableListener{
- databaseName: l.databaseName,
- singleTables: make(map[string]*TableReference),
- }
-
- antlr.ParseTreeWalkerDefault.Walk(singleTables, ctx.TableReferenceList())
-
- // When SET clause columns are unqualified (no table prefix), resolve them
- // to the owning table using database metadata. MySQL/TiDB allows unqualified
- // columns when they are unambiguous.
- if _, exists := listener.tables[""]; exists {
- delete(listener.tables, "")
- resolved := l.resolveUnqualifiedColumns(listener.unqualifiedColumns, singleTables.singleTables)
- for tableName := range resolved {
- listener.tables[tableName] = true
- }
- }
-
- for table := range listener.tables {
- singleTable, ok := singleTables.singleTables[table]
- if !ok {
- l.err = errors.Errorf("cannot extract reference table: no matched updated table %q in referenced table list", table)
- return
- }
-
- l.tables = append(l.tables, statementInfo{
- offset: l.offset,
- statement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),
- tree: ctx,
- table: singleTable,
- })
- }
-}
-
-type singleTableListener struct {
- *parser.BaseMySQLParserListener
-
- databaseName string
- singleTables map[string]*TableReference
- err error
-}
-
-func (l *singleTableListener) EnterSingleTable(ctx *parser.SingleTableContext) {
- if l.err != nil {
- return
- }
- database, tableName := mysql.NormalizeMySQLTableRef(ctx.TableRef())
- if len(database) > 0 && database != l.databaseName {
- l.err = errors.Errorf("database is not matched: %s != %s", database, l.databaseName)
- }
- if len(database) == 0 {
- database = l.databaseName
- }
- table := &TableReference{
- Database: database,
- Table: tableName,
- }
-
- if ctx.TableAlias() != nil {
- table.Alias = mysql.NormalizeMySQLIdentifier(ctx.TableAlias().Identifier())
- l.singleTables[table.Alias] = table
- } else {
- l.singleTables[table.Table] = table
- }
-}
-
-type updateTableListener struct {
- *parser.BaseMySQLParserListener
-
- tables map[string]bool
- unqualifiedColumns []string
-}
-
-func (l *updateTableListener) EnterUpdateElement(ctx *parser.UpdateElementContext) {
- _, table, column := mysql.NormalizeMySQLColumnRef(ctx.ColumnRef())
- l.tables[table] = true
- if table == "" {
- l.unqualifiedColumns = append(l.unqualifiedColumns, column)
- }
-}
diff --git a/backend/plugin/parser/tidb/backup_test.go b/backend/plugin/parser/tidb/backup_test.go
index 2c297e1d8f..3bcf1ca217 100644
--- a/backend/plugin/parser/tidb/backup_test.go
+++ b/backend/plugin/parser/tidb/backup_test.go
@@ -243,3 +243,311 @@ func buildFixedMockDatabaseMetadataGetterAndLister() (base.GetDatabaseMetadataFu
return []string{"db", "db1", "db2"}, nil
}
}
+
+// TestBackupRejectsAndPreserves pins behaviors the omni port must keep
+// (regressions caught in PR #20480 review):
+// - TiDB BATCH is rejected, not silently skipped (else the executor would run
+// the mutation with no backup).
+// - Cross-database mutations (DELETE and UPDATE) are rejected (a
+// BackupStatement carries no source database, so the executor would restore
+// into the wrong database).
+// - A derived table in the UPDATE FROM list is preserved (not dropped, which
+// would emit a malformed "FROM WHERE ..." clause).
+// - A WITH (CTE) prefix is carried into the backup SELECT (else a FROM that
+// references the CTE would be invalid SQL).
+func TestBackupRejectsAndPreserves(t *testing.T) {
+ a := require.New(t)
+ getter, lister := buildFixedMockDatabaseMetadataGetterAndLister()
+ run := func(sql string) ([]base.BackupStatement, error) {
+ return TransformDMLToSelect(context.Background(), base.TransformContext{
+ GetDatabaseMetadataFunc: getter,
+ ListDatabaseNamesFunc: lister,
+ IsCaseSensitive: false,
+ }, sql, "db", "backupDB", "_rollback")
+ }
+
+ _, err := run("BATCH LIMIT 2 DELETE FROM test WHERE id > 0")
+ a.Error(err, "BATCH (non-transactional DML) must be rejected")
+
+ _, err = run("DELETE FROM db1.t1 WHERE a = 1")
+ a.Error(err, "cross-database DELETE must be rejected")
+
+ _, err = run("UPDATE db1.t1 SET c1 = 1 WHERE c1 = 2")
+ a.Error(err, "cross-database UPDATE must be rejected")
+
+ result, err := run("UPDATE test, (SELECT id FROM test2) AS x SET test.c1 = 1 WHERE test.id = x.id")
+ a.NoError(err)
+ a.Len(result, 1)
+ a.Equal(
+ "CREATE TABLE `backupDB`.`_rollback_0_test` LIKE `db`.`test`;\n"+
+ "INSERT INTO `backupDB`.`_rollback_0_test` SELECT `test`.* FROM test, (SELECT id FROM test2) AS x WHERE test.id = x.id;",
+ result[0].Statement,
+ )
+
+ // A WITH (CTE) prefix must be carried into the backup SELECT, else the FROM
+ // (which joins the CTE) references an undefined name.
+ result, err = run("WITH x AS (SELECT id FROM test2) UPDATE test JOIN x ON test.id = x.id SET test.c1 = 1")
+ a.NoError(err)
+ a.Len(result, 1)
+ a.Equal(
+ "CREATE TABLE `backupDB`.`_rollback_0_test` LIKE `db`.`test`;\n"+
+ "INSERT INTO `backupDB`.`_rollback_0_test` WITH x AS (SELECT id FROM test2) SELECT `test`.* FROM test JOIN x ON test.id = x.id;",
+ result[0].Statement,
+ )
+ // The generated backup must be valid SQL (the CTE is defined before use).
+ _, perr := ParseTiDBOmni(result[0].Statement)
+ a.NoError(perr, "generated CTE backup must re-parse as valid SQL")
+
+ // More than maxMixedDMLCount same-table statements use the UNION ALL path,
+ // which cannot emit a per-arm WITH (TiDB rejects WITH after UNION ALL). A CTE
+ // in that batch must be rejected rather than produce invalid SQL.
+ manyWithCTE := "DELETE FROM test WHERE id = 1;\n" +
+ "DELETE FROM test WHERE id = 2;\n" +
+ "DELETE FROM test WHERE id = 3;\n" +
+ "DELETE FROM test WHERE id = 4;\n" +
+ "DELETE FROM test WHERE id = 5;\n" +
+ "WITH x AS (SELECT id FROM test2) DELETE FROM test WHERE id > 0;"
+ _, err = run(manyWithCTE)
+ a.Error(err, "CTE in a >maxMixedDMLCount same-table batch must be rejected")
+
+ // An unqualified SET column whose owner can't be resolved must fall back to
+ // real tables only, never the CTE join source (a CTE can't be a mutation
+ // target). "nonexistent_col" forces the metadata fallback path.
+ result, err = run("WITH x AS (SELECT id FROM test2) UPDATE test JOIN x ON test.id = x.id SET nonexistent_col = 1")
+ a.NoError(err)
+ a.Len(result, 1)
+ a.Equal("test", result[0].SourceTableName, "backup target must be the real table, not the CTE")
+
+ // A table alias colliding with a CTE name must resolve to the real table
+ // (a CTE can't be a mutation target), not be filtered out.
+ result, err = run("WITH x AS (SELECT id FROM test2) UPDATE test AS x JOIN test2 AS y ON x.a = y.a SET x.c = 1")
+ a.NoError(err)
+ a.Len(result, 1)
+ a.Equal("test", result[0].SourceTableName)
+
+ // Multi-target mutation: EVERY mutated table must be backed up, even when an
+ // alias collides with a CTE name. A partial backup (only test2) would leave
+ // test unprotected.
+ result, err = run("WITH x AS (SELECT id FROM test2) UPDATE test AS x JOIN test2 AS y ON x.a = y.a SET x.c = 1, y.c = 2")
+ a.NoError(err)
+ a.Len(result, 2)
+ a.ElementsMatch([]string{"test", "test2"}, []string{result[0].SourceTableName, result[1].SourceTableName})
+
+ // Multi-target DELETE: both deleted tables backed up despite the collision.
+ result, err = run("WITH x AS (SELECT id FROM test2) DELETE x, y FROM test AS x JOIN test2 AS y WHERE x.a = y.a")
+ a.NoError(err)
+ a.Len(result, 2)
+ a.ElementsMatch([]string{"test", "test2"}, []string{result[0].SourceTableName, result[1].SourceTableName})
+
+ // Updating only a CTE has no real target -> must error (never silently skip).
+ _, err = run("WITH x AS (SELECT id FROM test2) UPDATE test JOIN x ON test.id = x.id SET x.c = 1")
+ a.Error(err, "updating only a CTE must error")
+
+ // CTE names are matched case-insensitively (TiDB resolves a case-mismatched
+ // reference to the CTE, which shadows any same-named real table). The CTE
+ // "X" referenced as "x" must be excluded from the unqualified-column fallback
+ // candidates, so the backup targets only the real table test (not db.x).
+ result, err = run("WITH X AS (SELECT id FROM test2) UPDATE test JOIN x ON test.id = x.id SET missing_col = 1")
+ a.NoError(err)
+ a.Len(result, 1)
+ a.Equal("test", result[0].SourceTableName)
+
+ // A schema-qualified physical table is never a CTE, even when its name
+ // matches a CTE in scope (a CTE reference is always unqualified). Both
+ // physical tables (db.test via alias p, test2 via alias y) are mutated, so
+ // both must be backed up; skipping db.test would leave it unprotected
+ // (verified on TiDB v8.5.0: both physical tables are updated/deleted).
+ result, err = run("WITH test AS (SELECT a FROM test2) UPDATE db.test AS p JOIN test2 AS y ON p.a = y.a SET p.c = 1, y.c = 2")
+ a.NoError(err)
+ a.Len(result, 2)
+ a.ElementsMatch([]string{"test", "test2"}, []string{result[0].SourceTableName, result[1].SourceTableName})
+ for _, r := range result {
+ _, perr := ParseTiDBOmni(r.Statement)
+ a.NoError(perr, "generated multi-target backup must re-parse as valid SQL")
+ }
+
+ result, err = run("WITH test AS (SELECT a FROM test2) DELETE p, y FROM db.test AS p JOIN test2 AS y WHERE p.a = y.a")
+ a.NoError(err)
+ a.Len(result, 2)
+ a.ElementsMatch([]string{"test", "test2"}, []string{result[0].SourceTableName, result[1].SourceTableName})
+ for _, r := range result {
+ _, perr := ParseTiDBOmni(r.Statement)
+ a.NoError(perr, "generated multi-target backup must re-parse as valid SQL")
+ }
+
+ // A schema-qualified physical table (db.test) and an unqualified same-named
+ // CTE can coexist in one FROM; they collapse to the same map key, but the
+ // real table must win. Backing up only test2 would leave db.test unprotected
+ // (verified on TiDB v8.5.0: the DELETE removes rows from both physical
+ // targets).
+ result, err = run("WITH test AS (SELECT a FROM test2) DELETE db.test, test2 FROM db.test JOIN test2 ON db.test.a = test2.a CROSS JOIN test")
+ a.NoError(err)
+ a.Len(result, 2)
+ a.ElementsMatch([]string{"test", "test2"}, []string{result[0].SourceTableName, result[1].SourceTableName})
+
+ // The cross-database guard is case-insensitive (TiDB default): a different-
+ // case reference to the task database is the same database, not cross-db.
+ result, err = run("UPDATE DB.test SET c1 = 1 WHERE c1 = 2")
+ a.NoError(err)
+ a.Len(result, 1)
+ a.Equal("test", result[0].SourceTableName, "case-only db difference must be treated as same database")
+
+ // EXPLAIN ANALYZE executes the DML (modifying data) but can't be backed up,
+ // so it must be rejected. Plain EXPLAIN does not execute -> no backup needed.
+ _, err = run("EXPLAIN ANALYZE UPDATE test SET c1 = 1 WHERE c1 = 2")
+ a.Error(err, "EXPLAIN ANALYZE of a DML must be rejected")
+ result, err = run("EXPLAIN UPDATE test SET c1 = 1 WHERE c1 = 2")
+ a.NoError(err, "plain EXPLAIN does not execute and needs no backup")
+ a.Empty(result)
+
+ // REPLACE and INSERT ... ON DUPLICATE KEY UPDATE overwrite existing rows but
+ // have no backup support, so they must be rejected (not silently skipped). A
+ // plain INSERT only adds rows and needs no backup.
+ _, err = run("REPLACE INTO test VALUES (1, 2, 3)")
+ a.Error(err, "REPLACE must be rejected")
+ _, err = run("INSERT INTO test VALUES (1, 2, 3) ON DUPLICATE KEY UPDATE c = 5")
+ a.Error(err, "INSERT ... ON DUPLICATE KEY UPDATE must be rejected")
+ result, err = run("INSERT INTO test VALUES (1, 2, 3)")
+ a.NoError(err, "plain INSERT only adds rows and needs no backup")
+ a.Empty(result)
+
+ // EXPLAIN ANALYZE executes the wrapped statement, so the overwriting INSERT
+ // forms must be rejected there too -- not only as a direct statement. A plain
+ // INSERT under EXPLAIN ANALYZE only adds rows and needs no backup.
+ _, err = run("EXPLAIN ANALYZE REPLACE INTO test VALUES (1, 2, 3)")
+ a.Error(err, "EXPLAIN ANALYZE REPLACE must be rejected")
+ _, err = run("EXPLAIN ANALYZE INSERT INTO test VALUES (1, 2, 3) ON DUPLICATE KEY UPDATE c = 5")
+ a.Error(err, "EXPLAIN ANALYZE INSERT ... ON DUPLICATE KEY UPDATE must be rejected")
+ result, err = run("EXPLAIN ANALYZE INSERT INTO test VALUES (1, 2, 3)")
+ a.NoError(err, "EXPLAIN ANALYZE of a plain INSERT needs no backup")
+ a.Empty(result)
+
+ // A parenthesized leading join must produce valid backup SQL. omni's table-
+ // ref Loc starts after the wrapping "(", so a DELETE suffix sliced to the
+ // statement end would keep the ")" without its "(" -> malformed SQL.
+ result, err = run("UPDATE (test AS a JOIN test2 AS b ON a.a = b.a) SET a.c = 1")
+ a.NoError(err)
+ a.Len(result, 1)
+ for _, r := range result {
+ _, perr := ParseTiDBOmni(r.Statement)
+ a.NoError(perr, "parenthesized-join UPDATE backup must re-parse as valid SQL")
+ }
+ result, err = run("DELETE a FROM (test AS a JOIN test2 AS b ON a.a = b.a) WHERE a.a = 1")
+ a.NoError(err)
+ a.Len(result, 1)
+ for _, r := range result {
+ _, perr := ParseTiDBOmni(r.Statement)
+ a.NoError(perr, "parenthesized-join DELETE backup must re-parse as valid SQL")
+ }
+
+ // A parenthesized leading join FOLLOWED BY another join: the inner ")" falls
+ // inside the table-refs slice, so the wrapping "(" must be included too.
+ result, err = run("UPDATE (test AS t JOIN test2 AS y ON t.a = y.a) JOIN t1 AS z ON z.a = t.a SET t.c = 1 WHERE z.a = 1")
+ a.NoError(err)
+ a.Len(result, 1)
+ for _, r := range result {
+ _, perr := ParseTiDBOmni(r.Statement)
+ a.NoError(perr, "parenthesized-join-then-join UPDATE backup must re-parse as valid SQL")
+ }
+
+ // A right-operand parenthesized join: the slice carries an unmatched "(",
+ // so the wrapping ")" must be appended.
+ result, err = run("UPDATE t1 AS z JOIN (test AS t JOIN test2 AS y ON t.a = y.a) ON z.a = t.a SET z.c = 1 WHERE t.a = 1")
+ a.NoError(err)
+ a.Len(result, 1)
+ for _, r := range result {
+ _, perr := ParseTiDBOmni(r.Statement)
+ a.NoError(perr, "right-operand parenthesized-join UPDATE backup must re-parse as valid SQL")
+ }
+
+ // A block comment containing ")" between the wrapping "(" and the join must
+ // not defeat paren balancing (the comment is dropped, parens stay balanced).
+ result, err = run("UPDATE ( /* c ) */ test AS a LEFT JOIN test2 AS b ON a.a = b.a) JOIN t1 AS z ON z.a = a.a SET a.c = 1")
+ a.NoError(err)
+ a.Len(result, 1)
+ for _, r := range result {
+ _, perr := ParseTiDBOmni(r.Statement)
+ a.NoError(perr, "commented parenthesized-join UPDATE backup must re-parse as valid SQL")
+ }
+
+ // Alias/table-name qualifiers resolve case-insensitively (TiDB default): a
+ // SET or DELETE target whose case differs from the FROM alias must still be
+ // matched, not rejected. (TiDB executes all four of these.)
+ result, err = run("UPDATE test AS T SET t.c = 2 WHERE T.a = 1")
+ a.NoError(err)
+ a.Len(result, 1)
+ a.Equal("test", result[0].SourceTableName)
+
+ result, err = run("UPDATE test AS T JOIN test2 AS Y ON T.a = Y.a SET t.c = 2, y.c = 3")
+ a.NoError(err)
+ a.Len(result, 2)
+ a.ElementsMatch([]string{"test", "test2"}, []string{result[0].SourceTableName, result[1].SourceTableName})
+
+ result, err = run("DELETE t FROM test AS T WHERE T.a = 1")
+ a.NoError(err)
+ a.Len(result, 1)
+ a.Equal("test", result[0].SourceTableName)
+
+ result, err = run("DELETE T FROM test AS t WHERE t.a = 1")
+ a.NoError(err)
+ a.Len(result, 1)
+ a.Equal("test", result[0].SourceTableName)
+
+ // In the >maxMixedDMLCount same-table UNION path, case-only database
+ // differences (db.test vs DB.test) must be treated as the same table, not
+ // rejected as "different tables" — consistent with the cross-database guard.
+ mixedCaseDB := "UPDATE db.test SET c1 = 1 WHERE id = 1;\n" +
+ "UPDATE DB.test SET c1 = 1 WHERE id = 2;\n" +
+ "UPDATE db.test SET c1 = 1 WHERE id = 3;\n" +
+ "UPDATE DB.test SET c1 = 1 WHERE id = 4;\n" +
+ "UPDATE db.test SET c1 = 1 WHERE id = 5;\n" +
+ "UPDATE DB.test SET c1 = 1 WHERE id = 6;"
+ result, err = run(mixedCaseDB)
+ a.NoError(err, "case-only db differences must not be treated as different tables")
+ a.Len(result, 1)
+}
+
+// TestBackupHonorsCaseSensitivity pins that the cross-database guard and
+// equalTable respect the instance's IsCaseSensitive flag (consistent with
+// classifyColumns), so the same comparisons fold case or not as configured.
+func TestBackupHonorsCaseSensitivity(t *testing.T) {
+ a := require.New(t)
+ getter, lister := buildFixedMockDatabaseMetadataGetterAndLister()
+ run := func(caseSensitive bool, sql string) ([]base.BackupStatement, error) {
+ return TransformDMLToSelect(context.Background(), base.TransformContext{
+ GetDatabaseMetadataFunc: getter,
+ ListDatabaseNamesFunc: lister,
+ IsCaseSensitive: caseSensitive,
+ }, sql, "db", "backupDB", "_rollback")
+ }
+
+ // Cross-database guard: DB.test under task db is the same database when
+ // case-insensitive (allowed) but a different database when case-sensitive
+ // (rejected).
+ _, err := run(false, "UPDATE DB.test SET c = 1 WHERE c = 2")
+ a.NoError(err, "case-insensitive: DB.test is db.test")
+ _, err = run(true, "UPDATE DB.test SET c = 1 WHERE c = 2")
+ a.Error(err, "case-sensitive: DB.test is a different database than db")
+
+ // equalTable (the >maxMixedDMLCount UNION path): test and Test merge into one
+ // backup when case-insensitive, but are distinct tables (rejected) when
+ // case-sensitive.
+ sixMixedCase := "DELETE FROM test WHERE a = 1;\n" +
+ "DELETE FROM test WHERE a = 2;\n" +
+ "DELETE FROM test WHERE a = 3;\n" +
+ "DELETE FROM test WHERE a = 4;\n" +
+ "DELETE FROM test WHERE a = 5;\n" +
+ "DELETE FROM Test WHERE a = 6;"
+ _, err = run(false, sixMixedCase)
+ a.NoError(err, "case-insensitive: test and Test are the same table")
+ _, err = run(true, sixMixedCase)
+ a.Error(err, "case-sensitive: test and Test are different tables")
+
+ // Alias/qualifier matching honors case sensitivity: a SET qualifier whose
+ // case differs from the alias resolves when case-insensitive but is a
+ // distinct (unresolvable) identifier when case-sensitive.
+ _, err = run(false, "UPDATE test AS T SET t.c = 2 WHERE T.a = 1")
+ a.NoError(err, "case-insensitive: alias T resolves qualifier t")
+ _, err = run(true, "UPDATE test AS T SET t.c = 2 WHERE T.a = 1")
+ a.Error(err, "case-sensitive: alias T and qualifier t are different identifiers")
+}
diff --git a/backend/plugin/parser/tidb/test-data/test_backup.yaml b/backend/plugin/parser/tidb/test-data/test_backup.yaml
index 3b3b87f87a..e3402f8378 100644
--- a/backend/plugin/parser/tidb/test-data/test_backup.yaml
+++ b/backend/plugin/parser/tidb/test-data/test_backup.yaml
@@ -31,34 +31,6 @@
endposition:
line: 7
column: 47
-- input: |-
- UPDATE db1.t1 SET c1 = 1 WHERE c1 = 2;
- UPDATE db2.t2 SET c1 = 1 WHERE c1 = 2;
- result:
- - statement: |-
- CREATE TABLE `backupDB`.`_rollback_0_t1` LIKE `db1`.`t1`;
- INSERT INTO `backupDB`.`_rollback_0_t1` SELECT `t1`.* FROM db1.t1 WHERE c1 = 2;
- sourceschema: ""
- sourcetablename: t1
- targettablename: _rollback_0_t1
- startposition:
- line: 1
- column: 1
- endposition:
- line: 1
- column: 39
- - statement: |-
- CREATE TABLE `backupDB`.`_rollback_1_t2` LIKE `db2`.`t2`;
- INSERT INTO `backupDB`.`_rollback_1_t2` SELECT `t2`.* FROM db2.t2 WHERE c1 = 2;
- sourceschema: ""
- sourcetablename: t2
- targettablename: _rollback_1_t2
- startposition:
- line: 1
- column: 39
- endposition:
- line: 2
- column: 39
- input: DELETE test FROM test, test2 as t2 where test.id = t2.id;
result:
- statement: |-