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 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);
}
}
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);
}
