Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor(tsql): migrate MSSQL backup restore to omni (#20144)
rebelice099fe07f054a
diff --git a/backend/plugin/parser/tsql/backup.go b/backend/plugin/parser/tsql/backup.goindex 9850176bbe..a906ea00a7 100644--- a/backend/plugin/parser/tsql/backup.go+++ b/backend/plugin/parser/tsql/backup.go@@ -3,15 +3,12 @@ package tsqlimport ("context""fmt"- "log/slog""slices""strings"- "github.com/antlr4-go/antlr/v4"+ "github.com/bytebase/omni/mssql/ast""github.com/pkg/errors"- parser "github.com/bytebase/parser/tsql"-"github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base"@@ -46,11 +43,11 @@ type TableReference struct {}type statementInfo struct {- offset int- statement string- tree antlr.ParserRuleContext- table *TableReference- baseLine int+ statement string+ node ast.Node+ table *TableReference+ startPosition *storepb.Position+ endPosition *storepb.Position}func TransformDMLToSelect(_ context.Context, _ base.TransformContext, statement string, sourceDatabase string, targetDatabase string, tablePrefix string) ([]base.BackupStatement, error) {@@ -131,7 +128,7 @@ func generateSQLForTable(statementInfoList []statementInfo, targetDatabase strinreturn nil, errors.Wrap(err, "failed to write buffer")}}- topClause, fromClause, err := extractSuffixSelectStatement(item.tree)+ topClause, fromClause, err := extractSuffixSelectStatement(item.node, item.statement)if err != nil {return nil, errors.Wrap(err, "failed to extract suffix select statement")}@@ -166,333 +163,430 @@ func generateSQLForTable(statementInfoList []statementInfo, targetDatabase strinSourceSchema: table.Schema,SourceTableName: table.Table,TargetTableName: targetTable,- StartPosition: &storepb.Position{- Line: int32(statementInfoList[0].baseLine + statementInfoList[0].tree.GetStart().GetLine()),- Column: int32(statementInfoList[0].tree.GetStart().GetColumn()),- },- EndPosition: &storepb.Position{- Line: int32(statementInfoList[len(statementInfoList)-1].baseLine + statementInfoList[len(statementInfoList)-1].tree.GetStop().GetLine()),- Column: int32(statementInfoList[len(statementInfoList)-1].tree.GetStop().GetColumn()),- },+ StartPosition: statementInfoList[0].startPosition,+ EndPosition: statementInfoList[len(statementInfoList)-1].endPosition,}, nil}-func extractSuffixSelectStatement(tree antlr.Tree) (string, string, error) {- extractor := &suffixSelectStatementExtractor{}- antlr.ParseTreeWalkerDefault.Walk(extractor, tree)- return extractor.topClause, extractor.fromClause, extractor.err-}--type suffixSelectStatementExtractor struct {- *parser.BaseTSqlParserListener-- topClause string- fromClause string- err error+func extractSuffixSelectStatement(node ast.Node, source string) (string, string, error) {+ switch n := node.(type) {+ case *ast.UpdateStmt:+ if _, ok := n.WhereClause.(*ast.CurrentOfExpr); ok {+ return "", "", errors.New("UPDATE statement with CURSOR clause is not supported")+ }+ fromSource, searchStart := dmlFromSource(source, n.Relation, n.FromClause, dmlNodeLoc(n), n.WhereClause, n.OptionClause)+ return sourceFromLoc(source, dmlNodeLoc(n.Top)), buildDMLFromClause(source, fromSource, searchStart, dmlNodeLoc(n), n.WhereClause, n.OptionClause), nil+ case *ast.DeleteStmt:+ if _, ok := n.WhereClause.(*ast.CurrentOfExpr); ok {+ return "", "", errors.New("DELETE statement with CURSOR clause is not supported")+ }+ fromSource, searchStart := dmlFromSource(source, n.Relation, n.FromClause, dmlNodeLoc(n), n.WhereClause, n.OptionClause)+ return sourceFromLoc(source, dmlNodeLoc(n.Top)), buildDMLFromClause(source, fromSource, searchStart, dmlNodeLoc(n), n.WhereClause, n.OptionClause), nil+ default:+ return "", "", nil+ }}-func (e *suffixSelectStatementExtractor) EnterUpdate_statement(ctx *parser.Update_statementContext) {- if e.err != nil {- return+func prepareTransformation(databaseName, statement string) ([]statementInfo, error) {+ parsedStatements, err := parseTSQLStatements(statement)+ if err != nil {+ return nil, errors.Wrap(err, "failed to parse statement")}- if IsTopLevel(ctx.GetParent()) && ctx.Ddl_object() != nil {- if ctx.CURRENT() != nil {- e.err = errors.New("UPDATE statement with CURSOR clause is not supported")- return- }-- if ctx.TOP() != nil {- if ctx.PERCENT() != nil {- e.topClause = ctx.GetParser().GetTokenStream().GetTextFromTokens(ctx.TOP().GetSymbol(), ctx.PERCENT().GetSymbol())- } else {- e.topClause = ctx.GetParser().GetTokenStream().GetTextFromTokens(ctx.TOP().GetSymbol(), ctx.RR_BRACKET().GetSymbol())- }+ var dmls []statementInfo+ for _, parsedStatement := range parsedStatements {+ node, ok := GetOmniNode(parsedStatement.AST)+ if !ok || node == nil {+ continue+ }+ var (+ table *TableReference+ statementType StatementType+ err error+ )+ switch n := node.(type) {+ case *ast.UpdateStmt:+ table, err = resolveDMLTargetTable(n.Relation, n.FromClause, databaseName)+ statementType = StatementTypeUpdate+ case *ast.DeleteStmt:+ table, err = resolveDMLTargetTable(n.Relation, n.FromClause, databaseName)+ statementType = StatementTypeDelete+ default:+ continue}+ if err != nil {+ return nil, err+ }+ if table == nil {+ return nil, errors.Errorf("failed to resolve DML target table")+ }+ table.StatementType = statementType+ loc := dmlNodeLoc(node)+ dmls = append(dmls, statementInfo{+ statement: parsedStatement.Text,+ node: node,+ table: table,+ startPosition: positionFromByteOffset(parsedStatement.Start, parsedStatement.Text, loc.Start),+ endPosition: positionFromByteOffset(parsedStatement.Start, parsedStatement.Text, dmlEndOffset(parsedStatement.Text, loc)),+ })+ }- var buf strings.Builder- if _, err := buf.WriteString("FROM "); err != nil {- e.err = errors.Wrap(err, "failed to write buffer")- return- }- if ctx.Table_sources() == nil {- if _, err := buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx.Ddl_object())); err != nil {- e.err = errors.Wrap(err, "failed to write buffer")- return- }- } else {- if _, err := buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx.Table_sources())); err != nil {- e.err = errors.Wrap(err, "failed to write buffer")- return- }- }- if _, err := buf.WriteString(" "); err != nil {- e.err = errors.Wrap(err, "failed to write buffer")- return- }- var start, stop int- if ctx.WHERE() != nil {- start = ctx.WHERE().GetSymbol().GetTokenIndex()- } else if ctx.For_clause() != nil {- start = ctx.For_clause().GetStart().GetTokenIndex()- } else if ctx.Option_clause() != nil {- start = ctx.Option_clause().GetStart().GetTokenIndex()- } else if ctx.SEMI() != nil {- start = ctx.SEMI().GetSymbol().GetTokenIndex()- } else {- return- }+ return dmls, nil+}- if ctx.SEMI() != nil {- stop = ctx.SEMI().GetSymbol().GetTokenIndex() - 1- } else {- stop = ctx.GetStop().GetTokenIndex()- }- if _, err := buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromInterval(antlr.NewInterval(start, stop))); err != nil {- e.err = errors.Wrap(err, "failed to write buffer")- return+func resolveDMLTargetTable(relation ast.TableExpr, fromClause *ast.List, databaseName string) (*TableReference, error) {+ table, err := tableReferenceFromTableExpr(relation, databaseName, defaultSchema)+ if err != nil || table == nil {+ return table, err+ }+ if fromClause != nil && table.Database == databaseName && table.Schema == defaultSchema {+ if physical := findPhysicalTableForAlias(fromClause, table); physical != nil {+ return physical, nil}- e.fromClause = buf.String()}+ return table, nil}-func (e *suffixSelectStatementExtractor) EnterDelete_statement(ctx *parser.Delete_statementContext) {- if e.err != nil {- return+func tableReferenceFromTableExpr(expr ast.TableExpr, defaultDatabase, defaultSchema string) (*TableReference, error) {+ ref, ok := expr.(*ast.TableRef)+ if !ok {+ return nil, errors.Errorf("unsupported DML target table source %T", expr)}+ schemaName := defaultSchema+ if ref.Schema != "" {+ schemaName = ref.Schema+ }+ databaseName := defaultDatabase+ if ref.Database != "" {+ databaseName = ref.Database+ }+ return &TableReference{+ Database: databaseName,+ Schema: schemaName,+ Table: ref.Object,+ Alias: ref.Alias,+ }, nil+}- if IsTopLevel(ctx.GetParent()) {- if ctx.CURRENT() != nil {- e.err = errors.New("DELETE statement with CURSOR clause is not supported")- return+func findPhysicalTableForAlias(list *ast.List, table *TableReference) *TableReference {+ if list == nil || table == nil {+ return nil+ }+ for _, item := range list.Items {+ if result := findPhysicalTableForAliasInNode(item, table); result != nil {+ return result}+ }+ return nil+}- if ctx.TOP() != nil {- if ctx.DECIMAL() != nil {- e.topClause = "TOP DECIMAL"- } else {- if ctx.PERCENT() != nil {- e.topClause = ctx.GetParser().GetTokenStream().GetTextFromTokens(ctx.TOP().GetSymbol(), ctx.PERCENT().GetSymbol())- } else {- e.topClause = ctx.GetParser().GetTokenStream().GetTextFromTokens(ctx.TOP().GetSymbol(), ctx.RR_BRACKET().GetSymbol())- }+func findPhysicalTableForAliasInNode(node ast.Node, table *TableReference) *TableReference {+ switch n := node.(type) {+ case *ast.TableRef:+ if n.Alias != "" && n.Alias == table.Table {+ ref, err := tableReferenceFromTableExpr(n, table.Database, table.Schema)+ if err != nil {+ return nil}- }-- var buf strings.Builder- if _, err := buf.WriteString("FROM "); err != nil {- e.err = errors.Wrap(err, "failed to write buffer")- return- }- if ctx.From_table_sources() == nil {- if _, err := buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx.Delete_statement_from())); err != nil {- e.err = errors.Wrap(err, "failed to write buffer")- return+ ref.Alias = n.Alias+ return ref+ }+ case *ast.AliasedTableRef:+ if ref, ok := n.Table.(*ast.TableRef); ok && n.Alias == table.Table {+ result, err := tableReferenceFromTableExpr(ref, table.Database, table.Schema)+ if err != nil {+ return nil}- } else {- if _, err := buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx.From_table_sources().Table_sources())); err != nil {- e.err = errors.Wrap(err, "failed to write buffer")- return- }- }-- if _, err := buf.WriteString(" "); err != nil {- e.err = errors.Wrap(err, "failed to write buffer")- return- }- var start, stop int- if ctx.WHERE() != nil {- start = ctx.WHERE().GetSymbol().GetTokenIndex()- } else if ctx.For_clause() != nil {- start = ctx.For_clause().GetStart().GetTokenIndex()- } else if ctx.Option_clause() != nil {- start = ctx.Option_clause().GetStart().GetTokenIndex()- } else if ctx.SEMI() != nil {- start = ctx.SEMI().GetSymbol().GetTokenIndex()- } else {- return- }-- if ctx.SEMI() != nil {- stop = ctx.SEMI().GetSymbol().GetTokenIndex() - 1- } else {- stop = ctx.GetStop().GetTokenIndex()+ result.Alias = n.Alias+ return result}- if _, err := buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromInterval(antlr.NewInterval(start, stop))); err != nil {- e.err = errors.Wrap(err, "failed to write buffer")- return+ case *ast.JoinClause:+ if result := findPhysicalTableForAliasInNode(n.Left, table); result != nil {+ return result}- e.fromClause = buf.String()+ return findPhysicalTableForAliasInNode(n.Right, table)+ default:}+ return nil}-func prepareTransformation(databaseName, statement string) ([]statementInfo, error) {- antlrASTs, err := ParseTSQL(statement)- if err != nil {- return nil, errors.Wrap(err, "failed to parse statement")+func dmlFromSource(source string, relation ast.TableExpr, fromClause *ast.List, stmtLoc ast.Loc, where ast.ExprNode, option *ast.List) (string, int) {+ if fromClause != nil && len(fromClause.Items) > 0 {+ loc := listLoc(fromClause)+ end := dmlTailStart(source, loc.End, stmtLoc, where, option)+ if end < 0 {+ end = trimDMLStatementEnd(source, stmtLoc.End)+ }+ return strings.TrimSpace(source[loc.Start:end]), end}+ loc := dmlNodeLoc(relation)+ return sourceFromLoc(source, loc), loc.End+}- extractor := &dmlExtractor{- databaseName: databaseName,+func buildDMLFromClause(source, fromSource string, searchStart int, stmtLoc ast.Loc, where ast.ExprNode, option *ast.List) string {+ if fromSource == "" {+ return ""}-- for _, ast := range antlrASTs {- extractor.baseLine = base.GetLineOffset(ast.StartPosition)- antlr.ParseTreeWalkerDefault.Walk(extractor, ast.Tree)+ tail := dmlTrailingClause(source, searchStart, stmtLoc, where, option)+ if tail == "" {+ return "FROM " + fromSource}-- return extractor.dmls, nil+ return "FROM " + fromSource + " " + tail}-type dmlExtractor struct {- *parser.BaseTSqlParserListener-- databaseName string- dmls []statementInfo- offset int- baseLine int+func dmlTrailingClause(source string, searchStart int, stmtLoc ast.Loc, where ast.ExprNode, option *ast.List) string {+ end := trimDMLStatementEnd(source, stmtLoc.End)+ start := dmlTailStart(source, searchStart, stmtLoc, where, option)+ if start < 0 || start >= end {+ return ""+ }+ return strings.TrimSpace(source[start:end])}-func IsTopLevel(ctx antlr.Tree) bool {- if ctx == nil {- return true- }- switch ctx := ctx.(type) {- case *parser.Dml_clauseContext,- *parser.Sql_clausesContext,- *parser.Batch_without_goContext:- return IsTopLevel(ctx.GetParent())- case *parser.Tsql_fileContext:- return true- default:- return false+func dmlTailStart(source string, searchStart int, _ ast.Loc, where ast.ExprNode, option *ast.List) int {+ if where != nil {+ if start := findKeywordBefore(source, "WHERE", dmlNodeLoc(where).Start, searchStart); start >= 0 {+ return start+ }}+ if option != nil {+ return findKeywordAfter(source, "OPTION", searchStart, len(source))+ }+ return -1}-func (e *dmlExtractor) ExitBatch(ctx *parser.Batch_without_goContext) {- if len(ctx.AllSql_clauses()) == 0 {- e.offset+++func trimDMLStatementEnd(source string, end int) int {+ if end > len(source) {+ end = len(source)+ }+ for end > 0 {+ switch source[end-1] {+ case ';', ' ', '\t', '\r', '\n':+ end--+ default:+ return end+ }}+ return end}-func (e *dmlExtractor) ExitSql_clauses(ctx *parser.Sql_clausesContext) {- if IsTopLevel(ctx.GetParent()) {- e.offset+++func findKeywordBefore(source, keyword string, before int, after int) int {+ if before > len(source) {+ before = len(source)+ }+ if after < 0 {+ after = 0}+ return findKeywordOutsideSQL(source, keyword, after, before, true)}-func (e *dmlExtractor) EnterUpdate_statement(ctx *parser.Update_statementContext) {- if IsTopLevel(ctx.GetParent()) && ctx.Ddl_object() != nil {- extractor := &tableExtractor{- databaseName: e.databaseName,- }- antlr.ParseTreeWalkerDefault.Walk(extractor, ctx.Ddl_object())-- table := extractor.table- if extractor.table != nil && ctx.Table_sources() != nil && table.Database == e.databaseName && table.Schema == defaultSchema {- table = extractPhysicalTable(ctx.Table_sources(), extractor.table)- }- table.StatementType = StatementTypeUpdate- e.dmls = append(e.dmls, statementInfo{- offset: e.offset,- statement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),- tree: ctx,- table: table,- baseLine: e.baseLine,- })+func findKeywordAfter(source, keyword string, start int, end int) int {+ if start < 0 {+ start = 0+ }+ if end > len(source) {+ end = len(source)}+ return findKeywordOutsideSQL(source, keyword, start, end, false)}-func (e *dmlExtractor) EnterDelete_statement(ctx *parser.Delete_statementContext) {- if IsTopLevel(ctx.GetParent()) {- extractor := &tableExtractor{- databaseName: e.databaseName,- }- antlr.ParseTreeWalkerDefault.Walk(extractor, ctx.Delete_statement_from())-- table := extractor.table- if extractor.table != nil && ctx.From_table_sources() != nil && table.Database == e.databaseName && table.Schema == defaultSchema {- table = extractPhysicalTable(ctx.From_table_sources().Table_sources(), extractor.table)+func findKeywordOutsideSQL(source, keyword string, start, end int, last bool) int {+ if start >= end {+ return -1+ }+ result := -1+ for i := start; i < end; {+ switch source[i] {+ case '\'':+ i = skipQuotedSQL(source, i, end, '\'')+ case '"':+ i = skipQuotedSQL(source, i, end, '"')+ case '[':+ i = skipQuotedSQL(source, i, end, ']')+ case '-':+ if i+1 < end && source[i+1] == '-' {+ i = skipLineComment(source, i+2, end)+ continue+ }+ if keywordMatchAt(source, keyword, i, start, end) {+ if !last {+ return i+ }+ result = i+ i += len(keyword)+ continue+ }+ i+++ case '/':+ if i+1 < end && source[i+1] == '*' {+ i = skipBlockComment(source, i+2, end)+ continue+ }+ if keywordMatchAt(source, keyword, i, start, end) {+ if !last {+ return i+ }+ result = i+ i += len(keyword)+ continue+ }+ i+++ default:+ if keywordMatchAt(source, keyword, i, start, end) {+ if !last {+ return i+ }+ result = i+ i += len(keyword)+ continue+ }+ i++}- table.StatementType = StatementTypeDelete- e.dmls = append(e.dmls, statementInfo{- offset: e.offset,- statement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),- tree: ctx,- table: table,- baseLine: e.baseLine,- })}+ return result}-func extractPhysicalTable(ctx antlr.Tree, table *TableReference) *TableReference {- if ctx == nil || table == nil {- return table+func keywordMatchAt(source, keyword string, offset, start, end int) bool {+ if offset+len(keyword) > end || !strings.EqualFold(source[offset:offset+len(keyword)], keyword) {+ return false}-- extractor := &physicalTableExtractor{- table: table,+ if offset > start && isSQLIdentifierChar(source[offset-1]) {+ return false}- antlr.ParseTreeWalkerDefault.Walk(extractor, ctx)- if extractor.result != nil {- return extractor.result+ if offset+len(keyword) < end && isSQLIdentifierChar(source[offset+len(keyword)]) {+ return false}- return table+ return true}-type physicalTableExtractor struct {- *parser.BaseTSqlParserListener+func isSQLIdentifierChar(ch byte) bool {+ return ch == '_' || ch == '@' || ch == '#' || ch == '$' ||+ (ch >= '0' && ch <= '9') ||+ (ch >= 'A' && ch <= 'Z') ||+ (ch >= 'a' && ch <= 'z')+}++func skipQuotedSQL(source string, start, end int, closeCh byte) int {+ i := start + 1+ for i < end {+ if source[i] == closeCh {+ if i+1 < end && source[i+1] == closeCh {+ i += 2+ continue+ }+ return i + 1+ }+ i+++ }+ return end+}- table *TableReference- result *TableReference+func skipLineComment(source string, start, end int) int {+ for start < end && source[start] != '\n' {+ start+++ }+ return start}-func (e *physicalTableExtractor) EnterTable_source_item(ctx *parser.Table_source_itemContext) {- if ctx.As_table_alias() != nil && ctx.Full_table_name() != nil {- alias := unquote(ctx.As_table_alias().Table_alias().GetText())- if alias == e.table.Table {- databaseName, schemaName, tableName := extractFullTableName(ctx.Full_table_name(), e.table.Database, e.table.Schema)- e.result = &TableReference{- Database: databaseName,- Schema: schemaName,- Table: tableName,- Alias: alias,- StatementType: e.table.StatementType,+func skipBlockComment(source string, start, end int) int {+ depth := 1+ for start+1 < end {+ switch {+ case source[start] == '/' && source[start+1] == '*':+ depth+++ start += 2+ case source[start] == '*' && source[start+1] == '/':+ depth--+ start += 2+ if depth == 0 {+ return start}+ default:+ start++}}+ return end}-type tableExtractor struct {- *parser.BaseTSqlParserListener+func sourceFromLoc(source string, loc ast.Loc) string {+ if loc.Start < 0 || loc.End < 0 || loc.Start >= len(source) {+ return ""+ }+ end := loc.End+ if end > len(source) {+ end = len(source)+ }+ return strings.TrimSpace(source[loc.Start:end])+}- databaseName string- table *TableReference+func positionFromByteOffset(start *storepb.Position, source string, offset int) *storepb.Position {+ if offset < 0 {+ offset = 0+ }+ if offset >= len(source) && len(source) > 0 {+ offset = len(source) - 1+ }+ line, column := base.CalculateLineAndColumn(source, offset)+ startLine := int32(1)+ if start != nil {+ startLine = start.Line+ }+ return &storepb.Position{+ Line: startLine + int32(line),+ Column: int32(column),+ }}-func (e *tableExtractor) EnterFull_table_name(ctx *parser.Full_table_nameContext) {- databaseName, schemaName, tableName := extractFullTableName(ctx, e.databaseName, defaultSchema)- table := TableReference{- Database: databaseName,- Schema: schemaName,- Table: tableName,+func dmlEndOffset(source string, loc ast.Loc) int {+ if loc.End >= 0 && loc.End < len(source) && source[loc.End] == ';' {+ return loc.End}- e.table = &table+ return loc.End - 1}-func extractFullTableName(ctx parser.IFull_table_nameContext, defaultDatabase string, defaultSchema string) (string, string, string) {- name, err := NormalizeFullTableName(ctx)- if err != nil {- slog.Debug("Failed to normalize full table name", "error", err)- return defaultDatabase, defaultSchema, ""+func listLoc(list *ast.List) ast.Loc {+ if list == nil || len(list.Items) == 0 {+ return ast.NoLoc()}- schemaName := defaultSchema- if name.Schema != "" {- schemaName = name.Schema+ return ast.Loc{+ Start: dmlNodeLoc(list.Items[0]).Start,+ End: dmlNodeLoc(list.Items[len(list.Items)-1]).End,}- databaseName := defaultDatabase- if name.Database != "" {- databaseName = name.Database+}++func dmlNodeLoc(node ast.Node) ast.Loc {+ if common.IsNil(node) {+ return ast.NoLoc()+ }+ switch n := node.(type) {+ case *ast.UpdateStmt:+ return n.Loc+ case *ast.DeleteStmt:+ return n.Loc+ case *ast.TopClause:+ return n.Loc+ case *ast.TableRef:+ return n.Loc+ case *ast.TableVarRef:+ return n.Loc+ case *ast.TableVarMethodCallRef:+ return n.Loc+ case *ast.AliasedTableRef:+ return n.Loc+ case *ast.JoinClause:+ loc := n.Loc+ leftLoc := dmlNodeLoc(n.Left)+ if leftLoc.Start >= 0 && (loc.Start < 0 || leftLoc.Start < loc.Start) {+ loc.Start = leftLoc.Start+ }+ return loc+ case *ast.SetExpr:+ return n.Loc+ default:+ loc := omniNodeLoc(node)+ if loc.Start >= 0 {+ return loc+ }+ return ast.NoLoc()}- return databaseName, schemaName, name.Table}diff --git a/backend/plugin/parser/tsql/backup_test.go b/backend/plugin/parser/tsql/backup_test.goindex 00c48fdf54..57cacf3771 100644--- a/backend/plugin/parser/tsql/backup_test.go+++ b/backend/plugin/parser/tsql/backup_test.go@@ -5,6 +5,7 @@ import ("io""os""slices"+ "strings""testing""github.com/stretchr/testify/require"@@ -19,6 +20,90 @@ type rollbackCase struct {Result []base.BackupStatement}+func TestBackupRestoreDoNotDependOnANTLR(t *testing.T) {+ for _, path := range []string{"backup.go", "restore.go"} {+ content, err := os.ReadFile(path)+ require.NoError(t, err)+ source := string(content)+ require.NotContains(t, source, "github.com/antlr4-go/antlr/v4", path)+ require.NotContains(t, source, "github.com/bytebase/parser/tsql", path)+ require.NotContains(t, source, "ParseTSQL(", path)+ }+}++func TestBackupOmniBoundaryCases(t *testing.T) {+ tests := []struct {+ name string+ input string+ wantSQL string+ wantErrPart string+ }{+ {+ name: "update top option",+ input: "UPDATE TOP (3) test SET c1 = 1 WHERE c2 = 2 OPTION (RECOMPILE);",+ wantSQL: strings.Join([]string{+ "SELECT * INTO [backupDB].[dbo].[rollback_test_db] FROM (",+ " SELECT [db].[dbo].[test].* TOP (3) FROM test WHERE c2 = 2 OPTION (RECOMPILE)) AS backup_table;",+ }, "\n"),+ },+ {+ name: "where keyword in comment",+ input: "UPDATE test SET c1 = 1 WHERE /* WHERE */ c2 = 2;",+ wantSQL: strings.Join([]string{+ "SELECT * INTO [backupDB].[dbo].[rollback_test_db] FROM (",+ " SELECT [db].[dbo].[test].* FROM test WHERE /* WHERE */ c2 = 2) AS backup_table;",+ }, "\n"),+ },+ {+ name: "option keyword in comment",+ input: "UPDATE test SET c1 = 1 /* OPTION */ OPTION (RECOMPILE);",+ wantSQL: strings.Join([]string{+ "SELECT * INTO [backupDB].[dbo].[rollback_test_db] FROM (",+ " SELECT [db].[dbo].[test].* FROM test OPTION (RECOMPILE)) AS backup_table;",+ }, "\n"),+ },+ {+ name: "option keyword in nested comment",+ input: "UPDATE test SET c1 = 1 /* outer /* inner */ OPTION in outer */ OPTION (RECOMPILE);",+ wantSQL: strings.Join([]string{+ "SELECT * INTO [backupDB].[dbo].[rollback_test_db] FROM (",+ " SELECT [db].[dbo].[test].* FROM test OPTION (RECOMPILE)) AS backup_table;",+ }, "\n"),+ },+ {+ name: "delete alias from join",+ input: strings.Join([]string{+ "DELETE FROM t_alias",+ "FROM test AS t_alias JOIN test2 AS t2 ON t_alias.c1 = t2.c1",+ "WHERE t_alias.c1 = 1;",+ }, "\n"),+ wantSQL: strings.Join([]string{+ "SELECT * INTO [backupDB].[dbo].[rollback_test_db] FROM (",+ " SELECT [t_alias].* FROM test AS t_alias JOIN test2 AS t2 ON t_alias.c1 = t2.c1 WHERE t_alias.c1 = 1) AS backup_table;",+ }, "\n"),+ },+ {+ name: "update current of rejected",+ input: "UPDATE test SET c1 = 1 WHERE CURRENT OF my_cursor;",+ wantErrPart: "CURSOR clause is not supported",+ },+ }++ for _, tc := range tests {+ t.Run(tc.name, func(t *testing.T) {+ result, err := TransformDMLToSelect(context.Background(), base.TransformContext{}, tc.input, "db", "backupDB", "rollback")+ if tc.wantErrPart != "" {+ require.Error(t, err)+ require.Contains(t, err.Error(), tc.wantErrPart)+ return+ }+ require.NoError(t, err)+ require.Len(t, result, 1)+ require.Equal(t, tc.wantSQL, result[0].Statement)+ })+ }+}+func TestBackup(t *testing.T) {tests := []rollbackCase{}diff --git a/backend/plugin/parser/tsql/restore.go b/backend/plugin/parser/tsql/restore.goindex 0f00859ec1..a51d82b10f 100644--- a/backend/plugin/parser/tsql/restore.go+++ b/backend/plugin/parser/tsql/restore.go@@ -5,11 +5,9 @@ import ("fmt""strings"- "github.com/antlr4-go/antlr/v4"+ "github.com/bytebase/omni/mssql/ast""github.com/pkg/errors"- parser "github.com/bytebase/parser/tsql"-"github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base"@@ -34,23 +32,21 @@ func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statementreturn "", errors.Errorf("no original SQL")}- antlrASTs, err := ParseTSQL(statement)+ parsedStatements, err := parseTSQLStatements(statement)if err != nil {return "", err}// Find the AST that contains the statement at the backup position- var targetResult *base.ANTLRAST- for _, ast := range antlrASTs {- // Walk the tree to find if this AST contains the target statement- finder := &statementAtPositionFinder{- startPos: backupItem.StartPosition,- endPos: backupItem.EndPosition,- baseLine: base.GetLineOffset(ast.StartPosition),+ var targetResult ast.Node+ for _, parsedStatement := range parsedStatements {+ node, ok := GetOmniNode(parsedStatement.AST)+ if !ok || node == nil || !isRestorableDML(node) {+ continue}- antlr.ParseTreeWalkerDefault.Walk(finder, ast.Tree)- if finder.found {- targetResult = ast+ start, end := statementPositions(parsedStatement.Start, parsedStatement.Text, dmlNodeLoc(node))+ if inRange(start, end, backupItem.StartPosition, backupItem.EndPosition) {+ targetResult = nodebreak}}@@ -68,7 +64,7 @@ func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statementreturn doGenerate(ctx, rCtx, sqlForComment, targetResult, backupItem)}-func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment string, ast *base.ANTLRAST, backupItem *storepb.PriorBackupDetail_Item) (string, error) {+func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment string, node ast.Node, backupItem *storepb.PriorBackupDetail_Item) (string, error) {_, sourceDatabase, err := common.GetInstanceDatabaseID(backupItem.SourceTable.Database)if err != nil {return "", errors.Wrapf(err, "failed to get source database ID for %s", backupItem.SourceTable.Database)@@ -106,7 +102,6 @@ func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment str}g := &generator{- isFirst: true,ctx: ctx,rCtx: rCtx,backupDatabase: targetDatabase,@@ -117,16 +112,14 @@ func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment strpk: tableMetadata.GetPrimaryKey(),table: tableMetadata,}- antlr.ParseTreeWalkerDefault.Walk(g, ast.Tree)- if g.err != nil {- return "", g.err+ result, err := g.generate(node)+ if err != nil {+ return "", err}- return fmt.Sprintf("/*\nOriginal SQL:\n%s\n*/\n%s", sqlForComment, g.result), nil+ return fmt.Sprintf("/*\nOriginal SQL:\n%s\n*/\n%s", sqlForComment, result), nil}type generator struct {- *parser.BaseTSqlParserListener-ctx context.ContextrCtx base.RestoreContext@@ -137,10 +130,6 @@ type generator struct {originalTable stringpk *model.IndexMetadatatable *model.TableMetadata-- isFirst bool- result string- err error}// hasIdentityColumn checks if the table has any IDENTITY columns@@ -156,47 +145,54 @@ func (g *generator) hasIdentityColumn() bool {return false}-func (g *generator) EnterDelete_statement(ctx *parser.Delete_statementContext) {- if IsTopLevel(ctx.GetParent()) && g.isFirst {- g.isFirst = false-- // Check if the table has IDENTITY columns- hasIdentity := g.hasIdentityColumn()-- if hasIdentity {- // For tables with IDENTITY columns, we need to enable IDENTITY_INSERT- // and use explicit column lists- var buf strings.Builder-- // Build column list- var columnList strings.Builder- for i, column := range g.table.GetProto().GetColumns() {- if i > 0 {- columnList.WriteString(", ")- }- fmt.Fprintf(&columnList, "[%s]", column.Name)- }+func (g *generator) generate(node ast.Node) (string, error) {+ switch n := node.(type) {+ case *ast.DeleteStmt:+ return g.generateDelete()+ case *ast.UpdateStmt:+ return g.generateUpdate(n)+ default:+ return "", errors.Errorf("unsupported restore statement %T", node)+ }+}++func (g *generator) generateDelete() (string, error) {+ // Check if the table has IDENTITY columns+ hasIdentity := g.hasIdentityColumn()++ if hasIdentity {+ // For tables with IDENTITY columns, we need to enable IDENTITY_INSERT+ // and use explicit column lists+ var buf strings.Builder- fmt.Fprintf(&buf, "SET IDENTITY_INSERT [%s].[%s].[%s] ON;\n",- g.originalDatabase, g.originalSchema, g.originalTable)- fmt.Fprintf(&buf, "INSERT INTO [%s].[%s].[%s] (%s) SELECT %s FROM [%s].[dbo].[%s];\n",- g.originalDatabase, g.originalSchema, g.originalTable,- columnList.String(),- columnList.String(),- g.backupDatabase, g.backupTable)- fmt.Fprintf(&buf, "SET IDENTITY_INSERT [%s].[%s].[%s] OFF;\n",- g.originalDatabase, g.originalSchema, g.originalTable)- fmt.Fprintf(&buf, "EXEC('DBCC CHECKIDENT (''[%s].[%s].[%s]'', RESEED)');",- g.originalDatabase, g.originalSchema, g.originalTable)-- g.result = buf.String()- } else {- // Simple INSERT for tables without IDENTITY columns- g.result = fmt.Sprintf(`INSERT INTO [%s].[%s].[%s] SELECT * FROM [%s].[dbo].[%s];`,- g.originalDatabase, g.originalSchema, g.originalTable,- g.backupDatabase, g.backupTable)+ // Build column list+ var columnList strings.Builder+ for i, column := range g.table.GetProto().GetColumns() {+ if i > 0 {+ columnList.WriteString(", ")+ }+ fmt.Fprintf(&columnList, "[%s]", column.Name)}- }++ fmt.Fprintf(&buf, "SET IDENTITY_INSERT [%s].[%s].[%s] ON;\n",+ g.originalDatabase, g.originalSchema, g.originalTable)+ fmt.Fprintf(&buf, "INSERT INTO [%s].[%s].[%s] (%s) SELECT %s FROM [%s].[dbo].[%s];\n",+ g.originalDatabase, g.originalSchema, g.originalTable,+ columnList.String(),+ columnList.String(),+ g.backupDatabase, g.backupTable)+ fmt.Fprintf(&buf, "SET IDENTITY_INSERT [%s].[%s].[%s] OFF;\n",+ g.originalDatabase, g.originalSchema, g.originalTable)+ fmt.Fprintf(&buf, "EXEC('DBCC CHECKIDENT (''[%s].[%s].[%s]'', RESEED)');",+ g.originalDatabase, g.originalSchema, g.originalTable)++ return buf.String(), nil+ }++ // Simple INSERT for tables without IDENTITY columns+ return fmt.Sprintf(`INSERT INTO [%s].[%s].[%s] SELECT * FROM [%s].[dbo].[%s];`,+ g.originalDatabase, g.originalSchema, g.originalTable,+ g.backupDatabase, g.backupTable), nil}func disjoint(a []string, b map[string]bool) bool {@@ -232,139 +228,143 @@ func (g *generator) findDisjointUniqueKey(updateColumns []string) ([]string, errreturn nil, errors.Errorf("no disjoint unique key found for %s.%s.%s", g.originalDatabase, g.originalSchema, g.originalTable)}-func (g *generator) EnterUpdate_statement(ctx *parser.Update_statementContext) {- if IsTopLevel(ctx.GetParent()) && g.isFirst {- g.isFirst = false-- l := &updateElemListener{}- antlr.ParseTreeWalkerDefault.Walk(l, ctx)- if l.err != nil {- g.err = l.err- return- }+func (g *generator) generateUpdate(stmt *ast.UpdateStmt) (string, error) {+ updateColumns := updateSetColumns(stmt.SetClause)+ uk, err := g.findDisjointUniqueKey(updateColumns)+ if err != nil {+ return "", err+ }- uk, err := g.findDisjointUniqueKey(l.result)- if err != nil {- g.err = err- return- }+ var buf strings.Builder- var buf strings.Builder+ // Check if the table has IDENTITY columns+ hasIdentity := g.hasIdentityColumn()- // Check if the table has IDENTITY columns- hasIdentity := g.hasIdentityColumn()-- if hasIdentity {- // Enable IDENTITY_INSERT for MERGE statement- if _, err := fmt.Fprintf(&buf, "SET IDENTITY_INSERT [%s].[%s].[%s] ON;\n",- g.originalDatabase, g.originalSchema, g.originalTable); err != nil {- g.err = err- return- }+ if hasIdentity {+ // Enable IDENTITY_INSERT for MERGE statement+ if _, err := fmt.Fprintf(&buf, "SET IDENTITY_INSERT [%s].[%s].[%s] ON;\n",+ g.originalDatabase, g.originalSchema, g.originalTable); err != nil {+ return "", err}+ }- if _, err := fmt.Fprintf(&buf, "MERGE INTO [%s].[%s].[%s] AS t\nUSING [%s].[dbo].[%s] AS b\n ON", g.originalDatabase, g.originalSchema, g.originalTable, g.backupDatabase, g.backupTable); err != nil {- g.err = err- return- }- for i, column := range uk {- if i > 0 {- if _, err := fmt.Fprint(&buf, " AND"); err != nil {- g.err = err- return- }- }- if _, err := fmt.Fprintf(&buf, " t.[%s] = b.[%s]", column, column); err != nil {- g.err = err- return+ if _, err := fmt.Fprintf(&buf, "MERGE INTO [%s].[%s].[%s] AS t\nUSING [%s].[dbo].[%s] AS b\n ON", g.originalDatabase, g.originalSchema, g.originalTable, g.backupDatabase, g.backupTable); err != nil {+ return "", err+ }+ for i, column := range uk {+ if i > 0 {+ if _, err := fmt.Fprint(&buf, " AND"); err != nil {+ return "", err}}- if _, err := fmt.Fprint(&buf, "\nWHEN MATCHED THEN\n UPDATE SET"); err != nil {- g.err = err- return+ if _, err := fmt.Fprintf(&buf, " t.[%s] = b.[%s]", column, column); err != nil {+ return "", err}- for i, field := range l.result {- if i > 0 {- if _, err := fmt.Fprint(&buf, ","); err != nil {- g.err = err- return- }- }- if _, err := fmt.Fprintf(&buf, " t.[%s] = b.[%s]", field, field); err != nil {- g.err = err- return+ }+ if _, err := fmt.Fprint(&buf, "\nWHEN MATCHED THEN\n UPDATE SET"); err != nil {+ return "", err+ }+ for i, field := range updateColumns {+ if i > 0 {+ if _, err := fmt.Fprint(&buf, ","); err != nil {+ return "", err}}- if _, err := fmt.Fprint(&buf, "\nWHEN NOT MATCHED THEN\n INSERT ("); err != nil {- g.err = err- return+ if _, err := fmt.Fprintf(&buf, " t.[%s] = b.[%s]", field, field); err != nil {+ return "", err}- for i, column := range g.table.GetProto().GetColumns() {- if i > 0 {- if _, err := fmt.Fprint(&buf, ", "); err != nil {- g.err = err- return- }- }- if _, err := fmt.Fprintf(&buf, "[%s]", column.Name); err != nil {- g.err = err- return+ }+ if _, err := fmt.Fprint(&buf, "\nWHEN NOT MATCHED THEN\n INSERT ("); err != nil {+ return "", err+ }+ for i, column := range g.table.GetProto().GetColumns() {+ if i > 0 {+ if _, err := fmt.Fprint(&buf, ", "); err != nil {+ return "", err}}- if _, err := fmt.Fprint(&buf, ") VALUES ("); err != nil {- g.err = err- return+ if _, err := fmt.Fprintf(&buf, "[%s]", column.Name); err != nil {+ return "", err}- for i, column := range g.table.GetProto().GetColumns() {- if i > 0 {- if _, err := fmt.Fprint(&buf, ", "); err != nil {- g.err = err- return- }- }- if _, err := fmt.Fprintf(&buf, "b.[%s]", column.Name); err != nil {- g.err = err- return+ }+ if _, err := fmt.Fprint(&buf, ") VALUES ("); err != nil {+ return "", err+ }+ for i, column := range g.table.GetProto().GetColumns() {+ if i > 0 {+ if _, err := fmt.Fprint(&buf, ", "); err != nil {+ return "", err}}- if _, err := fmt.Fprint(&buf, ");"); err != nil {- g.err = err- return+ if _, err := fmt.Fprintf(&buf, "b.[%s]", column.Name); err != nil {+ return "", err}+ }+ if _, err := fmt.Fprint(&buf, ");"); err != nil {+ return "", err+ }- // Check if we need to disable IDENTITY_INSERT and reseed- if hasIdentity {- if _, err := fmt.Fprintf(&buf, "\n\nSET IDENTITY_INSERT [%s].[%s].[%s] OFF;\nEXEC('DBCC CHECKIDENT (''[%s].[%s].[%s]'', RESEED)');",- g.originalDatabase, g.originalSchema, g.originalTable,- g.originalDatabase, g.originalSchema, g.originalTable); err != nil {- g.err = err- return- }+ // Check if we need to disable IDENTITY_INSERT and reseed+ if hasIdentity {+ if _, err := fmt.Fprintf(&buf, "\n\nSET IDENTITY_INSERT [%s].[%s].[%s] OFF;\nEXEC('DBCC CHECKIDENT (''[%s].[%s].[%s]'', RESEED)');",+ g.originalDatabase, g.originalSchema, g.originalTable,+ g.originalDatabase, g.originalSchema, g.originalTable); err != nil {+ return "", err}-- g.result = buf.String()}-}--type updateElemListener struct {- *parser.BaseTSqlParserListener- result []string- err error+ return buf.String(), nil}-func (l *updateElemListener) EnterUpdate_elem(ctx *parser.Update_elemContext) {- if l.err != nil {- return+func updateSetColumns(setClause *ast.List) []string {+ if setClause == nil {+ return nil}- if ctx.Full_column_name() != nil {- _, columnName, err := NormalizeFullColumnName(ctx.Full_column_name())- if err != nil {- l.err = err- return+ var columns []string+ for _, item := range setClause.Items {+ setExpr, ok := item.(*ast.SetExpr)+ if !ok {+ continue+ }+ if setExpr.Column != nil {+ columns = append(columns, setExpr.Column.Column)+ continue}- l.result = append(l.result, columnName)+ if setExpr.VarColumn != nil {+ columns = append(columns, setExpr.VarColumn.Column)+ continue+ }+ if setExpr.Variable != "" {+ if column := updateColumnFromDualAssignment(setExpr.Value); column != "" {+ columns = append(columns, column)+ }+ }+ }+ return columns+}++func updateColumnFromDualAssignment(expr ast.ExprNode) string {+ switch e := expr.(type) {+ case *ast.BinaryExpr:+ if e.Op == ast.BinOpEq {+ return updateColumnFromExpr(e.Left)+ }+ case *ast.ParenExpr:+ return updateColumnFromDualAssignment(e.Expr)+ default:+ }+ return ""+}++func updateColumnFromExpr(expr ast.ExprNode) string {+ switch e := expr.(type) {+ case *ast.ColumnRef:+ return e.Column+ case *ast.ParenExpr:+ return updateColumnFromExpr(e.Expr)+ default:}+ return ""}func extractStatement(statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error) {@@ -372,105 +372,43 @@ func extractStatement(statement string, backupItem *storepb.PriorBackupDetail_Itreturn "", errors.Errorf("backup item is nil")}- parseResults, err := ParseTSQL(statement)+ parseResults, err := parseTSQLStatements(statement)if err != nil {return "", errors.Wrapf(err, "failed to parse statement")}- l := &originalSQLExtractor{- startPos: backupItem.StartPosition,- endPos: backupItem.EndPosition,- }-- // Walk all ASTs to find statements within the specified position range- for _, ast := range parseResults {- l.baseLine = base.GetLineOffset(ast.StartPosition)- antlr.ParseTreeWalkerDefault.Walk(l, ast.Tree)+ var originalSQL []string+ for _, parsedStatement := range parseResults {+ node, ok := GetOmniNode(parsedStatement.AST)+ if !ok || node == nil || !isRestorableDML(node) {+ continue+ }+ start, end := statementPositions(parsedStatement.Start, parsedStatement.Text, dmlNodeLoc(node))+ if !inRange(start, end, backupItem.StartPosition, backupItem.EndPosition) {+ continue+ }+ sql := strings.TrimSuffix(sourceFromLoc(parsedStatement.Text, dmlNodeLoc(node)), ";")+ originalSQL = append(originalSQL, sql)}-- if len(l.originalSQL) == 0 {+ if len(originalSQL) == 0 {return "", nil}// Join with semicolons and add a trailing semicolon- return strings.Join(l.originalSQL, ";\n") + ";", nil-}--// originalSQLExtractor extracts original SQL statements within a position range.-type originalSQLExtractor struct {- *parser.BaseTSqlParserListener-- originalSQL []string- startPos *storepb.Position- endPos *storepb.Position- baseLine int+ return strings.Join(originalSQL, ";\n") + ";", nil}-func (l *originalSQLExtractor) EnterUpdate_statement(ctx *parser.Update_statementContext) {- if IsTopLevel(ctx.GetParent()) {- if inRange(&storepb.Position{- Line: int32(ctx.GetStart().GetLine()) + int32(l.baseLine),- Column: int32(ctx.GetStart().GetColumn()),- }, &storepb.Position{- Line: int32(ctx.GetStop().GetLine()) + int32(l.baseLine),- Column: int32(ctx.GetStop().GetColumn()),- }, l.startPos, l.endPos) {- sql := ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx)- // Strip trailing semicolon to avoid double semicolons when joining- sql = strings.TrimSuffix(sql, ";")- l.originalSQL = append(l.originalSQL, sql)- }- }-}--func (l *originalSQLExtractor) EnterDelete_statement(ctx *parser.Delete_statementContext) {- if IsTopLevel(ctx.GetParent()) {- if inRange(&storepb.Position{- Line: int32(ctx.GetStart().GetLine()) + int32(l.baseLine),- Column: int32(ctx.GetStart().GetColumn()),- }, &storepb.Position{- Line: int32(ctx.GetStop().GetLine()) + int32(l.baseLine),- Column: int32(ctx.GetStop().GetColumn()),- }, l.startPos, l.endPos) {- sql := ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx)- // Strip trailing semicolon to avoid double semicolons when joining- sql = strings.TrimSuffix(sql, ";")- l.originalSQL = append(l.originalSQL, sql)- }- }-}--// statementAtPositionFinder finds if a parse tree contains a statement at the given position.-type statementAtPositionFinder struct {- *parser.BaseTSqlParserListener- startPos *storepb.Position- endPos *storepb.Position- baseLine int- found bool-}--func (f *statementAtPositionFinder) EnterUpdate_statement(ctx *parser.Update_statementContext) {- if IsTopLevel(ctx.GetParent()) && inRange(&storepb.Position{- Line: int32(ctx.GetStart().GetLine()) + int32(f.baseLine),- Column: int32(ctx.GetStart().GetColumn()),- }, &storepb.Position{- Line: int32(ctx.GetStop().GetLine()) + int32(f.baseLine),- Column: int32(ctx.GetStop().GetColumn()),- }, f.startPos, f.endPos) {- f.found = true+func isRestorableDML(node ast.Node) bool {+ switch node.(type) {+ case *ast.UpdateStmt, *ast.DeleteStmt:+ return true+ default:+ return false}}-func (f *statementAtPositionFinder) EnterDelete_statement(ctx *parser.Delete_statementContext) {- if IsTopLevel(ctx.GetParent()) && inRange(&storepb.Position{- Line: int32(ctx.GetStart().GetLine()) + int32(f.baseLine),- Column: int32(ctx.GetStart().GetColumn()),- }, &storepb.Position{- Line: int32(ctx.GetStop().GetLine()) + int32(f.baseLine),- Column: int32(ctx.GetStop().GetColumn()),- }, f.startPos, f.endPos) {- f.found = true- }+func statementPositions(start *storepb.Position, source string, loc ast.Loc) (*storepb.Position, *storepb.Position) {+ return positionFromByteOffset(start, source, loc.Start), positionFromByteOffset(start, source, dmlEndOffset(source, loc))}// inRange checks if a statement's position range is within the target range.diff --git a/backend/plugin/parser/tsql/restore_test.go b/backend/plugin/parser/tsql/restore_test.goindex 04666bf774..268951f98f 100644--- a/backend/plugin/parser/tsql/restore_test.go+++ b/backend/plugin/parser/tsql/restore_test.go@@ -5,6 +5,7 @@ import ("io""math""os"+ "strings""testing""github.com/stretchr/testify/require"@@ -100,6 +101,112 @@ func TestRestoreIdentityHandling(t *testing.T) {a.NotContains(restoreSQL, "SELECT * FROM")}+func TestRestoreOmniBoundaryCases(t *testing.T) {+ tests := []struct {+ name string+ input string+ startLine int32+ endLine int32+ want string+ }{+ {+ name: "selects only update inside backup position range",+ input: strings.Join([]string{+ "DELETE FROM test WHERE a = 1;",+ "UPDATE test SET b = b + 1, c = DEFAULT WHERE a = 2;",+ }, "\n"),+ startLine: 2,+ endLine: 2,+ want: strings.Join([]string{+ "/*",+ "Original SQL:",+ "UPDATE test SET b = b + 1, c = DEFAULT WHERE a = 2;",+ "*/",+ "MERGE INTO [db].[dbo].[test] AS t",+ "USING [bbarchive].[dbo].[prefix_1_test] AS b",+ " ON t.[a] = b.[a]",+ "WHEN MATCHED THEN",+ " UPDATE SET t.[b] = b.[b], t.[c] = b.[c]",+ "WHEN NOT MATCHED THEN",+ " INSERT ([a], [b], [c]) VALUES (b.[a], b.[b], b.[c]);",+ }, "\n"),+ },+ {+ name: "dual assignment update restores assigned column",+ input: "UPDATE test SET @v = b = 1 WHERE a = 1;",+ startLine: 1,+ endLine: 1,+ want: strings.Join([]string{+ "/*",+ "Original SQL:",+ "UPDATE test SET @v = b = 1 WHERE a = 1;",+ "*/",+ "MERGE INTO [db].[dbo].[test] AS t",+ "USING [bbarchive].[dbo].[prefix_1_test] AS b",+ " ON t.[a] = b.[a]",+ "WHEN MATCHED THEN",+ " UPDATE SET t.[b] = b.[b]",+ "WHEN NOT MATCHED THEN",+ " INSERT ([a], [b], [c]) VALUES (b.[a], b.[b], b.[c]);",+ }, "\n"),+ },+ {+ name: "variable read assignment does not restore read column",+ input: "UPDATE test SET @v = b, c = c + 1 WHERE a = 1;",+ startLine: 1,+ endLine: 1,+ want: strings.Join([]string{+ "/*",+ "Original SQL:",+ "UPDATE test SET @v = b, c = c + 1 WHERE a = 1;",+ "*/",+ "MERGE INTO [db].[dbo].[test] AS t",+ "USING [bbarchive].[dbo].[prefix_1_test] AS b",+ " ON t.[a] = b.[a]",+ "WHEN MATCHED THEN",+ " UPDATE SET t.[c] = b.[c]",+ "WHEN NOT MATCHED THEN",+ " INSERT ([a], [b], [c]) VALUES (b.[a], b.[b], b.[c]);",+ }, "\n"),+ },+ {+ name: "delete restore uses insert",+ input: "DELETE FROM test WHERE a = 1;",+ startLine: 1,+ endLine: 1,+ want: strings.Join([]string{+ "/*",+ "Original SQL:",+ "DELETE FROM test WHERE a = 1;",+ "*/",+ "INSERT INTO [db].[dbo].[test] SELECT * FROM [bbarchive].[dbo].[prefix_1_test];",+ }, "\n"),+ },+ }++ for _, tc := range tests {+ t.Run(tc.name, func(t *testing.T) {+ result, err := GenerateRestoreSQL(context.Background(), base.RestoreContext{+ GetDatabaseMetadataFunc: fixedMockDatabaseMetadataGetter,+ }, tc.input, &store.PriorBackupDetail_Item{+ SourceTable: &store.PriorBackupDetail_Item_Table{+ Database: "instances/i1/databases/db",+ Schema: "dbo",+ Table: "test",+ },+ TargetTable: &store.PriorBackupDetail_Item_Table{+ Database: "instances/i1/databases/bbarchive",+ Table: "prefix_1_test",+ },+ StartPosition: &store.Position{Line: tc.startLine, Column: 0},+ EndPosition: &store.Position{Line: tc.endLine, Column: math.MaxInt32},+ })+ require.NoError(t, err)+ require.Equal(t, tc.want, result)+ })+ }+}+func TestRestore(t *testing.T) {tests := []restoreCase{}