/// <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;
}
