/// <inheritdoc />
public virtual bool Update(TEntity instance, IDbTransaction transaction)
{
var sqlQuery = SqlGenerator.GetUpdate(instance);
var updated = TransientDapperExtentions.ExecuteWithRetry(() => Connection.Execute(sqlQuery.GetSql(), instance, transaction)) > 0;
return(updated);
}
/// <inheritdoc />
public virtual async Task <bool> UpdateAsync(Expression <Func <TEntity, bool> > predicate, TEntity instance, IDbTransaction transaction)
{
var sqlQuery = SqlGenerator.GetUpdate(predicate, instance);
var updated = (await TransientDapperExtentions.ExecuteWithRetryAsync(() => Connection.ExecuteAsync(sqlQuery.GetSql(), instance, transaction))) > 0;
return(updated);
}
/// <inheritdoc />
public virtual bool Delete(TEntity instance, IDbTransaction transaction = null)
{
var queryResult = SqlGenerator.GetDelete(instance);
var deleted = (TransientDapperExtentions.ExecuteWithRetry(() => Connection.Execute(queryResult.GetSql(), queryResult.Param, transaction))) > 0;
return(deleted);
}
/// <inheritdoc />
public async Task <bool> BulkUpdateAsync(IEnumerable <TEntity> instances, IDbTransaction transaction)
{
var queryResult = SqlGenerator.GetBulkUpdate(instances);
var result = (await TransientDapperExtentions.ExecuteWithRetryAsync(() => Connection.ExecuteAsync(queryResult.GetSql(), queryResult.Param, transaction))) > 0;
return(result);
}
/// <inheritdoc />
public virtual async Task <bool> DeleteAsync(Expression <Func <TEntity, bool> > predicate, IDbTransaction transaction = null)
{
var queryResult = SqlGenerator.GetDelete(predicate);
var deleted = (await TransientDapperExtentions.ExecuteWithRetryAsync(() => Connection.ExecuteAsync(queryResult.GetSql(), queryResult.Param, transaction))) > 0;
return(deleted);
}
/// <inheritdoc />
public virtual async Task <int> BulkInsertAsync(IEnumerable <TEntity> instances, IDbTransaction transaction = null)
{
var queryResult = SqlGenerator.GetBulkInsert(instances);
var count = await TransientDapperExtentions.ExecuteWithRetryAsync(() => Connection.ExecuteAsync(queryResult.GetSql(), queryResult.Param, transaction));
return(count);
}
/// <inheritdoc />
public Task <IEnumerable <TEntity> > FindAllBetweenAsync(object from, object to, Expression <Func <TEntity, object> > btwField, Expression <Func <TEntity, bool> > predicate,
IDbTransaction transaction = null)
{
var queryResult = SqlGenerator.GetSelectBetween(from, to, btwField, predicate);
return(TransientDapperExtentions.QueryWithRetryAsync(() => Connection.QueryAsync <TEntity>(queryResult.GetSql(), queryResult.Param, transaction)));
}
/// <inheritdoc />
public bool BulkUpsert(IEnumerable <TEntity> instances, IDbTransaction transaction)
{
var queryResult = SqlGenerator.GetBulkUpSert(instances);
var result = TransientDapperExtentions.ExecuteWithRetry(() => Connection.Execute(queryResult.GetSql(), null, transaction)) > 0;
return(result);
}
/// <inheritdoc />
public virtual async Task <bool> InsertAsync(TEntity instance, IDbTransaction transaction)
{
var queryResult = SqlGenerator.GetInsert(instance);
if (SqlGenerator.IsIdentity)
{
var newId = (await Connection.QueryAsync <long>(queryResult.GetSql(), queryResult.Param, transaction)).FirstOrDefault();
return(SetValue(newId, instance));
}
return(await TransientDapperExtentions.ExecuteWithRetryAsync(() => Connection.ExecuteAsync(queryResult.GetSql(), instance, transaction)) > 0);
}
/// <inheritdoc />
public virtual async Task <bool> UpSertAsync(TEntity instance, IDbTransaction transaction = null)
{
var sqlQuery = SqlGenerator.GetUpSert(instance);
bool modified;
if (SqlGenerator.IsIdentity)
{
var newId = (await TransientDapperExtentions.QueryWithRetryAsync(() => Connection.QueryAsync <long>(sqlQuery.GetSql(), sqlQuery.Param, transaction))).FirstOrDefault();
modified = newId > 0;
if (modified)
{
var newParsedId = Convert.ChangeType(newId, SqlGenerator.IdentitySqlProperty.PropertyInfo.PropertyType);
SqlGenerator.IdentitySqlProperty.PropertyInfo.SetValue(instance, newParsedId);
}
}
else
{
modified = (await TransientDapperExtentions.ExecuteWithRetryAsync(() => Connection.ExecuteAsync(sqlQuery.GetSql(), instance, transaction))) > 0;
}
return(modified);
}
/// <inheritdoc />
public virtual Task <TEntity> FindByIdAsync(object id, IDbTransaction transaction)
{
var queryResult = SqlGenerator.GetSelectById(id, true);
return(TransientDapperExtentions.QuerySingleOrDefaultWithRetryAsync(() => Connection.QuerySingleOrDefaultAsync <TEntity>(queryResult.GetSql(), queryResult.Param, transaction)));
}
/// <inheritdoc />
public virtual Task <IEnumerable <TEntity> > FindAllAsync(Expression <Func <TEntity, bool> > predicate, IDbTransaction transaction = null)
{
var queryResult = SqlGenerator.GetSelectAll(predicate);
return(TransientDapperExtentions.QueryWithRetryAsync(() => Connection.QueryAsync <TEntity>(queryResult.GetSql(), queryResult.Param, transaction)));
}
/// <summary>
/// Execute Join query
/// </summary>
protected virtual IEnumerable <TEntity> ExecuteJoinQuery <TChild1, TChild2, TChild3, TChild4, TChild5, TChild6>(
SqlQuery sqlQuery,
IDbTransaction transaction,
params Expression <Func <TEntity, object> >[] includes)
{
var type = typeof(TEntity);
var childPropertyNames = includes.Select(ExpressionHelper.GetPropertyName).ToList();
var childProperties = childPropertyNames.Select(p => type.GetProperty(p)).ToList();
if (!SqlGenerator.KeySqlProperties.Any())
{
throw new NotSupportedException("Join doesn't support without [Key] attribute");
}
var keyProperties = SqlGenerator.KeySqlProperties.Select(q => q.PropertyInfo).ToArray();
var childKeyProperties = new List <PropertyInfo>();
foreach (var property in childProperties)
{
var childType = property.PropertyType.IsGenericType() ? property.PropertyType.GenericTypeArguments[0] : property.PropertyType;
var properties = childType.FindClassProperties().Where(ExpressionHelper.GetPrimitivePropertiesPredicate());
var keyprop = properties.Where(p => p.GetCustomAttributes <KeyAttribute>().Any());
childKeyProperties.Add(keyprop.FirstOrDefault()); //just takes the first key in case of compound keys
}
if (!childKeyProperties.Any())
{
throw new NotSupportedException("Join doesn't support without [Key] attribute");
}
var lookup = new Dictionary <object, TEntity>();
const bool buffered = true;
var spiltOn = string.Join(",", childKeyProperties.Select(q => q.Name));
switch (includes.Length)
{
case 1:
//Connection.Query<TEntity, TChild1, TEntity>(sqlQuery.GetSql(), (entity, child1) =>
// EntityJoinMapping<TChild1, TChild2, TChild3, TChild4, TChild5, TChild6>(lookup, keyProperties, childKeyProperties, childProperties, childPropertyNames, type, entity, child1),
// sqlQuery.Param, transaction, buffered, spiltOn);
TransientDapperExtentions.QueryWithRetry(() => Connection.Query <TEntity, TChild1, TEntity>(sqlQuery.GetSql(), (entity, child1) =>
EntityJoinMapping <TChild1, TChild2, TChild3, TChild4, TChild5, TChild6>(lookup, keyProperties, childKeyProperties, childProperties, childPropertyNames, type, entity,
child1),
sqlQuery.Param, transaction, buffered, spiltOn));
break;
case 2:
TransientDapperExtentions.QueryWithRetry(() => Connection.Query <TEntity, TChild1, TChild2, TEntity>(sqlQuery.GetSql(), (entity, child1, child2) =>
EntityJoinMapping <TChild1, TChild2, TChild3, TChild4, TChild5, TChild6>(lookup, keyProperties, childKeyProperties, childProperties, childPropertyNames, type, entity, child1, child2),
sqlQuery.Param, transaction, buffered, spiltOn));
break;
case 3:
TransientDapperExtentions.QueryWithRetry(() => Connection.Query <TEntity, TChild1, TChild2, TChild3, TEntity>(sqlQuery.GetSql(), (entity, child1, child2, child3) =>
EntityJoinMapping <TChild1, TChild2, TChild3, TChild4, TChild5, TChild6>(lookup, keyProperties, childKeyProperties, childProperties, childPropertyNames, type, entity, child1, child2, child3),
sqlQuery.Param, transaction, buffered, spiltOn));
break;
case 4:
TransientDapperExtentions.QueryWithRetry(() => Connection.Query <TEntity, TChild1, TChild2, TChild3, TChild4, TEntity>(sqlQuery.GetSql(), (entity, child1, child2, child3, child4) =>
EntityJoinMapping <TChild1, TChild2, TChild3, TChild4, TChild5, TChild6>(lookup, keyProperties, childKeyProperties, childProperties, childPropertyNames, type, entity, child1, child2, child3, child4),
sqlQuery.Param, transaction, buffered, spiltOn));
break;
case 5:
TransientDapperExtentions.QueryWithRetry(() => Connection.Query <TEntity, TChild1, TChild2, TChild3, TChild4, TChild5, TEntity>(sqlQuery.GetSql(), (entity, child1, child2, child3, child4, child5) =>
EntityJoinMapping <TChild1, TChild2, TChild3, TChild4, TChild5, TChild6>(lookup, keyProperties, childKeyProperties, childProperties, childPropertyNames, type, entity, child1, child2, child3, child4, child5),
sqlQuery.Param, transaction, buffered, spiltOn));
break;
case 6:
TransientDapperExtentions.QueryWithRetry(() => Connection.Query <TEntity, TChild1, TChild2, TChild3, TChild4, TChild5, TChild6, TEntity>(sqlQuery.GetSql(), (entity, child1, child2, child3, child4, child5, child6) =>
EntityJoinMapping <TChild1, TChild2, TChild3, TChild4, TChild5, TChild6>(lookup, keyProperties, childKeyProperties, childProperties, childPropertyNames, type, entity, child1, child2, child3, child4, child5, child6),
sqlQuery.Param, transaction, buffered, spiltOn));
break;
default:
throw new NotSupportedException();
}
return(lookup.Values);
}
/// <inheritdoc />
public virtual Task <int> CountAsync(Expression <Func <TEntity, bool> > predicate, IDbTransaction transaction)
{
var queryResult = SqlGenerator.GetCount(predicate);
return(TransientDapperExtentions.QuerySingleOrDefaultWithRetryAsync(() => Connection.QueryFirstOrDefaultAsync <int>(queryResult.GetSql(), queryResult.Param, transaction)));
}
/// <inheritdoc />
public virtual int Count(Expression <Func <TEntity, bool> > predicate, Expression <Func <TEntity, object> > distinctField, IDbTransaction transaction)
{
var queryResult = SqlGenerator.GetCount(predicate, distinctField);
return(TransientDapperExtentions.QueryFirstOrDefaultWithRetry(() => Connection.QueryFirstOrDefault <int>(queryResult.GetSql(), queryResult.Param, transaction)));
}
/// <inheritdoc />
public virtual TEntity Find(Expression <Func <TEntity, bool> > predicate, IDbTransaction transaction)
{
var queryResult = SqlGenerator.GetSelectFirst(predicate, true);
return(TransientDapperExtentions.QueryFirstOrDefaultWithRetry(() => Connection.QueryFirstOrDefault <TEntity>(queryResult.GetSql(), queryResult.Param, transaction)));
}
