Skip to content

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

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.go
index 9850176bbe..a906ea00a7 100644
--- a/backend/plugin/parser/tsql/backup.go
+++ b/backend/plugin/parser/tsql/backup.go
@@ -3,15 +3,12 @@ package tsql
import (
"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 strin
return 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 strin
SourceSchema: 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.go
index 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.go
index 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, statement
return "", 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 = node
break
}
}
@@ -68,7 +64,7 @@ func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statement
return 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 str
pk: 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.Context
rCtx base.RestoreContext
@@ -137,10 +130,6 @@ type generator struct {
originalTable string
pk *model.IndexMetadata
table *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, err
return 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_It
return "", 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.go
index 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{}