public void RestoreDatabase(String databaseName, String filePath, String serverName, String userName, String password, String dataFilePath, String logFilePath) { try { Restore sqlRestore = new Restore(); BackupDeviceItem deviceItem = new BackupDeviceItem(filePath, DeviceType.File); sqlRestore.Devices.Add(deviceItem); sqlRestore.Database = databaseName; ServerConnection connection = new ServerConnection(serverName, userName, password); Server sqlServer = new Server(connection); Database db = sqlServer.Databases[databaseName]; sqlRestore.Action = RestoreActionType.Database; String dataFileLocation = dataFilePath + databaseName + ".mdf"; String logFileLocation = logFilePath + databaseName + "_Log.ldf"; db = sqlServer.Databases[databaseName]; RelocateFile rf = new RelocateFile(databaseName, dataFileLocation); sqlRestore.RelocateFiles.Add(new RelocateFile(databaseName, dataFileLocation)); sqlRestore.RelocateFiles.Add(new RelocateFile(databaseName + "_log", logFileLocation)); sqlRestore.ReplaceDatabase = true; sqlRestore.Complete += new ServerMessageEventHandler(sqlRestore_Complete); sqlRestore.PercentCompleteNotification = 10; sqlRestore.PercentComplete += new PercentCompleteEventHandler(sqlRestore_PercentComplete); sqlRestore.SqlRestore(sqlServer); db = sqlServer.Databases[databaseName]; db.SetOnline(); sqlServer.Refresh(); } catch (SqlServerManagementException ex) { ex.Message.ToString(); } }
public void RestoreDatabase(String databaseName, String filePath, String serverName, String userName, String password, String dataFilePath, String logFilePath) { WriteLogFile("Start DB Restore: " + DateTime.Now.ToString()); WriteLogFile("dataFilePath: " + dataFilePath + " logFilePath " + logFilePath); // Create Restore instance Restore sqlRestore = new Restore(); // Point to database BackupDeviceItem deviceItem = new BackupDeviceItem(filePath, DeviceType.File); sqlRestore.Devices.Add(deviceItem); sqlRestore.Database = databaseName; // Connect to DB Server ServerConnection connection; if (userName == "") // for Windows Authentication { SqlConnection sqlCon = new SqlConnection(@"Data Source=" + serverName + @"; Integrated Security=True;"); connection = new ServerConnection(sqlCon); } else // for Server Authentication { connection = new ServerConnection(serverName, userName, password); } // Restoring Server sqlServer = new Server(connection); Database db = sqlServer.Databases[databaseName]; sqlRestore.Action = RestoreActionType.Database; String dataFileLocation = dataFilePath + databaseName + ".mdf"; String logFileLocation = logFilePath + databaseName + "_log.ldf"; db = sqlServer.Databases[databaseName]; RelocateFile rf = new RelocateFile(databaseName, dataFileLocation); sqlRestore.RelocateFiles.Add(new RelocateFile(databaseName + "", dataFileLocation)); sqlRestore.RelocateFiles.Add(new RelocateFile(databaseName + "_log", logFileLocation)); sqlRestore.ReplaceDatabase = true; sqlRestore.PercentCompleteNotification = 10; sqlRestore.PercentComplete += new PercentCompleteEventHandler(myRestore_PercentComplete); sqlRestore.Complete += new ServerMessageEventHandler(myRestore_Complete); try { sqlRestore.SqlRestore(sqlServer); db = sqlServer.Databases[databaseName]; db.SetOnline(); } catch (Exception ex) { WriteLogFile("error on restore " + ex.Message); MessageBox.Show("Error occurred on db restore. LogFile: " + DYLogFile); } sqlServer.Refresh(); }
private void RollbackUpgrade(Server server, String databaseName) { if (backupFilePath != null) { Logger.DebugFormat("Restoring database from '{0}'.", backupFilePath); var db = server.Databases[databaseName]; server.KillAllProcesses(databaseName); Restore restoreDB = new Restore(); restoreDB.Database = databaseName; /* Specify whether you want to restore database, files or log */ restoreDB.Action = RestoreActionType.Database; restoreDB.Devices.AddDevice(backupFilePath, DeviceType.File); restoreDB.ReplaceDatabase = true; restoreDB.NoRecovery = false; restoreDB.PercentComplete += restoreDB_PercentComplete; restoreDB.Complete += restoreDB_Complete; restoreDB.SqlRestore(server); } }
public void RestoreDatabase(SqlConnectionStringBuilder sqlConnection, String backUpFile) { ServerConnection serverConnection = null; try { if (!FileManager.FileExists(backUpFile)) { throw new FileNotFoundException(); } serverConnection = new ServerConnection(sqlConnection.DataSource, sqlConnection.UserID, sqlConnection.Password); Server sqlServer = new Server(serverConnection); Restore restoreDatabase = new Restore() { Action = RestoreActionType.Database, Database = sqlConnection.InitialCatalog, }; BackupDeviceItem backupItem = new BackupDeviceItem(backUpFile, DeviceType.File); restoreDatabase.Devices.Add(backupItem); restoreDatabase.ReplaceDatabase = true; restoreDatabase.SqlRestore(sqlServer); } finally { if (serverConnection != null && serverConnection.IsOpen) { serverConnection.Disconnect(); } } }
private void barButtonItem28_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e) { bool check = checkUser("ReturnBackUp", "User_BackUp"); if (check == true) { Server server = new Server(@".\SQLEXPRESS"); Microsoft.SqlServer.Management.Smo.Database db = server.Databases["Sales_System"]; if (db != null) { server.KillAllProcesses(db.Name); } Restore restore = new Restore(); restore.Database = db.Name; restore.Action = RestoreActionType.Database; OpenFileDialog open = new OpenFileDialog(); open.Filter = "BackUp Files (*.Back) | *.back"; if (open.ShowDialog() == DialogResult.OK) { restore.Devices.AddDevice(open.FileName, DeviceType.File); restore.ReplaceDatabase = true; restore.NoRecovery = false; restore.SqlRestore(server); MessageBox.Show("تم استرجاع السنخه الاحتياطية بنجاح", "تاكيد"); } } }
private static void RestoreDB(ServerConnection connection, string dbName, string backupPath) { Server smoServer = new Server(connection); Database db = smoServer.Databases[dbName]; if (db == null) { db = new Database(smoServer, dbName); db.Create(); db.Refresh(); } Restore restore = new Restore(); BackupDeviceItem deviceItem = new BackupDeviceItem(backupPath, DeviceType.File); restore.Devices.Add(deviceItem); restore.Database = dbName; restore.Action = RestoreActionType.Database; restore.ReplaceDatabase = true; restore.NoRecovery = false; var mdfPath = $"{smoServer.DefaultFile}{dbName}.mdf"; var ldfPath = $"{smoServer.DefaultFile}{dbName}_log.ldf"; System.Data.DataTable logicalRestoreFiles = restore.ReadFileList(smoServer); restore.RelocateFiles.Add(new RelocateFile(logicalRestoreFiles.Rows[0][0].ToString(), mdfPath)); restore.RelocateFiles.Add(new RelocateFile(logicalRestoreFiles.Rows[1][0].ToString(), ldfPath)); smoServer.KillAllProcesses(dbName); restore.SqlRestore(smoServer); db = smoServer.Databases[dbName]; db.SetOnline(); smoServer.Refresh(); db.Refresh(); }
/// <summary> /// Method used to restore the database /// </summary> /// <param name="databaseName">database name</param> /// <param name="filePath">file path of the database</param> /// <param name="connectionString">sql connection</param> /// <param name="dataFilePath">mdf file path</param> /// <param name="logFilePath">ldf file path</param> /// <param name="dataBaseFileName">database file name of the restored.</param> public void RestoreDatabase(string databaseName, string filePath, SqlConnection connectionString, string dataFilePath, string logFilePath, string dataBaseFileName) { Restore sqlRestore = new Restore(); BackupDeviceItem deviceItem = new BackupDeviceItem(filePath, DeviceType.File); sqlRestore.Devices.Add(deviceItem); sqlRestore.Database = databaseName; ServerConnection connection = new ServerConnection(connectionString); Server sqlServer = new Server(connection); Database db = sqlServer.Databases[databaseName]; sqlRestore.Action = RestoreActionType.Database; string dataFileLocation = dataFilePath + dataBaseFileName + ".mdf"; string logFileLocation = logFilePath + dataBaseFileName + "_Log.ldf"; db = sqlServer.Databases[databaseName]; sqlRestore.RelocateFiles.Add(new RelocateFile(databaseName, dataFileLocation)); sqlRestore.RelocateFiles.Add(new RelocateFile(databaseName + "_log", logFileLocation)); sqlRestore.ReplaceDatabase = true; sqlRestore.Complete += new ServerMessageEventHandler(this.SqlRestoreComplete); sqlRestore.PercentCompleteNotification = 10; sqlRestore.PercentComplete += new PercentCompleteEventHandler(this.SqlRestorePercentComplete); sqlRestore.SqlRestore(sqlServer); //db = sqlServer.Databases[databaseName]; //db.SetOnline(); sqlServer.Refresh(); }
public bool RestoreDatabase() { timer1.Tick -= timer1_Tick; try { Restore sqlRestore = new Restore(); sqlRestore.Action = RestoreActionType.Database; sqlRestore.Database = BancoDados; BackupDeviceItem deviceItem = new BackupDeviceItem(ArqBackup, DeviceType.File); ServerConnection connection = new ServerConnection(Servidor, Usuario, Senha); Server sqlServer = new Server(connection); Database db = sqlServer.Databases[BancoDados]; sqlRestore.Devices.Add(deviceItem); sqlRestore.ReplaceDatabase = true; sqlRestore.Complete += new ServerMessageEventHandler(sqlRestore_Complete); // AQUI VC SETA O VALOR PARA 1; sqlRestore.PercentCompleteNotification = 1; sqlRestore.PercentComplete += new PercentCompleteEventHandler(sqlRestore_PercentComplete); sqlRestore.SqlRestore(sqlServer); timer1.Tick += timer1_Tick; return(true); } catch (Exception ex) { MessageBox.Show("Ocorreram problemas ao Restaurar o Backup!!!\n\n" + ex.InnerException.Message + "\n" + ex.Message, "Controller ERP", MessageBoxButtons.OK, MessageBoxIcon.Error); return(false); } }
public static void RestoreDbFromFile(string serverName, string dbName, string fileName) { Server server = CreateServer(serverName); Restore restore = new Restore { Database = dbName }; restore.Devices.AddDevice(fileName, DeviceType.File); foreach (DataRow row in restore.ReadFileList(server).Rows) { RelocateFile relocateFile = new RelocateFile { LogicalFileName = (string)row[DB_FIELD_LOGICALNAME], PhysicalFileName = NewFileName(server, (string)row[DB_FIELD_TYPE]) }; restore.RelocateFiles.Add(relocateFile); } if (server.Databases.Contains(dbName)) { // Wait until just before restoring to drop any existing database. server.KillDatabase(dbName); } restore.SqlRestore(server); }
public void RestoreDatabase(string backupFilePath, string destinationDatabaseName) { try { var restoreObj = new Restore { Action = RestoreActionType.Database, Database = destinationDatabaseName, NoRecovery = true }; Database currentDb = _server.Databases[destinationDatabaseName]; if (currentDb != null) { _server.KillAllProcesses(destinationDatabaseName); } restoreObj.ReplaceDatabase = true; restoreObj.Devices.AddDevice(backupFilePath, DeviceType.File); restoreObj.SqlRestore(_server); } catch (Exception e) { Console.WriteLine(e); throw; } }
public static void DatabaseRestoreFullOrDifferential(string backUpFile) { Restore restoreDB = new Restore(); restoreDB.Database = LoadEnvironment.DB_NAME; /* Specify whether you want to restore database, files or log */ restoreDB.Action = RestoreActionType.Database; restoreDB.Devices.AddDevice(backUpFile, DeviceType.File); /* You can specify ReplaceDatabase = false (default) to not create a new * database, the specified database must exist on SQL Server * instance. If you can specify ReplaceDatabase = true to create new * database image regardless of the existence of specified database with * the same name */ restoreDB.ReplaceDatabase = true; /* If you have a differential or log restore after the current restore, * you would need to specify NoRecovery = true, this will ensure no * recovery performed and subsequent restores are allowed. It means it * the database will be in a restoring state. */ restoreDB.NoRecovery = true; /* Wiring up events for progress monitoring */ restoreDB.PercentComplete += CompletionStatusInPercent; restoreDB.Complete += Restore_Completed; /* SqlRestore method starts to restore the database * You can also use SqlRestoreAsync method to perform restore * operation asynchronously */ Server myServer = new Server(new ServerConnection(LoadEnvironment.DB_SERVER)); restoreDB.SqlRestore(myServer); }
public static void RollBackDatabase(string databaseName, string bakfilePath) { SqlConnection.ClearAllPools(); SqlConnection cnn = SetSingleUser(databaseName); ServerConnection serverConn = new ServerConnection(cnn); Server server = new Server(serverConn); Database db = server.Databases[cnn.Database]; Restore restore = new Restore(); restore.Action = RestoreActionType.Database; restore.Devices.AddDevice(bakfilePath, DeviceType.File); restore.Database = databaseName; restore.ReplaceDatabase = true; restore.Complete += new ServerMessageEventHandler(Restore_Completed); restore.PercentComplete += new PercentCompleteEventHandler(CompletionStatusInPercent); restore.PercentCompleteNotification = 10; SqlCommand cmd = cnn.CreateCommand(); cmd.CommandText = string.Format("use master"); cmd.ExecuteNonQuery(); restore.SqlRestore(server); db = server.Databases[databaseName]; db.SetOnline(); server.Refresh(); if (server.ConnectionContext.IsOpen) { server.ConnectionContext.Disconnect(); } }
public void RestoreDatabase(string backupName) { var server = new Server("localhost"); server.ConnectionContext.LoginSecure = true; server.ConnectionContext.Connect(); var restoreDB = new Restore { Database = "PayAndGive", Action = RestoreActionType.Database, ReplaceDatabase = true, NoRecovery = false }; restoreDB.Devices.AddDevice(Path.Combine(_backupsPath, backupName), DeviceType.File); restoreDB.Information += (sender, args) => Console.WriteLine($"Information: {args.Error}"); restoreDB.PercentComplete += (sender, args) => Console.WriteLine($"Complete: {args.Percent}. Message: {args.Message}"); restoreDB.Complete += (sender, args) => { Console.WriteLine($"Completed! Error: {args.Error}"); server.ConnectionContext.Disconnect(); }; restoreDB.SqlRestore(server); }
private object Restore(string instName, string bkpDbName, string uname, string pw, string bkpFileName) { try { var conn = new ServerConnection(instName, uname, pw); var srv = new Server(conn); var res = new Restore { Action = RestoreActionType.Database, Database = bkpDbName, ReplaceDatabase = true }; res.Devices.AddDevice(bkpFileName, DeviceType.File); // Kill all processes srv.KillAllProcesses(res.Database); // Set single-user mode Database db = srv.Databases[res.Database]; db.DatabaseOptions.UserAccess = DatabaseUserAccess.Single; db.Alter(TerminationClause.RollbackTransactionsImmediately); // Detach database srv.DetachDatabase(res.Database, false); res.SqlRestore(srv); return(new { Error = 0, Message = "Successfully" }); } catch (Exception ex) { return(new { Error = 1, Message = ex }); } }
private static void RestoreDatabase(Server srv) { Restore restoreDB = new Restore(); restoreDB.Database = "TTDB"; /* Specify whether you want to restore database, files or log */ restoreDB.Action = RestoreActionType.Database; restoreDB.Devices.AddDevice(@"C:\Program Files\Microsoft SQL Server\MSSQL12.SQLEXPRESS\MSSQL\Backup\Test_Full_Backup1.bak", DeviceType.File); /* You can specify ReplaceDatabase = false (default) to not create a new * database, the specified database must exist on SQL Server * instance. If you can specify ReplaceDatabase = true to create new * database image regardless of the existence of specified database with * the same name */ restoreDB.ReplaceDatabase = true; /* If you have a differential or log restore after the current restore, * you would need to specify NoRecovery = true, this will ensure no * recovery performed and subsequent restores are allowed. It means it * the database will be in a restoring state. */ restoreDB.NoRecovery = true; /* SqlRestore method starts to restore the database * You can also use SqlRestoreAsync method to perform restore * operation asynchronously */ restoreDB.SqlRestore(srv); }
// Restore Database and trigger the stored procedure. private void RestoreDatabase(String databaseName, String filePath, String serverName, String userName, String password) { //System.Diagnostics.Debugger.Launch(); //FOR DEBUGGING String connectionString = "Server=" + serverName + "; DataBase=" + databaseName + ";Integrated Security=SSPI"; Restore sqlRestore = new Restore(); BackupDeviceItem deviceItem = new BackupDeviceItem(filePath, DeviceType.File); sqlRestore.Devices.Add(deviceItem); sqlRestore.Database = databaseName; ServerConnection connection = new ServerConnection(serverName, userName, password); Server sqlServer = new Server(connection); Database db = sqlServer.Databases[databaseName]; sqlRestore.Action = RestoreActionType.Database; db = sqlServer.Databases[databaseName]; sqlRestore.ReplaceDatabase = true; // Restoration in process. The Database is Restored at a Default location. Under the DATA Folder. sqlRestore.SqlRestore(sqlServer); db = sqlServer.Databases[databaseName]; db.SetOnline(); sqlServer.Refresh(); // Trigger Stored Procedure after restore. triggerSP(connectionString); }
public bool Restore(string path) { Connect(); if (srvSql != null) { try // If the user has chosen the file from which he wants the database to be restored { // Create a new database restore operation Restore rstDatabase = new Restore(); // Set the restore type to a database restore rstDatabase.Action = RestoreActionType.Database; // Set the database that we want to perform the restore on rstDatabase.Database = DBName; BackupDeviceItem bkpDevice = new BackupDeviceItem(path, DeviceType.File); // Add the backup device to the restore type rstDatabase.Devices.Add(bkpDevice); // If the database already exists, replace it rstDatabase.ReplaceDatabase = true; // Perform the restore rstDatabase.SqlRestore(srvSql); } catch (Exception ex) { TLog.WriteErr("TBackup.cs_retore ", ex.Message); return(false); } } else { TLog.WriteErr("TBackup.cs_retore ", "Not Connected to Server"); return(false); } return(true); }
public static void MakeRestore(ServerMessageEventHandler onComplete, Guid id, string serverName, string dbName, string uncDir, string userName, string password) { var sc = new ServerConnection(serverName); sc.LoginSecure = false; sc.Login = userName; sc.Password = password; var srv = new Server(sc); var rest = new Restore(); rest.Action = RestoreActionType.Database; rest.Database = dbName; rest.Devices.AddDevice(Path.Combine(uncDir, rest.Database + ".bak"), DeviceType.File); rest.ReplaceDatabase = true; var headers = rest.ReadBackupHeader(srv); var query = from DataRow row in headers.Rows where (string)row["BackupName"] == id.ToString() select(Int16) row["Position"]; rest.FileNumber = query.First(); if (onComplete != null) { rest.Complete += onComplete; } rest.SqlRestore(srv); }
public void RestoreDatabase(string databaseName, string backUpFile, string serverName, string restorePath) { try { ServerConnection connection = new ServerConnection(serverName); Server sqlServer = new Server(connection); Restore rstDatabase = new Restore(); rstDatabase.Action = RestoreActionType.Database; rstDatabase.Database = databaseName; BackupDeviceItem bkpDevice = new BackupDeviceItem(backUpFile, DeviceType.File); rstDatabase.Devices.Add(bkpDevice); var dataFilePath = restorePath; var logFilePath = restorePath; //Create The Restore Database Ldf & Mdf file name string dataFileLocation = dataFilePath + databaseName + ".mdf"; string logFileLocation = logFilePath + databaseName + "_Log.ldf"; RelocateFile rf = new RelocateFile(databaseName, dataFileLocation); // Replace ldf, mdf file name of selected Backup file System.Data.DataTable logicalRestoreFiles = rstDatabase.ReadFileList(sqlServer); rstDatabase.RelocateFiles.Add(new RelocateFile(logicalRestoreFiles.Rows[0][0].ToString(), dataFileLocation)); rstDatabase.RelocateFiles.Add(new RelocateFile(logicalRestoreFiles.Rows[1][0].ToString(), logFileLocation)); rstDatabase.ReplaceDatabase = true; rstDatabase.SqlRestore(sqlServer); } catch (Exception e) { Console.WriteLine("Failed to restore database" + e.Message); throw e; } }
public void RestoreDB(string databaseName) { Console.WriteLine("*** Restoring***"); // Don't drop it! /// If you do, anyone with the default database of that DB will croak! //server.Databases[databaseName].Drop(); Restore restore = new Restore(); restore.Devices.Clear(); string fileName = string.Format("{0}\\{1}.bak", testFolder, databaseName); restore.Devices.Add(new BackupDeviceItem(fileName, DeviceType.File)); // Just give it a new name string destinationDatabaseName = string.Format("{0}_newly_restored", databaseName); // Go grab the current database's logical names for the data and log files // For this example, we assume there are 1 for each. Database currentDatabase = server.Databases[databaseName]; string currentLogicalData = currentDatabase.FileGroups[0].Files[0].Name; string currentLogicalLog = currentDatabase.LogFiles[0].Name; // Now relocate the data and log files RelocateFile reloData = new RelocateFile(currentLogicalData, string.Format(@"{0}\{1}.mdf", testFolder, destinationDatabaseName)); RelocateFile reloLog = new RelocateFile(currentLogicalLog, string.Format(@"{0}\{1}_Log.ldf", testFolder, destinationDatabaseName)); restore.RelocateFiles.Add(reloData); restore.RelocateFiles.Add(reloLog); restore.Database = destinationDatabaseName; restore.ReplaceDatabase = true; restore.PercentCompleteNotification = 10; restore.PercentComplete += new PercentCompleteEventHandler(restore_PercentComplete); restore.Complete += new ServerMessageEventHandler(restore_Complete); restore.SqlRestore(server); }
public static void MakeRestore(ServerMessageEventHandler onComplete, Guid id, string serverName, string dbName, string uncDir, string userName, string password) { var sc = new ServerConnection(serverName); sc.LoginSecure = false; sc.Login = userName; sc.Password = password; var srv = new Server(sc); var rest = new Restore(); rest.Action = RestoreActionType.Database; rest.Database = dbName; rest.Devices.AddDevice(Path.Combine(uncDir, rest.Database + ".bak"), DeviceType.File); rest.ReplaceDatabase = true; var headers = rest.ReadBackupHeader(srv); var query = from DataRow row in headers.Rows where (string)row["BackupName"] == id.ToString() select (Int16)row["Position"]; rest.FileNumber = query.First(); if (onComplete != null) rest.Complete += onComplete; rest.SqlRestore(srv); }
public static void RestoreDB(Server myServer) { Database db = myServer.Databases["MemeWallStreet"]; Restore restoreDB = new Restore(); restoreDB.Database = db.Name; /* Specify whether you want to restore database, files or log */ restoreDB.Action = RestoreActionType.Database; restoreDB.Devices.AddDevice(@"D:\" + db.Name + ".bak", DeviceType.File); //myServer.KillAllProcesses(db.Name); /* You can specify ReplaceDatabase = false (default) to not create a new * database, the specified database must exist on SQL Server * instance. If you can specify ReplaceDatabase = true to create new * database image regardless of the existence of specified database with * the same name */ restoreDB.ReplaceDatabase = true; /* If you have a differential or log restore after the current restore, * you would need to specify NoRecovery = true, this will ensure no * recovery performed and subsequent restores are allowed. It means it * the database will be in a restoring state. */ restoreDB.NoRecovery = true; /* Wiring up events for progress monitoring */ restoreDB.PercentComplete += CompletionStatusInPercent; restoreDB.Complete += Restore_Completed; /* SqlRestore method starts to restore the database * You can also use SqlRestoreAsync method to perform restore * operation asynchronously */ try { restoreDB.SqlRestore(myServer); } catch { failed = true; Console.WriteLine("Fail"); } }
private void UltraButton3_Click(object sender, EventArgs e) { Server server = new Server(Mipsed7.Core.ApplicationDatabaseInformation.ServerName); server.ConnectionContext.LoginSecure = false; server.ConnectionContext.Login = Mipsed7.Core.ApplicationDatabaseInformation.SqlUserName; server.ConnectionContext.Password = Mipsed7.Core.ApplicationDatabaseInformation.SqlPassword; OpenFileDialog dialog = new OpenFileDialog { Title = "Odredite backup datoteku", RestoreDirectory = true, Filter = "bak datoteke|*.bak|sve datoteke|*.*" }; if (dialog.ShowDialog() == DialogResult.OK) { ExtendedWindowSmartPartInfo smartPartInfo = new ExtendedWindowSmartPartInfo { StartPosition = FormStartPosition.CenterScreen, Modal = true, ControlBox = true, Title = "Unesite naziv baze podataka!", Icon = ImageResourcesNew.mbs }; UnosNazivaBaze smartPart = this.Controller.WorkItem.Items.AddNew <UnosNazivaBaze>(); smartPart.Baze = server.Databases; this.Controller.WorkItem.RootWorkItem.Workspaces["window"].Show(smartPart, smartPartInfo); if ((smartPart.NazivBaze != null) && (Interaction.MsgBox("Odabrali ste: " + smartPart.NazivBaze, MsgBoxStyle.YesNo, null) == MsgBoxResult.Yes)) { Restore restore = new Restore(); restore.Devices.AddDevice(dialog.FileName, DeviceType.File); string nazivBaze = smartPart.NazivBaze; restore.Database = nazivBaze; restore.NoRecovery = false; restore.ReplaceDatabase = true; DataRow[] rowArray = restore.ReadFileList(server).Select(null); string logicalFileName = Conversions.ToString(rowArray[0][0]); string str3 = Conversions.ToString(rowArray[1][0]); restore.RelocateFiles.Add(new RelocateFile(logicalFileName, server.Information.MasterDBPath + @"\" + nazivBaze + ".MDF")); restore.RelocateFiles.Add(new RelocateFile(str3, server.Information.MasterDBPath + @"\" + nazivBaze + ".LDF")); this.TextBox1.Clear(); this.TextBox1.AppendText("Trenutna akcija - restore baze : " + nazivBaze); restore.PercentComplete += new PercentCompleteEventHandler(this.ProgressEventHandler); try { restore.SqlRestore(server); restore.PercentComplete -= new PercentCompleteEventHandler(this.ProgressEventHandler); this.TextBox1.Clear(); } catch (System.Exception exception1) { throw exception1; //restore.PercentComplete -= new PercentCompleteEventHandler(this.ProgressEventHandler); } } } this.Baze1.Clear(); this.PuniBaze(); }
//Restores the database using the file resides in the path specified by "backupFilePath" public void Restore(string backupFilePath) { try { CreateConnection(); Server svr = new Server(conn); Database db = svr.Databases[DATABASE]; Restore restore = new Restore { Database = DATABASE, RestrictedUser = true, Action = RestoreActionType.Database, ReplaceDatabase = true }; restore.Devices.AddDevice(backupFilePath, DeviceType.File); svr.KillAllProcesses(DATABASE); restore.Wait(); restore.SqlRestore(svr); } finally { CloseConnection(); } }
private void RestoreData(object sender, EventArgs e) { try { var connectionString = SqlHelper.GetConnectionString; SqlHelper sqlHelper = new SqlHelper(connectionString); ServerConnection serverConnection = sqlHelper.Username != null ? new ServerConnection(sqlHelper.ServerName, sqlHelper.Username, sqlHelper.Password) : new ServerConnection(sqlHelper.ServerName); Server dbServer = new Server(serverConnection); Restore dbRestore = new Restore { Action = RestoreActionType.Database, Database = sqlHelper.DatabaseName, ReplaceDatabase = true, NoRecovery = false }; BackupDeviceItem destination = new BackupDeviceItem(view.Path, DeviceType.File); dbRestore.Devices.Add(destination); dbRestore.SqlRestore(dbServer); serverConnection.Disconnect(); view.Path = ""; view.RestoreMessage = "Succeed"; } catch (Exception) { view.RestoreMessage = "Failed"; } }
private void ImportRecords() { string conString = string.Empty; var dir = @"C:/Ajoor App Database file"; using (StreamReader reader = new StreamReader(connectionPath)) { while (!reader.EndOfStream) { conString = reader.ReadLine(); } } SqlConnection con = new SqlConnection(conString); string databaseName = "Ajo"; ServerConnection connection = new ServerConnection(con); Server sqlServer = new Server(connection); Restore rstDatabase = new Restore(); rstDatabase.Action = RestoreActionType.Database; rstDatabase.Database = databaseName; string backupfileName = $"{databaseName}.bak"; string backedUpFile = Path.Combine(dir, backupfileName); BackupDeviceItem bkpDevice = new BackupDeviceItem(backedUpFile, DeviceType.File); rstDatabase.Devices.Add(bkpDevice); rstDatabase.ReplaceDatabase = true; rstDatabase.SqlRestore(sqlServer); }
public bool restore(string fileName) { bool exitCode = false; Restore res = new Restore(); try { res.Database = databaseName; res.Action = RestoreActionType.Database; res.Devices.AddDevice(fileName, DeviceType.File); res.PercentCompleteNotification = 10; res.ReplaceDatabase = true; res.SqlRestore(srv); exitCode = true; } catch (SmoException exSMO) { Console.WriteLine(exSMO.ToString()); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } return(exitCode); }
/// <summary> /// /// Restores database from file. /// <see cref="http://msdn.microsoft.com/en-us/library/microsoft.sqlserver.management.smo.restore.sqlrestore.aspx"/> /// </summary> /// <param name="fileName">File name</param> /// <param name="databaseName">Database name</param> /// <param name="withReplace"><code>true</code> - with replace</param> public static void Restore(string fileName, string databaseName, bool withReplace) { string sourceLogFileName = databaseName + "_log"; var server = GetConnectedServer(SqlServerName, UserName, Password); string rootPath = server.MasterDBPath; if (!rootPath.EndsWith(@"\")) { rootPath += @"\"; } var dbFile = Path.Combine(rootPath, String.Format("{0}.mdf", databaseName)); var logFile = Path.Combine(rootPath, String.Format("{0}.ldf", sourceLogFileName)); var restore = new Restore() { Database = databaseName, NoRecovery = false, FileNumber = 1, ReplaceDatabase = withReplace, }; restore.Devices.AddDevice(fileName, DeviceType.File); DbLogicalFileNames logicalFileNames = GetDbLogicalFileNames(fileName); restore.RelocateFiles.Add(new RelocateFile(logicalFileNames.LogicalNameData, dbFile)); restore.RelocateFiles.Add(new RelocateFile(logicalFileNames.LogicalNameLog, logFile)); restore.SqlRestore(server); System.Data.SqlClient.SqlConnection.ClearAllPools(); }
void RestoreDataBase(string backupFilePath, string destinationDatabaseName, string databaseFolder) { var server = GetServer(); var restore = new Restore(); restore.Database = destinationDatabaseName; var currentDb = server.Databases[destinationDatabaseName]; if (currentDb != null) { server.KillAllProcesses(destinationDatabaseName); } restore.Devices.AddDevice(backupFilePath, DeviceType.File); var files = restore.ReadFileList(server); Directory.CreateDirectory(databaseFolder); foreach (DataRow row in files.Rows) { var fileName = destinationDatabaseName + "_" + row["LogicalName"] + ((string)row["Type"] == "D" ? ".mdf" : ".ldf"); restore.RelocateFiles.Add(new RelocateFile((string)row["LogicalName"], Path.Combine(databaseFolder, fileName))); } restore.ReplaceDatabase = true; restore.PercentCompleteNotification = 1; restore.PercentComplete += myRestore_PercentComplete; restore.Complete += myRestore_Complete; ReportCurrentState(0, "Restoring: {0}", destinationDatabaseName); restore.SqlRestore(server); currentDb = server.Databases[destinationDatabaseName]; currentDb.SetOnline(); }
/// <summary> /// To Restote the database and return the string message /// </summary> /// <returns> return the string message</returns> #region Restore Database public string restoreDatabase(string path, string DatabaseName) { try { if (SqlServerConnect()) { Server srv = new Server(servConn); Database database = srv.Databases[DatabaseName]; Restore restoreBackUp = new Restore(); restoreBackUp.Action = RestoreActionType.Database; restoreBackUp.Database = DatabaseName; BackupDeviceItem source = new BackupDeviceItem(path, DeviceType.File); restoreBackUp.Devices.Add(source); restoreBackUp.ReplaceDatabase = true; restoreBackUp.NoRecovery = false; restoreBackUp.SqlRestore(srv); SqlServerDisconnect(); return("Database Restore Sucessfull"); } } catch (Exception ex) { writeLogMessage(ex.Message.ToString()); } return("Sorry Error While Restore DB"); }
public ActionResult RestoreDB(DBBackupObject dbObject, HttpPostedFileBase backupFile) { if (dbObject == null) { ViewBag.StatusMessage = "An unknown error was encountered. Please try again."; return(View("DBBackup")); } try { var srv = new Server(new ServerConnection(dbObject.ServerName, dbObject.UserName, dbObject.Password)); Database database = srv.Databases["AdventureWorks"]; var restore = new Restore { Action = RestoreActionType.Database, Database = database.Name, PercentCompleteNotification = 10, }; restore.Devices.AddDevice(@"E:\Data\Backup\AW.bak", DeviceType.File); //restore.PercentComplete += ProgressEventHandler; restore.SqlRestore(srv); ViewBag.StatusMessage = "Action completed successfully"; return(View("DBBackup")); } catch (Exception ex) { ErrorLogger.LogEror(ex.StackTrace, ex.Source, ex.Message); ViewBag.StatusMessage = ex.Message; return(View("DBBackup")); } }
protected override void ExecuteTask() { var server = new Server(ServerName); server.ConnectionContext.LoginSecure = true; server.ConnectionContext.Connect(); if (!ReplaceDB) { if (server.Databases.Contains(DBName)) { Log(Level.Info, DBName + " exists on " + ServerName + " and will not be replaced"); return; } } Log(Level.Info, "Restoring database " + DBName + " to " + ServerName); var restore = new Restore(); restore.Database = DBName; restore.ReplaceDatabase = ReplaceDB; restore.Action = RestoreActionType.Database; restore.Devices.AddDevice(BackupPath, DeviceType.File); var table = restore.ReadFileList(server); restore.RelocateFiles.Add(new RelocateFile(table.Rows[0][0].ToString(), Path.Combine(server.Settings.DefaultFile, DBName + ".mdf"))); restore.RelocateFiles.Add(new RelocateFile(table.Rows[1][0].ToString(), Path.Combine(server.Settings.DefaultFile, DBName + "_Log.ldf"))); restore.PercentComplete += UpdatePercent; restore.Complete += RestoreCompleted; restore.SqlRestore(server); if (server.ConnectionContext.IsOpen) server.ConnectionContext.Disconnect(); }
private void restoreDBToolStripMenuItem_Click(object sender, EventArgs e) { DBConnection dbConnection = DBConnection.getDB(); OpenFileDialog openFileDialog1 = new OpenFileDialog(); if (openFileDialog1.ShowDialog() == DialogResult.OK) { ServerConnection connsql = new ServerConnection(@dbConnection.ServerName); Server server = new Server(connsql); Restore destination = new Restore(); destination.Action = RestoreActionType.Database; destination.Database = @dbConnection.DBName; try { destination.Devices.AddDevice(@openFileDialog1.FileName, DeviceType.File); destination.ReplaceDatabase = true; destination.SqlRestore(server); MessageBox.Show("База успешно восстановлена"); } catch (Exception exc) { MessageBox.Show(exc.Message); } } }
/// <summary> /// This method restores the specified database from the backup file (.bak) /// </summary> public void RestoreDatabase() { string _extractedBakFile = String.Empty; try { if (Server != null) { Restore _restoreDatabase = new Restore(); _restoreDatabase.Action = RestoreActionType.Database; _restoreDatabase.Database = DbName; //Extracts the zip file if (FilePath.EndsWith(".zip")) { _extractedBakFile = ExtractZipFile(FilePath); } else { _extractedBakFile = FilePath; } if (String.IsNullOrEmpty(_extractedBakFile)) { throw new InvalidArgumentException("File extraction failed. Please try again!"); } BackupDeviceItem bkpDevice = new BackupDeviceItem(_extractedBakFile, DeviceType.File); _restoreDatabase.Devices.Add(bkpDevice); _restoreDatabase.ReplaceDatabase = true; _restoreDatabase.PercentComplete += new PercentCompleteEventHandler(PercentComplete); _restoreDatabase.SqlRestore(Server); IsCompleted = true; } else { IsCompleted = false; throw new InvalidArgumentException("A connection to the database server could not be established"); } } catch (Exception ex) { throw new InvalidOperationException("Database restore could not be successfully completed\n" + ex.Message); } finally { //check if the .bak is an extracted file. If so, delete .bak and leave the .zip file string _zipFile = _extractedBakFile.Replace(".bak", ".zip"); if (!String.IsNullOrEmpty(_extractedBakFile) && File.Exists(_zipFile)) { File.Delete(_extractedBakFile); } } }
public static void RestoreDatabase(string databaseName, string backupName, string serverName = Server) { Server server = string.IsNullOrEmpty(serverName) ? new Server() : new Server(serverName); var restore = new Restore { Database = databaseName, Action = RestoreActionType.Database, ReplaceDatabase = true, NoRecovery = false }; restore.Devices.AddDevice(backupName + ".bak", DeviceType.File); server.KillAllProcesses(databaseName); restore.SqlRestore(server); }
static void Main(string[] args) { if (args.Length != 3) return; string serverName = args[0]; string databaseName = args[1]; string restoreFilePath = args[2]; Restore restoreDB = new Restore(); restoreDB.Database = databaseName; restoreDB.Action = RestoreActionType.Database; restoreDB.Devices.AddDevice(@restoreFilePath, DeviceType.File); restoreDB.ReplaceDatabase = true; /* If you have a differential or log restore after the current restore, * you would need to specify NoRecovery = true, this will ensure no * recovery performed and subsequent restores are allowed. It means it * the database will be in a restoring state. */ restoreDB.NoRecovery = false; restoreDB.PercentComplete += (obj, e) => { Console.WriteLine("Percent completed: {0}%.", e.Percent); }; Server srv = new Server(@serverName); /* Check if database exists, if not, create one. */ Database db = srv.Databases[databaseName]; if (db == null) { db = new Database(srv,databaseName); Console.WriteLine("Creating database..."); db.Create(); Console.WriteLine("Created {0}.", databaseName); } Console.WriteLine("Verifying backup media..."); bool valid = restoreDB.SqlVerify(srv); if (valid) { Console.WriteLine("Backup media is valid."); Console.WriteLine("Starting restore..."); restoreDB.SqlRestore(srv); } else { Console.WriteLine("Backup media is invalid. Aborting operation..."); } }
/// <summary> /// Restore DB from backup. /// </summary> private static bool RestoreDB() { string connectionString = ConfigurationManager.ConnectionStrings["DeathsConnectionString"].ToString(); var builder = new SqlConnectionStringBuilder(connectionString); var myServer = new Server(builder.DataSource); var res = new Restore(); res.Database = "Deaths"; res.Action = RestoreActionType.Database; res.Devices.AddDevice( Environment.CurrentDirectory + @"\Resources\DeathsFullBackup", DeviceType.File); res.ReplaceDatabase = true; res.SqlRestore(myServer); return true; }
public void Restore(BackupParameters parameters) { var databaseName = parameters.DatabaseName; var filePath = GetFullPathFrom(parameters.FilePath); Logger.WriteLine("Restoring {0} from file {1}", databaseName, filePath); var server = new Server(parameters.Server); try { server.ConnectionContext.LoginSecure = true; server.ConnectionContext.Connect(); var restore = new Restore { Database = databaseName, Action = RestoreActionType.Database }; restore.Devices.AddDevice(filePath, DeviceType.File); restore.ReplaceDatabase = true; var database = server.Databases[databaseName]; if (database == null) { Logger.WriteLine("Database {0} does not exist", databaseName); return; } var users = server.GetLoginUsers(database); Logger.WriteLine("User mappings to restore: {0}", string.Join(",", users)); RelocateFiles(database, restore); server.RenewConnection(); restore.PercentComplete += HandlePercentComplete; restore.Complete += HandleComplete; restore.SqlRestore(server); RestoreUserMappings(server, users, databaseName); } finally { if (server.ConnectionContext.IsOpen) { Logger.Write("Closing connection..."); server.ConnectionContext.Disconnect(); Logger.WriteLine("OK"); } } }
public static void RestoreDatabase(this Server server, string databaseName, string filePath) { var res = new Restore(); res.Devices.AddDevice(filePath, DeviceType.File); var DataFile = new RelocateFile(); string MDF = res.ReadFileList(server).Rows[0][1].ToString(); DataFile.LogicalFileName = res.ReadFileList(server).Rows[0][0].ToString(); DataFile.PhysicalFileName = server.Databases[databaseName].FileGroups[0].Files[0].FileName; var LogFile = new RelocateFile(); string LDF = res.ReadFileList(server).Rows[1][1].ToString(); LogFile.LogicalFileName = res.ReadFileList(server).Rows[1][0].ToString(); LogFile.PhysicalFileName = server.Databases[databaseName].LogFiles[0].FileName; res.RelocateFiles.Add(DataFile); res.RelocateFiles.Add(LogFile); res.Database = databaseName; res.NoRecovery = false; res.ReplaceDatabase = true; res.SqlRestore(server); }
private void RestoreDB(string databaseName, string serverName, string path) { try { // Create a new database restore operation Restore rstDatabase = new Restore(); // Set the restore type to a database restore rstDatabase.Action = RestoreActionType.Database; // Set the database that we want to perform the restore on rstDatabase.Database = databaseName; // Set the backup device from which we want to restore, to a file BackupDeviceItem deviceItem = new BackupDeviceItem(path, DeviceType.File); // Add the backup device to the restore type rstDatabase.Devices.Add(deviceItem); // If the database already exists, replace it rstDatabase.ReplaceDatabase = true; ServerConnection connection = new ServerConnection(serverName); Server sqlServer = new Server(connection); // Perform the restore rstDatabase.SqlRestore(sqlServer); MessageBox.Show(Constant.MESSAGE_SUCCESS_RESTORE, Constant.CAPTION_CONFIRMATION, MessageBoxButtons.OK, MessageBoxIcon.Information); FormMain.isRestored = true; Application.Exit(); } catch (Exception ex) { MessageBox.Show(Constant.MESSAGE_ERROR_RESTORE + Constant.MESSAGE_NEW_LINE + Constant.MESSAGE_ERROR_BACKUP_PATH, Constant.CAPTION_ERROR, MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public bool RealizarRestoreBD(string rutaArchivo) { bool resultado = false; try { string baseDeDatos = ConfigurationManager.AppSettings["BaseDeDatos"].ToString(); if (File.Exists(rutaArchivo)) { using (SqlConnection conexion = Conexion.ObtenerInstancia().CrearConexionSQLMaster()) { ServerConnection conexionServer = new ServerConnection(conexion); Server servidor = new Server(conexionServer); Restore restoreBD = new Restore(); restoreBD.Action = RestoreActionType.Database; restoreBD.Database = baseDeDatos; String query = "ALTER DATABASE " + baseDeDatos + " SET SINGLE_USER WITH ROLLBACK IMMEDIATE"; using(SqlCommand comando = new SqlCommand(query, conexion)) { comando.Connection.Open(); comando.ExecuteNonQuery(); } BackupDeviceItem deviceItem = new BackupDeviceItem(rutaArchivo, DeviceType.File); restoreBD.Devices.Add(deviceItem); restoreBD.ReplaceDatabase = true; restoreBD.SqlRestore(servidor); conexionServer.Disconnect(); } resultado = true; } return resultado; } catch (AccesoBDException ex) { throw new DALException("BDDAO", "RealizarRestoreBD", "AccesoBD", ex.Message, ex); } catch (SqlException ex) { throw new DALException("BDDAO", "RealizarRestoreBD", "SQL", ex.Message, ex); } catch (Exception ex) { throw new DALException("BDDAO", "RealizarRestoreBD", "General: " + ex.GetType().ToString(), ex.Message, ex); } }
private void RS() { Restore sqlRestore = new Restore(); BackupDeviceItem deviceItem = new BackupDeviceItem(@"D:\Bakup\Weedon.bak", DeviceType.File); sqlRestore.Devices.Add(deviceItem); sqlRestore.Database = "Weedon"; ServerConnection connection = new ServerConnection(@".\SQLEXPRESS"); Server sqlServer = new Server(connection); Database db = sqlServer.Databases["Weedon"]; sqlRestore.Action = RestoreActionType.Database; String dataFileLocation = @"C:\Program Files\Microsoft SQL Server\MSSQL10.SQLEXPRESS\MSSQL\DATA\Weedon.mdf"; String logFileLocation = @"C:\Program Files\Microsoft SQL Server\MSSQL10.SQLEXPRESS\MSSQL\DATA\Weedon_Log.ldf"; db = sqlServer.Databases["Weedon"]; RelocateFile rf = new RelocateFile("Weedon", dataFileLocation); //sqlRestore.RelocateFiles.Add(new RelocateFile("Weedon", dataFileLocation)); //sqlRestore.RelocateFiles.Add(new RelocateFile("Weedon" + "_log", logFileLocation)); System.Data.DataTable logicalRestoreFiles = sqlRestore.ReadFileList(sqlServer); sqlRestore.RelocateFiles.Add(new RelocateFile(logicalRestoreFiles.Rows[0][0].ToString(), dataFileLocation)); sqlRestore.RelocateFiles.Add(new RelocateFile(logicalRestoreFiles.Rows[1][0].ToString(), logFileLocation)); sqlRestore.ReplaceDatabase = true; //sqlRestore.Complete += new ServerMessageEventHandler(sqlRestore_Complete); sqlRestore.PercentCompleteNotification = 10; //sqlRestore.PercentComplete += //new PercentCompleteEventHandler(sqlRestore_PercentComplete); //sqlServer.ConnectionContext.Disconnect(); sqlRestore.SqlRestore(sqlServer); db = sqlServer.Databases["Weedon"]; db.SetOnline(); sqlServer.Refresh(); }
private void btnRestore_Click(object sender, EventArgs e) { try { if (String.IsNullOrEmpty(txtPath.Text)) { MessageBox.Show("No File Selected"); return; } else if (!File.Exists(txtPath.Text)) { MessageBox.Show("File Not Found"); return; } if (String.IsNullOrEmpty(txtDatabaseName.Text)) { MessageBox.Show("No Database Name Entered"); return; } string path = txtPath.Text; string name = txtDatabaseName.Text; Restore sqlRestore = new Restore { Database = name }; Server sqlServer = GetServer(); if (sqlServer.Databases[name] != null) { if ( MessageBox.Show("Delete existing database?", "Confirm Delete", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes) { sqlServer.KillDatabase(name); } else { return; } } Database db = new Database(sqlServer, name); db.Create(); BackupDeviceItem backupDevice = new BackupDeviceItem(path, DeviceType.File); sqlRestore.Action = RestoreActionType.Database; sqlRestore.Devices.Add(backupDevice); var table = sqlRestore.ReadBackupHeader(sqlServer); var fileNumber = sqlRestore.FileNumber; foreach (DataRow r in table.Rows) { var tempNum = -1; if (!int.TryParse(r["Position"].ToString(), out tempNum)) continue; if (tempNum > fileNumber) { fileNumber = tempNum; } } sqlRestore.FileNumber = fileNumber; String dataFileLocation = db.FileGroups[0].Files[0].FileName; String logFileLocation = db.LogFiles[0].FileName; db = sqlServer.Databases[name]; sqlServer.ConnectionContext.Disconnect(); RelocateFile rf = new RelocateFile(sqlRestore.ReadFileList(sqlServer).Rows[0]["LogicalName"].ToString(), dataFileLocation); RelocateFile lf = new RelocateFile(sqlRestore.ReadFileList(sqlServer).Rows[1]["LogicalName"].ToString(), logFileLocation); sqlRestore.RelocateFiles.Add(rf); sqlRestore.RelocateFiles.Add(lf); sqlRestore.ReplaceDatabase = true; sqlRestore.PercentCompleteNotification = 1; sqlRestore.PercentComplete += new PercentCompleteEventHandler(PercentCompleteHandler); //sqlRestore.Complete += new ServerMessageEventHandler(sqlRestore_Complete); sqlRestore.SqlRestore(sqlServer); db = sqlServer.Databases[name]; db.SetOnline(); sqlServer.Refresh(); MessageBox.Show("Restore Completed"); progressBar.Visible = false; } catch (Exception ex) { MessageBox.Show(ex.Message); } }
public void Restore(DatabaseRestoreRequest request, PercentCompleteEventHandler percentCompleteDelegate) { var server = new Server(request.TargetInstance); Database database = server.Databases[request.TargetDatabase]; // Start by locking down the database database.DatabaseOptions.UserAccess = DatabaseUserAccess.Single; database.Alter(TerminationClause.RollbackTransactionsImmediately); var restoreDb = new Restore { Database = database.Name, Action = RestoreActionType.Database }; //Specify whether you want to restore database or files or log etc restoreDb.Devices.AddDevice(request.FullBackupFile, DeviceType.File); // For now we only support database replacement. restoreDb.ReplaceDatabase = true; // For full backup no recovery is not usefull. Will need to to change this if support for restoring transactional backup file happens. restoreDb.NoRecovery = false; // Associate the correct physical path for each file to be restored foreach (FileToRestore fileToRestore in request.FilesLists) { restoreDb.RelocateFiles.Add(new RelocateFile(fileToRestore.BackupLogicalName, fileToRestore.TargetPhysicalPath)); } if (percentCompleteDelegate != null) { restoreDb.PercentComplete += percentCompleteDelegate; } // Magic! restoreDb.SqlRestore(server); restoreDb.SqlRestoreAsync(server); // After the restore, ensure the recovery model is set to simple. // Since we only support DEV/TEST/DEMO, we dont want the overhead of the other recovery models. database.RecoveryModel = RecoveryModel.Simple; database.Alter(); string sqlConnectionString = string.Format("Integrated Security=SSPI;Persist Security Info=True;Initial Catalog={1};Data Source={0}", server.Name, database.Name); foreach (var script in request.ScriptsToExecute) { var fileInfo = new FileInfo(script); string sql; using (var text = fileInfo.OpenText()) { sql = text.ReadToEnd(); text.Close(); } SqlConnection connection = new SqlConnection(sqlConnectionString); Server srv = new Server(new ServerConnection(connection)); srv.ConnectionContext.SqlExecutionModes = SqlExecutionModes.ExecuteAndCaptureSql; srv.ConnectionContext.ExecuteNonQuery(sql); } }
private void btn_restore_Click(object sender, EventArgs e) { if (cmbDataBase.SelectedIndex.ToString().Equals("")) { MessageBox.Show("Please choose Database", "Server", MessageBoxButtons.OK, MessageBoxIcon.Information); return; } // If there was a SQL connection created if (_srvr != null) { try { btn_backup.Enabled = false; btn_restore.Enabled = false; db_change.Enabled = false; server_change.Enabled = false; Cursor = Cursors.WaitCursor; // If the user has chosen the file from which he wants the database to be restored // Create a new database restore operation var rstDatabase = new Restore { Action = RestoreActionType.Database, Database = cmbDataBase.SelectedItem.ToString() }; // Set the restore type to a database restore // Set the database that we want to perform the restore on // Set the backup device from which we want to restore, to a file var bkpDevice = new BackupDeviceItem(_dBpath + "\\Backup.bak", DeviceType.File); // Add the backup device to the restore type rstDatabase.Devices.Add(bkpDevice); // If the database already exists, replace it rstDatabase.ReplaceDatabase = true; // Perform the restore rstDatabase.SqlRestore(_srvr); MessageBox.Show("Database " + cmbDataBase.Text + " succefully restored", "Server", MessageBoxButtons.OK, MessageBoxIcon.Information); } catch (Exception) { MessageBox.Show("ERROR: An error ocurred while restoring the database", "Application Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } finally { Cursor = Cursors.Arrow; btn_backup.Enabled = true; btn_restore.Enabled = true; db_change.Enabled = true; server_change.Enabled = true; } } else { MessageBox.Show("ERROR: A connection to a SQL server was not established.", "Server", MessageBoxButtons.OK, MessageBoxIcon.Error); Cursor = Cursors.Arrow; } }
private void btnRestore_Click(object sender, RoutedEventArgs e) { string blankDBFile = string.Empty; string dbScriptsDefaultPath = string.Empty; string backupFileName = string.Empty; string sSQLServerDetails = string.Empty; bool bDBExists = false; try { Cursor = System.Windows.Input.Cursors.Wait; sSQLServerDetails = GetConnectionString(); bDBExists = DBSettings.CheckDBExists(sSQLServerDetails, txtDataBases.Text, 60); if (bDBExists == true) { MessageBox.ShowText(string.Format("{0} {1}", txtDataBases.Text, FindResource("MessageID50")), BMC_Icon.Information); LogManager.WriteLog(string.Format("{0} {1}", txtDataBases.Text, FindResource("MessageID50")), LogManager.enumLogLevel.Info); } else { dbScriptsDefaultPath = ConfigurationManager.AppSettings.Get("DBScriptsDefaultPath"); if (this.strType.ToUpper() == "EXCHANGE") { blankDBFile = ConfigurationManager.AppSettings.Get("ExchangeBlankDB"); } if (this.strType.ToUpper() == "TICKETING") { blankDBFile = ConfigurationManager.AppSettings.Get("TicketingBlankDB"); } if (this.strType.ToUpper() == "EXTSYSMSG") { blankDBFile = ConfigurationManager.AppSettings.Get("EXTSYSMSGBlankDB"); } backupFileName = string.Format("{0}\\{1}", dbScriptsDefaultPath, blankDBFile); // Create a new connection to the Server ServerConnection serverConnection = new ServerConnection(cmbServers.SelectedItem.ToString()); // Log in using SQL authentication instead of Windows authentication serverConnection.LoginSecure = false; // Give the login username serverConnection.Login = txtUsername.Text; // Give the login password serverConnection.Password = txtPassword.Password; // Create a new SQL Server object using the connection we created Server server = new Server(serverConnection); // Create a new database restore operation Restore rstDatabase = new Restore(); // Set the restore type to a database restore rstDatabase.Action = RestoreActionType.Database; // Set the database that we want to perform the restore on rstDatabase.Database = txtDataBases.Text; // Set the backup device from which we want to restore the db BackupDeviceItem bkpDevice = new BackupDeviceItem(backupFileName, DeviceType.File); // Add the backup device to the restore type rstDatabase.Devices.Add(bkpDevice); // Optional. ReplaceDatabase property ensures that any existing copy of the database is overwritten. rstDatabase.ReplaceDatabase = true; // Perform the restore rstDatabase.SqlRestore(server); LogManager.WriteLog(string.Format("{0} - {1}", "Database Restore Complete. Running Updgrade Scripts for database", txtDataBases.Text), LogManager.enumLogLevel.Info); if (this.strType.ToUpper() == "EXCHANGE" | this.strType.ToUpper() == "TICKETING") { if (Convert.ToBoolean(ConfigurationManager.AppSettings.Get("AutoRunUpgradeScriptAfterDBRestore"))) { try { RunDatabaseUpgradeScripts(); } catch (Exception ex) { ExceptionManager.Publish(ex); if (this.strType.ToUpper() == "EXCHANGE") { MessageBox.ShowBox("MessageID106", BMC_Icon.Error); } if (this.strType.ToUpper() == "TICKETING") { MessageBox.ShowBox("MessageID107", BMC_Icon.Error); } } } LogManager.WriteLog(string.Format("{0} - {1}", "Updgrade Scripts run successfully for database", txtDataBases.Text), LogManager.enumLogLevel.Info); } MessageBox.ShowText(string.Format("{0} {1} {2}.", FindResource("MessageID53"), txtDataBases.Text, FindResource("MessageID54")), BMC_Icon.Information); } } catch (Exception ex) { MessageBox.ShowBox("MessageID74", BMC_Icon.Error); ExceptionManager.Publish(ex); } finally { btnRestore.IsEnabled = true; Cursor = System.Windows.Input.Cursors.Arrow; } }
public void RestoreDataBase(string backupFilePath, string destinationDatabaseName, string databaseFolder, string databaseFileName, string databaseLogFileName) { try { Server srv = GetServer(); Restore restore = new Restore { Database = destinationDatabaseName, Action = RestoreActionType.Database }; Database database = srv.Databases[destinationDatabaseName]; if (database != null) { srv.KillAllProcesses(destinationDatabaseName); string primaryFilePath = database.PrimaryFilePath; if (backupFilePath != null) restore.Devices.AddDevice(backupFilePath, DeviceType.File); DataTable datosbackup = restore.ReadFileList(srv); restore.ReplaceDatabase = true; //restore.NoRecovery = true; string physicalFileName = String.Format(@"{0}\{1}.mdf", primaryFilePath, destinationDatabaseName); string str3 = String.Format(@"{0}\{1}_log.ldf", primaryFilePath, destinationDatabaseName); restore.RelocateFiles.Add(new RelocateFile(datosbackup.Rows[0][0].ToString(), physicalFileName)); restore.RelocateFiles.Add(new RelocateFile(datosbackup.Rows[1][0].ToString(), str3)); } //restore.ReplaceDatabase = true; restore.PercentCompleteNotification = 5; restore.PercentComplete += Progreso_PercentComplete; restore.Complete += Progreso_Complete; restore.SqlRestore(srv); srv.Databases[destinationDatabaseName].SetOnline(); srv.Databases[destinationDatabaseName].Refresh(); } catch (SqlException ex) { MessageBox.Show(ex.Message); } }
private static void Restore(string backupFileName, string destinationDbName, SqlConnection connection) { Contract.Ensures(File.Exists(backupFileName), "File.Exists(backupFileName)"); var restoreDb = new Restore { Database = destinationDbName, Action = RestoreActionType.Database, ReplaceDatabase = true, NoRecovery = false }; restoreDb.Devices.AddDevice(backupFileName, DeviceType.File); connection.Open(); var server = new Server(new ServerConnection(connection)); var relocateFiles = GetRelocateFiles(connection, backupFileName, destinationDbName, server.DefaultFile, server.DefaultLog); restoreDb.RelocateFiles.AddRange(relocateFiles); restoreDb.SqlRestore(server); }
public static void RollBackDatabase(string databaseName, string bakfilePath) { SqlConnection.ClearAllPools(); SqlConnection cnn = SetSingleUser(databaseName); ServerConnection serverConn = new ServerConnection(cnn); Server server = new Server(serverConn); Database db = server.Databases[cnn.Database]; Restore restore = new Restore(); restore.Action = RestoreActionType.Database; restore.Devices.AddDevice(bakfilePath, DeviceType.File); restore.Database = databaseName; restore.ReplaceDatabase = true; restore.Complete += new ServerMessageEventHandler(Restore_Completed); restore.PercentComplete += new PercentCompleteEventHandler(CompletionStatusInPercent); restore.PercentCompleteNotification = 10; SqlCommand cmd = cnn.CreateCommand(); cmd.CommandText = string.Format("use master"); cmd.ExecuteNonQuery(); restore.SqlRestore(server); db = server.Databases[databaseName]; db.SetOnline(); server.Refresh(); if (server.ConnectionContext.IsOpen) server.ConnectionContext.Disconnect(); }
void MSDNCode() { //Connect to the local, default instance of SQL Server. Server srv = new Server(); //Reference the AdventureWorks2008R2 database. Database db = default(Database); db = srv.Databases["AdventureWorks2008R2"]; //Store the current recovery model in a variable. int recoverymod; recoverymod = (int)db.DatabaseOptions.RecoveryModel; //Define a Backup object variable. Backup bk = new Backup(); //Specify the type of backup, the description, the name, and the database to be backed up. bk.Action = BackupActionType.Database; bk.BackupSetDescription = "Full backup of Adventureworks2008R2"; bk.BackupSetName = "AdventureWorks2008R2 Backup"; bk.Database = "AdventureWorks2008R2"; //Declare a BackupDeviceItem by supplying the backup device file name in the constructor, and the type of device is a file. BackupDeviceItem bdi = default(BackupDeviceItem); bdi = new BackupDeviceItem("Test_Full_Backup1", DeviceType.File); //Add the device to the Backup object. bk.Devices.Add(bdi); //Set the Incremental property to False to specify that this is a full database backup. bk.Incremental = false; //Set the expiration date. System.DateTime backupdate = new System.DateTime(); backupdate = new System.DateTime(2006, 10, 5); bk.ExpirationDate = backupdate; //Specify that the log must be truncated after the backup is complete. bk.LogTruncation = BackupTruncateLogType.Truncate; //Run SqlBackup to perform the full database backup on the instance of SQL Server. bk.SqlBackup(srv); //Inform the user that the backup has been completed. Console.WriteLine("Full Backup complete."); //Remove the backup device from the Backup object. bk.Devices.Remove(bdi); //Make a change to the database, in this case, add a table called test_table. Table t = default(Table); t = new Table(db, "test_table"); Column c = default(Column); c = new Column(t, "col", DataType.Int); t.Columns.Add(c); t.Create(); //Create another file device for the differential backup and add the Backup object. BackupDeviceItem bdid = default(BackupDeviceItem); bdid = new BackupDeviceItem("Test_Differential_Backup1", DeviceType.File); //Add the device to the Backup object. bk.Devices.Add(bdid); //Set the Incremental property to True for a differential backup. bk.Incremental = true; //Run SqlBackup to perform the incremental database backup on the instance of SQL Server. bk.SqlBackup(srv); //Inform the user that the differential backup is complete. Console.WriteLine("Differential Backup complete."); //Remove the device from the Backup object. bk.Devices.Remove(bdid); //Delete the AdventureWorks2008R2 database before restoring it // db.Drop(); //Define a Restore object variable. Restore rs = new Restore(); //Set the NoRecovery property to true, so the transactions are not recovered. rs.NoRecovery = true; //Add the device that contains the full database backup to the Restore object. rs.Devices.Add(bdi); //Specify the database name. rs.Database = "AdventureWorks2008R2"; //Restore the full database backup with no recovery. rs.SqlRestore(srv); //Inform the user that the Full Database Restore is complete. Console.WriteLine("Full Database Restore complete."); //reacquire a reference to the database db = srv.Databases["AdventureWorks2008R2"]; //Remove the device from the Restore object. rs.Devices.Remove(bdi); //Set the NoRecovery property to False. rs.NoRecovery = false; //Add the device that contains the differential backup to the Restore object. rs.Devices.Add(bdid); //Restore the differential database backup with recovery. rs.SqlRestore(srv); //Inform the user that the differential database restore is complete. Console.WriteLine("Differential Database Restore complete."); //Remove the device. rs.Devices.Remove(bdid); //Set the database recovery mode back to its original value. db.RecoveryModel = (RecoveryModel)recoverymod; //Drop the table that was added. db.Tables["test_table"].Drop(); db.Alter(); //Remove the backup files from the hard disk. //This location is dependent on the installation of SQL Server File.Delete("C:\\Program Files\\Microsoft SQL Server\\MSSQL10.MSSQLSERVER\\MSSQL\\Backup\\Test_Full_Backup1"); File.Delete("C:\\Program Files\\Microsoft SQL Server\\MSSQL10.MSSQLSERVER\\MSSQL\\Backup\\Test_Differential_Backup1"); }
private static void RestoreDatabase(CollectionInformation collectionInfo, string databaseBackupFile) { var connectionStringBuilder = new SqlConnectionStringBuilder(collectionInfo.ConnectionString); var serverConnection = new ServerConnection(connectionStringBuilder.DataSource); var server = new Server(serverConnection); var restore = new Restore(); restore.Devices.AddDevice(databaseBackupFile, DeviceType.File); restore.Database = connectionStringBuilder.InitialCatalog; restore.ReplaceDatabase = true; server.KillAllProcesses(restore.Database); restore.SqlRestore(server); }
private void Button_Click_2(object sender, RoutedEventArgs e) { Restore rest = new Restore(); string PathtobackUp =""; OpenFileDialog dlg = new OpenFileDialog(); dlg.InitialDirectory = "c:\\"; dlg.Filter = "Backup Files (*.bak)|*.bak|All Files (*.*)|*.*"; dlg.RestoreDirectory = true; if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK) { PathtobackUp = dlg.FileName.ToString(); } else { return; } string fileName = PathtobackUp; //this.Cursor = Cursors.WaitCursor; //this.dataGridView1.DataSource = string.Empty; try { rest.Devices.AddDevice(fileName, DeviceType.File); Server srv = new Server("(localdb)\\v11.0"); bool verifySuccessful = rest.SqlVerify(srv); string databaseName = "LoanManagement.Domain.finalContext"; if (verifySuccessful) { System.Windows.MessageBox.Show("Backup Verified!", "Info"); System.Windows.MessageBoxResult dr = System.Windows.MessageBox.Show("Do you want to restore?","Question",MessageBoxButton.YesNo); if (dr == MessageBoxResult.Yes) { //fileName = dlg.FileName.Replace(Directory.GetCurrentDirectory(), ""); System.Windows.MessageBox.Show(fileName); rest.Database = databaseName; rest.Action = RestoreActionType.Database; BackupDeviceItem bdi = default(BackupDeviceItem); bdi = new BackupDeviceItem(fileName, DeviceType.File); rest.Devices.Add(bdi); //rest.Devices.Add(bdi); rest.ReplaceDatabase = true; srv = new Server("(localdb)\\v11.0"); rest.SqlRestore(srv); srv.Refresh(); System.Windows.MessageBox.Show("Restore of " + databaseName +" Complete!"); } } else { System.Windows.MessageBox.Show("ERROR: Backup not verified!", "Error"); } } catch (Exception ex) { System.Windows.MessageBox.Show("The system has been successfully restored"); } finally { //this.Cursor = Cursors.Default; } }
private void PhucHoiDuLieu() { GetDatabaseInformation(); var cnn = new SqlConnection(_connectionString); cnn.Open(); var conn = new ServerConnection(cnn); var server = new Server(conn); cnn.Close(); Restore restore = new Restore(); //string fileName = string.Format("{0}\\{1}.bak", testFolder, databaseName); string fileName = txtTenTapTin.Text; restore.Devices.Add(new BackupDeviceItem(fileName, DeviceType.File)); // Just give it a new name //string destinationDatabaseName = string.Format("{0}_newly_restored", databaseName); string destinationDatabaseName = txtCoSoDuLieu.Text; // Go grab the current database’s logical names for the data // and log files. For this example, we assume there are 1 for each. //Database currentDatabase = server.Databases[databaseName]; //string currentLogicalData_ = currentDatabase.FileGroups[0].Files[0].Name; //string currentLogicalLog_ = currentDatabase.LogFiles[0].Name; // Now relocate the data and log files //RelocateFile reloData = new RelocateFile(currentLogicalData, string.Format(@"{0}\{1}.mdf", testFolder, destinationDatabaseName)); //RelocateFile reloLog = new RelocateFile(currentLogicalLog, string.Format(@"{0}\{1}_Log.ldf", testFolder, destinationDatabaseName)); RelocateFile reloData = new RelocateFile(currentLogicalData, physicalFileName); RelocateFile reloLog = new RelocateFile(currentLogicalLog, physicalFileLogName); //MessageBox.Show(fileName); //MessageBox.Show(destinationDatabaseName); //MessageBox.Show(currentLogicalData); //MessageBox.Show(currentLogicalLog); //MessageBox.Show(currentLogicalData_); //MessageBox.Show(currentLogicalLog_); //MessageBox.Show(string.Format(@"{0}\{1}.mdf", testFolder, destinationDatabaseName)); //MessageBox.Show(string.Format(@"{0}\{1}_Log.ldf", testFolder, destinationDatabaseName)); //MessageBox.Show(physicalFileName); //MessageBox.Show(physicalFileLogName); restore.RelocateFiles.Add(reloData); restore.RelocateFiles.Add(reloLog); restore.Database = destinationDatabaseName; restore.ReplaceDatabase = true; restore.PercentCompleteNotification = 10; restore.PercentComplete += restore_PercentComplete; //restore.Complete += restore_Complete; restore.ReplaceDatabase = true; server.KillAllProcesses(txtCoSoDuLieu.Text); restore.SqlRestore(server); server.Refresh(); MessageBox.Show("Quá trình hoàn tất"); Bar.EditValue = 0; Bar.Refresh(); //progressBar1.Value = 0; //progressBar1.Refresh(); }
private static void restore(Server srv, string d, string f) { // Backup device BackupDeviceItem bdi = default(BackupDeviceItem); bdi = new BackupDeviceItem(f, DeviceType.File); // Delete database before restoring it Database db = default(Database); db = srv.Databases[d]; //Define a Restore object variable. Restore rs = new Restore(); //Set the NoRecovery property to true, so the transactions are not recovered. rs.NoRecovery = false; // set to replace database rs.ReplaceDatabase = true; //Add the device that contains the full database backup to the Restore object. rs.Devices.Add(bdi); //Specify the database name. rs.Database = d; //Restore the full database backup with no recovery. rs.SqlRestore(srv); //Inform the user that the Full Database Restore is complete. Common.WriteToConsoleOut("Full Database Restore complete."); }
public bool Restore(string path) { Connect(); if (srvSql != null) { try // If the user has chosen the file from which he wants the database to be restored { // Create a new database restore operation Restore rstDatabase = new Restore(); // Set the restore type to a database restore rstDatabase.Action = RestoreActionType.Database; // Set the database that we want to perform the restore on rstDatabase.Database = DBName; BackupDeviceItem bkpDevice = new BackupDeviceItem(path, DeviceType.File); // Add the backup device to the restore type rstDatabase.Devices.Add(bkpDevice); // If the database already exists, replace it rstDatabase.ReplaceDatabase = true; // Perform the restore rstDatabase.SqlRestore(srvSql); } catch(Exception ex) { TLog.WriteErr("TBackup.cs_retore ",ex.Message); return false; } } else { TLog.WriteErr("TBackup.cs_retore ", "Not Connected to Server"); return false; } return true; }
public static void RestoreDB(string backUpFilePath, string databaseName) { try { Console.WriteLine("Restore operation started"); Restore restore = new Restore(); //Set type of backup to be performed to database restore.Database = databaseName; restore.Action = RestoreActionType.Database; //Set up the backup device to use filesystem. restore.Devices.AddDevice(backUpFilePath, DeviceType.File); //set ReplaceDatabase = true to create new database //regardless of the existence of specified database restore.ReplaceDatabase = true; //If you have a differential or log restore to be followed, //you would specify NoRecovery = true restore.NoRecovery = false; //if you want to restore to a different location, specify //the logical and physical file names restore.RelocateFiles.Add(new RelocateFile("Test", @"C:\Temp\Test.mdf")); restore.RelocateFiles.Add(new RelocateFile("Test_Log", @"C:\Temp\Test_Log.ldf")); ServerConnection connection = new ServerConnection(@"SERVER_NAME"); //my SQL user doesnt have sufficient permissions, //so i am using my windows account connection.LoginSecure = true; //connection.LoginSecure = false; //connection.Login = "******"; //connection.Password = "******"; Server sqlServer = new Server(connection); //SqlRestore method starts to restore database restore.SqlRestore(sqlServer); Console.WriteLine("Restore operation succeeded"); } catch (Exception ex) { Console.WriteLine("Restore operation failed"); Console.WriteLine(ex.Message); } Console.ReadLine(); }
/// <summary> /// Method to Restore a DB from file /// </summary> public void RestoreDBFromFile() { // Call Set Up // Not needed if we wrap this in a [Test] Server myServer = new Server(CF.Server); //Using SQL Server authentication myServer.ConnectionContext.LoginSecure = false; myServer.ConnectionContext.Login = CF.UserName; myServer.ConnectionContext.Password = CF.Password; Restore restoreDB = new Restore(); foreach (Database myDatabase in myServer.Databases) { Console.WriteLine(myDatabase.Name); if (myDatabase.Name.Equals(CF.DBName)) { restoreDB.Database = myDatabase.Name; // Restore Action = Database restoreDB.Action = RestoreActionType.Database; restoreDB.Devices.AddDevice(CF.RestoreDevicePath, DeviceType.File); // Replace the existing database restoreDB.ReplaceDatabase = true; // Allows for DB recovery after restore restoreDB.NoRecovery = false; /* Wiring up events for progress monitoring */ restoreDB.PercentComplete += CompletionStatusInPercent; restoreDB.Complete += Restore_Completed; // Start the restore restoreDB.SqlRestore(myServer); } } }
private void Restore() { if (this.DatabaseItem == null) { this.Log.LogError("DatabaseItem is required"); return; } if (this.ReplaceDatabase && this.LogFilePath == null) { this.Log.LogError("LogFilePath must be specified if ReplaceDatabase is true."); return; } string primaryDataFileName = (!string.IsNullOrEmpty(this.PrimaryDataFileName)) ? this.PrimaryDataFileName : this.DatabaseItem.ItemSpec; this.LogTaskMessage(string.Format(CultureInfo.CurrentCulture, "Restoring SQL {2}: {0} from {1}", this.DatabaseItem.ItemSpec, this.DataFilePath.GetMetadata("FullPath"), this.RestoreAction)); Restore sqlRestore = new Restore { Database = this.DatabaseItem.ItemSpec, Action = this.restoreAction, PercentCompleteNotification = this.NotificationInterval, ReplaceDatabase = this.ReplaceDatabase }; sqlRestore.Devices.AddDevice(this.DataFilePath.GetMetadata("FullPath"), DeviceType.File); sqlRestore.PercentComplete += this.ProgressEventHandler; if (string.IsNullOrEmpty(this.LogName)) { this.LogName = primaryDataFileName + "_log"; } // add primary data file sqlRestore.RelocateFiles.Add(new RelocateFile(primaryDataFileName, (this.NewDataFilePath != null) ? this.NewDataFilePath.GetMetadata("FullPath") : this.DataFilePath.GetMetadata("FullPath"))); // add log file, if path provided if (this.LogFilePath != null) { sqlRestore.RelocateFiles.Add(new RelocateFile(this.LogName, this.LogFilePath.GetMetadata("FullPath"))); } // add secondary data file, if name and path provided if (!string.IsNullOrEmpty(this.SecondaryDataFileName) && this.SecondaryDataFilePath != null) { sqlRestore.RelocateFiles.Add(new RelocateFile(this.SecondaryDataFileName, this.SecondaryDataFilePath.GetMetadata("FullPath"))); } sqlRestore.SqlRestore(this.sqlServer); }
public void RestoreDatabase(string backUpFile) { ServerConnection serverConnection = new ServerConnection(@"ROHAN-PC\SQLEXPRESS"); Server myServer = new Server(serverConnection); Restore destination = new Restore(); destination.Action = RestoreActionType.Database; destination.Database = "RecordKeeper"; BackupDeviceItem source = new BackupDeviceItem(backUpFile, DeviceType.File); destination.Devices.Add(source); destination.ReplaceDatabase = true; destination.SqlRestore(myServer); }