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 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 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); }
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); }
//** 2013.11.25 naoto xlsset public void ReadXlsSchema(string xlsFile) { _dbCommandBuilder = null; IDbCommandBuilder dbCommandBuilder = GetDbCommandBuilder(); dbCommandBuilder.BuildCommandsXls(xlsFile); _initialized = true; _dataSet = dbCommandBuilder.GetSchema().Copy(); }