private void DoBackupModule(IDataWriteOperator writer, DbFactory dbFactory, IModuleSpecifics module)
{
Logger.Debug("begin saving data for module {0}", module.ModuleName);
var tablesToProcess = module.Tables.Where(t => !IgnoredTables.Contains(t.Name) && t.InsertMethod != InsertMethod.None).ToList();
int tablesCount = tablesToProcess.Count;
int tablesProcessed = 0;
using (var connection = dbFactory.OpenConnection())
{
foreach (var table in tablesToProcess)
{
Logger.Debug("begin load table {0}", table.Name);
using (var data = new DataTable(table.Name))
{
ActionInvoker.Try(
state =>
{
data.Clear();
var t = (TableInfo)state;
var dataAdapter = dbFactory.CreateDataAdapter();
dataAdapter.SelectCommand = module.CreateSelectCommand(connection.Fix(), TenantId, t).WithTimeout(600);
((DbDataAdapter)dataAdapter).Fill(data);
},
table,
maxAttempts: 5,
onFailure: error => { throw ThrowHelper.CantBackupTable(table.Name, error); },
onAttemptFailure: error => Logger.Warn("backup attempt failure: {0}", error));
foreach (var col in data.Columns.Cast <DataColumn>().Where(col => col.DataType == typeof(DateTime)))
{
col.DateTimeMode = DataSetDateTime.Unspecified;
}
module.PrepareData(data);
Logger.Debug("end load table {0}", table.Name);
Logger.Debug("begin saving table {0}", table.Name);
var tmp = Path.GetTempFileName();
using (var file = File.OpenWrite(tmp))
{
data.WriteXml(file, XmlWriteMode.WriteSchema);
data.Clear();
}
writer.WriteEntry(KeyHelper.GetTableZipKey(module, data.TableName), tmp);
File.Delete(tmp);
Logger.Debug("end saving table {0}", table.Name);
}
SetCurrentStepProgress((int)((++tablesProcessed * 100) / (double)tablesCount));
}
}
Logger.Debug("end saving data for module {0}", module.ModuleName);
}
private void DoBackupModule(IDataWriteOperator writer, DbFactory dbFactory, IModuleSpecifics module)
{
InvokeInfo("begin saving data for module {0}", module.ModuleName);
int tablesCount = module.Tables.Count();
int tablesProcessed = 0;
using (var connection = dbFactory.OpenConnection(module.ConnectionStringName))
{
foreach (var table in module.Tables)
{
InvokeInfo("begin saving table {0}", table.Name);
using (var data = new DataTable(table.Name))
{
ActionInvoker.Try(
state =>
{
data.Clear();
var t = (TableInfo)state;
var dataAdapter = dbFactory.CreateDataAdapter(module.ConnectionStringName);
dataAdapter.SelectCommand = module.CreateSelectCommand(connection.Fix(), Tenant.TenantId, t).WithTimeout(600);
((DbDataAdapter)dataAdapter).Fill(data);
},
table,
maxAttempts: 5,
onFailure: error => { throw ThrowHelper.CantBackupTable(table.Name, error); },
onAttemptFailure: error => InvokeWarning("backup attempt failure: {0}", error));
foreach (var col in data.Columns.Cast <DataColumn>().Where(col => col.DataType == typeof(DateTime)))
{
col.DateTimeMode = DataSetDateTime.Unspecified;
}
var stream = writer.BeginWriteEntry(KeyHelper.GetTableZipKey(module, data.TableName));
data.WriteXml(stream, XmlWriteMode.WriteSchema);
writer.EndWriteEntry();
data.Clear();
}
SetStepProgress((int)((++tablesProcessed * 100) / (double)tablesCount));
}
}
InvokeInfo("end saving data for module {0}", module.ModuleName);
}
private void RestoreTable(IDbConnection connection, TableInfo tableInfo, ref int transactionsCommited, ref int rowsInserted)
{
using (var stream = _reader.GetEntry(KeyHelper.GetTableZipKey(_module, tableInfo.Name)))
{
var lowImportanceRelations = _module
.TableRelations
.Where(r => string.Equals(r.ParentTable, tableInfo.Name, StringComparison.InvariantCultureIgnoreCase))
.Where(r => r.Importance == RelationImportance.Low && !r.IsSelfRelation())
.Select(r => Tuple.Create(r, _module.Tables.Single(t => t.Name == r.ChildTable)))
.ToList();
foreach (IEnumerable <DataRowInfo> rows in GetRows(tableInfo, stream).Skip(transactionsCommited * TransactionLength).MakeParts(TransactionLength))
{
using (var transaction = connection.BeginTransaction())
{
int rowsSuccess = 0;
foreach (DataRowInfo row in rows)
{
if (_replaceDate)
{
foreach (var column in tableInfo.DateColumns)
{
_columnMapper.SetDateMapping(tableInfo.Name, column, row[column.Key]);
}
}
object oldIdValue = null;
object newIdValue = null;
if (tableInfo.HasIdColumn())
{
oldIdValue = row[tableInfo.IdColumn];
newIdValue = _columnMapper.GetMapping(tableInfo.Name, tableInfo.IdColumn, oldIdValue);
if (newIdValue == null)
{
if (tableInfo.IdType == IdType.Guid)
{
newIdValue = Guid.NewGuid().ToString("D");
}
else if (tableInfo.IdType == IdType.Integer)
{
newIdValue = connection
.CreateCommand(string.Format("select max({0}) from {1};", tableInfo.IdColumn, tableInfo.Name))
.WithTimeout(120)
.ExecuteScalar <int>() + 1;
}
}
if (newIdValue != null)
{
_columnMapper.SetMapping(tableInfo.Name, tableInfo.IdColumn, oldIdValue, newIdValue);
}
}
var insertCommand = _module.CreateInsertCommand(connection, _columnMapper, tableInfo, row);
if (insertCommand == null)
{
WarnCantInsertRow(row);
_columnMapper.Rollback();
continue;
}
insertCommand.WithTimeout(120).ExecuteNonQuery();
rowsSuccess++;
if (tableInfo.HasIdColumn() && tableInfo.IdType == IdType.Autoincrement)
{
var lastIdCommand = _factory.CreateLastInsertIdCommand(_module.ConnectionStringName);
lastIdCommand.Connection = connection;
newIdValue = Convert.ToInt32(lastIdCommand.ExecuteScalar());
_columnMapper.SetMapping(tableInfo.Name, tableInfo.IdColumn, oldIdValue, newIdValue);
}
_columnMapper.Commit();
foreach (Tuple <RelationInfo, TableInfo> relation in lowImportanceRelations)
{
if (!relation.Item2.HasTenantColumn())
{
InvokeWarning("Table {0} does not contain tenant id column. Can't apply low importance relations on such tables.", relation.Item2.Name);
continue;
}
object oldValue = row[relation.Item1.ParentColumn];
object newValue = _columnMapper.GetMapping(relation.Item1.ParentTable, relation.Item1.ParentColumn, oldValue);
connection.CreateCommand(string.Format("update {0} set {1} = {2} where {1} = {3} and {4} = {5}",
relation.Item1.ChildTable,
relation.Item1.ChildColumn,
newValue is string? "'" + newValue + "'" : newValue,
oldValue is string? "'" + oldValue + "'" : oldValue,
relation.Item2.TenantColumn,
_columnMapper.GetTenantMapping())).WithTimeout(120).ExecuteNonQuery();
}
}
transaction.Commit();
transactionsCommited++;
rowsInserted += rowsSuccess;
}
}
}
}