/// <summary> /// Executes this operation /// </summary> public override IAsyncEnumerable <Row> Execute(IAsyncEnumerable <Row> rows, CancellationToken cancellationToken = default) { return(new AsyncEnumerable <Row>(async yield => { Guard.Against <ArgumentException>(rows == null, "SqlBulkInsertOperation cannot accept a null enumerator"); PrepareSchema(); PrepareMapping(); CreateInputSchema(); using (SqlConnection connection = (SqlConnection)await Database.Connection(ConnectionStringSettings, cancellationToken)) using (SqlTransaction transaction = (SqlTransaction)BeginTransaction(connection)) { sqlBulkCopy = CreateSqlBulkCopy(connection, transaction); DictionaryEnumeratorDataReader adapter = new DictionaryEnumeratorDataReader(_inputSchema, rows, cancellationToken); try { await sqlBulkCopy.WriteToServerAsync(adapter, cancellationToken); } catch (InvalidOperationException) { await CompareSqlColumns(connection, transaction, rows, cancellationToken); throw; } if (PipelineExecuter.HasErrors) { Warn("Rolling back transaction in {OperationName}", Name); if (transaction != null) { transaction.Rollback(); } Warn("Rolled back transaction in {OperationName}", Name); } else { Debug("Committing {OperationName}", Name); if (transaction != null) { transaction.Commit(); } Debug("Committed {OperationName}", Name); } } yield.Break(); })); }
public void WillDisposeInternalEnumeratorAndEnumerableWhenDisposed() { MockRepository mocks = new MockRepository(); IAsyncEnumerable <Row> enumerable = mocks.DynamicMultiMock <IAsyncEnumerable <Row> >(typeof(IAsyncDisposable)); IAsyncEnumerator <Row> enumerator = mocks.DynamicMock <IAsyncEnumerator <Row> >(); using (mocks.Record()) { SetupResult.For(enumerable.GetAsyncEnumerator(Arg <CancellationToken> .Is.Anything)).Return(enumerator); SetupResult.For(enumerator.DisposeAsync()).Return(new ValueTask()); SetupResult.For(((IAsyncDisposable)enumerable).DisposeAsync()).Return(new ValueTask()); } using (mocks.Playback()) { DictionaryEnumeratorDataReader reader = new DictionaryEnumeratorDataReader(new Dictionary <string, Type>(), enumerable); reader.Dispose(); } }
public void WillDisposeInternalEnumeratorAndEnumerableWhenDisposed() { MockRepository mocks = new MockRepository(); IEnumerable <Row> enumerable = mocks.DynamicMultiMock <IEnumerable <Row> >(typeof(IDisposable)); IEnumerator <Row> enumerator = mocks.DynamicMock <IEnumerator <Row> >(); using (mocks.Record()) { SetupResult.For(enumerable.GetEnumerator()).Return(enumerator); enumerator.Dispose(); ((IDisposable)enumerable).Dispose(); } using (mocks.Playback()) { DictionaryEnumeratorDataReader reader = new DictionaryEnumeratorDataReader(new Dictionary <string, Type>(), enumerable); reader.Dispose(); } }
/// <summary> /// Executes this operation /// </summary> public override IEnumerable <Row> Execute(IEnumerable <Row> rows) { Guard.Against <ArgumentException>(rows == null, "SqlBulkInsertOperation cannot accept a null enumerator"); PrepareSchema(); PrepareMapping(); CreateInputSchema(); using (SqlConnection connection = (SqlConnection)Use.Connection(ConnectionStringSettings)) using (SqlTransaction transaction = (SqlTransaction)BeginTransaction(connection)) { sqlBulkCopy = CreateSqlBulkCopy(connection, transaction); DictionaryEnumeratorDataReader adapter = new DictionaryEnumeratorDataReader(_inputSchema, rows); try { sqlBulkCopy.WriteToServer(adapter); } catch (InvalidOperationException) { CompareSqlColumns(connection, transaction, rows); throw; } if (PipelineExecuter.HasErrors) { Warn("Rolling back transaction in {0}", Name); if (transaction != null) { transaction.Rollback(); } Warn("Rolled back transaction in {0}", Name); } else { Debug("Committing {0}", Name); if (transaction != null) { transaction.Commit(); } Debug("Committed {0}", Name); } } yield break; }
/// <summary> /// Executes this operation /// </summary> public override IEnumerable<Row> Execute(IEnumerable<Row> rows) { Guard.Against<ArgumentException>(rows == null, "SqlBulkInsertOperation cannot accept a null enumerator"); PrepareSchema(); PrepareMapping(); CreateInputSchema(); using (SqlConnection connection = (SqlConnection)Use.Connection(ConnectionStringSettings)) using (SqlTransaction transaction = connection.BeginTransaction()) { sqlBulkCopy = CreateSqlBulkCopy(connection, transaction); DictionaryEnumeratorDataReader adapter = new DictionaryEnumeratorDataReader(_inputSchema, rows); sqlBulkCopy.WriteToServer(adapter); if (PipelineExecuter.HasErrors) { Warn("Rolling back transaction in {0}", Name); transaction.Rollback(); Warn("Rolled back transaction in {0}", Name); } else { Debug("Committing {0}", Name); transaction.Commit(); Debug("Committed {0}", Name); } } yield break; }
/// <summary> /// Executes this operation /// </summary> public override IEnumerable<Row> Execute(IEnumerable<Row> rows) { Guard.Against<ArgumentException>(rows == null, "SqlBulkInsertOperation cannot accept a null enumerator"); PrepareSchema(); PrepareMapping(); CreateInputSchema(); using (SqlConnection connection = (SqlConnection)Use.Connection(ConnectionStringSettings)) using (SqlTransaction transaction = (SqlTransaction)BeginTransaction(connection)) { if (!string.IsNullOrEmpty(PreCommand)) { Debug("Executing PreCommand '{0}'", PreCommand); using (IDbCommand preCmd = connection.CreateCommand()) { preCmd.CommandTimeout = Timeout; preCmd.CommandText = PreCommand; preCmd.Transaction = transaction; preCmd.ExecuteNonQuery(); } } sqlBulkCopy = CreateSqlBulkCopy(connection, transaction); DictionaryEnumeratorDataReader adapter = new DictionaryEnumeratorDataReader(_inputSchema, rows); sqlBulkCopy.WriteToServer(adapter); if (!string.IsNullOrEmpty(PostCommand)) { using (IDbCommand postCmd = connection.CreateCommand()) { postCmd.CommandTimeout = Timeout; postCmd.CommandText = PostCommand; postCmd.Transaction = transaction; postCmd.ExecuteNonQuery(); } } if (PipelineExecuter.HasErrors) { Warn("Rolling back transaction in {0}", Name); if (transaction != null) transaction.Rollback(); Warn("Rolled back transaction in {0}", Name); } else { Debug("Committing {0}", Name); if (transaction != null) transaction.Commit(); Debug("Committed {0}", Name); } } yield break; }
/// <summary> /// Executes this operation /// </summary> public override IEnumerable <Row> Execute(IEnumerable <Row> rows) { Guard.Against <ArgumentException>(rows == null, "SqlBulkInsertOperation cannot accept a null enumerator"); PrepareSchema(); PrepareMapping(); CreateInputSchema(); using (var cn = (SqlConnection)Use.Connection(Connection)) { _sqlBulkCopy = CreateSqlBulkCopy(cn, null); var adapter = new DictionaryEnumeratorDataReader(_inputSchema, rows); try { _sqlBulkCopy.WriteToServer(adapter); } catch (SqlException ex) { if (!ex.Message.Contains("Received an invalid column length from the bcp client for colid")) { throw; } const string pattern = @"\d+"; var match = Regex.Match(ex.Message, pattern); var index = Convert.ToInt32(match.Value) - 1; var fi = typeof(SqlBulkCopy).GetField("_sortedColumnMappings", BindingFlags.NonPublic | BindingFlags.Instance); if (fi == null) { throw; } var sortedColumns = fi.GetValue(_sqlBulkCopy); if (sortedColumns == null) { throw; } var field = sortedColumns.GetType().GetField("_items", BindingFlags.NonPublic | BindingFlags.Instance); if (field == null) { throw; } var items = (object[])field.GetValue(sortedColumns); var itemdata = items[index].GetType().GetField("_metadata", BindingFlags.NonPublic | BindingFlags.Instance); if (itemdata == null) { throw; } var metadata = itemdata.GetValue(items[index]); if (metadata == null) { throw; } var f = metadata.GetType().GetField("column", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); if (f == null) { throw; } var column = f.GetValue(metadata); var l = metadata.GetType().GetField("length", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); if (l == null) { throw; } var length = l.GetValue(metadata); throw new TransformalizeException(Logger, string.Empty, "Column: {0} contains data with a length greater than: {1}", column, length); } } yield break; }