public override void SetUp()
{
base.SetUp();
_tableDefinitionFinder = new TableDefinitionFinder(new RdbmsPersistenceModelProvider());
_dbCommandBuilderFactoryStrictMock = MockRepository.GenerateStrictMock <IDbCommandBuilderFactory>();
_objectReaderFactoryStrictMock = MockRepository.GenerateStrictMock <IObjectReaderFactory>();
_dbCommandBuilder1Stub = MockRepository.GenerateStub <IDbCommandBuilder>();
_dbCommandBuilder2Stub = MockRepository.GenerateStub <IDbCommandBuilder>();
_timestampReader1Stub = MockRepository.GenerateStub <IObjectReader <Tuple <ObjectID, object> > > ();
_timestampReader2Stub = MockRepository.GenerateStub <IObjectReader <Tuple <ObjectID, object> > > ();
_dataContainerReader1Stub = MockRepository.GenerateStub <IObjectReader <DataContainer> > ();
_dataContainerReader2Stub = MockRepository.GenerateStub <IObjectReader <DataContainer> > ();
_factory = new LookupCommandFactory(
TestDomainStorageProviderDefinition,
_dbCommandBuilderFactoryStrictMock,
_objectReaderFactoryStrictMock,
_tableDefinitionFinder);
_tableDefinition1 = TableDefinitionObjectMother.Create(TestDomainStorageProviderDefinition);
_tableDefinition2 = TableDefinitionObjectMother.Create(TestDomainStorageProviderDefinition);
_objectID1 = CreateObjectID(_tableDefinition1);
_objectID2 = CreateObjectID(_tableDefinition1);
_objectID3 = CreateObjectID(_tableDefinition2);
}
public override void SetUp()
{
base.SetUp();
_rdbmsPersistenceModelProvider = new RdbmsPersistenceModelProvider();
_dbCommandBuilderFactoryStrictMock = MockRepository.GenerateStrictMock <IDbCommandBuilderFactory>();
_objectReaderFactoryStrictMock = MockRepository.GenerateStrictMock <IObjectReaderFactory>();
_dbCommandBuilderStub = MockRepository.GenerateStub <IDbCommandBuilder> ();
_dataContainerReaderStub = MockRepository.GenerateStub <IObjectReader <DataContainer> > ();
_objectIDReaderStub = MockRepository.GenerateStub <IObjectReader <ObjectID> > ();
_fakeStorageProviderCommandFactory = MockRepository.GenerateStub <IStorageProviderCommandFactory <IRdbmsProviderCommandExecutionContext> >();
_factory = new RelationLookupCommandFactory(
_fakeStorageProviderCommandFactory,
_dbCommandBuilderFactoryStrictMock,
_rdbmsPersistenceModelProvider,
_objectReaderFactoryStrictMock);
_tableDefinition = TableDefinitionObjectMother.Create(TestDomainStorageProviderDefinition, new EntityNameDefinition(null, "Table1"));
_unionViewDefinition = UnionViewDefinitionObjectMother.Create(
TestDomainStorageProviderDefinition,
new EntityNameDefinition(null, "ViewName"),
_tableDefinition);
_foreignKeyValue = CreateObjectID(_tableDefinition);
_foreignKeyStoragePropertyDefinitionStrictMock = MockRepository.GenerateStrictMock <IRdbmsStoragePropertyDefinition>();
_fakeComparedColumns = new[] { new ColumnValue(ColumnDefinitionObjectMother.IDColumn, _foreignKeyValue.Value) };
}
public DataSet GetDataSetFromDb(StringCollection tableNames, DbTransaction dbTransaction)
{
checkInitialized();
IDbCommandBuilder dbCommandBuilder = GetDbCommandBuilder();
if (null == tableNames)
{
tableNames = new StringCollection();
foreach (DataTable dt in _dataSet.Tables)
{
tableNames.Add(dt.TableName);
}
}
DbConnection dbConnection = dbCommandBuilder.Connection;
using (new OpenConnectionGuard(dbConnection))
{
DataSet dsToFill = _dataSet.Clone();
dsToFill.EnforceConstraints = false;
foreach (string tableName in tableNames)
{
OnGetDataSetFromDb(tableName, ref dsToFill, dbConnection, dbTransaction);
}
dsToFill.EnforceConstraints = true;
return(dsToFill);
}
}
protected virtual void OnUpdate(DataSet ds, IDbCommandBuilder dbCommandBuilder, DbTransaction dbTransaction, string tableName)
{
DbTransaction sqlTransaction = dbTransaction;
//DisableTableConstraints(ds.Tables[tableName], dbTransaction);
DbDataAdapter sqlDataAdapter = CreateDbDataAdapter();
try
{
using (var updateCommand = dbCommandBuilder.GetUpdateCommand(dbTransaction, tableName))
{
updateCommand.Connection = sqlTransaction.Connection;
updateCommand.Transaction = sqlTransaction;
sqlDataAdapter.UpdateCommand = updateCommand;
((DbDataAdapter)sqlDataAdapter).Update(ds, tableName);
}
}
finally
{
var disposable = sqlDataAdapter as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
//EnableTableConstraints(ds.Tables[tableName], dbTransaction);
}
public SingleObjectLoadCommand(IDbCommandBuilder dbCommandBuilder, IObjectReader <T> objectReader)
{
ArgumentUtility.CheckNotNull("dbCommandBuilder", dbCommandBuilder);
ArgumentUtility.CheckNotNull("objectReader", objectReader);
_dbCommandBuilder = dbCommandBuilder;
_objectReader = objectReader;
}
/// <summary>
/// Invalidates the cache.
/// </summary>
/// <param name="commandBuilder">The command builder.</param>
/// <param name="cacheKey">The cache key.</param>
/// <returns>ILink.</returns>
public static ILink <int?> InvalidateCache(this IDbCommandBuilder commandBuilder, string cacheKey)
{
if (commandBuilder == null)
{
throw new ArgumentNullException("commandBuilder", "commandBuilder is null.");
}
return(new InvalidateCacheAppender <int?>(commandBuilder.AsNonQuery(), cacheKey));
}
protected IDbCommandBuilder GetDbCommandBuilder()
{
if (_dbCommandBuilder == null)
{
_dbCommandBuilder = CreateDbCommandBuilder(ConnectionManager);
}
return(_dbCommandBuilder);
}
public void Refresh(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction)
{
DataSetTableIterator iterator = new DataSetTableIterator(ds, false);
foreach (DataTable dataTable in iterator)
{
OnRefresh(ds, dbCommandBuilder, dbTransaction, dataTable.TableName);
}
}
public void Refresh(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction)
{
DataSetTableIterator iterator = new DataSetTableIterator(ds, false);
foreach (DataTable dataTable in iterator)
{
OnRefresh(ds, dbCommandBuilder, dbTransaction, dataTable.TableName);
}
}
public void SetUp()
{
_fakeResult = new object();
_commandExecutionContextMock = MockRepository.GenerateStrictMock <IRdbmsProviderCommandExecutionContext>();
_dbCommandMock = MockRepository.GenerateStrictMock <IDbCommand>();
_dbCommandBuilderMock = MockRepository.GenerateStrictMock <IDbCommandBuilder>();
_command = new ScalarValueLoadCommand(_dbCommandBuilderMock);
}
public void SetUp()
{
_fakeResult = new object();
_dataReaderMock = MockRepository.GenerateStub <IDataReader>();
_commandExecutionContextMock = MockRepository.GenerateStrictMock <IRdbmsProviderCommandExecutionContext>();
_dbCommandMock = MockRepository.GenerateStrictMock <IDbCommand>();
_dbCommandBuilderMock = MockRepository.GenerateStrictMock <IDbCommandBuilder>();
_objectReaderMock = MockRepository.GenerateStrictMock <IObjectReader <object> > ();
_command = new SingleObjectLoadCommand <object> (_dbCommandBuilderMock, _objectReaderMock);
}
public void _SetUp()
{
_mockSchemaFileStream = new FileStream(GetXmlSchemaFilename(), FileMode.Open, FileAccess.Read, FileShare.Read);
_mockDataFileStream = new FileStream(GetXmlFilename(), FileMode.Open, FileAccess.Read, FileShare.Read);
_mocker = new MockRepository();
_mockDbCommandBuilder = _mocker.CreateMock <IDbCommandBuilder>();
_mockDbOperation = _mocker.CreateMock <IDbOperation>();
_nDbUnitTestStub = GetUnitTestStub();
_mockConnection = _mocker.CreateMock <IDbConnection>();
_mockTransaction = _mocker.CreateMock <IDbTransaction>();
}
public void Refresh(DataSet ds, IDbCommandBuilder dbCommandBuilder, DbTransaction dbTransaction)
{
DataSetTableIterator iterator = new DataSetTableIterator(ds, false);
DisableAllTableConstraints(ds, dbTransaction);
foreach (DataTable dataTable in iterator)
{
OnRefresh(ds, dbCommandBuilder, dbTransaction, dataTable.TableName, true);
}
EnableAllTableConstraints(ds, dbTransaction);
}
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 ReadXmlSchema(Stream xmlSchema)
{
IDbCommandBuilder dbCommandBuilder = GetDbCommandBuilder();
dbCommandBuilder.BuildCommands(xmlSchema);
DataSet dsSchema = dbCommandBuilder.GetSchema();
ValidateNamespace(dsSchema);
_dataSet = dsSchema.Clone();
_initialized = true;
}
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);
}
}
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);
}
}
protected virtual void OnUpdate(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction, string tableName)
{
IDbTransaction sqlTransaction = dbTransaction;
//DisableTableConstraints(ds.Tables[tableName], dbTransaction);
IDbDataAdapter sqlDataAdapter = CreateDbDataAdapter();
sqlDataAdapter.UpdateCommand = dbCommandBuilder.GetUpdateCommand(tableName);
sqlDataAdapter.UpdateCommand.Connection = sqlTransaction.Connection;
sqlDataAdapter.UpdateCommand.Transaction = sqlTransaction;
((DbDataAdapter)sqlDataAdapter).Update(ds, tableName);
//EnableTableConstraints(ds.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();
}
public void SetUp()
{
_repository = new MockRepository();
_dataReaderMock = _repository.StrictMock <IDataReader>();
_commandExecutionContextStub = _repository.Stub <IRdbmsProviderCommandExecutionContext>();
_dbCommandMock1 = _repository.StrictMock <IDbCommand>();
_dbCommandMock2 = _repository.StrictMock <IDbCommand>();
_dbCommandBuilderMock1 = _repository.StrictMock <IDbCommandBuilder>();
_dbCommandBuilderMock2 = _repository.StrictMock <IDbCommandBuilder>();
_objectReaderStub1 = _repository.Stub <IObjectReader <object> > ();
_objectReaderStub2 = _repository.Stub <IObjectReader <object> > ();
_fakeResult1 = new object();
_fakeResult2 = new object();
}
public void Update(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction)
{
DataSet dsCopy = ds.Copy();
dsCopy.AcceptChanges();
DataSetTableIterator iterator = new DataSetTableIterator(dsCopy, true);
foreach (DataTable dataTable in iterator)
{
foreach (DataRow dataRow in dataTable.Rows)
{
// Modify every table row.
dataRow.BeginEdit();
dataRow.EndEdit();
}
OnUpdate(dsCopy, dbCommandBuilder, dbTransaction, dataTable.TableName);
}
}
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));
}
public void Update(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction)
{
DataSet dsCopy = ds.Copy();
dsCopy.AcceptChanges();
DataSetTableIterator iterator = new DataSetTableIterator(dsCopy, true);
foreach (DataTable dataTable in iterator)
{
foreach (DataRow dataRow in dataTable.Rows)
{
// Modify every table row.
dataRow.BeginEdit();
dataRow.EndEdit();
}
OnUpdate(dsCopy, dbCommandBuilder, dbTransaction, dataTable.TableName);
}
}
public DataSet GetDataSetFromDb(StringCollection tableNames)
{
checkInitialized();
IDbCommandBuilder dbCommandBuilder = GetDbCommandBuilder();
if (null == tableNames)
{
tableNames = new StringCollection();
foreach (DataTable dt in _dataSet.Tables)
{
tableNames.Add(dt.TableName);
}
}
IDbConnection dbConnection = dbCommandBuilder.Connection;
try
{
dbConnection.Open();
DataSet dsToFill = _dataSet.Clone();
dsToFill.EnforceConstraints = false;
foreach (string tableName in tableNames)
{
OnGetDataSetFromDb(tableName, ref dsToFill, dbConnection);
}
dsToFill.EnforceConstraints = true;
return(dsToFill);
}
finally
{
if (ConnectionState.Open == dbConnection.State)
{
dbConnection.Close();
}
}
}
public override void SetUp()
{
base.SetUp();
_repository = new MockRepository();
_dbCommandBuilder1Mock = _repository.StrictMock <IDbCommandBuilder>();
_dbCommandBuilder2Mock = _repository.StrictMock <IDbCommandBuilder>();
_commandExecutionContextStub = _repository.Stub <IRdbmsProviderCommandExecutionContext> ();
_objectIDReaderStub = _repository.Stub <IObjectReader <ObjectID> > ();
_dbCommandMock1 = _repository.StrictMock <IDbCommand>();
_dbCommandMock2 = _repository.StrictMock <IDbCommand> ();
_dataReaderMock = _repository.StrictMock <IDataReader>();
_command = new MultiObjectIDLoadCommand(new[] { _dbCommandBuilder1Mock, _dbCommandBuilder2Mock }, _objectIDReaderStub);
_objectID1 = new ObjectID("Order", Guid.NewGuid());
_fakeResult = new[] { _objectID1 };
}
public void Insert(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction)
{
insertCommon(ds, dbCommandBuilder, dbTransaction, false);
}
public void InsertIdentity(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction)
{
insertCommon(ds, dbCommandBuilder, dbTransaction, true);
}
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();
}
protected override void OnRefresh(DataSet ds, IDbCommandBuilder dbCommandBuilder, DbTransaction dbTransaction, string tableName, bool insertIdentity)
{
base.OnRefresh(ds, dbCommandBuilder, dbTransaction, tableName, true);
}
public void _SetUp()
{
_mockSchemaFileStream = new FileStream(GetXmlSchemaFilename(), FileMode.Open, FileAccess.Read, FileShare.Read);
_mockDataFileStream = new FileStream(GetXmlFilename(), FileMode.Open, FileAccess.Read, FileShare.Read);
_mocker = new MockRepository();
_mockDbCommandBuilder = _mocker.CreateMock<IDbCommandBuilder>();
_mockDbOperation = _mocker.CreateMock<IDbOperation>();
_nDbUnitTestStub = GetUnitTestStub();
_mockConnection = _mocker.CreateMock<IDbConnection>();
_mockTransaction = _mocker.CreateMock<IDbTransaction>();
}
public static IDbCommand GetInsertCommand(this IDbCommandBuilder cmdBuilder, string table, IDictionary <string, object> data)
{
return(cmdBuilder.GetInsertCommand(table, DataHelper.GetChangeset(data)));
}
public static IDbCommand GetUpdateCommand(this IDbCommandBuilder cmdBuilder, Query q, IDictionary <string, object> data)
{
return(cmdBuilder.GetUpdateCommand(q, DataHelper.GetChangeset(data)));
}
private void insertRecursive(DataSet ds, DataTable dataTableSchema, IDbCommandBuilder dbCommandBuilder,
DbTransaction dbTransaction, Hashtable insertedTableColl, bool insertIdentity)
{
// Table has already been inserted into.
if (insertedTableColl.ContainsKey(dataTableSchema.TableName))
{
return;
}
// [20060724 - sdh] Move here (from end of method) to avoid infinite-loop when package has relation to itself
// Table was inserted into in the database.
insertedTableColl[dataTableSchema.TableName] = null;
ConstraintCollection constraints = dataTableSchema.Constraints;
if (null != constraints)
{
foreach (Constraint constraint in constraints)
{
// The table has a foreign key constraint.
if (constraint.GetType() == typeof(ForeignKeyConstraint))
{
ForeignKeyConstraint fkConstraint = (ForeignKeyConstraint)constraint;
// Must insert parent table first.
insertRecursive(ds, fkConstraint.RelatedTable, dbCommandBuilder, dbTransaction,
insertedTableColl, insertIdentity);
}
}
}
// process parent tables first!
DataRelationCollection parentRelations = dataTableSchema.ParentRelations;
if (null != parentRelations)
{
foreach (DataRelation parentRelation in parentRelations)
{
// Must insert parent table first.
insertRecursive(ds, parentRelation.ParentTable, dbCommandBuilder, dbTransaction, insertedTableColl,
insertIdentity);
}
}
DataRow dataRowClone = null;
DataTable dataTable = ds.Tables[dataTableSchema.TableName];
DataTable dataTableClone = dataTableSchema.Clone();
foreach (DataRow dataRow in dataTable.Rows)
{
// Insert as a new row.
dataRowClone = CloneDataRow(dataTableClone, dataRow);
dataTableClone.Rows.Add(dataRowClone);
}
if (insertIdentity)
{
using (DbCommand dbCommand = dbCommandBuilder.GetInsertIdentityCommand(dbTransaction, dataTableSchema.TableName))
{
OnInsertIdentity(dataTableClone, dbCommand, dbTransaction);
}
}
else
{
using (DbCommand dbCommand = dbCommandBuilder.GetInsertCommand(dbTransaction, dataTableSchema.TableName))
{
OnInsert(dataTableClone, dbCommand, 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);
}
public IDbCommandBuilder GetDbCommandBuilder()
{
if (_dbCommandBuilder == null)
if (_connection == null)
{
_dbCommandBuilder = CreateDbCommandBuilder(_connectionString);
}
else
{
_dbCommandBuilder = CreateDbCommandBuilder(_connection);
}
return _dbCommandBuilder;
}
public void DeleteAll(DataSet ds, IDbCommandBuilder dbCommandBuilder, DbTransaction dbTransaction)
{
DisableAllTableConstraints(ds, dbTransaction);
deleteCommon(ds, dbCommandBuilder, dbTransaction, true);
EnableAllTableConstraints(ds, dbTransaction);
}
public void InsertIdentity(DataSet ds, IDbCommandBuilder dbCommandBuilder, DbTransaction dbTransaction)
{
DisableAllTableConstraints(ds, dbTransaction);
insertCommon(ds, dbCommandBuilder, dbTransaction, true);
EnableAllTableConstraints(ds, dbTransaction);
}
public void _SetUp()
{
_commandBuilder = GetDbCommandBuilder();
ExecuteSchemaCreationScript();
_commandBuilder.BuildCommands(GetXmlSchemaFilename());
}
protected virtual void OnUpdate(DataSet ds, IDbCommandBuilder dbCommandBuilder, DbTransaction dbTransaction, string tableName)
{
DbTransaction sqlTransaction = dbTransaction;
//DisableTableConstraints(ds.Tables[tableName], dbTransaction);
DbDataAdapter sqlDataAdapter = CreateDbDataAdapter();
try
{
using (var updateCommand = dbCommandBuilder.GetUpdateCommand(dbTransaction, tableName))
{
updateCommand.Connection = sqlTransaction.Connection;
updateCommand.Transaction = sqlTransaction;
sqlDataAdapter.UpdateCommand = updateCommand;
((DbDataAdapter)sqlDataAdapter).Update(ds, tableName);
}
}
finally
{
var disposable = sqlDataAdapter as IDisposable;
if (disposable != null)
disposable.Dispose();
}
//EnableTableConstraints(ds.Tables[tableName], dbTransaction);
}
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);
}
}
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);
}
}
}
}
}
}
private void deleteRecursive(DataSet ds, DataTable dataTableSchema, IDbCommandBuilder dbCommandBuilder,
DbTransaction dbTransaction, Hashtable deletedTableColl, bool deleteAll)
{
// Table has already been deleted from.
if (deletedTableColl.ContainsKey(dataTableSchema.TableName))
{
return;
}
// [20060724 - sdh] Move here (from end of method) to avoid infinite-loop when package has relation to itself
// Table was deleted from in the database.
deletedTableColl[dataTableSchema.TableName] = null;
DataRelationCollection childRelations = dataTableSchema.ChildRelations;
// The table has children.
if (null != childRelations)
{
foreach (DataRelation childRelation in childRelations)
{
// Must delete the child table first.
deleteRecursive(ds, childRelation.ChildTable, dbCommandBuilder, dbTransaction, deletedTableColl,
deleteAll);
}
}
if (deleteAll)
{
using (DbCommand dbCommand = dbCommandBuilder.GetDeleteAllCommand(dbTransaction, dataTableSchema.TableName))
{
try
{
OnDeleteAll(dbCommand, dbTransaction);
}
catch (DBConcurrencyException)
{
// Swallow deletion of zero records.
}
}
}
else
{
DataTable dataTable = ds.Tables[dataTableSchema.TableName];
DataTable dataTableCopy = dataTable.Copy();
dataTableCopy.AcceptChanges();
foreach (DataRow dataRow in dataTableCopy.Rows)
{
// Delete the row.
dataRow.Delete();
}
using (DbCommand dbCommand = dbCommandBuilder.GetDeleteCommand(dbTransaction, dataTableSchema.TableName))
{
try
{
OnDelete(dataTableCopy, dbCommand, dbTransaction);
}
catch (DBConcurrencyException)
{
// Swallow deletion of zero records.
}
}
}
}
public static IDbCommand GetUpdateCommand(this IDbCommandBuilder cmdBuilder, Query q, object poco)
{
return(cmdBuilder.GetUpdateCommand(q, DataHelper.GetChangeset(poco, null)));
}
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);
}
}
public static IDbCommand GetInsertCommand(this IDbCommandBuilder cmdBuilder, string table, object poco)
{
return(cmdBuilder.GetInsertCommand(table, DataHelper.GetChangeset(poco, null)));
}
public void DeleteAll(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction)
{
deleteCommon(ds, dbCommandBuilder, dbTransaction, true);
}
public void DeleteAll(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction)
{
deleteCommon(ds, dbCommandBuilder, dbTransaction, true);
}
public void Insert(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction)
{
insertCommon(ds, dbCommandBuilder, dbTransaction, false);
}
//** 2013.11.25 naoto xlsset
public void ReadXlsSchema(string xlsFile)
{
_dbCommandBuilder = null;
IDbCommandBuilder dbCommandBuilder = GetDbCommandBuilder();
dbCommandBuilder.BuildCommandsXls(xlsFile);
_initialized = true;
_dataSet = dbCommandBuilder.GetSchema().Copy();
}
public void Refresh(DataSet ds, IDbCommandBuilder dbCommandBuilder, DbTransaction dbTransaction)
{
DataSetTableIterator iterator = new DataSetTableIterator(ds, false);
DisableAllTableConstraints(ds, dbTransaction);
foreach (DataTable dataTable in iterator)
{
OnRefresh(ds, dbCommandBuilder, dbTransaction, dataTable.TableName, true);
}
EnableAllTableConstraints(ds, dbTransaction);
}
public void InsertIdentity(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction)
{
insertCommon(ds, dbCommandBuilder, dbTransaction, true);
}
protected virtual void OnUpdate(DataSet ds, IDbCommandBuilder dbCommandBuilder, IDbTransaction dbTransaction, string tableName)
{
IDbTransaction sqlTransaction = dbTransaction;
//DisableTableConstraints(ds.Tables[tableName], dbTransaction);
IDbDataAdapter sqlDataAdapter = CreateDbDataAdapter();
sqlDataAdapter.UpdateCommand = dbCommandBuilder.GetUpdateCommand(tableName);
sqlDataAdapter.UpdateCommand.Connection = sqlTransaction.Connection;
sqlDataAdapter.UpdateCommand.Transaction = sqlTransaction;
((DbDataAdapter)sqlDataAdapter).Update(ds, tableName);
//EnableTableConstraints(ds.Tables[tableName], dbTransaction);
}
