public int BulkSelectAndUpdate(IQueryable query, IContextTransaction contextTransaction)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var selectBindings = this.ExtractSelectBindings(query);
var mappings = this.GetMapping();
var selectQuery = this.BuildSelect(query);
var selectParameters = selectQuery.Item2;
var requiredSelectLines = this.FixAdditionalSelectedColumn(selectQuery.Item1, selectBindings.Count);
var actualSelectQuery = string.Join(Environment.NewLine, requiredSelectLines);
// gets alias using Regex which might be a bit brittle,
// possibily find a way to get alias's from IQueryable
var columnAliasMappings = this.MapColumnsToAliases(selectBindings, mappings, requiredSelectLines);
const string fromAlias = "a";
var tableName = mappings.FullyQualifiedTableName;
var setQuery = this.BuildComplexUpdateSetQuery(mappings, fromAlias, columnAliasMappings);
var whereTableKeyEqualsSelectKey = this.BuildComplexUpdateWhere(mappings, fromAlias, columnAliasMappings);
var updateQuery =
$"UPDATE {tableName} SET {setQuery} FROM ({actualSelectQuery}) AS {fromAlias} WHERE {whereTableKeyEqualsSelectKey}";
return(this.Execute(updateQuery, selectParameters, contextTransaction));
}
public int Truncate(IContextTransaction contextTransaction)
{
var tableName = this.GetMapping().FullyQualifiedTableName;
var truncateQuery = $"TRUNCATE TABLE {tableName}";
return(this.Execute(truncateQuery, null, contextTransaction));
}
public IBulkInserter <TEntity> BuildInserter(int bufferSize, IContextTransaction contextTransaction)
{
return(this.bulkInserterFactory.BuildInserter(
this.GetMapping(),
contextTransaction,
bufferSize,
this.contextSettingsCacheService.BulkInsertTimeout <TContext>(),
true));
}
public IBulkInserter <TEntity> BuildInserter <TEntity, TContext>(
TableMapping <TEntity, TContext> mapping,
IContextTransaction contextTransaction,
int bufferSize,
int timeout,
bool preInitialise)
where TEntity : class, IEntity <TContext>, new()
where TContext : IDbContext
{
return(new BulkInserter <TEntity, TContext>(mapping, contextTransaction, bufferSize, timeout, preInitialise));
}
public int TruncateWithForeignKeys(IContextTransaction contextTransaction)
{
var tableName = this.GetMapping().FullyQualifiedTableName;
// Adapted from http://stackoverflow.com/questions/472578/dbcc-checkident-sets-identity-to-0
// Issue when previously no records and reseed to 0, will start ids at 0 instead of 1
// Changing RESEED to 1, could potentially start ids at 2
// Logic below checks if the Id column has already been seeded and if so then reseeds to 0, which will result in the next Id of 1
// if Id column has not been used then the RESEED is not required, as the next Id will be 1 anyway
var truncateQuery = $"DELETE FROM {tableName}; IF EXISTS (SELECT * FROM sys.identity_columns WHERE QUOTENAME(OBJECT_SCHEMA_NAME(object_id)) + '.' + QUOTENAME(OBJECT_NAME(object_id)) = '{tableName}' AND last_value IS NOT NULL) DBCC CHECKIDENT ('{tableName}',RESEED, 0);";
return(this.Execute(truncateQuery, null, contextTransaction));
}
private int ExecuteAdd(IEnumerable <TEntity> items, int bufferSize, IContextTransaction contextTransaction)
{
if (contextTransaction == null)
{
if (this.session.HasCurrentTransaction())
{
return(this.ExceuteAddWithExternalTransaction(items, bufferSize, this.session.CurrentTransaction()));
}
return(this.ExecuteAddWithLocalTransaction(items, bufferSize));
}
return(this.ExceuteAddWithExternalTransaction(items, bufferSize, contextTransaction));
}
public BulkInserter(TableMapping <TEntity, TContext> tableMapping, IContextTransaction contextTransaction, int bufferSize, int timeout, bool preInitialise)
{
this.noOfInsertedItems = 0;
this.bufferSize = bufferSize;
this.timeout = timeout;
this.loclObj = new object();
this.queue = new List <TEntity>();
this.contextTransaction = contextTransaction;
this.tableMapping = tableMapping;
if (preInitialise)
{
this.EnsureInitialised();
}
}
protected int Execute(
string sql,
IEnumerable <ObjectParameter> parameters,
IContextTransaction contextTransaction)
{
if (contextTransaction == null)
{
if (this.session.HasCurrentTransaction())
{
return(this.ExecuteWithExternalTransaction(sql, parameters, this.session.CurrentTransaction()));
}
return(this.ExecuteWithLocalTransaction(sql, parameters));
}
return(this.ExecuteWithExternalTransaction(sql, parameters, contextTransaction));
}
public int BulkDelete(
IQueryable <TEntity> target,
IContextTransaction contextTransaction)
{
const string wrapperAlias = "a";
const string originalAlias = "b";
var tableName = this.GetMapping().FullyQualifiedTableName;
var queryWithPrimaryKeySelected = this.BuildSelectExtractPrimaryKeys(target);
var joinWrapperAndOriginal = this.BuildWrapperJoinOnPrimaryKeys(wrapperAlias, originalAlias);
// Delete using inner join on SELECT statement, which returns primary key collections of records to be removed
// More effecient than using WHERE PK1 in (SELECT PK1 from ....) type syntax, esp. when hundreds of records
var deleteQuery =
$"DELETE {wrapperAlias} FROM {tableName} AS {wrapperAlias} INNER JOIN ({queryWithPrimaryKeySelected.Item1}) AS {originalAlias} ON {joinWrapperAndOriginal}";
return(this.Execute(deleteQuery, queryWithPrimaryKeySelected.Item2, contextTransaction));
}
public OperationTypeFamilyService(
IOperationTypeFamilyRepository operationTypeFamilyRepository,
ISelectService selectService,
IMovementService movementService,
IMapper mapper,
IHostingEnvironment hostingEnvironment,
IContextTransaction contextTransaction,
IMailService mailService
//IOperationTypeService operationTypeService
)
{
_operationTypeFamilyRepository = operationTypeFamilyRepository;
_selectService = selectService;
_mapper = mapper;
_movementService = movementService;
_hostingEnvironment = hostingEnvironment;
_contextTransaction = contextTransaction;
_mailService = mailService;
//_operationTypeService = operationTypeService;
}
private void ExecuteSelectAndAdd(IQueryable query, IContextTransaction contextTransaction)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var mappings = this.GetMapping();
var selectBindings = this.ExtractSelectBindings(query);
var selectQuery = this.BuildSelect(query);
var selectParameters = selectQuery.Item2;
var tableName = mappings.FullyQualifiedTableName;
var orderedColumns = this.MapPropertiesToColumns(selectBindings, mappings);
var requiredSelectLines = this.FixAdditionalSelectedColumn(selectQuery.Item1, selectBindings.Count);
var actualSelectQuery = string.Join(Environment.NewLine, requiredSelectLines);
var insertQuery = $"INSERT INTO {tableName} ({orderedColumns}) {actualSelectQuery}";
this.Execute(insertQuery, selectParameters, contextTransaction);
}
protected int ExecuteWithExternalTransaction(
string sql,
IEnumerable <ObjectParameter> parameters,
IContextTransaction contextTransaction)
{
if (contextTransaction == null)
{
throw new ArgumentNullException(nameof(contextTransaction));
}
var sqlTransaction = contextTransaction.UnderlyingTransaction <SqlTransaction>();
if (sqlTransaction == null)
{
throw new InvalidOperationException("Bulk Inserter requires a SQL Transaction");
}
var sqlConnection = sqlTransaction.Connection;
return(this.ExecuteBulkNonQuery(sql, parameters, sqlTransaction, sqlConnection));
}
public int BulkUpdate(
IQueryable <TEntity> target,
Expression <Func <TEntity, TEntity> > updateExpression,
IContextTransaction contextTransaction)
{
const string wrapperAlias = "a";
const string originalAlias = "b";
var tableName = this.GetMapping().FullyQualifiedTableName;
var setQuery = this.BuildSetQuery(updateExpression, wrapperAlias);
var selectQuery = this.BuildSelectExtractPrimaryKeys(target);
var joinWrapperAndOriginal = this.BuildWrapperJoinOnPrimaryKeys(wrapperAlias, originalAlias);
var allParameters = setQuery.Item2.ToList().Union(selectQuery.Item2.ToList());
// Update using inner join on SELECT statement, which returns primary key collections of records to be updated
// More effecient than using WHERE PK1 in (SELECT PK1 from ....) syntax
var updateQuery =
$"UPDATE {wrapperAlias} SET {setQuery.Item1} FROM {tableName} AS {wrapperAlias} INNER JOIN ({selectQuery.Item1}) AS {originalAlias} ON {joinWrapperAndOriginal}";
return(this.Execute(updateQuery, allParameters, contextTransaction));
}
public AccountStatementImportService(
IMapper mapper,
IAccountStatementImportRepository accountStatementImportRepository,
IBankFileDefinitionService bankFileDefinitionService,
IAccountStatementImportFileService accountStatementImportFileService,
IAccountService accountService,
IParameterService parameterService,
IContextTransaction contextTransaction,
IBanquePopulaireImportFileService banquePopulaireImportFileService,
ICreditAgricoleImportFileService creditAgricoleImportFileService)
{
_mapper = mapper;
_accountStatementImportRepository = accountStatementImportRepository;
_bankFileDefinitionService = bankFileDefinitionService;
_accountStatementImportFileService = accountStatementImportFileService;
_accountService = accountService;
_parameterService = parameterService;
_contextTransaction = contextTransaction;
_banquePopulaireImportFileService = banquePopulaireImportFileService;
_creditAgricoleImportFileService = creditAgricoleImportFileService;
}
public int BulkAdd(IEnumerable <TEntity> items, int bufferSize, IContextTransaction contextTransaction)
{
return(this.ExecuteAdd(items, bufferSize, contextTransaction));
}
public int BulkAdd(IEnumerable <TEntity> items, IContextTransaction contextTransaction)
{
return(this.BulkAdd(items, 5000, contextTransaction));
}
public int BulkAdd(TEntity item, IContextTransaction contextTransaction)
{
return(this.BulkAdd(new[] { item }, contextTransaction));
}
private int ExceuteAddWithExternalTransaction(IEnumerable <TEntity> items, int bufferSize, IContextTransaction contextTransaction)
{
using (
var inserter = this.bulkInserterFactory.BuildInserter(
this.GetMapping(),
contextTransaction,
bufferSize,
this.contextSettingsCacheService.BulkInsertTimeout <TContext>(),
true))
{
inserter.Insert(items);
return(inserter.InsertedCount());
}
}
public IContextTransaction BeginTransaction(IsolationLevel isolationLevel)
{
transaction = new DbContextTransactionProxy(Database.BeginTransaction(isolationLevel));
return(transaction);
}
public NestedContextTransaction(IContextTransaction transaction)
{
this.transaction = transaction;
}
public int BulkUpdate(Expression <Func <TEntity, bool> > predicate, Expression <Func <TEntity, TEntity> > updateExpression, IContextTransaction contextTransaction)
{
return(this.BulkUpdate(this.FindAll(predicate), updateExpression, contextTransaction));
}
public int BulkDelete(Expression <Func <TEntity, bool> > predicate, IContextTransaction contextTransaction)
{
return(this.BulkDelete(this.FindAll(predicate), contextTransaction));
}
public void BulkSelectAndAdd(IQueryable query, IContextTransaction contextTransaction)
{
this.ExecuteSelectAndAdd(query, contextTransaction);
}
