Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
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.goindex 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, statereturn 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.Datif 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].tablefor _, 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, statable := statementInfo.tabletargetTable := 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.Builderif _, 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, statableNameOrAlias = 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, stareturn 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, stareturn 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, stareturn 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.GetDatabareturn 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.GetDatabareturn 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.goindex 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.GetDatabaseMetadataFureturn []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.yamlindex 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: 7column: 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: |-