Skip to content

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

chore: handle IDENTITY columns during SQL Server restore (#17657)

Vincent Huangdb815514cece
diff --git a/backend/plugin/parser/tsql/backup.go b/backend/plugin/parser/tsql/backup.go
index 83c026379c..f8741a8d37 100644
--- a/backend/plugin/parser/tsql/backup.go
+++ b/backend/plugin/parser/tsql/backup.go
@@ -121,7 +121,7 @@ func generateSQLForTable(statementInfoList []statementInfo, targetDatabase strin
targetTable := fmt.Sprintf("%s_%s_%s", tablePrefix, table.Table, table.Database)
targetTable, _ = common.TruncateString(targetTable, maxTableNameLength)
var buf strings.Builder
- if _, err := buf.WriteString(fmt.Sprintf(`SELECT * INTO "%s"."%s"."%s" FROM (`+"\n", targetDatabase, defaultSchema, targetTable)); err != nil {
+ if _, err := buf.WriteString(fmt.Sprintf(`SELECT * INTO [%s].[%s].[%s] FROM (`+"\n", targetDatabase, defaultSchema, targetTable)); err != nil {
return nil, errors.Wrap(err, "failed to write buffer")
}
for i, item := range statementInfoList {
@@ -135,11 +135,11 @@ func generateSQLForTable(statementInfoList []statementInfo, targetDatabase strin
return nil, errors.Wrap(err, "failed to extract suffix select statement")
}
if len(item.table.Alias) == 0 {
- if _, err := buf.WriteString(fmt.Sprintf(` SELECT "%s"."%s"."%s".* `, item.table.Database, item.table.Schema, item.table.Table)); err != nil {
+ if _, err := buf.WriteString(fmt.Sprintf(` SELECT [%s].[%s].[%s].* `, item.table.Database, item.table.Schema, item.table.Table)); err != nil {
return nil, errors.Wrap(err, "failed to write buffer")
}
} else {
- if _, err := buf.WriteString(fmt.Sprintf(` SELECT "%s".* `, item.table.Alias)); err != nil {
+ if _, err := buf.WriteString(fmt.Sprintf(` SELECT [%s].* `, item.table.Alias)); err != nil {
return nil, errors.Wrap(err, "failed to write buffer")
}
}
diff --git a/backend/plugin/parser/tsql/backup_test.go b/backend/plugin/parser/tsql/backup_test.go
index 2114ba4b90..b415b97339 100644
--- a/backend/plugin/parser/tsql/backup_test.go
+++ b/backend/plugin/parser/tsql/backup_test.go
@@ -72,3 +72,91 @@ func TestBackup(t *testing.T) {
a.NoError(err)
}
}
+
+// TestIdentityColumnHandling validates that our implementation correctly handles IDENTITY columns
+// This test verifies:
+// 1. The backup uses simple SELECT INTO (copying IDENTITY properties naturally)
+// 2. The restore.go handles IDENTITY_INSERT during rollback
+func TestIdentityColumnHandling(t *testing.T) {
+ a := require.New(t)
+
+ // Test case: DELETE from a table that typically has IDENTITY columns
+ input := `DELETE FROM positions WHERE position_id = 1;`
+
+ result, err := TransformDMLToSelect(context.Background(), base.TransformContext{},
+ input, "db", "backupDB", "rollback")
+ a.NoError(err)
+ a.Len(result, 1)
+
+ // Verify the generated SQL uses simple SELECT INTO
+ stmt := result[0].Statement
+
+ // Key assertions about the generated SQL:
+ // 1. Uses simple SELECT INTO
+ a.Contains(stmt, "SELECT * INTO [backupDB].[dbo].[rollback_positions_db]")
+
+ // 2. Selects from the original table with proper bracketing
+ a.Contains(stmt, "SELECT [db].[dbo].[positions].* FROM")
+
+ // 3. Includes the WHERE clause
+ a.Contains(stmt, "WHERE position_id = 1")
+
+ // The approach:
+ // Backup: Simple SELECT * INTO backup_table (copies IDENTITY property naturally)
+ // Restore: restore.go handles IDENTITY_INSERT ON/OFF for rollback
+}
+
+// TestBackupStatementStructure validates the structure of backup statements
+func TestBackupStatementStructure(t *testing.T) {
+ a := require.New(t)
+
+ // Test that UPDATE statements generate correct backup SQL
+ input := `UPDATE employees SET salary = salary * 1.1 WHERE department_id = 5;`
+
+ result, err := TransformDMLToSelect(context.Background(), base.TransformContext{},
+ input, "production", "backup", "migration")
+ a.NoError(err)
+ a.Len(result, 1)
+
+ backupStmt := result[0]
+
+ // Verify backup statement metadata
+ a.Equal("dbo", backupStmt.SourceSchema)
+ a.Equal("employees", backupStmt.SourceTableName)
+ a.Equal("migration_employees_production", backupStmt.TargetTableName)
+
+ // Verify the SQL structure handles the WHERE clause properly
+ a.Contains(backupStmt.Statement, "WHERE department_id = 5")
+}
+
+// TestBackupWithQuotedStrings validates that single quotes in WHERE clauses are properly handled
+func TestBackupWithQuotedStrings(t *testing.T) {
+ a := require.New(t)
+
+ // Test case with single quotes
+ input := `DELETE FROM AdminPosition WHERE positionName = 'BPM Admin';`
+
+ result, err := TransformDMLToSelect(context.Background(), base.TransformContext{},
+ input, "TestIdentityDB", "bbdataarchive", "backup")
+ a.NoError(err)
+ a.Len(result, 1)
+
+ stmt := result[0].Statement
+
+ // With simple SELECT INTO, quotes are handled naturally by SQL Server
+ // The WHERE clause should appear as-is
+ a.Contains(stmt, "WHERE positionName = 'BPM Admin'")
+
+ // Also test with apostrophes in the string
+ input2 := `UPDATE positions SET title = 'O''Reilly''s Manager' WHERE id = 1;`
+ result2, err := TransformDMLToSelect(context.Background(), base.TransformContext{},
+ input2, "db", "backup", "rollback")
+ a.NoError(err)
+ a.Len(result2, 1)
+
+ // For UPDATE, we only backup the rows that will be changed (WHERE clause)
+ // The SET clause is not part of the backup, only the WHERE clause matters
+ stmt2 := result2[0].Statement
+ // The WHERE clause should be present
+ a.Contains(stmt2, "WHERE id = 1")
+}
diff --git a/backend/plugin/parser/tsql/restore.go b/backend/plugin/parser/tsql/restore.go
index 0eb1ddd270..ee6dfa61e1 100644
--- a/backend/plugin/parser/tsql/restore.go
+++ b/backend/plugin/parser/tsql/restore.go
@@ -121,10 +121,59 @@ type generator struct {
err error
}
+// hasIdentityColumn checks if the table has any IDENTITY columns
+func (g *generator) hasIdentityColumn() bool {
+ if g.table == nil {
+ return false
+ }
+ for _, col := range g.table.GetColumns() {
+ if col.IsIdentity {
+ return true
+ }
+ }
+ return false
+}
+
func (g *generator) EnterDelete_statement(ctx *parser.Delete_statementContext) {
if IsTopLevel(ctx.GetParent()) && g.isFirst {
g.isFirst = false
- g.result = fmt.Sprintf(`INSERT INTO [%s].[%s].[%s] SELECT * FROM [%s].[dbo].[%s];`, g.originalDatabase, g.originalSchema, g.originalTable, g.backupDatabase, g.backupTable)
+
+ // 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.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)
+
+ 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)
+ }
}
}
@@ -179,6 +228,19 @@ func (g *generator) EnterUpdate_statement(ctx *parser.Update_statementContext) {
}
var buf strings.Builder
+
+ // 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 _, 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
@@ -247,6 +309,17 @@ func (g *generator) EnterUpdate_statement(ctx *parser.Update_statementContext) {
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 {
+ g.err = err
+ return
+ }
+ }
+
g.result = buf.String()
}
}
diff --git a/backend/plugin/parser/tsql/restore_test.go b/backend/plugin/parser/tsql/restore_test.go
index 767fbda8ca..01843c5316 100644
--- a/backend/plugin/parser/tsql/restore_test.go
+++ b/backend/plugin/parser/tsql/restore_test.go
@@ -10,6 +10,7 @@ import (
"github.com/stretchr/testify/require"
"gopkg.in/yaml.v3"
+ "github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
"github.com/bytebase/bytebase/backend/store/model"
@@ -25,6 +26,79 @@ type restoreCase struct {
Result string
}
+// TestRestoreIdentityHandling validates that restore operations properly handle IDENTITY columns
+// This test verifies:
+// 1. DELETE rollback uses SET IDENTITY_INSERT ON/OFF for tables with IDENTITY columns
+// 2. UPDATE rollback (MERGE) also properly handles IDENTITY_INSERT
+// 3. DBCC CHECKIDENT is called to reseed IDENTITY values
+func TestRestoreIdentityHandling(t *testing.T) {
+ a := require.New(t)
+
+ // Mock metadata with IDENTITY column
+ mockMetadata := func(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {
+ // Extract just the database name from the resource ID
+ _, dbName, _ := common.GetInstanceDatabaseID(databaseName)
+ if dbName == "" {
+ dbName = databaseName
+ }
+ return databaseName, model.NewDatabaseMetadata(&store.DatabaseSchemaMetadata{
+ Name: dbName,
+ Schemas: []*store.SchemaMetadata{
+ {
+ Name: "dbo",
+ Tables: []*store.TableMetadata{
+ {
+ Name: "positions",
+ Columns: []*store.ColumnMetadata{
+ {
+ Name: "position_id",
+ Type: "int",
+ IsIdentity: true, // This is an IDENTITY column
+ },
+ {
+ Name: "title",
+ Type: "nvarchar(100)",
+ },
+ },
+ },
+ },
+ },
+ },
+ }, false, false), nil
+ }
+
+ // Test DELETE rollback with IDENTITY column
+ deleteSQL := "DELETE FROM positions WHERE position_id = 1;"
+ restoreSQL, err := GenerateRestoreSQL(context.Background(), base.RestoreContext{
+ GetDatabaseMetadataFunc: mockMetadata,
+ InstanceID: "instances/test-instance",
+ }, deleteSQL, &store.PriorBackupDetail_Item{
+ SourceTable: &store.PriorBackupDetail_Item_Table{
+ Database: "instances/test-instance/databases/db",
+ Schema: "dbo",
+ Table: "positions",
+ },
+ TargetTable: &store.PriorBackupDetail_Item_Table{
+ Database: "instances/test-instance/databases/backupDB",
+ Table: "backup_positions",
+ },
+ StartPosition: &store.Position{Line: 1, Column: 0},
+ EndPosition: &store.Position{Line: 1, Column: 40},
+ })
+
+ a.NoError(err)
+
+ // Verify the restore SQL includes IDENTITY_INSERT handling
+ a.Contains(restoreSQL, "SET IDENTITY_INSERT [db].[dbo].[positions] ON")
+ a.Contains(restoreSQL, "SET IDENTITY_INSERT [db].[dbo].[positions] OFF")
+ a.Contains(restoreSQL, "EXEC('DBCC CHECKIDENT (''[db].[dbo].[positions]'', RESEED)')")
+
+ // Verify the INSERT statement uses explicit column list, not SELECT *
+ // This is required by SQL Server when IDENTITY_INSERT is ON
+ a.Contains(restoreSQL, "INSERT INTO [db].[dbo].[positions] ([position_id], [title])")
+ a.NotContains(restoreSQL, "SELECT * FROM")
+}
+
func TestRestore(t *testing.T) {
tests := []restoreCase{}
diff --git a/backend/plugin/parser/tsql/test-data/test_backup.yaml b/backend/plugin/parser/tsql/test-data/test_backup.yaml
index dcc33fb07a..87bdc19a60 100644
--- a/backend/plugin/parser/tsql/test-data/test_backup.yaml
+++ b/backend/plugin/parser/tsql/test-data/test_backup.yaml
@@ -8,20 +8,20 @@
UPDATE test SET test.c1 = 7 WHERE test.b1 = 7;
result:
- statement: |-
- SELECT * INTO "backupDB"."dbo"."rollback_test_db" FROM (
- SELECT "db"."dbo"."test".* FROM test WHERE test.b1 = 1
+ SELECT * INTO [backupDB].[dbo].[rollback_test_db] FROM (
+ SELECT [db].[dbo].[test].* FROM test WHERE test.b1 = 1
UNION
- SELECT "db"."dbo"."test".* FROM test WHERE test.b1 = 2
+ SELECT [db].[dbo].[test].* FROM test WHERE test.b1 = 2
UNION
- SELECT "db"."dbo"."test".* FROM test WHERE test.b1 = 3
+ SELECT [db].[dbo].[test].* FROM test WHERE test.b1 = 3
UNION
- SELECT "db"."dbo"."test".* FROM test WHERE test.b1 = 4
+ SELECT [db].[dbo].[test].* FROM test WHERE test.b1 = 4
UNION
- SELECT "db"."dbo"."test".* FROM test WHERE test.b1 = 5
+ SELECT [db].[dbo].[test].* FROM test WHERE test.b1 = 5
UNION
- SELECT "db"."dbo"."test".* FROM test WHERE test.b1 = 6
+ SELECT [db].[dbo].[test].* FROM test WHERE test.b1 = 6
UNION
- SELECT "db"."dbo"."test".* FROM test WHERE test.b1 = 7) AS backup_table;
+ SELECT [db].[dbo].[test].* FROM test WHERE test.b1 = 7) AS backup_table;
sourceschema: dbo
sourcetablename: test
targettablename: rollback_test_db
@@ -37,8 +37,8 @@
WHERE t_alias.c1 = 1;
result:
- statement: |-
- SELECT * INTO "backupDB"."dbo"."rollback_test_db" FROM (
- SELECT "t_alias".* FROM test AS t_alias WHERE t_alias.c1 = 1) AS backup_table;
+ SELECT * INTO [backupDB].[dbo].[rollback_test_db] FROM (
+ SELECT [t_alias].* FROM test AS t_alias WHERE t_alias.c1 = 1) AS backup_table;
sourceschema: dbo
sourcetablename: test
targettablename: rollback_test_db
@@ -55,8 +55,8 @@
WHERE t_alias.c1 = 1;
result:
- statement: |-
- SELECT * INTO "backupDB"."dbo"."rollback_test_db" FROM (
- SELECT "t_alias".* FROM test AS t_alias WHERE t_alias.c1 = 1) AS backup_table;
+ SELECT * INTO [backupDB].[dbo].[rollback_test_db] FROM (
+ SELECT [t_alias].* FROM test AS t_alias WHERE t_alias.c1 = 1) AS backup_table;
sourceschema: dbo
sourcetablename: test
targettablename: rollback_test_db
@@ -72,8 +72,8 @@
WHERE test.c1 = 1;
result:
- statement: |-
- SELECT * INTO "backupDB"."dbo"."rollback_test_db" FROM (
- SELECT "db"."dbo"."test".* FROM test JOIN test2 ON test.c1 = test2.c1 WHERE test.c1 = 1) AS backup_table;
+ SELECT * INTO [backupDB].[dbo].[rollback_test_db] FROM (
+ SELECT [db].[dbo].[test].* FROM test JOIN test2 ON test.c1 = test2.c1 WHERE test.c1 = 1) AS backup_table;
sourceschema: dbo
sourcetablename: test
targettablename: rollback_test_db
@@ -90,8 +90,8 @@
WHERE test.c1 = 1;
result:
- statement: |-
- SELECT * INTO "backupDB"."dbo"."rollback_test_db" FROM (
- SELECT "db"."dbo"."test".* FROM test JOIN test2 ON test.c1 = test2.c1 WHERE test.c1 = 1) AS backup_table;
+ SELECT * INTO [backupDB].[dbo].[rollback_test_db] FROM (
+ SELECT [db].[dbo].[test].* FROM test JOIN test2 ON test.c1 = test2.c1 WHERE test.c1 = 1) AS backup_table;
sourceschema: dbo
sourcetablename: test
targettablename: rollback_test_db
@@ -106,8 +106,8 @@
UPDATE test SET test.c1 = 2 WHERE test.c1 = 1;
result:
- statement: |-
- SELECT * INTO "backupDB"."dbo"."rollback_test1_db" FROM (
- SELECT "db"."dbo"."test1".* FROM test1 WHERE c1 = 1) AS backup_table;
+ SELECT * INTO [backupDB].[dbo].[rollback_test1_db] FROM (
+ SELECT [db].[dbo].[test1].* FROM test1 WHERE c1 = 1) AS backup_table;
sourceschema: dbo
sourcetablename: test1
targettablename: rollback_test1_db
@@ -118,8 +118,8 @@
line: 1
column: 30
- statement: |-
- SELECT * INTO "backupDB"."dbo"."rollback_test_db" FROM (
- SELECT "db"."dbo"."test".* FROM test WHERE test.c1 = 1) AS backup_table;
+ SELECT * INTO [backupDB].[dbo].[rollback_test_db] FROM (
+ SELECT [db].[dbo].[test].* FROM test WHERE test.c1 = 1) AS backup_table;
sourceschema: dbo
sourcetablename: test
targettablename: rollback_test_db
@@ -132,8 +132,8 @@
- input: DELETE FROM test WHERE c1 = 1;
result:
- statement: |-
- SELECT * INTO "backupDB"."dbo"."rollback_test_db" FROM (
- SELECT "db"."dbo"."test".* FROM test WHERE c1 = 1) AS backup_table;
+ SELECT * INTO [backupDB].[dbo].[rollback_test_db] FROM (
+ SELECT [db].[dbo].[test].* FROM test WHERE c1 = 1) AS backup_table;
sourceschema: dbo
sourcetablename: test
targettablename: rollback_test_db
@@ -146,8 +146,8 @@
- input: UPDATE test SET c1 = 1 WHERE c1=2;
result:
- statement: |-
- SELECT * INTO "backupDB"."dbo"."rollback_test_db" FROM (
- SELECT "db"."dbo"."test".* FROM test WHERE c1=2) AS backup_table;
+ SELECT * INTO [backupDB].[dbo].[rollback_test_db] FROM (
+ SELECT [db].[dbo].[test].* FROM test WHERE c1=2) AS backup_table;
sourceschema: dbo
sourcetablename: test
targettablename: rollback_test_db
@@ -162,10 +162,10 @@
UPDATE test SET test.c1 = 3 WHERE test.c1 = 5;
result:
- statement: |-
- SELECT * INTO "backupDB"."dbo"."rollback_test_db" FROM (
- SELECT "db"."dbo"."test".* FROM test WHERE test.c1 = 1
+ SELECT * INTO [backupDB].[dbo].[rollback_test_db] FROM (
+ SELECT [db].[dbo].[test].* FROM test WHERE test.c1 = 1
UNION
- SELECT "db"."dbo"."test".* FROM test WHERE test.c1 = 5) AS backup_table;
+ SELECT [db].[dbo].[test].* FROM test WHERE test.c1 = 5) AS backup_table;
sourceschema: dbo
sourcetablename: test
targettablename: rollback_test_db
@@ -175,3 +175,31 @@
endposition:
line: 2
column: 45
+- input: DELETE FROM employees WHERE department_id = 10;
+ result:
+ - statement: |-
+ SELECT * INTO [backupDB].[dbo].[rollback_employees_db] FROM (
+ SELECT [db].[dbo].[employees].* FROM employees WHERE department_id = 10) AS backup_table;
+ sourceschema: dbo
+ sourcetablename: employees
+ targettablename: rollback_employees_db
+ startposition:
+ line: 1
+ column: 0
+ endposition:
+ line: 1
+ column: 46
+- input: UPDATE positions SET title = 'Senior Engineer' WHERE position_id = 1;
+ result:
+ - statement: |-
+ SELECT * INTO [backupDB].[dbo].[rollback_positions_db] FROM (
+ SELECT [db].[dbo].[positions].* FROM positions WHERE position_id = 1) AS backup_table;
+ sourceschema: dbo
+ sourcetablename: positions
+ targettablename: rollback_positions_db
+ startposition:
+ line: 1
+ column: 0
+ endposition:
+ line: 1
+ column: 68