Skip to content

PostgreSQL backup tool with Point-In-Time-Recovery and restore verification

FEATURE (restores): Allow to exclude extensions over restore

Rostislav Duginc6261d434b17
diff --git a/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.go b/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.go
index b7c9e957..79e3db93 100644
--- a/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.go
+++ b/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.go
@@ -131,7 +131,8 @@ func (uc *CreatePostgresqlBackupUsecase) streamToStorage(
}
defer func() {
if pgpassFile != "" {
- _ = os.Remove(pgpassFile)
+ // Remove the entire temp directory (which contains the .pgpass file)
+ _ = os.RemoveAll(filepath.Dir(pgpassFile))
}
}()
diff --git a/backend/internal/features/databases/databases/postgresql/model.go b/backend/internal/features/databases/databases/postgresql/model.go
index d28d7497..83143883 100644
--- a/backend/internal/features/databases/databases/postgresql/model.go
+++ b/backend/internal/features/databases/databases/postgresql/model.go
@@ -34,6 +34,9 @@ type PostgresqlDatabase struct {
// backup settings
IncludeSchemas []string `json:"includeSchemas" gorm:"-"`
IncludeSchemasString string `json:"-" gorm:"column:include_schemas;type:text;not null;default:''"`
+
+ // restore settings (not saved to DB)
+ IsExcludeExtensions bool `json:"isExcludeExtensions" gorm:"-"`
}
func (p *PostgresqlDatabase) TableName() string {
diff --git a/backend/internal/features/restores/controller_test.go b/backend/internal/features/restores/controller_test.go
index 2d247da5..c02b74d3 100644
--- a/backend/internal/features/restores/controller_test.go
+++ b/backend/internal/features/restores/controller_test.go
@@ -171,6 +171,36 @@ func Test_RestoreBackup_WhenUserIsNotWorkspaceMember_ReturnsForbidden(t *testing
assert.Contains(t, string(testResp.Body), "insufficient permissions")
}
+func Test_RestoreBackup_WithIsExcludeExtensions_FlagPassedCorrectly(t *testing.T) {
+ router := createTestRouter()
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+
+ _, backup := createTestDatabaseWithBackupForRestore(workspace, owner, router)
+
+ request := RestoreBackupRequest{
+ PostgresqlDatabase: &postgresql.PostgresqlDatabase{
+ Version: tools.PostgresqlVersion16,
+ Host: "localhost",
+ Port: 5432,
+ Username: "postgres",
+ Password: "postgres",
+ IsExcludeExtensions: true,
+ },
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/restores/%s/restore", backup.ID.String()),
+ "Bearer "+owner.Token,
+ request,
+ http.StatusOK,
+ )
+
+ assert.Contains(t, string(testResp.Body), "restore started successfully")
+}
+
func Test_RestoreBackup_AuditLogWritten(t *testing.T) {
router := createTestRouter()
owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
diff --git a/backend/internal/features/restores/service.go b/backend/internal/features/restores/service.go
index c5f228c1..a30e9878 100644
--- a/backend/internal/features/restores/service.go
+++ b/backend/internal/features/restores/service.go
@@ -214,6 +214,11 @@ func (s *RestoreService) RestoreBackup(
return fmt.Errorf("failed to auto-detect database version: %w", err)
}
+ isExcludeExtensions := false
+ if requestDTO.PostgresqlDatabase != nil {
+ isExcludeExtensions = requestDTO.PostgresqlDatabase.IsExcludeExtensions
+ }
+
err = s.restoreBackupUsecase.Execute(
backupConfig,
restore,
@@ -221,6 +226,7 @@ func (s *RestoreService) RestoreBackup(
restoringToDB,
backup,
storage,
+ isExcludeExtensions,
)
if err != nil {
errMsg := err.Error()
diff --git a/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go b/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go
index ddedd1dd..968c31cd 100644
--- a/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go
+++ b/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go
@@ -42,6 +42,7 @@ func (uc *RestorePostgresqlBackupUsecase) Execute(
restore models.Restore,
backup *backups.Backup,
storage *storages.Storage,
+ isExcludeExtensions bool,
) error {
if originalDB.Type != databases.DatabaseTypePostgres {
return errors.New("database type not supported")
@@ -96,6 +97,7 @@ func (uc *RestorePostgresqlBackupUsecase) Execute(
backup,
storage,
pg,
+ isExcludeExtensions,
)
}
@@ -108,6 +110,7 @@ func (uc *RestorePostgresqlBackupUsecase) restoreFromStorage(
backup *backups.Backup,
storage *storages.Storage,
pgConfig *pgtypes.PostgresqlDatabase,
+ isExcludeExtensions bool,
) error {
uc.logger.Info(
"Restoring PostgreSQL backup from storage via temporary file",
@@ -115,6 +118,8 @@ func (uc *RestorePostgresqlBackupUsecase) restoreFromStorage(
pgBin,
"args",
args,
+ "isExcludeExtensions",
+ isExcludeExtensions,
)
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Minute)
@@ -171,6 +176,26 @@ func (uc *RestorePostgresqlBackupUsecase) restoreFromStorage(
}
defer cleanupFunc()
+ // If excluding extensions, generate filtered TOC list and use it
+ if isExcludeExtensions {
+ tocListFile, err := uc.generateFilteredTocList(
+ ctx,
+ pgBin,
+ tempBackupFile,
+ pgpassFile,
+ pgConfig,
+ )
+ if err != nil {
+ return fmt.Errorf("failed to generate filtered TOC list: %w", err)
+ }
+ defer func() {
+ _ = os.Remove(tocListFile)
+ }()
+
+ // Add -L flag to use the filtered list
+ args = append(args, "-L", tocListFile)
+ }
+
// Add the temporary backup file as the last argument to pg_restore
args = append(args, tempBackupFile)
@@ -554,6 +579,75 @@ func containsIgnoreCase(str, substr string) bool {
return strings.Contains(strings.ToLower(str), strings.ToLower(substr))
}
+// generateFilteredTocList generates a pg_restore TOC list file with extensions filtered out.
+// This is used when isExcludeExtensions is true to skip CREATE EXTENSION statements.
+func (uc *RestorePostgresqlBackupUsecase) generateFilteredTocList(
+ ctx context.Context,
+ pgBin string,
+ backupFile string,
+ pgpassFile string,
+ pgConfig *pgtypes.PostgresqlDatabase,
+) (string, error) {
+ uc.logger.Info("Generating filtered TOC list to exclude extensions", "backupFile", backupFile)
+
+ // Run pg_restore -l to get the TOC list
+ listCmd := exec.CommandContext(ctx, pgBin, "-l", backupFile)
+ uc.setupPgRestoreEnvironment(listCmd, pgpassFile, pgConfig)
+
+ tocOutput, err := listCmd.Output()
+ if err != nil {
+ return "", fmt.Errorf("failed to generate TOC list: %w", err)
+ }
+
+ // Filter out EXTENSION lines
+ var filteredLines []string
+ for _, line := range strings.Split(string(tocOutput), "\n") {
+ // Skip lines that contain EXTENSION (but not COMMENT ON EXTENSION)
+ // TOC format: "123; 1234 12345 EXTENSION - extension_name owner"
+ trimmedLine := strings.TrimSpace(line)
+ if trimmedLine == "" {
+ continue
+ }
+
+ // Check if this is an EXTENSION entry (not a comment about extension)
+ // Extension lines look like: "3420; 0 0 EXTENSION - uuid-ossp"
+ if strings.Contains(trimmedLine, " EXTENSION ") &&
+ !strings.Contains(strings.ToUpper(trimmedLine), "COMMENT") {
+ uc.logger.Info("Excluding extension from restore", "tocLine", trimmedLine)
+ continue
+ }
+
+ filteredLines = append(filteredLines, line)
+ }
+
+ // Write filtered TOC to temporary file
+ tocFile, err := os.CreateTemp("", "pg_restore_toc_*.list")
+ if err != nil {
+ return "", fmt.Errorf("failed to create TOC list file: %w", err)
+ }
+ tocFilePath := tocFile.Name()
+
+ filteredContent := strings.Join(filteredLines, "\n")
+ if _, err := tocFile.WriteString(filteredContent); err != nil {
+ _ = tocFile.Close()
+ _ = os.Remove(tocFilePath)
+ return "", fmt.Errorf("failed to write TOC list file: %w", err)
+ }
+
+ if err := tocFile.Close(); err != nil {
+ _ = os.Remove(tocFilePath)
+ return "", fmt.Errorf("failed to close TOC list file: %w", err)
+ }
+
+ uc.logger.Info("Generated filtered TOC list file",
+ "tocFile", tocFilePath,
+ "originalLines", len(strings.Split(string(tocOutput), "\n")),
+ "filteredLines", len(filteredLines),
+ )
+
+ return tocFilePath, nil
+}
+
// createTempPgpassFile creates a temporary .pgpass file with the given password
func (uc *RestorePostgresqlBackupUsecase) createTempPgpassFile(
pgConfig *pgtypes.PostgresqlDatabase,
diff --git a/backend/internal/features/restores/usecases/restore_backup_uc.go b/backend/internal/features/restores/usecases/restore_backup_uc.go
index 92fd16c7..2879e998 100644
--- a/backend/internal/features/restores/usecases/restore_backup_uc.go
+++ b/backend/internal/features/restores/usecases/restore_backup_uc.go
@@ -21,6 +21,7 @@ func (uc *RestoreBackupUsecase) Execute(
restoringToDB *databases.Database,
backup *backups.Backup,
storage *storages.Storage,
+ isExcludeExtensions bool,
) error {
if originalDB.Type == databases.DatabaseTypePostgres {
return uc.restorePostgresqlBackupUsecase.Execute(
@@ -30,6 +31,7 @@ func (uc *RestoreBackupUsecase) Execute(
restore,
backup,
storage,
+ isExcludeExtensions,
)
}
diff --git a/backend/internal/features/tests/postgresql_backup_restore_test.go b/backend/internal/features/tests/postgresql_backup_restore_test.go
index eb6272eb..a4930bc4 100644
--- a/backend/internal/features/tests/postgresql_backup_restore_test.go
+++ b/backend/internal/features/tests/postgresql_backup_restore_test.go
@@ -243,8 +243,186 @@ func Test_BackupAndRestoreSupabase_PublicSchemaOnly_RestoreIsSuccessful(t *testi
func Test_BackupPostgresql_SchemaSelection_AllSchemasWhenNoneSpecified(t *testing.T) {
env := config.GetEnv()
+ cases := []struct {
+ name string
+ version string
+ port string
+ }{
+ {"PostgreSQL 12", "12", env.TestPostgres12Port},
+ {"PostgreSQL 13", "13", env.TestPostgres13Port},
+ {"PostgreSQL 14", "14", env.TestPostgres14Port},
+ {"PostgreSQL 15", "15", env.TestPostgres15Port},
+ {"PostgreSQL 16", "16", env.TestPostgres16Port},
+ {"PostgreSQL 17", "17", env.TestPostgres17Port},
+ {"PostgreSQL 18", "18", env.TestPostgres18Port},
+ }
- container, err := connectToPostgresContainer("16", env.TestPostgres16Port)
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
+ testSchemaSelectionAllSchemasForVersion(t, tc.version, tc.port)
+ })
+ }
+}
+
+func Test_BackupAndRestorePostgresql_WithExcludeExtensions_RestoreIsSuccessful(t *testing.T) {
+ env := config.GetEnv()
+ cases := []struct {
+ name string
+ version string
+ port string
+ }{
+ {"PostgreSQL 12", "12", env.TestPostgres12Port},
+ {"PostgreSQL 13", "13", env.TestPostgres13Port},
+ {"PostgreSQL 14", "14", env.TestPostgres14Port},
+ {"PostgreSQL 15", "15", env.TestPostgres15Port},
+ {"PostgreSQL 16", "16", env.TestPostgres16Port},
+ {"PostgreSQL 17", "17", env.TestPostgres17Port},
+ {"PostgreSQL 18", "18", env.TestPostgres18Port},
+ }
+
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
+ testBackupRestoreWithExcludeExtensionsForVersion(t, tc.version, tc.port)
+ })
+ }
+}
+
+func Test_BackupAndRestorePostgresql_WithoutExcludeExtensions_ExtensionsAreRecovered(t *testing.T) {
+ env := config.GetEnv()
+ cases := []struct {
+ name string
+ version string
+ port string
+ }{
+ {"PostgreSQL 12", "12", env.TestPostgres12Port},
+ {"PostgreSQL 13", "13", env.TestPostgres13Port},
+ {"PostgreSQL 14", "14", env.TestPostgres14Port},
+ {"PostgreSQL 15", "15", env.TestPostgres15Port},
+ {"PostgreSQL 16", "16", env.TestPostgres16Port},
+ {"PostgreSQL 17", "17", env.TestPostgres17Port},
+ {"PostgreSQL 18", "18", env.TestPostgres18Port},
+ }
+
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
+ testBackupRestoreWithoutExcludeExtensionsForVersion(t, tc.version, tc.port)
+ })
+ }
+}
+
+func Test_BackupPostgresql_SchemaSelection_OnlySpecifiedSchemas(t *testing.T) {
+ env := config.GetEnv()
+ cases := []struct {
+ name string
+ version string
+ port string
+ }{
+ {"PostgreSQL 12", "12", env.TestPostgres12Port},
+ {"PostgreSQL 13", "13", env.TestPostgres13Port},
+ {"PostgreSQL 14", "14", env.TestPostgres14Port},
+ {"PostgreSQL 15", "15", env.TestPostgres15Port},
+ {"PostgreSQL 16", "16", env.TestPostgres16Port},
+ {"PostgreSQL 17", "17", env.TestPostgres17Port},
+ {"PostgreSQL 18", "18", env.TestPostgres18Port},
+ }
+
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
+ testSchemaSelectionOnlySpecifiedSchemasForVersion(t, tc.version, tc.port)
+ })
+ }
+}
+
+func testBackupRestoreForVersion(t *testing.T, pgVersion string, port string) {
+ container, err := connectToPostgresContainer(pgVersion, port)
+ assert.NoError(t, err)
+ defer func() {
+ if container.DB != nil {
+ container.DB.Close()
+ }
+ }()
+
+ _, err = container.DB.Exec(createAndFillTableQuery)
+ assert.NoError(t, err)
+
+ router := createTestRouter()
+ user := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+
+ storage := storages.CreateTestStorage(workspace.ID)
+
+ database := createDatabaseViaAPI(
+ t, router, "Test Database", workspace.ID,
+ container.Host, container.Port,
+ container.Username, container.Password, container.Database,
+ user.Token,
+ )
+
+ enableBackupsViaAPI(
+ t, router, database.ID, storage.ID,
+ backups_config.BackupEncryptionNone, user.Token,
+ )
+
+ createBackupViaAPI(t, router, database.ID, user.Token)
+
+ backup := waitForBackupCompletion(t, router, database.ID, user.Token, 5*time.Minute)
+ assert.Equal(t, backups.BackupStatusCompleted, backup.Status)
+
+ newDBName := "restoreddb"
+ _, err = container.DB.Exec(fmt.Sprintf("DROP DATABASE IF EXISTS %s;", newDBName))
+ assert.NoError(t, err)
+
+ _, err = container.DB.Exec(fmt.Sprintf("CREATE DATABASE %s;", newDBName))
+ assert.NoError(t, err)
+
+ newDSN := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
+ container.Host, container.Port, container.Username, container.Password, newDBName)
+ newDB, err := sqlx.Connect("postgres", newDSN)
+ assert.NoError(t, err)
+ defer newDB.Close()
+
+ createRestoreViaAPI(
+ t, router, backup.ID,
+ container.Host, container.Port,
+ container.Username, container.Password, newDBName,
+ user.Token,
+ )
+
+ restore := waitForRestoreCompletion(t, router, backup.ID, user.Token, 5*time.Minute)
+ assert.Equal(t, restores_enums.RestoreStatusCompleted, restore.Status)
+
+ var tableExists bool
+ err = newDB.Get(
+ &tableExists,
+ "SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'test_data')",
+ )
+ assert.NoError(t, err)
+ assert.True(t, tableExists, "Table 'test_data' should exist in restored database")
+
+ verifyDataIntegrity(t, container.DB, newDB)
+
+ err = os.Remove(filepath.Join(config.GetEnv().DataFolder, backup.ID.String()))
+ if err != nil {
+ t.Logf("Warning: Failed to delete backup file: %v", err)
+ }
+
+ test_utils.MakeDeleteRequest(
+ t,
+ router,
+ "/api/v1/databases/"+database.ID.String(),
+ "Bearer "+user.Token,
+ http.StatusNoContent,
+ )
+ storages.RemoveTestStorage(storage.ID)
+ workspaces_testing.RemoveTestWorkspace(workspace, router)
+}
+
+func testSchemaSelectionAllSchemasForVersion(t *testing.T, pgVersion string, port string) {
+ container, err := connectToPostgresContainer(pgVersion, port)
assert.NoError(t, err)
defer container.DB.Close()
@@ -296,7 +474,7 @@ func Test_BackupPostgresql_SchemaSelection_AllSchemasWhenNoneSpecified(t *testin
backup := waitForBackupCompletion(t, router, database.ID, user.Token, 5*time.Minute)
assert.Equal(t, backups.BackupStatusCompleted, backup.Status)
- newDBName := "restored_all_schemas"
+ newDBName := "restored_all_schemas_" + pgVersion
_, err = container.DB.Exec(fmt.Sprintf("DROP DATABASE IF EXISTS %s;", newDBName))
assert.NoError(t, err)
@@ -365,48 +543,44 @@ func Test_BackupPostgresql_SchemaSelection_AllSchemasWhenNoneSpecified(t *testin
workspaces_testing.RemoveTestWorkspace(workspace, router)
}
-func Test_BackupPostgresql_SchemaSelection_OnlySpecifiedSchemas(t *testing.T) {
- env := config.GetEnv()
-
- container, err := connectToPostgresContainer("16", env.TestPostgres16Port)
+func testBackupRestoreWithExcludeExtensionsForVersion(t *testing.T, pgVersion string, port string) {
+ container, err := connectToPostgresContainer(pgVersion, port)
assert.NoError(t, err)
defer container.DB.Close()
+ // Create table with uuid-ossp extension
_, err = container.DB.Exec(`
- DROP SCHEMA IF EXISTS schema_a CASCADE;
- DROP SCHEMA IF EXISTS schema_b CASCADE;
- CREATE SCHEMA schema_a;
- CREATE SCHEMA schema_b;
+ DROP EXTENSION IF EXISTS "uuid-ossp" CASCADE;
+ CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
- CREATE TABLE public.public_table (id SERIAL PRIMARY KEY, data TEXT);
- CREATE TABLE schema_a.table_a (id SERIAL PRIMARY KEY, data TEXT);
- CREATE TABLE schema_b.table_b (id SERIAL PRIMARY KEY, data TEXT);
+ DROP TABLE IF EXISTS test_extension_data;
+ CREATE TABLE test_extension_data (
+ id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+ name TEXT NOT NULL,
+ created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+ );
- INSERT INTO public.public_table (data) VALUES ('public_data');
- INSERT INTO schema_a.table_a (data) VALUES ('schema_a_data');
- INSERT INTO schema_b.table_b (data) VALUES ('schema_b_data');
+ INSERT INTO test_extension_data (name) VALUES ('test1'), ('test2'), ('test3');
`)
assert.NoError(t, err)
defer func() {
_, _ = container.DB.Exec(`
- DROP TABLE IF EXISTS public.public_table;
- DROP SCHEMA IF EXISTS schema_a CASCADE;
- DROP SCHEMA IF EXISTS schema_b CASCADE;
+ DROP TABLE IF EXISTS test_extension_data;
+ DROP EXTENSION IF EXISTS "uuid-ossp" CASCADE;
`)
}()
router := createTestRouter()
user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Schema Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace("Extension Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
- database := createDatabaseWithSchemasViaAPI(
- t, router, "Specific Schemas Database", workspace.ID,
+ database := createDatabaseViaAPI(
+ t, router, "Extension Test Database", workspace.ID,
container.Host, container.Port,
container.Username, container.Password, container.Database,
- []string{"public", "schema_a"},
user.Token,
)
@@ -420,7 +594,8 @@ func Test_BackupPostgresql_SchemaSelection_OnlySpecifiedSchemas(t *testing.T) {
backup := waitForBackupCompletion(t, router, database.ID, user.Token, 5*time.Minute)
assert.Equal(t, backups.BackupStatusCompleted, backup.Status)
- newDBName := "restored_specific_schemas"
+ // Create new database for restore with extension pre-installed
+ newDBName := "restored_exclude_ext_" + pgVersion
_, err = container.DB.Exec(fmt.Sprintf("DROP DATABASE IF EXISTS %s;", newDBName))
assert.NoError(t, err)
@@ -433,46 +608,191 @@ func Test_BackupPostgresql_SchemaSelection_OnlySpecifiedSchemas(t *testing.T) {
assert.NoError(t, err)
defer newDB.Close()
- createRestoreViaAPI(
+ // Pre-install the extension in the target database (simulating managed service behavior)
+ _, err = newDB.Exec(`CREATE EXTENSION IF NOT EXISTS "uuid-ossp";`)
+ assert.NoError(t, err)
+
+ // Restore with isExcludeExtensions=true
+ createRestoreWithOptionsViaAPI(
t, router, backup.ID,
container.Host, container.Port,
container.Username, container.Password, newDBName,
+ true, // isExcludeExtensions
user.Token,
)
restore := waitForRestoreCompletion(t, router, backup.ID, user.Token, 5*time.Minute)
assert.Equal(t, restores_enums.RestoreStatusCompleted, restore.Status)
- var publicTableExists bool
- err = newDB.Get(&publicTableExists, `
+ // Verify the table was restored
+ var tableExists bool
+ err = newDB.Get(&tableExists, `
SELECT EXISTS (
SELECT FROM information_schema.tables
- WHERE table_schema = 'public' AND table_name = 'public_table'
+ WHERE table_schema = 'public' AND table_name = 'test_extension_data'
)
`)
assert.NoError(t, err)
- assert.True(t, publicTableExists, "public.public_table should exist (was included)")
+ assert.True(t, tableExists, "test_extension_data should exist in restored database")
- var schemaATableExists bool
- err = newDB.Get(&schemaATableExists, `
+ // Verify data was restored
+ var count int
+ err = newDB.Get(&count, `SELECT COUNT(*) FROM test_extension_data`)
+ assert.NoError(t, err)
+ assert.Equal(t, 3, count, "Should have 3 rows after restore")
+
+ // Verify extension still works (uuid_generate_v4 should work)
+ var newUUID string
+ err = newDB.Get(&newUUID, `SELECT uuid_generate_v4()::text`)
+ assert.NoError(t, err)
+ assert.NotEmpty(t, newUUID, "uuid_generate_v4 should work")
+
+ // Cleanup
+ err = os.Remove(filepath.Join(config.GetEnv().DataFolder, backup.ID.String()))
+ if err != nil {
+ t.Logf("Warning: Failed to delete backup file: %v", err)
+ }
+
+ test_utils.MakeDeleteRequest(
+ t,
+ router,
+ "/api/v1/databases/"+database.ID.String(),
+ "Bearer "+user.Token,
+ http.StatusNoContent,
+ )
+ storages.RemoveTestStorage(storage.ID)
+ workspaces_testing.RemoveTestWorkspace(workspace, router)
+}
+
+func testBackupRestoreWithoutExcludeExtensionsForVersion(
+ t *testing.T,
+ pgVersion string,
+ port string,
+) {
+ container, err := connectToPostgresContainer(pgVersion, port)
+ assert.NoError(t, err)
+ defer container.DB.Close()
+
+ // Create table with uuid-ossp extension
+ _, err = container.DB.Exec(`
+ DROP EXTENSION IF EXISTS "uuid-ossp" CASCADE;
+ CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+ DROP TABLE IF EXISTS test_extension_recovery;
+ CREATE TABLE test_extension_recovery (
+ id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+ name TEXT NOT NULL,
+ created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+ );
+
+ INSERT INTO test_extension_recovery (name) VALUES ('test1'), ('test2'), ('test3');
+ `)
+ assert.NoError(t, err)
+
+ defer func() {
+ _, _ = container.DB.Exec(`
+ DROP TABLE IF EXISTS test_extension_recovery;
+ DROP EXTENSION IF EXISTS "uuid-ossp" CASCADE;
+ `)
+ }()
+
+ router := createTestRouter()
+ user := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(
+ "Extension Recovery Test Workspace",
+ user,
+ router,
+ )
+
+ storage := storages.CreateTestStorage(workspace.ID)
+
+ database := createDatabaseViaAPI(
+ t, router, "Extension Recovery Test Database", workspace.ID,
+ container.Host, container.Port,
+ container.Username, container.Password, container.Database,
+ user.Token,
+ )
+
+ enableBackupsViaAPI(
+ t, router, database.ID, storage.ID,
+ backups_config.BackupEncryptionNone, user.Token,
+ )
+
+ createBackupViaAPI(t, router, database.ID, user.Token)
+
+ backup := waitForBackupCompletion(t, router, database.ID, user.Token, 5*time.Minute)
+ assert.Equal(t, backups.BackupStatusCompleted, backup.Status)
+
+ // Create new database for restore WITHOUT pre-installed extension
+ newDBName := "restored_with_ext_" + pgVersion
+ _, err = container.DB.Exec(fmt.Sprintf("DROP DATABASE IF EXISTS %s;", newDBName))
+ assert.NoError(t, err)
+
+ _, err = container.DB.Exec(fmt.Sprintf("CREATE DATABASE %s;", newDBName))
+ assert.NoError(t, err)
+
+ newDSN := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
+ container.Host, container.Port, container.Username, container.Password, newDBName)
+ newDB, err := sqlx.Connect("postgres", newDSN)
+ assert.NoError(t, err)
+ defer newDB.Close()
+
+ // Verify extension does NOT exist before restore
+ var extensionExistsBefore bool
+ err = newDB.Get(&extensionExistsBefore, `
SELECT EXISTS (
- SELECT FROM information_schema.tables
- WHERE table_schema = 'schema_a' AND table_name = 'table_a'
+ SELECT FROM pg_extension WHERE extname = 'uuid-ossp'
)
`)
assert.NoError(t, err)
- assert.True(t, schemaATableExists, "schema_a.table_a should exist (was included)")
+ assert.False(t, extensionExistsBefore, "Extension should NOT exist before restore")
- var schemaBTableExists bool
- err = newDB.Get(&schemaBTableExists, `
+ // Restore with isExcludeExtensions=false (extensions should be recovered)
+ createRestoreWithOptionsViaAPI(
+ t, router, backup.ID,
+ container.Host, container.Port,
+ container.Username, container.Password, newDBName,
+ false, // isExcludeExtensions = false means extensions ARE included
+ user.Token,
+ )
+
+ restore := waitForRestoreCompletion(t, router, backup.ID, user.Token, 5*time.Minute)
+ assert.Equal(t, restores_enums.RestoreStatusCompleted, restore.Status)
+
+ // Verify the extension was recovered
+ var extensionExists bool
+ err = newDB.Get(&extensionExists, `
+ SELECT EXISTS (
+ SELECT FROM pg_extension WHERE extname = 'uuid-ossp'
+ )
+ `)
+ assert.NoError(t, err)
+ assert.True(t, extensionExists, "Extension 'uuid-ossp' should be recovered during restore")
+
+ // Verify the table was restored
+ var tableExists bool
+ err = newDB.Get(&tableExists, `
SELECT EXISTS (
SELECT FROM information_schema.tables
- WHERE table_schema = 'schema_b' AND table_name = 'table_b'
+ WHERE table_schema = 'public' AND table_name = 'test_extension_recovery'
)
`)
assert.NoError(t, err)
- assert.False(t, schemaBTableExists, "schema_b.table_b should NOT exist (was excluded)")
+ assert.True(t, tableExists, "test_extension_recovery should exist in restored database")
+
+ // Verify data was restored
+ var count int
+ err = newDB.Get(&count, `SELECT COUNT(*) FROM test_extension_recovery`)
+ assert.NoError(t, err)
+ assert.Equal(t, 3, count, "Should have 3 rows after restore")
+ // Verify extension works (uuid_generate_v4 should work)
+ var newUUID string
+ err = newDB.Get(&newUUID, `SELECT uuid_generate_v4()::text`)
+ assert.NoError(t, err)
+ assert.NotEmpty(t, newUUID, "uuid_generate_v4 should work after extension recovery")
+
+ // Cleanup
err = os.Remove(filepath.Join(config.GetEnv().DataFolder, backup.ID.String()))
if err != nil {
t.Logf("Warning: Failed to delete backup file: %v", err)
@@ -489,28 +809,50 @@ func Test_BackupPostgresql_SchemaSelection_OnlySpecifiedSchemas(t *testing.T) {
workspaces_testing.RemoveTestWorkspace(workspace, router)
}
-func testBackupRestoreForVersion(t *testing.T, pgVersion string, port string) {
+func testSchemaSelectionOnlySpecifiedSchemasForVersion(
+ t *testing.T,
+ pgVersion string,
+ port string,
+) {
container, err := connectToPostgresContainer(pgVersion, port)
assert.NoError(t, err)
- defer func() {
- if container.DB != nil {
- container.DB.Close()
- }
- }()
+ defer container.DB.Close()
- _, err = container.DB.Exec(createAndFillTableQuery)
+ _, err = container.DB.Exec(`
+ DROP SCHEMA IF EXISTS schema_a CASCADE;
+ DROP SCHEMA IF EXISTS schema_b CASCADE;
+ CREATE SCHEMA schema_a;
+ CREATE SCHEMA schema_b;
+
+ CREATE TABLE public.public_table (id SERIAL PRIMARY KEY, data TEXT);
+ CREATE TABLE schema_a.table_a (id SERIAL PRIMARY KEY, data TEXT);
+ CREATE TABLE schema_b.table_b (id SERIAL PRIMARY KEY, data TEXT);
+
+ INSERT INTO public.public_table (data) VALUES ('public_data');
+ INSERT INTO schema_a.table_a (data) VALUES ('schema_a_data');
+ INSERT INTO schema_b.table_b (data) VALUES ('schema_b_data');
+ `)
assert.NoError(t, err)
+ defer func() {
+ _, _ = container.DB.Exec(`
+ DROP TABLE IF EXISTS public.public_table;
+ DROP SCHEMA IF EXISTS schema_a CASCADE;
+ DROP SCHEMA IF EXISTS schema_b CASCADE;
+ `)
+ }()
+
router := createTestRouter()
user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace("Schema Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
- database := createDatabaseViaAPI(
- t, router, "Test Database", workspace.ID,
+ database := createDatabaseWithSchemasViaAPI(
+ t, router, "Specific Schemas Database", workspace.ID,
container.Host, container.Port,
container.Username, container.Password, container.Database,
+ []string{"public", "schema_a"},
user.Token,
)
@@ -524,7 +866,7 @@ func testBackupRestoreForVersion(t *testing.T, pgVersion string, port string) {
backup := waitForBackupCompletion(t, router, database.ID, user.Token, 5*time.Minute)
assert.Equal(t, backups.BackupStatusCompleted, backup.Status)
- newDBName := "restoreddb"
+ newDBName := "restored_specific_schemas_" + pgVersion
_, err = container.DB.Exec(fmt.Sprintf("DROP DATABASE IF EXISTS %s;", newDBName))
assert.NoError(t, err)
@@ -547,15 +889,35 @@ func testBackupRestoreForVersion(t *testing.T, pgVersion string, port string) {
restore := waitForRestoreCompletion(t, router, backup.ID, user.Token, 5*time.Minute)
assert.Equal(t, restores_enums.RestoreStatusCompleted, restore.Status)
- var tableExists bool
- err = newDB.Get(
- &tableExists,
- "SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'test_data')",
- )
+ var publicTableExists bool
+ err = newDB.Get(&publicTableExists, `
+ SELECT EXISTS (
+ SELECT FROM information_schema.tables
+ WHERE table_schema = 'public' AND table_name = 'public_table'
+ )
+ `)
assert.NoError(t, err)
- assert.True(t, tableExists, "Table 'test_data' should exist in restored database")
+ assert.True(t, publicTableExists, "public.public_table should exist (was included)")
- verifyDataIntegrity(t, container.DB, newDB)
+ var schemaATableExists bool
+ err = newDB.Get(&schemaATableExists, `
+ SELECT EXISTS (
+ SELECT FROM information_schema.tables
+ WHERE table_schema = 'schema_a' AND table_name = 'table_a'
+ )
+ `)
+ assert.NoError(t, err)
+ assert.True(t, schemaATableExists, "schema_a.table_a should exist (was included)")
+
+ var schemaBTableExists bool
+ err = newDB.Get(&schemaBTableExists, `
+ SELECT EXISTS (
+ SELECT FROM information_schema.tables
+ WHERE table_schema = 'schema_b' AND table_name = 'table_b'
+ )
+ `)
+ assert.NoError(t, err)
+ assert.False(t, schemaBTableExists, "schema_b.table_b should NOT exist (was excluded)")
err = os.Remove(filepath.Join(config.GetEnv().DataFolder, backup.ID.String()))
if err != nil {
@@ -852,14 +1214,41 @@ func createRestoreViaAPI(
password string,
database string,
token string,
+) {
+ createRestoreWithOptionsViaAPI(
+ t,
+ router,
+ backupID,
+ host,
+ port,
+ username,
+ password,
+ database,
+ false,
+ token,
+ )
+}
+
+func createRestoreWithOptionsViaAPI(
+ t *testing.T,
+ router *gin.Engine,
+ backupID uuid.UUID,
+ host string,
+ port int,
+ username string,
+ password string,
+ database string,
+ isExcludeExtensions bool,
+ token string,
) {
request := restores.RestoreBackupRequest{
PostgresqlDatabase: &pgtypes.PostgresqlDatabase{
- Host: host,
- Port: port,
- Username: username,
- Password: password,
- Database: &database,
+ Host: host,
+ Port: port,
+ Username: username,
+ Password: password,
+ Database: &database,
+ IsExcludeExtensions: isExcludeExtensions,
},
}
diff --git a/frontend/src/entity/databases/model/postgresql/PostgresqlDatabase.ts b/frontend/src/entity/databases/model/postgresql/PostgresqlDatabase.ts
index 0e0fe8d1..6f14fbc8 100644
--- a/frontend/src/entity/databases/model/postgresql/PostgresqlDatabase.ts
+++ b/frontend/src/entity/databases/model/postgresql/PostgresqlDatabase.ts
@@ -14,4 +14,7 @@ export interface PostgresqlDatabase {
// backup settings
includeSchemas?: string[];
+
+ // restore settings (not saved to DB)
+ isExcludeExtensions?: boolean;
}
diff --git a/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsx b/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsx
index 74dcaad2..5562b116 100644
--- a/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsx
+++ b/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsx
@@ -1,5 +1,5 @@
-import { CopyOutlined, DownOutlined, UpOutlined } from '@ant-design/icons';
-import { App, Button, Input, InputNumber, Select, Switch } from 'antd';
+import { CopyOutlined, DownOutlined, InfoCircleOutlined, UpOutlined } from '@ant-design/icons';
+import { App, Button, Checkbox, Input, InputNumber, Select, Switch, Tooltip } from 'antd';
import { useEffect, useState } from 'react';
import { type Database, DatabaseType, databaseApi } from '../../../../entity/databases';
@@ -20,6 +20,7 @@ interface Props {
onSaved: (database: Database) => void;
isShowDbName?: boolean;
+ isRestoreMode?: boolean;
}
export const EditDatabaseSpecificDataComponent = ({
@@ -35,6 +36,7 @@ export const EditDatabaseSpecificDataComponent = ({
isSaveToApi,
onSaved,
isShowDbName = true,
+ isRestoreMode = false,
}: Props) => {
const { message } = App.useApp();
@@ -45,7 +47,8 @@ export const EditDatabaseSpecificDataComponent = ({
const [isTestingConnection, setIsTestingConnection] = useState(false);
const [isConnectionFailed, setIsConnectionFailed] = useState(false);
- const hasAdvancedValues = !!database.postgresql?.includeSchemas?.length;
+ const hasAdvancedValues =
+ !!database.postgresql?.includeSchemas?.length || !!database.postgresql?.isExcludeExtensions;
const [isShowAdvanced, setShowAdvanced] = useState(hasAdvancedValues);
const [hasAutoAddedPublicSchema, setHasAutoAddedPublicSchema] = useState(false);
@@ -366,25 +369,60 @@ export const EditDatabaseSpecificDataComponent = ({
</div>
{isShowAdvanced && (
- <div className="mb-1 flex w-full items-center">
- <div className="min-w-[150px]">Include schemas</div>
- <Select
- mode="tags"
- value={editingDatabase.postgresql?.includeSchemas || []}
- onChange={(values) => {
- if (!editingDatabase.postgresql) return;
+ <>
+ {!isRestoreMode && (
+ <div className="mb-1 flex w-full items-center">
+ <div className="min-w-[150px]">Include schemas</div>
+ <Select
+ mode="tags"
+ value={editingDatabase.postgresql?.includeSchemas || []}
+ onChange={(values) => {
+ if (!editingDatabase.postgresql) return;
+
+ setEditingDatabase({
+ ...editingDatabase,
+ postgresql: { ...editingDatabase.postgresql, includeSchemas: values },
+ });
+ }}
+ size="small"
+ className="max-w-[200px] grow"
+ placeholder="All schemas (default)"
+ tokenSeparators={[',']}
+ />
+ </div>
+ )}
- setEditingDatabase({
- ...editingDatabase,
- postgresql: { ...editingDatabase.postgresql, includeSchemas: values },
- });
- }}
- size="small"
- className="max-w-[200px] grow"
- placeholder="All schemas (default)"
- tokenSeparators={[',']}
- />
- </div>
+ {isRestoreMode && (
+ <div className="mb-1 flex w-full items-center">
+ <div className="min-w-[150px]">Exclude extensions</div>
+ <div className="flex items-center">
+ <Checkbox
+ checked={editingDatabase.postgresql?.isExcludeExtensions || false}
+ onChange={(e) => {
+ if (!editingDatabase.postgresql) return;
+
+ setEditingDatabase({
+ ...editingDatabase,
+ postgresql: {
+ ...editingDatabase.postgresql,
+ isExcludeExtensions: e.target.checked,
+ },
+ });
+ }}
+ >
+ Skip extensions
+ </Checkbox>
+
+ <Tooltip
+ className="cursor-pointer"
+ title="Skip restoring extension definitions (CREATE EXTENSION statements). Enable this if you're restoring to a managed PostgreSQL service where extensions are managed by the provider."
+ >
+ <InfoCircleOutlined className="ml-2" style={{ color: 'gray' }} />
+ </Tooltip>
+ </div>
+ </div>
+ )}
+ </>
)}
</>
)}
diff --git a/frontend/src/features/restores/ui/RestoresComponent.tsx b/frontend/src/features/restores/ui/RestoresComponent.tsx
index 6631ed03..3be30e73 100644
--- a/frontend/src/features/restores/ui/RestoresComponent.tsx
+++ b/frontend/src/features/restores/ui/RestoresComponent.tsx
@@ -111,6 +111,7 @@ export const RestoresComponent = ({ database, backup }: Props) => {
setEditingDatabase({ ...database });
restore(database);
}}
+ isRestoreMode={true}
/>
</>
);
@@ -245,6 +246,13 @@ export const RestoresComponent = ({ database, backup }: Props) => {
</Button>
}
>
+ {showingRestoreError.failMessage?.includes('must be owner of extension') && (
+ <div className="mb-4 rounded border border-yellow-300 bg-yellow-50 p-3 text-sm dark:border-yellow-600 dark:bg-yellow-900/30">
+ <strong>💡 Tip:</strong> This error typically occurs when restoring to managed
+ PostgreSQL services (like Yandex Cloud, AWS RDS or similar). Try enabling{' '}
+ <strong>&quot;Exclude extensions&quot;</strong> in Advanced settings before restoring.
+ </div>
+ )}
<div className="overflow-y-auto text-sm whitespace-pre-wrap" style={{ height: '400px' }}>
{showingRestoreError.failMessage}
</div>