/// <summary>
///
/// </summary>
/// <param name="entityType"></param>
/// <param name="connection"></param>
/// <param name="tableName"></param>
/// <param name="entities"></param>
/// <param name="qualifiers"></param>
/// <param name="batchSize"></param>
/// <param name="fields"></param>
/// <param name="hints"></param>
/// <param name="transaction"></param>
/// <param name="statementBuilder"></param>
/// <returns></returns>
public static UpdateAllExecutionContext Create(Type entityType,
IDbConnection connection,
string tableName,
IEnumerable <object> entities,
IEnumerable <Field> qualifiers,
int batchSize,
IEnumerable <Field> fields,
string hints = null,
IDbTransaction transaction = null,
IStatementBuilder statementBuilder = null)
{
var key = GetKey(entityType, tableName, qualifiers, fields, batchSize, hints);
// Get from cache
var context = UpdateAllExecutionContextCache.Get(key);
if (context != null)
{
return(context);
}
// Create
var dbFields = DbFieldCache.Get(connection, tableName, transaction);
var request = new UpdateAllRequest(tableName,
connection,
transaction,
fields,
qualifiers,
batchSize,
hints,
statementBuilder);
var commandText = CommandTextCache.GetUpdateAllText(request);
// Call
context = CreateInternal(entityType,
connection,
tableName,
entities,
dbFields,
qualifiers,
batchSize,
fields,
commandText);
// Add to cache
UpdateAllExecutionContextCache.Add(key, context);
// Return
return(context);
}
/// <summary>
///
/// </summary>
/// <param name="entityType"></param>
/// <param name="connection"></param>
/// <param name="tableName"></param>
/// <param name="qualifiers"></param>
/// <param name="fields"></param>
/// <param name="hints"></param>
/// <param name="transaction"></param>
/// <param name="statementBuilder"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public static async Task <MergeExecutionContext> CreateAsync(Type entityType,
IDbConnection connection,
string tableName,
IEnumerable <Field> qualifiers,
IEnumerable <Field> fields,
string hints = null,
IDbTransaction transaction = null,
IStatementBuilder statementBuilder = null,
CancellationToken cancellationToken = default)
{
var key = GetKey(entityType, tableName, qualifiers, fields, hints);
// Get from cache
var context = MergeExecutionContextCache.Get(key);
if (context != null)
{
return(context);
}
// Create
var dbFields = await DbFieldCache.GetAsync(connection, tableName, transaction, cancellationToken);
var request = new MergeRequest(tableName,
connection,
transaction,
fields,
qualifiers,
hints,
statementBuilder);
var commandText = await CommandTextCache.GetMergeTextAsync(request, cancellationToken);
// Call
context = CreateInternal(entityType,
connection,
dbFields,
tableName,
fields,
commandText);
// Add to cache
MergeExecutionContextCache.Add(key, context);
// Return
return(context);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="connection"></param>
/// <param name="tableName"></param>
/// <param name="where"></param>
/// <param name="fields"></param>
/// <param name="hints"></param>
/// <param name="transaction"></param>
/// <param name="statementBuilder"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public static async Task <UpdateExecutionContext <TEntity> > CreateAsync <TEntity>(IDbConnection connection,
string tableName,
QueryGroup where,
IEnumerable <Field> fields,
string hints = null,
IDbTransaction transaction = null,
IStatementBuilder statementBuilder = null,
CancellationToken cancellationToken = default)
where TEntity : class
{
var key = GetKey <TEntity>(tableName, fields, hints, where);
// Get from cache
var context = UpdateExecutionContextCache.Get <TEntity>(key);
if (context != null)
{
return(context);
}
// Create
var dbFields = await DbFieldCache.GetAsync(connection, tableName, transaction, cancellationToken);
var request = new UpdateRequest(tableName,
connection,
transaction,
where,
fields,
hints,
statementBuilder);
var commandText = await CommandTextCache.GetUpdateTextAsync(request, cancellationToken);
// Call
context = CreateInternal <TEntity>(connection,
tableName,
dbFields,
fields,
commandText);
// Add to cache
UpdateExecutionContextCache.Add <TEntity>(key, context);
// Return
return(context);
}
/// <summary>
///
/// </summary>
/// <param name="entityType"></param>
/// <param name="connection"></param>
/// <param name="tableName"></param>
/// <param name="where"></param>
/// <param name="fields"></param>
/// <param name="hints"></param>
/// <param name="transaction"></param>
/// <param name="statementBuilder"></param>
/// <returns></returns>
public static UpdateExecutionContext Create(Type entityType,
IDbConnection connection,
string tableName,
QueryGroup where,
IEnumerable <Field> fields,
string hints = null,
IDbTransaction transaction = null,
IStatementBuilder statementBuilder = null)
{
var key = GetKey(entityType, tableName, fields, hints, where);
// Get from cache
var context = UpdateExecutionContextCache.Get(key);
if (context != null)
{
return(context);
}
// Create
var dbFields = DbFieldCache.Get(connection, tableName, transaction);
var request = new UpdateRequest(tableName,
connection,
transaction,
where,
fields,
hints,
statementBuilder);
var commandText = CommandTextCache.GetUpdateText(request);
// Call
context = CreateInternal(entityType,
connection,
tableName,
dbFields,
fields,
commandText);
// Add to cache
UpdateExecutionContextCache.Add(key, context);
// Return
return(context);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="connection"></param>
/// <param name="tableName"></param>
/// <param name="qualifiers"></param>
/// <param name="fields"></param>
/// <param name="hints"></param>
/// <param name="transaction"></param>
/// <param name="statementBuilder"></param>
/// <returns></returns>
public static MergeExecutionContext <TEntity> Create <TEntity>(IDbConnection connection,
string tableName,
IEnumerable <Field> qualifiers,
IEnumerable <Field> fields,
string hints = null,
IDbTransaction transaction = null,
IStatementBuilder statementBuilder = null)
where TEntity : class
{
var key = GetKey <TEntity>(tableName, qualifiers, fields, hints);
// Get from cache
var context = MergeExecutionContextCache.Get <TEntity>(key);
if (context != null)
{
return(context);
}
// Create
var dbFields = DbFieldCache.Get(connection, tableName, transaction);
var request = new MergeRequest(tableName,
connection,
transaction,
fields,
qualifiers,
hints,
statementBuilder);
var commandText = CommandTextCache.GetMergeText(request);
// Call
context = CreateInternal <TEntity>(connection,
dbFields,
tableName,
fields,
commandText);
// Add to cache
MergeExecutionContextCache.Add <TEntity>(key, context);
// Return
return(context);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="connection"></param>
/// <param name="tableName"></param>
/// <param name="where"></param>
/// <param name="dbFields"></param>
/// <param name="fields"></param>
/// <param name="hints"></param>
/// <param name="transaction"></param>
/// <param name="statementBuilder"></param>
/// <returns></returns>
private static UpdateExecutionContext <TEntity> CreateInternal <TEntity>(IDbConnection connection,
string tableName,
QueryGroup where,
IEnumerable <DbField> dbFields,
IEnumerable <Field> fields,
string hints = null,
IDbTransaction transaction = null,
IStatementBuilder statementBuilder = null)
where TEntity : class
{
var dbSetting = connection.GetDbSetting();
var inputFields = new List <DbField>();
// Filter the actual properties for input fields
inputFields = dbFields?
.Where(dbField => dbField.IsIdentity == false)
.Where(dbField =>
fields.FirstOrDefault(field => string.Equals(field.Name.AsUnquoted(true, dbSetting), dbField.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) != null)
.AsList();
// Identify the requests
var updateRequest = new UpdateRequest(tableName,
connection,
transaction,
where,
fields,
hints,
statementBuilder);
// Return the value
return(new UpdateExecutionContext <TEntity>
{
CommandText = CommandTextCache.GetUpdateText(updateRequest),
InputFields = inputFields,
ParametersSetterFunc = FunctionCache.GetDataEntityDbParameterSetterCompiledFunction <TEntity>(
string.Concat(typeof(TEntity).FullName, StringConstant.Period, tableName, ".Update"),
inputFields?.AsList(),
null,
dbSetting)
});
}
public void TestDbHelperForQueryAll()
{
// Prepare
var dbHelper = new Mock <IDbHelper>();
var connection = new CustomDbConnectionForDbHelper();
// Act
CommandTextCache.Flush();
DbFieldCache.Flush();
StatementBuilderMapper.Add(typeof(CustomDbConnectionForDbHelper), new SqlStatementBuilder(), true);
DbHelperMapper.Add(typeof(CustomDbConnectionForDbHelper), dbHelper.Object, true);
// Act
connection.QueryAll <DataEntityForDbHelper>();
// Assert
dbHelper.Verify(builder =>
builder.GetFields(
It.Is <string>(s => s == connection.ConnectionString),
It.Is <string>(s => s == ClassMappedNameCache.Get <DataEntityForDbHelper>())), Times.Exactly(1));
}
public void TestDbHelperForQueryAllViaTableName()
{
// Prepare
var dbHelper = GetMockedDbHelper();
var connection = new DbHelperDbConnection();
// Act
CommandTextCache.Flush();
DbFieldCache.Flush();
DbHelperMapper.Add(typeof(DbHelperDbConnection), dbHelper.Object, true);
// Act
connection.QueryAll(ClassMappedNameCache.Get <DbHelperDataEntity>());
// Assert
dbHelper.Verify(builder =>
builder.GetFields(
It.Is <IDbConnection>(s => s == connection),
It.Is <string>(s => s == ClassMappedNameCache.Get <DbHelperDataEntity>()),
It.IsAny <IDbTransaction>()), Times.Exactly(1));
}
public void TestDbHelperForInsert()
{
// Prepare
var dbHelper = new Mock <IDbHelper>();
var connection = new DbHelperDbConnection();
// Act
CommandTextCache.Flush();
DbFieldCache.Flush();
DbHelperMapper.Add(typeof(DbHelperDbConnection), dbHelper.Object, true);
// Act
connection.Insert <DbHelperDataEntity>(new DbHelperDataEntity {
Id = 1, Name = "Name"
});
// Assert
dbHelper.Verify(builder =>
builder.GetFields(
It.Is <IDbConnection>(s => s == connection),
It.Is <string>(s => s == ClassMappedNameCache.Get <DbHelperDataEntity>()),
It.IsAny <IDbTransaction>()), Times.Exactly(1));
}
public void TestDbHelperForUpdateAll()
{
// Prepare
var dbHelper = new Mock <IDbHelper>();
var connection = new CustomDbConnectionForDbHelper();
// Act
CommandTextCache.Flush();
DbFieldCache.Flush();
StatementBuilderMapper.Add(typeof(CustomDbConnectionForDbHelper), new SqlServerStatementBuilder(), true);
DbHelperMapper.Add(typeof(CustomDbConnectionForDbHelper), dbHelper.Object, true);
// Act
connection.UpdateAll <DataEntityForDbHelper>(new[] { new DataEntityForDbHelper {
Id = 1, Name = "Name"
} });
// Assert
dbHelper.Verify(builder =>
builder.GetFields(
It.Is <IDbConnection>(s => s == connection),
It.Is <string>(s => s == ClassMappedNameCache.Get <DataEntityForDbHelper>()),
It.IsAny <IDbTransaction>()), Times.Exactly(1));
}
public void TestDbHelperForBatchQuery()
{
// Prepare
var dbHelper = GetMockedDbHelper();
var connection = new DbHelperDbConnection();
// Act
CommandTextCache.Flush();
DbFieldCache.Flush();
DbHelperMapper.Add(typeof(DbHelperDbConnection), dbHelper.Object, true);
// Act
connection.BatchQuery <DbHelperDataEntity>(0,
10,
OrderField.Ascending <DbHelperDataEntity>(e => e.Id).AsEnumerable(),
e => e.Id == 1);
// Assert
dbHelper.Verify(builder =>
builder.GetFields(
It.Is <IDbConnection>(s => s == connection),
It.Is <string>(s => s == ClassMappedNameCache.Get <DbHelperDataEntity>()),
It.IsAny <IDbTransaction>()), Times.Exactly(1));
}
/// <summary>
///
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="connection"></param>
/// <param name="entities"></param>
/// <param name="dbFields"></param>
/// <param name="tableName"></param>
/// <param name="qualifiers"></param>
/// <param name="batchSize"></param>
/// <param name="fields"></param>
/// <param name="hints"></param>
/// <param name="transaction"></param>
/// <param name="statementBuilder"></param>
/// <param name="skipIdentityCheck"></param>
/// <returns></returns>
private static MergeAllExecutionContext <TEntity> CreateInternal <TEntity>(IDbConnection connection,
IEnumerable <TEntity> entities,
IEnumerable <DbField> dbFields,
string tableName,
IEnumerable <Field> qualifiers,
int batchSize,
IEnumerable <Field> fields,
string hints = null,
IDbTransaction transaction = null,
IStatementBuilder statementBuilder = null,
bool skipIdentityCheck = false)
where TEntity : class
{
var dbSetting = connection.GetDbSetting();
var identity = (Field)null;
var inputFields = (IEnumerable <DbField>)null;
var identityDbField = dbFields?.FirstOrDefault(f => f.IsIdentity);
// Check the fields
if (fields?.Any() != true)
{
fields = dbFields?.AsFields();
}
// Check the qualifiers
if (qualifiers?.Any() != true)
{
var primary = dbFields?.FirstOrDefault(dbField => dbField.IsPrimary == true);
qualifiers = primary?.AsField().AsEnumerable();
}
// Set the identity value
if (skipIdentityCheck == false)
{
identity = IdentityCache.Get <TEntity>()?.AsField();
if (identity == null && identityDbField != null)
{
identity = FieldCache.Get <TEntity>()?.FirstOrDefault(field =>
string.Equals(field.Name.AsUnquoted(true, dbSetting), identityDbField.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase));
}
}
// Filter the actual properties for input fields
inputFields = dbFields?
.Where(dbField =>
fields.FirstOrDefault(field => string.Equals(field.Name.AsUnquoted(true, dbSetting), dbField.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) != null)
.AsList();
// Exclude the fields not on the actual entity
if (typeof(TEntity).IsClassType() == false)
{
var entityFields = Field.Parse(entities?.FirstOrDefault());
inputFields = inputFields?
.Where(field =>
entityFields.FirstOrDefault(f => string.Equals(f.Name.AsUnquoted(true, dbSetting), field.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) != null)
.AsList();
}
// Variables for the context
var multipleEntitiesFunc = (Action <DbCommand, IList <TEntity> >)null;
var singleEntityFunc = (Action <DbCommand, TEntity>)null;
var identitySetterFunc = (Action <TEntity, object>)null;
// Get if we have not skipped it
if (skipIdentityCheck == false && identity != null && typeof(TEntity).IsClassType())
{
identitySetterFunc = FunctionCache.GetDataEntityPropertySetterCompiledFunction <TEntity>(identity);
}
// Identity which objects to set
if (batchSize <= 1)
{
singleEntityFunc = FunctionCache.GetDataEntityDbParameterSetterCompiledFunction <TEntity>(
string.Concat(typeof(TEntity).FullName, StringConstant.Period, tableName, ".MergeAll"),
inputFields?.AsList(),
null,
dbSetting);
}
else
{
multipleEntitiesFunc = FunctionCache.GetDataEntityListDbParameterSetterCompiledFunction <TEntity>(
string.Concat(typeof(TEntity).FullName, StringConstant.Period, tableName, ".MergeAll"),
inputFields?.AsList(),
null,
batchSize,
dbSetting);
}
// Identify the requests
var mergeAllRequest = (MergeAllRequest)null;
var mergeRequest = (MergeRequest)null;
// Create a different kind of requests
if (batchSize > 1)
{
mergeAllRequest = new MergeAllRequest(tableName,
connection,
transaction,
fields,
qualifiers,
batchSize,
hints,
statementBuilder);
}
else
{
mergeRequest = new MergeRequest(tableName,
connection,
transaction,
fields,
qualifiers,
hints,
statementBuilder);
}
// Return the value
return(new MergeAllExecutionContext <TEntity>
{
CommandText = batchSize > 1 ? CommandTextCache.GetMergeAllText(mergeAllRequest) : CommandTextCache.GetMergeText(mergeRequest),
InputFields = inputFields,
BatchSize = batchSize,
SingleDataEntityParametersSetterFunc = singleEntityFunc,
MultipleDataEntitiesParametersSetterFunc = multipleEntitiesFunc,
IdentityPropertySetterFunc = identitySetterFunc
});
}
/// <summary>
///
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="connection"></param>
/// <param name="tableName"></param>
/// <param name="batchSize"></param>
/// <param name="fields"></param>
/// <param name="hints"></param>
/// <param name="transaction"></param>
/// <param name="statementBuilder"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public static async Task <InsertAllExecutionContext <TEntity> > CreateAsync <TEntity>(IDbConnection connection,
string tableName,
int batchSize,
IEnumerable <Field> fields,
string hints = null,
IDbTransaction transaction = null,
IStatementBuilder statementBuilder = null,
CancellationToken cancellationToken = default)
where TEntity : class
{
var key = GetKey <TEntity>(tableName, fields, batchSize, hints);
// Get from cache
var context = InsertAllExecutionContextCache.Get <TEntity>(key);
if (context != null)
{
return(context);
}
// Create
var dbFields = await DbFieldCache.GetAsync(connection, tableName, transaction, cancellationToken);
var commandText = (string)null;
// Create a different kind of requests
if (batchSize > 1)
{
var request = new InsertAllRequest(tableName,
connection,
transaction,
fields,
batchSize,
hints,
statementBuilder);
commandText = await CommandTextCache.GetInsertAllTextAsync(request, cancellationToken);
}
else
{
var request = new InsertRequest(tableName,
connection,
transaction,
fields,
hints,
statementBuilder);
commandText = await CommandTextCache.GetInsertTextAsync(request, cancellationToken);
}
// Call
context = CreateInternal <TEntity>(connection,
tableName,
dbFields,
batchSize,
fields,
commandText);
// Add to cache
InsertAllExecutionContextCache.Add <TEntity>(key, context);
// Return
return(context);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="connection"></param>
/// <param name="tableName"></param>
/// <param name="entities"></param>
/// <param name="dbFields"></param>
/// <param name="qualifiers"></param>
/// <param name="batchSize"></param>
/// <param name="fields"></param>
/// <param name="hints"></param>
/// <param name="transaction"></param>
/// <param name="statementBuilder"></param>
/// <returns></returns>
private static UpdateAllExecutionContext <TEntity> CreateInternal <TEntity>(IDbConnection connection,
string tableName,
IEnumerable <TEntity> entities,
IEnumerable <DbField> dbFields,
IEnumerable <Field> qualifiers,
int batchSize,
IEnumerable <Field> fields,
string hints = null,
IDbTransaction transaction = null,
IStatementBuilder statementBuilder = null)
where TEntity : class
{
// Variables needed
var dbSetting = connection.GetDbSetting();
var inputFields = new List <DbField>();
// Check the qualifiers
if (qualifiers?.Any() != true)
{
var key = dbFields?.FirstOrDefault(dbField => dbField.IsPrimary == true) ??
dbFields?.FirstOrDefault(dbField => dbField.IsIdentity == true);
qualifiers = key?.AsField().AsEnumerable();
}
// Filter the actual properties for input fields
inputFields = dbFields?
.Where(dbField =>
fields.FirstOrDefault(field => string.Equals(field.Name.AsUnquoted(true, dbSetting), dbField.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) != null)
.AsList();
// Exclude the fields not on the actual entity
if (typeof(TEntity).IsClassType() == false)
{
var entityFields = Field.Parse(entities?.FirstOrDefault());
inputFields = inputFields?
.Where(field =>
entityFields.FirstOrDefault(f => string.Equals(f.Name.AsUnquoted(true, dbSetting), field.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) != null)
.AsList();
}
// Variables for the context
var multipleEntitiesFunc = (Action <DbCommand, IList <TEntity> >)null;
var singleEntityFunc = (Action <DbCommand, TEntity>)null;
// Identity which objects to set
if (batchSize <= 1)
{
singleEntityFunc = FunctionCache.GetDataEntityDbParameterSetterCompiledFunction <TEntity>(
string.Concat(typeof(TEntity).FullName, StringConstant.Period, tableName, ".UpdateAll"),
inputFields?.AsList(),
null,
dbSetting);
}
else
{
multipleEntitiesFunc = FunctionCache.GetDataEntityListDbParameterSetterCompiledFunction <TEntity>(
string.Concat(typeof(TEntity).FullName, StringConstant.Period, tableName, ".UpdateAll"),
inputFields?.AsList(),
null,
batchSize,
dbSetting);
}
// Identity the requests
var updateAllRequest = new UpdateAllRequest(tableName,
connection,
transaction,
fields,
qualifiers,
batchSize,
hints,
statementBuilder);
// Return the value
return(new UpdateAllExecutionContext <TEntity>
{
CommandText = CommandTextCache.GetUpdateAllText(updateAllRequest),
InputFields = inputFields,
SingleDataEntityParametersSetterFunc = singleEntityFunc,
MultipleDataEntitiesParametersSetterFunc = multipleEntitiesFunc
});
}
/// <summary>
///
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="connection"></param>
/// <param name="dbFields"></param>
/// <param name="tableName"></param>
/// <param name="fields"></param>
/// <param name="hints"></param>
/// <param name="transaction"></param>
/// <param name="statementBuilder"></param>
/// <returns></returns>
private static InsertExecutionContext <TEntity> CreateInternal <TEntity>(IDbConnection connection,
IEnumerable <DbField> dbFields,
string tableName,
IEnumerable <Field> fields,
string hints = null,
IDbTransaction transaction = null,
IStatementBuilder statementBuilder = null)
where TEntity : class
{
var typeOfEntity = typeof(TEntity);
var dbSetting = connection.GetDbSetting();
var identity = (Field)null;
var inputFields = (IEnumerable <DbField>)null;
var identityDbField = dbFields?.FirstOrDefault(f => f.IsIdentity);
// Set the identity field
if (typeOfEntity.IsClassType())
{
identity = IdentityCache.Get <TEntity>()?.AsField() ??
FieldCache
.Get <TEntity>()?
.FirstOrDefault(field =>
string.Equals(field.Name.AsUnquoted(true, dbSetting), identityDbField?.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) ??
identityDbField?.AsField();
}
// Filter the actual properties for input fields
inputFields = dbFields?
.Where(dbField => dbField.IsIdentity == false)
.Where(dbField =>
fields.FirstOrDefault(field =>
string.Equals(field.Name.AsUnquoted(true, dbSetting), dbField.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) != null)
.AsList();
// Variables for the entity action
var identityPropertySetter = (Action <TEntity, object>)null;
// Get the identity setter
if (typeOfEntity.IsClassType() == true && identity != null)
{
identityPropertySetter = FunctionCache.GetDataEntityPropertySetterCompiledFunction <TEntity>(identity);
}
// Identify the requests
var insertRequest = new InsertRequest(tableName,
connection,
transaction,
fields,
hints,
statementBuilder);
// Return the value
return(new InsertExecutionContext <TEntity>
{
CommandText = CommandTextCache.GetInsertText(insertRequest),
InputFields = inputFields,
ParametersSetterFunc = FunctionCache.GetDataEntityDbParameterSetterCompiledFunction <TEntity>(
string.Concat(typeof(TEntity).FullName, StringConstant.Period, tableName, ".Insert"),
inputFields?.AsList(),
null,
dbSetting),
IdentityPropertySetterFunc = identityPropertySetter
});
}
/// <summary>
///
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="connection"></param>
/// <param name="tableName"></param>
/// <param name="dbFields"></param>
/// <param name="batchSize"></param>
/// <param name="fields"></param>
/// <param name="hints"></param>
/// <param name="transaction"></param>
/// <param name="statementBuilder"></param>
/// <returns></returns>
private static InsertAllExecutionContext <TEntity> CreateInternal <TEntity>(IDbConnection connection,
string tableName,
IEnumerable <DbField> dbFields,
int batchSize,
IEnumerable <Field> fields,
string hints = null,
IDbTransaction transaction = null,
IStatementBuilder statementBuilder = null)
where TEntity : class
{
var typeOfEntity = typeof(TEntity);
var dbSetting = connection.GetDbSetting();
var identity = (Field)null;
var inputFields = (IEnumerable <DbField>)null;
var identityDbField = dbFields?.FirstOrDefault(f => f.IsIdentity);
// Set the identity value
if (typeOfEntity.IsClassType())
{
identity = IdentityCache.Get <TEntity>()?.AsField() ??
FieldCache
.Get <TEntity>()?
.FirstOrDefault(field =>
string.Equals(field.Name.AsUnquoted(true, dbSetting), identityDbField?.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) ??
identityDbField?.AsField();
}
// Filter the actual properties for input fields
inputFields = dbFields?
.Where(dbField => dbField.IsIdentity == false)
.Where(dbField =>
fields.FirstOrDefault(field => string.Equals(field.Name.AsUnquoted(true, dbSetting), dbField.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) != null)
.AsList();
// Variables for the context
var multipleEntitiesFunc = (Action <DbCommand, IList <TEntity> >)null;
var identitySettersFunc = (List <Action <TEntity, DbCommand> >)null;
var singleEntityFunc = (Action <DbCommand, TEntity>)null;
var identitySetterFunc = (Action <TEntity, object>)null;
// Get if we have not skipped it
if (typeOfEntity.IsClassType() && identity != null)
{
identitySetterFunc = FunctionCache.GetDataEntityPropertySetterCompiledFunction <TEntity>(identity);
}
// Identity which objects to set
if (batchSize <= 1)
{
singleEntityFunc = FunctionCache.GetDataEntityDbParameterSetterCompiledFunction <TEntity>(
string.Concat(typeof(TEntity).FullName, StringConstant.Period, tableName, ".InsertAll"),
inputFields?.AsList(),
null,
dbSetting);
}
else
{
multipleEntitiesFunc = FunctionCache.GetDataEntityListDbParameterSetterCompiledFunction <TEntity>(
string.Concat(typeof(TEntity).FullName, StringConstant.Period, tableName, ".InsertAll"),
inputFields?.AsList(),
null,
batchSize,
dbSetting);
}
// Identify the requests
var insertAllRequest = (InsertAllRequest)null;
var insertRequest = (InsertRequest)null;
// Create a different kind of requests
if (batchSize > 1)
{
insertAllRequest = new InsertAllRequest(tableName,
connection,
transaction,
fields,
batchSize,
hints,
statementBuilder);
}
else
{
insertRequest = new InsertRequest(tableName,
connection,
transaction,
fields,
hints,
statementBuilder);
}
// Return the value
return(new InsertAllExecutionContext <TEntity>
{
CommandText = batchSize > 1 ? CommandTextCache.GetInsertAllText(insertAllRequest) : CommandTextCache.GetInsertText(insertRequest),
InputFields = inputFields,
BatchSize = batchSize,
SingleDataEntityParametersSetterFunc = singleEntityFunc,
MultipleDataEntitiesParametersSetterFunc = multipleEntitiesFunc,
IdentityPropertySetterFunc = identitySetterFunc,
IdentityPropertySettersFunc = identitySettersFunc
});
}
/// <summary>
///
/// </summary>
/// <param name="entityType"></param>
/// <param name="connection"></param>
/// <param name="tableName"></param>
/// <param name="batchSize"></param>
/// <param name="fields"></param>
/// <param name="hints"></param>
/// <param name="transaction"></param>
/// <param name="statementBuilder"></param>
/// <returns></returns>
public static InsertAllExecutionContext Create(Type entityType,
IDbConnection connection,
string tableName,
int batchSize,
IEnumerable <Field> fields,
string hints = null,
IDbTransaction transaction = null,
IStatementBuilder statementBuilder = null)
{
var key = GetKey(entityType, tableName, fields, batchSize, hints);
// Get from cache
var context = InsertAllExecutionContextCache.Get(key);
if (context != null)
{
return(context);
}
// Create
var dbFields = DbFieldCache.Get(connection, tableName, transaction);
var commandText = (string)null;
// Create a different kind of requests
if (batchSize > 1)
{
var request = new InsertAllRequest(tableName,
connection,
transaction,
fields,
batchSize,
hints,
statementBuilder);
commandText = CommandTextCache.GetInsertAllText(request);
}
else
{
var request = new InsertRequest(tableName,
connection,
transaction,
fields,
hints,
statementBuilder);
commandText = CommandTextCache.GetInsertText(request);
}
// Call
context = CreateInternal(entityType,
connection,
tableName,
dbFields,
batchSize,
fields,
commandText);
// Add to cache
InsertAllExecutionContextCache.Add(key, context);
// Return
return(context);
}
