/// <summary>
/// Compact the database file by connection string to it.
/// </summary>
/// <param name="connectionString">Connection string to the database file that should be compact.</param>
/// <param name="newConnectionString">Connection string to the new destination database file that will be created.</param>
private static void CompactDatabaseFile(string connectionString, string newConnectionString = null)
{
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new ArgumentNullException("connectionString");
}
using (var sqlCeEngine = new SqlCeEngine(connectionString))
{
// Specify null destination connection string for in-place compaction
sqlCeEngine.Compact(null);
if (!string.IsNullOrWhiteSpace(newConnectionString))
{
// Specify connection string for new database options; The following
// tokens are valid:
// - Password
// - LCID
// - Encrypt
//
// All other SqlCeConnection.ConnectionString tokens are ignored
sqlCeEngine.Compact(newConnectionString);
}
}
}
/// <summary>
/// Reclaims wasted space in the database and recalculates identity column values.
/// </summary>
public void Compact()
{
using (var engine = new SqlCeEngine(ConnectionString))
{
engine.Compact(null);
}
// Same thing using Reflection:
//object sqlCeEngine = null;
//try
//{
// sqlCeEngine = SqlCeEngineType.InvokeMember(null, BindingFlags.CreateInstance, null, null, new object[] { ConnectionString });
// SqlCeEngineType.InvokeMember("Compact", BindingFlags.InvokeMethod, null, sqlCeEngine, new object[] { null });
//}
//catch (TargetInvocationException ex)
//{
// AppEventController.LogError(ex.InnerException ?? ex);
// throw;
//}
//finally
//{
// if (sqlCeEngine != null)
// SqlCeEngineType.InvokeMember("Dispose", BindingFlags.InvokeMethod, null, sqlCeEngine, null);
//}
}
public void CompactDatabase(string connectionString, int commandTimeout = 30)
{
using (SqlCeEngine engine = new SqlCeEngine(connectionString))
{
engine.Compact(null);
}
}
public void CompactDatabase(string connectionString)
{
using (SqlCeEngine engine = new SqlCeEngine(connectionString))
{
engine.Compact(null);
}
}
/// <summary>
/// Упаковать БД
/// </summary>
public static bool Compact()
{
if (string.IsNullOrEmpty(Conn.ConnectionString))
{
return(false);
}
else
{
bool wasConnected = Connected;
try
{
if (wasConnected)
{
Conn.Close();
}
SqlCeEngine engine = new SqlCeEngine(Conn.ConnectionString);
engine.Compact(string.Empty);
}
finally
{
if (wasConnected)
{
Conn.Open();
}
}
return(true);
}
}
/// <summary>
/// Copies the LM.
/// </summary>
/// <returns></returns>
/// <remarks>Documented by Dev07, 2009-05-20</remarks>
public static bool CopyLM(string source, string destination)
{
try
{
string filename = destination;
if (File.Exists(filename))
{
int i = 0;
while (File.Exists(filename.Replace(".mlm", "_" + i + ".mlm"))) i++;
filename = filename.Replace(".mlm", "_" + i + ".mlm");
}
string sourceConString = MSSQLCEConn.GetFullConnectionString(source);
string desConString = MSSQLCEConn.GetFullConnectionString(filename);
SqlCeEngine engine = new SqlCeEngine(sourceConString);
engine.Compact(desConString);
engine.Dispose();
}
catch (Exception e)
{
Trace.WriteLine(e.ToString());
return false;
}
return true;
}
public override void CompactDatabase()
{
using (SqlCeEngine engine = new SqlCeEngine())
{
engine.Compact(ConnectionString);
}
}
/// <summary>
/// Compacts the SQL CE database. No action is taken for other databases. Besides compacting the database, the
/// process performs a critical task of resetting the identity columns of all tables. Without this step the app
/// is at risk of generating the error 'A duplicate value cannot be inserted into a unique index' during a subsequent
/// insert.
/// </summary>
/// <param name="backupFile">The backup file.</param>
/// <exception cref="CannotCompactSqlCeException">Thrown when the database could not be compacted.</exception>
private static void CompactSqlCeDb(IBackupFile backupFile)
{
if (backupFile.GalleryDataStore != ProviderDataStore.SqlCe)
{
return;
}
try
{
var engine = new SqlCeEngine(backupFile.ConnectionString);
engine.Compact(null);
}
catch (SqlCeException)
{
// During testing it was observed that calling Compact could result in the error "Could not load database compaction library".
// But if we pause and try again it succeeds.
Pause();
var engineSecondTry = new SqlCeEngine(backupFile.ConnectionString);
try
{
engineSecondTry.Compact(null);
}
catch (SqlCeException ex)
{
throw new CannotCompactSqlCeException("The database was successfully restored, but it could not be compacted. Navigate to the Site Settings page and manually perform a compaction. Error: " + ex.Message, ex);
}
}
}
/// <summary>
/// Reclaims wasted space in the database and recalculates identity column values. Applies only to SQL CE.
/// </summary>
internal static void Compact()
{
using (SqlCeEngine engine = new SqlCeEngine(Util.ConnectionString))
{
engine.Compact(null);
}
}
/// <summary>
/// Copies the LM.
/// </summary>
/// <returns></returns>
/// <remarks>Documented by Dev07, 2009-05-20</remarks>
public static bool CopyLM(string source, string destination)
{
try
{
string filename = destination;
if (File.Exists(filename))
{
int i = 0;
while (File.Exists(filename.Replace(".mlm", "_" + i + ".mlm")))
{
i++;
}
filename = filename.Replace(".mlm", "_" + i + ".mlm");
}
string sourceConString = MSSQLCEConn.GetFullConnectionString(source);
string desConString = MSSQLCEConn.GetFullConnectionString(filename);
SqlCeEngine engine = new SqlCeEngine(sourceConString);
engine.Compact(desConString);
engine.Dispose();
}
catch (Exception e)
{
Trace.WriteLine(e.ToString());
return(false);
}
return(true);
}
public void CompactDatabase(string connectionString)
{
using (SqlCeEngine engine = new SqlCeEngine(connectionString))
{
engine.Compact(null);
}
}
public void Optimize() //сжимает и перестаривает индексы
{
connection.Close();
using (SqlCeEngine engine = new SqlCeEngine(connectionString))
engine.Compact(null);
connection.Open();
}
//=================METODO PARA COMPACTAR A BASE DE DADOS=======================
//40º
//compactar a base de dados = ao usuario excluir um registro fica uma linha em branco
//aqui veremos um metodo para apagar essas linhas em branco e compactar a base de dados
public bool COMPACTAR_BASEDADOS()
{
bool concluido = false;
try
{
SqlCeEngine motor = new SqlCeEngine();
motor.LocalConnectionString = stringconexao;
motor.Compact(stringconexao);
concluido = true;
}
catch (Exception ex)
{
concluido = false;
MessageBox.Show("ERROR: " + ex.Message);//so coloco esse erro para min para o usario nao posso por Exception
}
return(concluido);
//o usuario não precisa saber da existencia desse metodo
//então nao coloque botoes de compactar base de dados, apenas adicione no codigo
//lembrando que a base de dados precisa estar fechada no pc principal do codigo !!!!
//executar ao atingir 100 registros, de 100 em 100 seria legal.
}
/// <summary>
/// Compacts and shrinks the given database.
/// </summary>
public void Compact()
{
using (var eng = new SqlCeEngine(_connectionString))
{
eng.Compact(_connectionString);
eng.Shrink();
}
}
private void CompactDatabase(object sender, EventArgs e)
{
_connection.Close();
var connectionString = _objectExplorer.ConnectionString;
var engine = new SqlCeEngine(connectionString);
engine.Compact(null);
_connection.Open();
}
private void CompactDataBaseToolStripMenuItem_Click(object sender, EventArgs e)
{
Program.dbData3060.SubmitChanges();
Program.dbData3060.Connection.Close();
Program.dbData3060 = null;
string connectString = "Data Source = " + global::nsPuls3060.Properties.Settings.Default.DataBasePath;
SqlCeEngine engine = new SqlCeEngine(connectString);
engine.Compact(null);
this.Close();
}
public void ChangeDatabasePassword(string connectionString, string password)
{
if (string.IsNullOrEmpty(password))
{
throw new NullReferenceException("Password missing");
}
using (SqlCeEngine engine = new SqlCeEngine(connectionString))
{
engine.Compact(string.Format("Data Source=;Password={0}", password));
}
}
public bool ChangeLocalDataBasePassword(string password)
{
//testing
//password = "";
//
try
{
SqlCeEngine engine = new SqlCeEngine(this.ConnectionString);
engine.Compact(null);
string operationConnectionString = "Data Source=; Password="******";";
engine.Compact(operationConnectionString);
DatabaseAccess.LocalDbPassword = password;
return(true);
}
catch (Exception ex)
{
Console.WriteLine("Exception in ChangeLocalDataBasePassword() => " + ex.Message);
return(false);
}
}
// Calls SQLCE's compactor
public void compactDatabase()
{
string connString = @"Data Source = " + dbPath; // Create connection string for SQLCE DB
SqlCeEngine engine = new SqlCeEngine(connString); // Instantiate engine object
// Do the compaction
engine.Compact(null);
// We then verify the database, just incase.
if (!engine.Verify())
{
throw new Exception("Database corrupt");
}
}
public void butChangeSSCEPwd_ClickTest()
{
string oldPwd = string.Empty;
string newPwd = "1111";
//Change old pwd to new pwd
using (SqlCeEngine eg = new SqlCeEngine())
{
eg.LocalConnectionString = String.Format("Data Source={0};Password={1}", GlobalInfo.SqlCE_TestFile, oldPwd);
eg.Compact(string.Format("Data Source={0};Password={1}", GlobalInfo.SqlCE_TestFile, newPwd));
}
CoreEA.ICoreEAHander core = new CoreEA.CoreE(CoreEA.CoreE.UsedDatabaseType.SqlCE35).X_Handler;
core.Open(new LoginInfo_SSCE()
{
DbName = GlobalInfo.SqlCE_TestFile,
Pwd = newPwd,
});
bool status1 = core.IsOpened;
if (core.IsOpened)
{
core.Close();
core.Dispose();
}
//change new pwd to old pwd
using (SqlCeEngine eg = new SqlCeEngine())
{
eg.LocalConnectionString = String.Format("Data Source={0};Password={1}", GlobalInfo.SqlCE_TestFile, newPwd);
eg.Compact(string.Format("Data Source={0};Password={1}", GlobalInfo.SqlCE_TestFile, oldPwd));
}
CoreEA.ICoreEAHander core2 = new CoreEA.CoreE(CoreEA.CoreE.UsedDatabaseType.SqlCE35).X_Handler;
core2.Open(new LoginInfo_SSCE()
{
DbName = GlobalInfo.SqlCE_TestFile,
Pwd = oldPwd,
});
bool status2 = core2.IsOpened;
if (core2.IsOpened)
{
core2.Close();
core2.Dispose();
}
Assert.AreEqual(status1, status2);
}
public bool ShrinkDatabase()
{
try
{
SqlCeEngine engine = new SqlCeEngine(_connection.ConnectionString);
engine.Compact(_connection.ConnectionString);
engine.Shrink();
}
catch (Exception exp)
{
string msg = exp.Message;
//System.Windows.Forms.MessageBox.Show(msg);
return(false);
}
return(true);
}
public string ChangeDatabasePassword(string connectionString, string password)
{
if (password == null)
{
password = string.Empty;
}
using (SqlCeEngine engine = new SqlCeEngine(connectionString))
{
engine.Compact(string.Format("Data Source=;Password={0}", password));
}
#if V40
var builder = new SqlCeConnectionStringBuilder(connectionString);
builder.Password = password;
return(builder.ConnectionString);
#else
return(string.Empty);
#endif
}
/// <summary>
/// Calls the engine compact asynchronous.
/// </summary>
/// <returns>Task.</returns>
public static Task CallEngineCompactAsync()
{
Task t = Task.Run(() =>
{
DatabaseCommands commands = new DatabaseCommands();
using (SqlCeEngine engine = new SqlCeEngine(commands.GetConnectionString()))
{
ConnectionStringSettings conSetting = new ConnectionStringSettings();
conSetting = ConfigHelper.save_new_connection(commands.GetConnectionString());
engine.Compact(conSetting.ConnectionString);
}
});
t.Wait();
return(t);
}
/// <summary>
/// Compacte la base de donnée
/// </summary>
/// <param name="compactException"></param>
/// <returns></returns>
public bool Compact(out Exception compactException)
{
compactException = null;
GetConnection().Close();
try
{
using (SqlCeEngine engine = new SqlCeEngine(ConnectionString))
{
engine.Compact(null);
return(true);
}
}
catch (Exception innerCompactException)
{
compactException = innerCompactException;
IsAvailable = false;
}
return(false);
}
internal bool ChangePassword(string connectionString, string oldPassword, string newPassword)
{
try
{
SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(connectionString);
builder.Password = oldPassword;
SqlCeConnection con = new SqlCeConnection(builder.ConnectionString);
SqlCeEngine engine = new SqlCeEngine(builder.ConnectionString);
builder.Encrypt = true;
builder.Password = newPassword;
engine.Compact(builder.ConnectionString);
return(true);
}
catch (Exception)
{
return(false);
}
}
private void CompactDatabase(object sender, EventArgs e)
{
var form = DataCommanderApplication.Instance.MainForm.ActiveMdiChild;
var cursor = form.Cursor;
try
{
form.Cursor = Cursors.WaitCursor;
_connection.Close();
var connectionString = _objectExplorer.ConnectionString;
var engine = new SqlCeEngine(connectionString);
engine.Compact(null);
_connection.Open();
}
finally
{
form.Cursor = cursor;
}
}
} // PrepareDatabase
static void CompactDatabase()
{
Console.Write("Compacting EPG database...");
try
{
using (var engine = new SqlCeEngine())
{
engine.LocalConnectionString = "Data source=\"" + DbFile + "\";Password=\"movistartv.codeplex.com\"";
engine.Compact("Data source=;Password=\"movistartv.codeplex.com\"");
} // using engine
}
catch (Exception ex)
{
Console.WriteLine(" error");
Console.WriteLine(ex.Message);
} // try-catch
Console.WriteLine(" ok");
} // CompactDatabase
private void butCompact_Click(object sender, RoutedEventArgs e)
{
try
{
string connStr = CoreEA.ConnSTR.DbConnectionString.SSCE.GetSSCEConnectionString(txtDbPath.Text,
txtPwd.Password, (bool)chkIsEncrypted.IsChecked);
string targetFile = Guid.NewGuid().ToString();
targetFile += ".sdf";
SqlCeEngine ce = new SqlCeEngine(connStr);
string connStr2 = CoreEA.ConnSTR.DbConnectionString.SSCE.GetSSCEConnectionString(targetFile,
"", false);
ce.Compact(connStr2);
("Compact successful to" + targetFile).Show();
}
catch (Exception eee)
{
eee.HandleMyException();
}
}
public static void CompactDatabase()
{
string src = ConnectionParamter;
string dest = ConnectionParamter+".tmp";
// Initialize SqlCeEngine object.
SqlCeEngine engine = new SqlCeEngine("Data Source = " + src);
try {
//engine.Repair("Data Source = " + src, RepairOption.DeleteCorruptedRows);
engine.Compact("Data Source = " + dest);
engine.Dispose();
File.Delete(src);
File.Move(dest, src);
} catch(SqlCeException e) {
//Use your own error handling routine.
//ShowErrors(e);
CommonUtils.LogError(e.Message,e);
} finally {
//Dispose of the SqlCeEngine object.
engine.Dispose();
}
}
/// <summary>
/// Compacts the SQL CE database. No action is taken for other databases. Besides compacting the database, the
/// process performs a critical task of resetting the identity columns of all tables. Without this step the app
/// is at risk of generating the error 'A duplicate value cannot be inserted into a unique index' during a subsequent
/// insert.
/// </summary>
/// <param name="backupFile">The backup file.</param>
/// <exception cref="CannotCompactSqlCeException">Thrown when the database could not be compacted.</exception>
private static void CompactSqlCeDb(IBackupFile backupFile)
{
if (backupFile.GalleryDataStore != ProviderDataStore.SqlCe)
return;
try
{
var engine = new SqlCeEngine(backupFile.ConnectionString);
engine.Compact(null);
}
catch (SqlCeException)
{
// During testing it was observed that calling Compact could result in the error "Could not load database compaction library".
// But if we pause and try again it succeeds.
Pause();
var engineSecondTry = new SqlCeEngine(backupFile.ConnectionString);
try
{
engineSecondTry.Compact(null);
}
catch (SqlCeException ex)
{
throw new CannotCompactSqlCeException("The database was successfully restored, but it could not be compacted. Navigate to the Site Settings page and manually perform a compaction. Error: " + ex.Message, ex);
}
}
}
internal void Execute(EngineAction action, string newConnectionString)
{
// Specify connection string for new database options; The following
// tokens are valid:
// - Password
// - LCID
// - Encryption Mode
// - Case Sensitive
//
// All other SqlCeConnection.ConnectionString tokens are ignored
//
// engine.Compact("Data Source=; Password =a@3!7f$dQ;");
if (action != EngineAction.GetInfo)
{
using (SqlCeEngine engine = new SqlCeEngine(connectionString))
{
switch (action)
{
case EngineAction.Undefined:
break;
case EngineAction.Shrink:
engine.Shrink();
Console.WriteLine("Database successfully shrunk");
break;
case EngineAction.Verify:
Console.WriteLine(engine.Verify(VerifyOption.Enhanced)
? "Database successfully verified"
: "Database verification failed");
break;
case EngineAction.Compact:
engine.Compact(null);
Console.WriteLine("Database successfully compacted");
break;
case EngineAction.Upgrade:
engine.Upgrade();
Console.WriteLine("Database successfully upgraded");
break;
case EngineAction.Create:
engine.CreateDatabase();
Console.WriteLine("Database successfully created");
break;
case EngineAction.RepairDelete:
engine.Repair(null, RepairOption.DeleteCorruptedRows);
Console.WriteLine("Database successfully repaired");
break;
case EngineAction.RepairRecover:
engine.Repair(null, RepairOption.RecoverAllOrFail);
Console.WriteLine("Database successfully repaired");
break;
case EngineAction.SetOption:
engine.Compact(newConnectionString);
Console.WriteLine("Database option(s) successfully changed");
break;
default:
break;
}
}
}
else if (action == EngineAction.GetInfo)
{
using (SqlCeConnection cn = new SqlCeConnection(connectionString))
{
cn.Open();
List <KeyValuePair <string, string> > valueList = new List <KeyValuePair <string, string> >();
// 3.5 or later only API
valueList = cn.GetDatabaseInfo();
valueList.Add(new KeyValuePair <string, string>("Database", cn.Database));
valueList.Add(new KeyValuePair <string, string>("ServerVersion", cn.ServerVersion));
if (System.IO.File.Exists(cn.Database))
{
System.IO.FileInfo fi = new System.IO.FileInfo(cn.Database);
valueList.Add(new KeyValuePair <string, string>("DatabaseSize", fi.Length.ToString(CultureInfo.InvariantCulture)));
valueList.Add(new KeyValuePair <string, string>("Created", fi.CreationTime.ToShortDateString() + " " + fi.CreationTime.ToShortTimeString()));
}
valueList.Add(new KeyValuePair <string, string>(string.Empty, string.Empty));
valueList.Insert(0, new KeyValuePair <string, string>("SqlCeCmd", "Database Information"));
foreach (KeyValuePair <string, string> pair in valueList)
{
Console.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0}: {1}", pair.Key, pair.Value));
}
}
}
return;
}
public string ChangeDatabasePassword(string connectionString, string password)
{
if (password == null)
{
password = string.Empty;
}
using (SqlCeEngine engine = new SqlCeEngine(connectionString))
{
engine.Compact(string.Format("Data Source=;Password={0}", password));
}
#if V40
var builder = new SqlCeConnectionStringBuilder(connectionString);
builder.Password = password;
return builder.ConnectionString;
#else
return string.Empty;
#endif
}
/// <summary>
/// Compacte la base de donnée
/// </summary>
/// <param name="compactException"></param>
/// <returns></returns>
public bool Compact(out Exception compactException)
{
compactException = null;
GetConnection().Close();
try
{
using (SqlCeEngine engine = new SqlCeEngine(ConnectionString))
{
engine.Compact(null);
return true;
}
}
catch (Exception innerCompactException)
{
compactException = innerCompactException;
IsAvailable = false;
}
return false;
}
public void Compact()
{
using (var engine = new SqlCeEngine(ConnectionString))
engine.Compact(null);
}
/// <summary>
/// Reclaims wasted space in the database and recalculates identity column values.
/// </summary>
public void Compact()
{
using (var engine = new SqlCeEngine(ConnectionString))
{
engine.Compact(null);
}
// Same thing using Reflection:
//object sqlCeEngine = null;
//try
//{
// sqlCeEngine = SqlCeEngineType.InvokeMember(null, BindingFlags.CreateInstance, null, null, new object[] { ConnectionString });
// SqlCeEngineType.InvokeMember("Compact", BindingFlags.InvokeMethod, null, sqlCeEngine, new object[] { null });
//}
//catch (TargetInvocationException ex)
//{
// AppEventController.LogError(ex.InnerException ?? ex);
// throw;
//}
//finally
//{
// if (sqlCeEngine != null)
// SqlCeEngineType.InvokeMember("Dispose", BindingFlags.InvokeMethod, null, sqlCeEngine, null);
//}
}
public static void CompactSqlCe(string connectionString)
{
SqlCeEngine engine = new SqlCeEngine(connectionString);
engine.Compact(connectionString);
}
/// <summary>
/// Упаковать БД
/// </summary>
public static bool Compact()
{
if (string.IsNullOrEmpty(Conn.ConnectionString))
{
return false;
}
else
{
bool wasConnected = Connected;
try
{
if (wasConnected)
Conn.Close();
SqlCeEngine engine = new SqlCeEngine(Conn.ConnectionString);
engine.Compact(string.Empty);
}
finally
{
if (wasConnected)
Conn.Open();
}
return true;
}
}
private void CompactDb()
{
try
{
main.database.CloseConnection();
SendMessage("Compacting DB.. vent litt" + Environment.NewLine + "(Dette kan ta en stund)");
this.Update();
Log.n("Compacting DB.. vent litt");
SqlCeEngine eng = new SqlCeEngine(FormMain.SqlConStr);
eng.Compact(FormMain.SqlConStr);
//eng.Compact("Data Source=" + Path.Combine(FormMain.settingsPath, @"\db_compacting.sdf"));
main.database.OpenConnection();
DBsize();
Log.n("Compacting av " + FormMain.fileDatabase + " fullført.", Color.Green);
SendMessage("Ferdig.", Color.Green);
}
catch (Exception ex)
{
SendMessage("Feil!", Color.Red);
FormError errorMsg = new FormError("Feil oppstod under database optimalisering", ex);
errorMsg.ShowDialog(this);
}
}
private void butChange_Click(object sender, RoutedEventArgs e)
{
string oldPwd = txtOldPwd.Password;
string newPwd = txtNewPwd1.Password;
string newPwd2 = txtNewConfirmPwd.Password;
if (!newPwd.Equals(newPwd2))
{
"PwdNotEqual".GetFromResourece().Notify();
return;
}
try
{
#region Close Connection First
if (null != App.MainEngineer)
{
if (App.MainEngineer.IsOpened)
{
//If change pwd after the connection opened , it will access violation
//so close the Global Connection Frist,
//Then after the changing pwd processing ,reopen the global connection
App.MainEngineer.Close();
}
}
#endregion
#region Change PWD
using (SqlCeEngine eg = new SqlCeEngine())
{
eg.LocalConnectionString = String.Format("Data Source={0};Password={1}", Db, oldPwd);
eg.Compact(string.Format("Data Source={0};Password={1}", Db, newPwd));
}
"ChangePwdOK".GetFromResourece().Notify();
X_NewPwd = newPwd;
#endregion
#region Reopen DB
if (null != App.MainEngineer)
{
App.MainEngineer.CurPwd = newPwd;
App.MainEngineer.Open(new LoginInfo_SSCE()
{
DbName = App.MainEngineer.CurDatabase,
Pwd = App.MainEngineer.CurPwd,
IsEncrypted = true,
});
}
#endregion
DialogResult = true;
}
catch (SqlCeException ee)
{
String.Format("{0}\r\n{1}", ee.Message, "This may the old password you input is not valid").Notify();
return;
}
}
public void Compact()
{
using (SqlCeEngine engine = new SqlCeEngine(_connString))
engine.Compact(null);
}
/// <summary>
/// Imports the data in <paramref name="galleryData"/> to the SQL CE database.
/// </summary>
/// <param name="galleryData">An XML-formatted string containing the gallery data. The data must conform to the schema defined in the project for
/// the data provider's implementation.</param>
/// <param name="importMembershipData">if set to <c>true</c> import membership data.</param>
/// <param name="importGalleryData">if set to <c>true</c> import gallery data.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="galleryData" /> is null.</exception>
internal static void ImportData(string galleryData, bool importMembershipData, bool importGalleryData)
{
if (String.IsNullOrEmpty(galleryData))
throw new ArgumentNullException("galleryData");
SqlCeTransaction tran = null;
SqlCeConnection cn = Util.GetDbConnectionForGallery();
cn.Open();
try
{
tran = cn.BeginTransaction();
ClearData(importMembershipData, importGalleryData, cn, tran);
using (DataSet ds = GenerateDataSet(galleryData))
{
if (importMembershipData)
{
InsertApplications(ds, cn, tran);
InsertRoles(ds, cn, tran);
InsertUsers(ds, cn, tran);
InsertMembership(ds, cn, tran);
InsertUsersInRoles(ds, cn, tran);
InsertProfiles(ds, cn, tran);
}
if (importGalleryData)
{
InsertGalleries(ds, cn, tran);
Pause();
InsertAlbums(ds, cn, tran);
Pause();
InsertGalleryRoles(ds, cn, tran);
Pause();
InsertRolesAlbums(ds, cn, tran);
Pause();
InsertMediaObjects(ds, cn, tran);
Pause();
InsertMediaObjectMetadata(ds, cn, tran);
Pause();
InsertAppErrors(ds, cn, tran);
Pause();
InsertAppSettings(ds, cn, tran);
Pause();
InsertGalleryControlSettings(ds, cn, tran);
Pause();
InsertGallerySettings(ds, cn, tran);
Pause();
InsertBrowserTemplates(ds, cn, tran);
Pause();
InsertMimeTypes(ds, cn, tran);
Pause();
InsertMimeTypeGalleries(ds, cn, tran);
Pause();
InsertGalleryProfiles(ds, cn, tran);
Pause();
}
}
tran.Commit();
}
catch
{
if (tran != null)
tran.Rollback();
throw;
}
finally
{
if (tran != null)
tran.Dispose();
cn.Close();
}
try
{
SqlCeEngine engine = new SqlCeEngine(Util.ConnectionString);
engine.Compact(null);
}
catch (SqlCeException)
{
// During testing it was observed that calling Compact could result in the error "Could not load database compaction library".
// But if we pause and try again it succeeds.
Pause();
SqlCeEngine engineSecondTry = new SqlCeEngine(Util.ConnectionString);
engineSecondTry.Compact(null);
}
}
