public virtual async Task <int> ExecuteAsync(
IEnumerable <ModificationCommandBatch> commandBatches,
IRelationalConnection connection,
CancellationToken cancellationToken = default(CancellationToken))
{
var rowsAffected = 0;
await connection.OpenAsync(cancellationToken);
IRelationalTransaction startedTransaction = null;
try
{
if (connection.Transaction == null)
{
startedTransaction = connection.BeginTransaction();
}
foreach (var commandbatch in commandBatches)
{
await commandbatch.ExecuteAsync(connection, cancellationToken);
rowsAffected += commandbatch.ModificationCommands.Count;
}
startedTransaction?.Commit();
}
finally
{
startedTransaction?.Dispose();
connection.Close();
}
return(rowsAffected);
}
private static List <Account> GetEnvironmentAccounts(IRelationalTransaction transaction, string environmentId)
{
return(transaction.Query <Account>()
.Where("[EnvironmentIds] IS NULL OR [EnvironmentIds] = '' OR [EnvironmentIds] LIKE @environmentId")
.LikePipedParameter(nameof(environmentId), environmentId)
.ToList());
}
public virtual int Execute(
IEnumerable <ModificationCommandBatch> commandBatches,
IRelationalConnection connection)
{
var rowsAffected = 0;
connection.Open();
IRelationalTransaction startedTransaction = null;
try
{
if (connection.Transaction == null)
{
startedTransaction = connection.BeginTransaction();
}
foreach (var commandbatch in commandBatches)
{
commandbatch.Execute(connection);
rowsAffected += commandbatch.ModificationCommands.Count;
}
startedTransaction?.Commit();
}
finally
{
startedTransaction?.Dispose();
connection.Close();
}
return(rowsAffected);
}
public async Task ExecuteAsync_calls_Commit_if_no_transaction()
{
var sqlGenerator = new Mock <IUpdateSqlGenerator>().Object;
var mockModificationCommandBatch = new Mock <ModificationCommandBatch>(sqlGenerator);
mockModificationCommandBatch.Setup(m => m.ModificationCommands.Count).Returns(1);
var mockRelationalConnection = new Mock <IRelationalConnection>();
var transactionMock = new Mock <IRelationalTransaction>();
IRelationalTransaction currentTransaction = null;
mockRelationalConnection.Setup(m => m.BeginTransaction()).Returns(() => currentTransaction = transactionMock.Object);
mockRelationalConnection.Setup(m => m.Transaction).Returns(() => currentTransaction);
var cancellationToken = new CancellationTokenSource().Token;
var relationalTypeMapper = new ConcreteTypeMapper();
var batchExecutor = new BatchExecutorForTest(relationalTypeMapper);
await batchExecutor.ExecuteAsync(new[] { mockModificationCommandBatch.Object }, mockRelationalConnection.Object, cancellationToken);
mockRelationalConnection.Verify(rc => rc.OpenAsync(cancellationToken));
mockRelationalConnection.Verify(rc => rc.Close());
transactionMock.Verify(t => t.Commit());
mockModificationCommandBatch.Verify(mcb => mcb.ExecuteAsync(
It.IsAny <IRelationalTransaction>(),
relationalTypeMapper,
It.IsAny <DbContext>(),
null,
cancellationToken));
}
private static Release GetPreviousReleaseForEnvironment(IRelationalTransaction transaction, string projectId, string environmentId, string releaseId)
{
return(transaction.Query <Release>()
.Where("[Id] = (SELECT TOP 1 [ReleaseId] FROM Deployment WHERE [ProjectId] = @projectId AND [EnvironmentId] = @environmentId AND [ReleaseId] <> @releaseId ORDER BY [Created] DESC)")
.Parameter(nameof(projectId), projectId)
.Parameter(nameof(environmentId), environmentId)
.Parameter(nameof(releaseId), releaseId)
.First());
}
private static Release GetPreviousRelease(IRelationalTransaction transaction, string releaseId, string projectId)
{
return(transaction.Query <Release>()
.Where("[Id] <> @releaseId AND [ProjectId] = @projectId")
.Parameter(nameof(releaseId), releaseId)
.Parameter(nameof(projectId), projectId)
.OrderByDescending("Assembled")
.First());
}
public UnitOfWork(AuroraContext context, bool isReadOnly)
{
_context = context;
_isReadOnly = isReadOnly;
if (!isReadOnly)
{
_transaction = context.Database.BeginTransaction();
}
}
public TableSourceQueryBuilder(string tableOrViewName,
IRelationalTransaction relationalTransaction,
ITableAliasGenerator tableAliasGenerator,
IUniqueParameterNameGenerator uniqueParameterNameGenerator,
CommandParameterValues parameterValues,
Parameters parameters,
ParameterDefaults parameterDefaults)
: base(relationalTransaction, tableAliasGenerator, uniqueParameterNameGenerator, parameterValues, parameters, parameterDefaults)
{
this.tableOrViewName = tableOrViewName;
}
public SubquerySourceBuilder(ISelect select,
IRelationalTransaction relationalTransaction,
ITableAliasGenerator tableAliasGenerator,
IUniqueParameterNameGenerator uniqueParameterNameGenerator,
CommandParameterValues parameterValues,
Parameters parameters,
ParameterDefaults parameterDefaults)
: base(relationalTransaction, tableAliasGenerator, uniqueParameterNameGenerator, parameterValues, parameters, parameterDefaults)
{
this.select = select;
}
public DeleteQueryBuilder(IRelationalTransaction relationalTransaction,
IUniqueParameterNameGenerator uniqueParameterNameGenerator,
string tableName,
IEnumerable <IWhereClause> whereClauses,
CommandParameterValues parameterValues)
{
this.relationalTransaction = relationalTransaction;
this.uniqueParameterNameGenerator = uniqueParameterNameGenerator;
this.tableName = tableName;
this.whereClauses = whereClauses;
this.parameterValues = parameterValues;
}
public QueryBuilderFixture()
{
transaction = Substitute.For <IRelationalTransaction>();
var tableNumber = 0;
tableAliasGenerator.GenerateTableAlias(Arg.Any <string>()).Returns(delegate
{
tableNumber++;
return("t" + tableNumber);
});
}
public VariableCasingFixture()
{
query = null;
parameters = null;
transaction = Substitute.For<IRelationalTransaction>();
transaction.WhenForAnyArgs(c => c.ExecuteReader<IId>("", Arg.Any<CommandParameters>()))
.Do(c =>
{
query = c.Arg<string>();
parameters = c.Arg<CommandParameters>();
});
}
public void BeginTransaction(IsolationLevel isolationLevel)
{
RaseExceptionIfConnectionIsNotInitialization();
if (_transactionCount <= 0)
{
_transaction = _context.Database.BeginTransaction(isolationLevel);
}
else
{
_transactionCount++;
}
}
public void DisposeTransaction()
{
RaseExceptionIfConnectionIsNotInitialization();
if (_transactionCount > 0)
{
_transactionCount--;
}
else
{
_transaction.Dispose();
_transaction = null;
}
}
protected SourceQueryBuilder(IRelationalTransaction relationalTransaction,
ITableAliasGenerator tableAliasGenerator,
IUniqueParameterNameGenerator uniqueParameterNameGenerator,
CommandParameterValues parameterValues,
Parameters parameters,
ParameterDefaults parameterDefaults)
{
RelationalTransaction = relationalTransaction;
TableAliasGenerator = tableAliasGenerator;
UniqueParameterNameGenerator = uniqueParameterNameGenerator;
ParamValues = parameterValues;
Params = parameters;
ParamDefaults = parameterDefaults;
}
public QueryBuilder(TSelectBuilder selectBuilder,
IRelationalTransaction transaction,
ITableAliasGenerator tableAliasGenerator,
IUniqueParameterNameGenerator uniqueParameterNameGenerator,
CommandParameterValues paramValues,
Parameters @params,
ParameterDefaults paramDefaults)
{
this.selectBuilder = selectBuilder;
this.transaction = transaction;
this.tableAliasGenerator = tableAliasGenerator;
this.uniqueParameterNameGenerator = uniqueParameterNameGenerator;
this.paramValues = paramValues;
this.@params = @params;
this.paramDefaults = paramDefaults;
}
public async Task InsertLog(BatNodeLog log)
{
using (IRelationalTransaction transaction = await Database.BeginTransactionAsync())
{
List <BatCall> calls = log.Calls;
log.Calls = new List <BatCall>();
Logs.Add(log);
await SaveChangesAsync();
DbConnection dbConnection = Database.GetDbConnection();
await InsertCalls(log, calls, dbConnection);
transaction.Commit();
}
}
public JoinSourceQueryBuilder(IAliasedSelectSource originalSource,
JoinType joinType,
IAliasedSelectSource nextJoin,
IRelationalTransaction relationalTransaction,
ITableAliasGenerator tableAliasGenerator,
IUniqueParameterNameGenerator uniqueParameterNameGenerator,
CommandParameterValues parameterValues,
Parameters parameters,
ParameterDefaults parameterDefaults)
: base(relationalTransaction, tableAliasGenerator, uniqueParameterNameGenerator, parameterValues, parameters, parameterDefaults)
{
this.originalSource = originalSource;
clauses = new List <JoinClause>();
joinSource = nextJoin;
type = joinType;
}
void InsertProductAndLineItems(string productName, decimal productPrice, IRelationalTransaction trn, params int[] quantities)
{
var product = new Product
{
Name = productName,
Price = productPrice
};
trn.Insert(product);
foreach (var quantity in quantities)
{
var lineItem = new LineItem {
ProductId = product.Id, Name = "Some line item", Quantity = quantity
};
trn.Insert(lineItem);
}
}
public override async Task ExecuteAsync(
IRelationalTransaction transaction,
IRelationalTypeMapper typeMapper,
DbContext context,
ILogger logger,
CancellationToken cancellationToken = default(CancellationToken))
{
Check.NotNull(transaction, nameof(transaction));
Check.NotNull(typeMapper, nameof(typeMapper));
Check.NotNull(context, nameof(context));
Check.NotNull(logger, nameof(logger));
var commandText = GetCommandText();
using (var storeCommand = CreateStoreCommand(commandText, transaction.DbTransaction, typeMapper, transaction.Connection?.CommandTimeout))
{
if (logger.IsEnabled(LogLevel.Verbose))
{
logger.LogCommand(storeCommand);
}
try
{
using (var reader = await storeCommand.ExecuteReaderAsync(cancellationToken))
{
await ConsumeAsync(reader, context, cancellationToken);
}
}
catch (DbUpdateException)
{
throw;
}
catch (Exception ex)
{
throw new DbUpdateException(Strings.UpdateStoreException, ex);
}
}
}
public override void Execute(
IRelationalTransaction transaction,
IRelationalTypeMapper typeMapper,
DbContext context,
ILogger logger)
{
Check.NotNull(transaction, nameof(transaction));
Check.NotNull(typeMapper, nameof(typeMapper));
Check.NotNull(context, nameof(context));
Check.NotNull(logger, nameof(logger));
var commandText = GetCommandText();
using (var storeCommand = CreateStoreCommand(commandText, transaction.DbTransaction, typeMapper, transaction.Connection?.CommandTimeout))
{
if (logger.IsEnabled(LogLevel.Verbose))
{
logger.LogCommand(storeCommand);
}
try
{
using (var reader = storeCommand.ExecuteReader())
{
Consume(reader, context);
}
}
catch (DbUpdateException)
{
throw;
}
catch (Exception ex)
{
throw new DbUpdateException(Strings.UpdateStoreException, ex);
}
}
}
public QueryBuilderStateFixture()
{
transaction = Substitute.For <IRelationalTransaction>();
transaction.ExecuteScalar <int>(Arg.Do <string>(q => executedQueries.Add(q)), Arg.Any <CommandParameterValues>());
transaction.ExecuteReader <IDocument>(Arg.Do <string>(q => executedQueries.Add(q)), Arg.Any <CommandParameterValues>());
}
public QueryBuilder(IRelationalTransaction transaction, string viewOrTableName, ITableAliasGenerator tableAliasGenerator = null)
{
this.transaction = transaction;
QueryGenerator = new SqlQueryGenerator(viewOrTableName, tableAliasGenerator);
}
public abstract void Execute(
[NotNull] IRelationalTransaction transaction,
[NotNull] IRelationalTypeMapper typeMapper,
[NotNull] DbContext context,
[NotNull] ILogger logger);
public abstract Task ExecuteAsync(
[NotNull] IRelationalTransaction transaction,
[NotNull] IRelationalTypeMapper typeMapper,
[NotNull] DbContext context,
[NotNull] ILogger logger,
CancellationToken cancellationToken = default(CancellationToken));
private static Channel GetChannel(IRelationalTransaction transaction, string channelId)
{
return(transaction.LoadRequired <Channel>(channelId));
}
private static List <MachinePolicy> GetMachinePolicies(IRelationalTransaction transaction)
{
return(transaction.Query <MachinePolicy>()
.ToList());
}
public DeleteQueryBuilderFixture()
{
transaction = Substitute.For <IRelationalTransaction>();
}
public TransactionWrapper(IRelationalTransaction transaction)
{
_transaction = transaction;
}
public void PopulateRelatedDocuments <TDocument>(IRelationalTransaction transaction, TDocument instance) where TDocument : class, IId
{
}