public void Refresh_Executes_Without_Exception()
{
DeleteAll_Executes_Without_Exception();
Insert_Executes_Without_Exception();
DataSet dsSchema = _commandBuilder.GetSchema();
DataSet ds = dsSchema.Clone();
ds.ReadXml(ReadOnlyStreamFromFilename(GetXmlRefeshFilename()));
using (var sqlTransaction = _commandBuilder.Connection.BeginTransaction())
{
try
{
_dbOperation.Refresh(ds, _commandBuilder, sqlTransaction);
sqlTransaction.Commit();
}
catch
{
sqlTransaction.Rollback();
throw;
}
}
Assert.IsTrue(true);
}
private void insertCommon(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction,
bool insertIdentity)
{
Hashtable insertedTableColl = new Hashtable();
DataSet dsSchema = dbCommandBuilder.GetSchema();
DataSetTableIterator iterator = new DataSetTableIterator(dsSchema, true);
foreach (DataTable dataTable in iterator)
{
insertRecursive(ds, dataTable, dbCommandBuilder, dbTransaction, insertedTableColl, insertIdentity);
}
}
private void deleteCommon(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction,
bool deleteAll)
{
Hashtable deletedTableColl = new Hashtable();
DataSet dsSchema = dbCommandBuilder.GetSchema();
DataSetTableIterator iterator = new DataSetTableIterator(dsSchema, true);
foreach (DataTable dataTable in iterator)
{
deleteRecursive(ds, dataTable, dbCommandBuilder, dbTransaction, deletedTableColl, deleteAll);
}
}
public void ReadXmlSchema(Stream xmlSchema)
{
IDbCommandBuilder dbCommandBuilder = GetDbCommandBuilder();
dbCommandBuilder.BuildCommands(xmlSchema);
DataSet dsSchema = dbCommandBuilder.GetSchema();
ValidateNamespace(dsSchema);
_dataSet = dsSchema.Clone();
_initialized = true;
}
public void GetSchema_Throws_NDbUnit_Exception_When_Not_Initialized()
{
IDbCommandBuilder builder = GetDbCommandBuilder();
try
{
builder.GetSchema();
Assert.Fail("Expected Exception of type NDbUnitException not thrown!");
}
catch (NDbUnitException ex)
{
Assert.IsNotNull(ex);
}
}
public void _FixtureSetUp()
{
_commandBuilder = GetCommandBuilder();
string xmlSchemaFile = GetXmlSchemaFilename();
_xmlFile = GetXmlFilename();
_commandBuilder.BuildCommands(xmlSchemaFile);
DataSet dsSchema = _commandBuilder.GetSchema();
_dsData = dsSchema.Clone();
_dsData.ReadXml(ReadOnlyStreamFromFilename(_xmlFile));
_dbOperation = GetDbOperation();
}
public void GetSchema_Contains_Proper_Tables()
{
IDbCommandBuilder builder = GetDbCommandBuilder();
builder.BuildCommands(GetXmlSchemaFilename());
DataSet schema = builder.GetSchema();
IList <string> schemaTables = new List <string>();
foreach (DataTable dataTable in schema.Tables)
{
schemaTables.Add(dataTable.TableName);
Console.WriteLine("Table '" + dataTable.TableName + "' found in dataset");
}
Assert.AreEqual(EXPECTED_COUNT_OF_COMMANDS, schema.Tables.Count, string.Format("Should be {0} Tables in dataset", EXPECTED_COUNT_OF_COMMANDS));
Assert.That(ExpectedDataSetTableNames, Is.EquivalentTo(schemaTables));
}
protected void ResetIdentityColumns()
{
IDbTransaction sqlTransaction = null;
try
{
DataSet dsSchema = _commandBuilder.GetSchema();
sqlTransaction = _commandBuilder.Connection.BeginTransaction();
foreach (DataTable table in dsSchema.Tables)
{
foreach (DataColumn column in table.Columns)
{
if (column.AutoIncrement)
{
IDbCommand sqlCommand = GetResetIdentityColumnsDbCommand(table, column);
sqlCommand.Transaction = (IDbTransaction)sqlTransaction;
if (sqlCommand != null)
{
sqlCommand.ExecuteNonQuery();
}
break;
}
}
}
sqlTransaction.Commit();
}
catch (Exception)
{
if (sqlTransaction != null)
{
sqlTransaction.Rollback();
}
throw;
}
}
public void GetDeleteAllCommand_Creates_Correct_SQL_Commands()
{
IList <string> commandList = new List <string>();
DataSet ds = _commandBuilder.GetSchema();
foreach (DataTable dataTable in ds.Tables)
{
IDbCommand dbCommand = _commandBuilder.GetDeleteAllCommand(dataTable.TableName);
commandList.Add(dbCommand.CommandText);
Console.WriteLine("Table '" + dataTable.TableName + "' delete all command");
Console.WriteLine("\t" + dbCommand.CommandText);
}
Assert.AreEqual(EXPECTED_COUNT_OF_COMMANDS, commandList.Count, string.Format("Should be {0} commands", EXPECTED_COUNT_OF_COMMANDS));
Assert.That(ExpectedDeleteAllCommands, Is.EquivalentTo(commandList));
}
protected virtual void OnRefresh(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction, string tableName)
{
IDbTransaction sqlTransaction = dbTransaction;
IDbDataAdapter sqlDataAdapter = CreateDbDataAdapter();
sqlDataAdapter.SelectCommand = dbCommandBuilder.GetSelectCommand(tableName);
sqlDataAdapter.SelectCommand.Connection = sqlTransaction.Connection;
sqlDataAdapter.SelectCommand.Transaction = sqlTransaction;
DataSet dsDb = new DataSet();
// Query all records in the database table.
((DbDataAdapter)sqlDataAdapter).Fill(dsDb, tableName);
DataSet dsUpdate = dbCommandBuilder.GetSchema().Clone();
dsUpdate.EnforceConstraints = false;
DataTable dataTable = ds.Tables[tableName];
DataTable dataTableDb = dsDb.Tables[tableName];
// Iterate all rows in the table.
foreach (DataRow dataRow in dataTable.Rows)
{
bool rowDoesNotExist = true;
// Iterate all rows in the database table.
foreach (DataRow dataRowDb in dataTableDb.Rows)
{
// The row exists in the database.
if (IsPrimaryKeyValueEqual(dataRow, dataRowDb, dsUpdate.Tables[tableName].PrimaryKey))
{
rowDoesNotExist = false;
DataRow dataRowNew = CloneDataRow(dsUpdate.Tables[tableName], dataRow);
dsUpdate.Tables[tableName].Rows.Add(dataRowNew);
dataRowNew.AcceptChanges();
MarkRowAsModified(dataRowNew);
break;
}
}
// The row does not exist in the database.
if (rowDoesNotExist)
{
DataRow dataRowNew = CloneDataRow(dsUpdate.Tables[tableName], dataRow);
dsUpdate.Tables[tableName].Rows.Add(dataRowNew);
dataRowNew.AcceptChanges();
}
}
// Does not insert identity.
sqlDataAdapter.InsertCommand = dbCommandBuilder.GetInsertCommand(tableName);
sqlDataAdapter.InsertCommand.Connection = sqlTransaction.Connection;
sqlDataAdapter.InsertCommand.Transaction = sqlTransaction;
sqlDataAdapter.UpdateCommand = dbCommandBuilder.GetUpdateCommand(tableName);
sqlDataAdapter.UpdateCommand.Connection = sqlTransaction.Connection;
sqlDataAdapter.UpdateCommand.Transaction = sqlTransaction;
//DisableTableConstraints(dsUpdate.Tables[tableName], dbTransaction);
((DbDataAdapter)sqlDataAdapter).Update(dsUpdate, tableName);
//EnableTableConstraints(dsUpdate.Tables[tableName], dbTransaction);
}
public void _FixtureSetUp()
{
_commandBuilder = GetCommandBuilder();
string xmlSchemaFile = GetXmlSchemaFilename();
_xmlFile = GetXmlFilename();
_commandBuilder.BuildCommands(xmlSchemaFile);
DataSet dsSchema = _commandBuilder.GetSchema();
_dsData = dsSchema.Clone();
_dsData.ReadXml(ReadOnlyStreamFromFilename(_xmlFile));
_dbOperation = GetDbOperation();
}
private void insertCommon(DataSet ds, IDbCommandBuilder dbCommandBuilder, DbTransaction dbTransaction,
bool insertIdentity)
{
Hashtable insertedTableColl = new Hashtable();
DataSet dsSchema = dbCommandBuilder.GetSchema();
DataSetTableIterator iterator = new DataSetTableIterator(dsSchema, true);
foreach (DataTable dataTable in iterator)
{
insertRecursive(ds, dataTable, dbCommandBuilder, dbTransaction, insertedTableColl, insertIdentity);
}
}
private void deleteCommon(DataSet ds, IDbCommandBuilder dbCommandBuilder, DbTransaction dbTransaction,
bool deleteAll)
{
Hashtable deletedTableColl = new Hashtable();
DataSet dsSchema = dbCommandBuilder.GetSchema();
DataSetTableIterator iterator = new DataSetTableIterator(dsSchema, true);
foreach (DataTable dataTable in iterator)
{
deleteRecursive(ds, dataTable, dbCommandBuilder, dbTransaction, deletedTableColl, deleteAll);
}
}
protected virtual void OnRefresh(DataSet ds, IDbCommandBuilder dbCommandBuilder, DbTransaction dbTransaction, string tableName, bool insertIdentity)
{
DbTransaction sqlTransaction = dbTransaction;
using (DbDataAdapter sqlDataAdapter = CreateDbDataAdapter())
{
using (var selectCommand = dbCommandBuilder.GetSelectCommand(dbTransaction, tableName))
{
selectCommand.Connection = sqlTransaction.Connection;
selectCommand.Transaction = sqlTransaction;
sqlDataAdapter.SelectCommand = selectCommand;
DataSet dsDb = new DataSet();
// Query all records in the database table.
((DbDataAdapter)sqlDataAdapter).Fill(dsDb, tableName);
DataSet dsUpdate = dbCommandBuilder.GetSchema().Clone();
dsUpdate.EnforceConstraints = false;
DataTable dataTable = ds.Tables[tableName];
DataTable dataTableDb = dsDb.Tables[tableName];
var schemaTable = dsUpdate.Tables[tableName];
if (dataTableDb.PrimaryKey.Length == 0)
dataTableDb.PrimaryKey = schemaTable
.PrimaryKey
.Select(c => dataTableDb.Columns[c.ColumnName])
.OrderBy(c => c.Ordinal)
.ToArray();
// Iterate all rows in the table.
foreach (DataRow dataRow in dataTable.Rows)
{
var pkValues = dataTableDb.PrimaryKey
.Select(c => dataRow[c.ColumnName])
.ToArray();
var dataRowDb = dataTableDb.Rows.Find(pkValues);
bool rowExists = dataRowDb != null;
DataRow dataRowNew = CloneDataRow(dsUpdate.Tables[tableName], dataRow);
dsUpdate.Tables[tableName].Rows.Add(dataRowNew);
// The row does not exist in the database.
if (rowExists)
{
dataRowNew.AcceptChanges();
if (dataTableDb.PrimaryKey.Length != dataTableDb.Columns.Count)
MarkRowAsModified(dataRowNew);
}
}
var hasAutoIncColumn = dataTable.Columns.Cast<DataColumn>().Any(x => x.AutoIncrement);
var identityInsertGuard = insertIdentity && hasAutoIncColumn ? ActivateInsertIdentity(dataTable.TableName, dbTransaction) : null;
using (identityInsertGuard)
{
DbCommand insertCommand =
insertIdentity && hasAutoIncColumn
? dbCommandBuilder.GetInsertIdentityCommand(dbTransaction, tableName)
: dbCommandBuilder.GetInsertCommand(dbTransaction, tableName);
using (insertCommand)
{
insertCommand.Connection = sqlTransaction.Connection;
insertCommand.Transaction = sqlTransaction;
sqlDataAdapter.InsertCommand = insertCommand;
using (var updateCommand = dbCommandBuilder.GetUpdateCommand(dbTransaction, tableName))
{
updateCommand.Connection = sqlTransaction.Connection;
updateCommand.Transaction = sqlTransaction;
sqlDataAdapter.UpdateCommand = updateCommand;
//DisableTableConstraints(dsUpdate.Tables[tableName], dbTransaction);
sqlDataAdapter.Update(dsUpdate, tableName);
//EnableTableConstraints(dsUpdate.Tables[tableName], dbTransaction);
}
}
}
}
}
}
protected virtual void OnRefresh(DataSet ds, IDbCommandBuilder dbCommandBuilder, DbTransaction dbTransaction, string tableName, bool insertIdentity)
{
DbTransaction sqlTransaction = dbTransaction;
using (DbDataAdapter sqlDataAdapter = CreateDbDataAdapter())
{
using (var selectCommand = dbCommandBuilder.GetSelectCommand(dbTransaction, tableName))
{
selectCommand.Connection = sqlTransaction.Connection;
selectCommand.Transaction = sqlTransaction;
sqlDataAdapter.SelectCommand = selectCommand;
DataSet dsDb = new DataSet();
// Query all records in the database table.
((DbDataAdapter)sqlDataAdapter).Fill(dsDb, tableName);
DataSet dsUpdate = dbCommandBuilder.GetSchema().Clone();
dsUpdate.EnforceConstraints = false;
DataTable dataTable = ds.Tables[tableName];
DataTable dataTableDb = dsDb.Tables[tableName];
var schemaTable = dsUpdate.Tables[tableName];
if (dataTableDb.PrimaryKey.Length == 0)
{
dataTableDb.PrimaryKey = schemaTable
.PrimaryKey
.Select(c => dataTableDb.Columns[c.ColumnName])
.OrderBy(c => c.Ordinal)
.ToArray();
}
// Iterate all rows in the table.
foreach (DataRow dataRow in dataTable.Rows)
{
var pkValues = dataTableDb.PrimaryKey
.Select(c => dataRow[c.ColumnName])
.ToArray();
var dataRowDb = dataTableDb.Rows.Find(pkValues);
bool rowExists = dataRowDb != null;
DataRow dataRowNew = CloneDataRow(dsUpdate.Tables[tableName], dataRow);
dsUpdate.Tables[tableName].Rows.Add(dataRowNew);
// The row does not exist in the database.
if (rowExists)
{
dataRowNew.AcceptChanges();
if (dataTableDb.PrimaryKey.Length != dataTableDb.Columns.Count)
{
MarkRowAsModified(dataRowNew);
}
}
}
var hasAutoIncColumn = dataTable.Columns.Cast <DataColumn>().Any(x => x.AutoIncrement);
var identityInsertGuard = insertIdentity && hasAutoIncColumn?ActivateInsertIdentity(dataTable.TableName, dbTransaction) : null;
using (identityInsertGuard)
{
DbCommand insertCommand =
insertIdentity && hasAutoIncColumn
? dbCommandBuilder.GetInsertIdentityCommand(dbTransaction, tableName)
: dbCommandBuilder.GetInsertCommand(dbTransaction, tableName);
using (insertCommand)
{
insertCommand.Connection = sqlTransaction.Connection;
insertCommand.Transaction = sqlTransaction;
sqlDataAdapter.InsertCommand = insertCommand;
using (var updateCommand = dbCommandBuilder.GetUpdateCommand(dbTransaction, tableName))
{
updateCommand.Connection = sqlTransaction.Connection;
updateCommand.Transaction = sqlTransaction;
sqlDataAdapter.UpdateCommand = updateCommand;
//DisableTableConstraints(dsUpdate.Tables[tableName], dbTransaction);
sqlDataAdapter.Update(dsUpdate, tableName);
//EnableTableConstraints(dsUpdate.Tables[tableName], dbTransaction);
}
}
}
}
}
}
protected virtual void OnRefresh(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction, string tableName)
{
IDbTransaction sqlTransaction = dbTransaction;
IDbDataAdapter sqlDataAdapter = CreateDbDataAdapter();
sqlDataAdapter.SelectCommand = dbCommandBuilder.GetSelectCommand(tableName);
sqlDataAdapter.SelectCommand.Connection = sqlTransaction.Connection;
sqlDataAdapter.SelectCommand.Transaction = sqlTransaction;
DataSet dsDb = new DataSet();
// Query all records in the database table.
((DbDataAdapter)sqlDataAdapter).Fill(dsDb, tableName);
DataSet dsUpdate = dbCommandBuilder.GetSchema().Clone();
dsUpdate.EnforceConstraints = false;
DataTable dataTable = ds.Tables[tableName];
DataTable dataTableDb = dsDb.Tables[tableName];
// Iterate all rows in the table.
foreach (DataRow dataRow in dataTable.Rows)
{
bool rowDoesNotExist = true;
// Iterate all rows in the database table.
foreach (DataRow dataRowDb in dataTableDb.Rows)
{
// The row exists in the database.
if (IsPrimaryKeyValueEqual(dataRow, dataRowDb, dsUpdate.Tables[tableName].PrimaryKey))
{
rowDoesNotExist = false;
DataRow dataRowNew = CloneDataRow(dsUpdate.Tables[tableName], dataRow);
dsUpdate.Tables[tableName].Rows.Add(dataRowNew);
dataRowNew.AcceptChanges();
MarkRowAsModified(dataRowNew);
break;
}
}
// The row does not exist in the database.
if (rowDoesNotExist)
{
DataRow dataRowNew = CloneDataRow(dsUpdate.Tables[tableName], dataRow);
dsUpdate.Tables[tableName].Rows.Add(dataRowNew);
dataRowNew.AcceptChanges();
}
}
// Does not insert identity.
sqlDataAdapter.InsertCommand = dbCommandBuilder.GetInsertCommand(tableName);
sqlDataAdapter.InsertCommand.Connection = sqlTransaction.Connection;
sqlDataAdapter.InsertCommand.Transaction = sqlTransaction;
sqlDataAdapter.UpdateCommand = dbCommandBuilder.GetUpdateCommand(tableName);
sqlDataAdapter.UpdateCommand.Connection = sqlTransaction.Connection;
sqlDataAdapter.UpdateCommand.Transaction = sqlTransaction;
//DisableTableConstraints(dsUpdate.Tables[tableName], dbTransaction);
((DbDataAdapter)sqlDataAdapter).Update(dsUpdate, tableName);
//EnableTableConstraints(dsUpdate.Tables[tableName], dbTransaction);
}
