internal static Task <int> UpdateAsync <T>(this IDbCommand dbCmd, T item, Expression <Func <T, bool> > expression, Action <IDbCommand> commandFilter, CancellationToken token)
{
OrmLiteUtils.AssertNotAnonType <T>();
OrmLiteConfig.UpdateFilter?.Invoke(dbCmd, item);
var q = dbCmd.GetDialectProvider().SqlExpression <T>();
q.Where(expression);
q.PrepareUpdateStatement(dbCmd, item);
commandFilter?.Invoke(dbCmd);
return(dbCmd.ExecNonQueryAsync(token));
}
public static Task <int> UpdateAddAsync <T>(this IDbCommand dbCmd,
Expression <Func <T> > updateFields,
SqlExpression <T> q,
Action <IDbCommand> commandFilter,
CancellationToken token)
{
OrmLiteUtils.AssertNotAnonType <T>();
var cmd = dbCmd.InitUpdateAdd(updateFields, q);
commandFilter?.Invoke(cmd);
return(cmd.ExecNonQueryAsync(token));
}
internal static async Task <long> InsertAsync <T>(this IDbCommand dbCmd, T obj, Action <IDbCommand> commandFilter, bool selectIdentity, CancellationToken token)
{
OrmLiteUtils.AssertNotAnonType <T>();
OrmLiteConfig.InsertFilter?.Invoke(dbCmd, obj);
var dialectProvider = dbCmd.GetDialectProvider();
dialectProvider.PrepareParameterizedInsertStatement <T>(dbCmd,
insertFields: dialectProvider.GetNonDefaultValueInsertFields <T>(obj));
return(await InsertInternalAsync <T>(dialectProvider, dbCmd, obj, commandFilter, selectIdentity, token));
}
internal static int UpdateOnly <T>(this IDbCommand dbCmd,
Expression <Func <T> > updateFields,
string whereExpression,
IEnumerable <IDbDataParameter> dbParams,
Action <IDbCommand> commandFilter = null)
{
OrmLiteUtils.AssertNotAnonType <T>();
var cmd = dbCmd.InitUpdateOnly(updateFields, whereExpression, dbParams);
commandFilter?.Invoke(cmd);
return(cmd.ExecNonQuery());
}
internal static async Task DeleteByIdAsync <T>(this IDbCommand dbCmd, object id, ulong rowVersion, CancellationToken token)
{
OrmLiteUtils.AssertNotAnonType <T>();
var sql = dbCmd.DeleteByIdSql <T>(id, rowVersion);
var rowsAffected = await dbCmd.ExecuteSqlAsync(sql, token);
if (rowsAffected == 0)
{
throw new OptimisticConcurrencyException("The row was modified or deleted since the last read");
}
}
internal static Task <int> DeleteAsync <T>(this IDbCommand dbCmd, object anonType, CancellationToken token)
{
OrmLiteUtils.AssertNotAnonType <T>();
var dialectProvider = dbCmd.GetDialectProvider();
var hadRowVersion = dialectProvider.PrepareParameterizedDeleteStatement <T>(
dbCmd, anonType.AllFieldsMap <T>());
dialectProvider.SetParameterValues <T>(dbCmd, anonType);
return(AssertRowsUpdatedAsync(dbCmd, hadRowVersion, token));
}
internal static long Insert <T>(this IDbCommand dbCmd, T obj, Action <IDbCommand> commandFilter, bool selectIdentity = false)
{
OrmLiteUtils.AssertNotAnonType <T>();
OrmLiteConfig.InsertFilter?.Invoke(dbCmd, obj);
var dialectProvider = dbCmd.GetDialectProvider();
dialectProvider.PrepareParameterizedInsertStatement <T>(dbCmd,
insertFields: dialectProvider.GetNonDefaultValueInsertFields <T>(obj));
return(InsertInternal <T>(dialectProvider, dbCmd, obj, commandFilter, selectIdentity));
}
public static object ConvertNumber(this IOrmLiteConverter converter, Type toIntegerType, object value)
{
if (value.GetType() == toIntegerType)
{
return(value);
}
var typeCode = toIntegerType.GetUnderlyingTypeCode();
switch (typeCode)
{
case TypeCode.Byte:
return(Convert.ToByte(value));
case TypeCode.Int16:
return(Convert.ToInt16(value));
case TypeCode.UInt16:
return(Convert.ToUInt16(value));
case TypeCode.Int32:
return(Convert.ToInt32(value));
case TypeCode.UInt32:
return(Convert.ToUInt32(value));
case TypeCode.Int64:
return(Convert.ToInt64(value));
case TypeCode.UInt64:
var byteValue = value as byte[];
if (byteValue != null)
{
return(OrmLiteUtils.ConvertToULong(byteValue));
}
return(Convert.ToUInt64(value));
case TypeCode.Single:
return(Convert.ToSingle(value));
case TypeCode.Double:
return(Convert.ToDouble(value));
case TypeCode.Decimal:
return(Convert.ToDecimal(value));
}
var convertedValue = converter.DialectProvider.StringSerializer.DeserializeFromString(value.ToString(), toIntegerType);
return(convertedValue);
}
internal static int UpdateAll <T>(this IDbCommand dbCmd, IEnumerable <T> objs, Action <IDbCommand> commandFilter = null)
{
OrmLiteUtils.AssertNotAnonType <T>();
IDbTransaction dbTrans = null;
int count = 0;
try
{
if (dbCmd.Transaction == null)
{
dbCmd.Transaction = dbTrans = dbCmd.Connection.BeginTransaction();
}
var dialectProvider = dbCmd.GetDialectProvider();
var hadRowVersion = dialectProvider.PrepareParameterizedUpdateStatement <T>(dbCmd);
if (string.IsNullOrEmpty(dbCmd.CommandText))
{
return(0);
}
foreach (var obj in objs)
{
OrmLiteConfig.UpdateFilter?.Invoke(dbCmd, obj);
dialectProvider.SetParameterValues <T>(dbCmd, obj);
commandFilter?.Invoke(dbCmd); //filters can augment SQL & only should be invoked once
commandFilter = null;
var rowsUpdated = dbCmd.ExecNonQuery();
if (hadRowVersion && rowsUpdated == 0)
{
throw new OptimisticConcurrencyException();
}
count += rowsUpdated;
}
dbTrans?.Commit();
}
finally
{
dbTrans?.Dispose();
}
return(count);
}
public static int Update <T>(this IDbCommand dbCmd, object updateOnly, Expression <Func <T, bool> > where = null, Action <IDbCommand> commandFilter = null)
{
OrmLiteUtils.AssertNotAnonType <T>();
OrmLiteConfig.UpdateFilter?.Invoke(dbCmd, updateOnly.ToFilterType <T>());
var q = dbCmd.GetDialectProvider().SqlExpression <T>();
var whereSql = q.Where(where).WhereExpression;
q.CopyParamsTo(dbCmd);
var hadRowVersion = dbCmd.PrepareUpdateAnonSql <T>(dbCmd.GetDialectProvider(), updateOnly, whereSql);
return(dbCmd.UpdateAndVerify <T>(commandFilter, hadRowVersion));
}
internal static Task <int> UpdateOnlyAsync <T>(this IDbCommand dbCmd,
Expression <Func <T> > updateFields,
string whereExpression,
IEnumerable <IDbDataParameter> sqlParams,
Action <IDbCommand> commandFilter,
CancellationToken token)
{
OrmLiteUtils.AssertNotAnonType <T>();
var cmd = dbCmd.InitUpdateOnly(updateFields, whereExpression, sqlParams);
commandFilter?.Invoke(cmd);
return(cmd.ExecNonQueryAsync(token));
}
internal static Task <int> UpdateAsync <T>(this IDbCommand dbCmd, object updateOnly, Expression <Func <T, bool> > where, Action <IDbCommand> commandFilter, CancellationToken token)
{
OrmLiteUtils.AssertNotAnonType <T>();
OrmLiteConfig.UpdateFilter?.Invoke(dbCmd, updateOnly.ToFilterType <T>());
var q = dbCmd.GetDialectProvider().SqlExpression <T>();
var whereSql = q.Where(where).WhereExpression;
q.CopyParamsTo(dbCmd);
dbCmd.PrepareUpdateAnonSql <T>(dbCmd.GetDialectProvider(), updateOnly, whereSql);
commandFilter?.Invoke(dbCmd);
return(dbCmd.ExecNonQueryAsync(token));
}
internal static async Task<int> UpdateInternalAsync<T>(this IDbCommand dbCmd, object obj, CancellationToken token, Action<IDbCommand> commandFilter=null)
{
OrmLiteUtils.AssertNotAnonType<T>();
OrmLiteConfig.UpdateFilter?.Invoke(dbCmd, obj.ToFilterType<T>());
var dialectProvider = dbCmd.GetDialectProvider();
var hadRowVersion = dialectProvider.PrepareParameterizedUpdateStatement<T>(dbCmd);
if (string.IsNullOrEmpty(dbCmd.CommandText))
return 0;
dialectProvider.SetParameterValues<T>(dbCmd, obj);
return await dbCmd.UpdateAndVerifyAsync<T>(commandFilter, hadRowVersion, token);
}
internal static int DeleteByIds <T>(this IDbCommand dbCmd, IEnumerable idValues)
{
OrmLiteUtils.AssertNotAnonType <T>();
var sqlIn = dbCmd.SetIdsInSqlParams(idValues);
if (string.IsNullOrEmpty(sqlIn))
{
return(0);
}
var sql = GetDeleteByIdsSql <T>(sqlIn, dbCmd.GetDialectProvider());
return(dbCmd.ExecuteSql(sql));
}
internal static async Task <int> UpdateAllAsync <T>(this IDbCommand dbCmd, IEnumerable <T> objs, Action <IDbCommand> commandFilter, CancellationToken token)
{
OrmLiteUtils.AssertNotAnonType <T>();
IDbTransaction dbTrans = null;
int count = 0;
if (dbCmd.Transaction == null)
{
dbCmd.Transaction = dbTrans = dbCmd.Connection.BeginTransaction();
}
var dialectProvider = dbCmd.GetDialectProvider();
var hadRowVersion = dialectProvider.PrepareParameterizedUpdateStatement <T>(dbCmd);
if (string.IsNullOrEmpty(dbCmd.CommandText))
{
return(0);
}
using (dbTrans)
{
foreach (var obj in objs)
{
OrmLiteConfig.UpdateFilter?.Invoke(dbCmd, obj);
dialectProvider.SetParameterValues <T>(dbCmd, obj);
commandFilter?.Invoke(dbCmd);
commandFilter = null;
var rowsUpdated = await dbCmd.ExecNonQueryAsync(token);
if (hadRowVersion && rowsUpdated == 0)
{
throw new OptimisticConcurrencyException();
}
count += rowsUpdated;
}
dbTrans?.Commit();
}
return(count);
}
internal static int UpdateInternal <T>(this IDbCommand dbCmd, object obj, Action <IDbCommand> commandFilter = null)
{
OrmLiteUtils.AssertNotAnonType <T>();
OrmLiteConfig.UpdateFilter?.Invoke(dbCmd, obj.ToFilterType <T>());
var dialectProvider = dbCmd.GetDialectProvider();
var hadRowVersion = dialectProvider.PrepareParameterizedUpdateStatement <T>(dbCmd);
if (string.IsNullOrEmpty(dbCmd.CommandText))
{
return(0);
}
dialectProvider.SetParameterValues <T>(dbCmd, obj);
return(dbCmd.UpdateAndVerify <T>(commandFilter, hadRowVersion));
}
internal static int UpdateOnlyFields <T>(this IDbCommand dbCmd, T obj,
string[] onlyFields = null,
Expression <Func <T, bool> > where = null,
Action <IDbCommand> commandFilter = null)
{
OrmLiteUtils.AssertNotAnonType <T>();
if (onlyFields == null)
{
throw new ArgumentNullException(nameof(onlyFields));
}
var q = dbCmd.GetDialectProvider().SqlExpression <T>();
q.Update(onlyFields);
q.Where(where);
return(dbCmd.UpdateOnlyFields(obj, q, commandFilter));
}
internal static long Insert <T>(this IDbCommand dbCmd, T obj, bool selectIdentity = false)
{
OrmLiteConfig.InsertFilter?.Invoke(dbCmd, obj);
var dialectProvider = dbCmd.GetDialectProvider();
dialectProvider.PrepareParameterizedInsertStatement <T>(dbCmd,
insertFields: OrmLiteUtils.GetNonDefaultValueInsertFields(obj));
dialectProvider.SetParameterValues <T>(dbCmd, obj);
if (selectIdentity)
{
return(dialectProvider.InsertAndGetLastInsertId <T>(dbCmd));
}
return(dbCmd.ExecNonQuery());
}
internal static Task <long> InsertAsync <T>(this IDbCommand dbCmd, T obj, bool selectIdentity, CancellationToken token)
{
OrmLiteConfig.InsertFilter?.Invoke(dbCmd, obj);
var dialectProvider = dbCmd.GetDialectProvider();
dialectProvider.PrepareParameterizedInsertStatement <T>(dbCmd,
insertFields: OrmLiteUtils.GetNonDefaultValueInsertFields(obj));
dialectProvider.SetParameterValues <T>(dbCmd, obj);
if (selectIdentity)
{
return(dialectProvider.InsertAndGetLastInsertIdAsync <T>(dbCmd, token));
}
return(dbCmd.ExecNonQueryAsync(token).Then(i => (long)i));
}
internal static long Insert <T>(this IDbCommand dbCmd, T obj, Action <IDbCommand> commandFilter, bool selectIdentity = false)
{
OrmLiteConfig.InsertFilter?.Invoke(dbCmd, obj);
var dialectProvider = dbCmd.GetDialectProvider();
dialectProvider.PrepareParameterizedInsertStatement <T>(dbCmd,
insertFields: OrmLiteUtils.GetNonDefaultValueInsertFields(obj));
dialectProvider.SetParameterValues <T>(dbCmd, obj);
commandFilter?.Invoke(dbCmd); //dbCmd.OnConflictInsert() needs to be applied before last insert id
var modelDef = typeof(T).GetModelDefinition();
if (modelDef.HasReturnAttribute)
{
using (var reader = dbCmd.ExecReader(dbCmd.CommandText))
using (reader)
{
if (reader.Read())
{
var values = new object[reader.FieldCount];
var indexCache = reader.GetIndexFieldsCache(ModelDefinition <T> .Definition, dialectProvider);
obj.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);
if ((modelDef.PrimaryKey != null) && modelDef.PrimaryKey.AutoIncrement)
{
var id = modelDef.GetPrimaryKey(obj);
return(Convert.ToInt64(id));
}
}
return(0);
}
}
if (selectIdentity)
{
dbCmd.CommandText += dialectProvider.GetLastInsertIdSqlSuffix <T>();
return(dbCmd.ExecLongScalar());
}
return(dbCmd.ExecNonQuery());
}
internal static void UpdateOnlySql <T>(this IDbCommand dbCmd, T model, SqlExpression <T> onlyFields)
{
OrmLiteUtils.AssertNotAnonType <T>();
OrmLiteConfig.UpdateFilter?.Invoke(dbCmd, model);
var fieldsToUpdate = onlyFields.UpdateFields.Count == 0
? onlyFields.GetAllFields()
: onlyFields.UpdateFields;
onlyFields.CopyParamsTo(dbCmd);
dbCmd.GetDialectProvider().PrepareUpdateRowStatement(dbCmd, model, fieldsToUpdate);
if (!onlyFields.WhereExpression.IsNullOrEmpty())
{
dbCmd.CommandText += " " + onlyFields.WhereExpression;
}
}
private static int DeleteAll <T>(IDbCommand dbCmd, IEnumerable <T> objs,
Func <object, Dictionary <string, object> > fieldValuesFn, Action <IDbCommand> commandFilter = null)
{
OrmLiteUtils.AssertNotAnonType <T>();
IDbTransaction dbTrans = null;
int count = 0;
try
{
if (dbCmd.Transaction == null)
{
dbCmd.Transaction = dbTrans = dbCmd.Connection.BeginTransaction();
}
var dialectProvider = dbCmd.GetDialectProvider();
foreach (var obj in objs)
{
var fieldValues = fieldValuesFn != null
? fieldValuesFn(obj)
: obj.AllFieldsMap <T>();
dialectProvider.PrepareParameterizedDeleteStatement <T>(dbCmd, fieldValues);
dialectProvider.SetParameterValues <T>(dbCmd, obj);
commandFilter?.Invoke(dbCmd); //filters can augment SQL & only should be invoked once
commandFilter = null;
count += dbCmd.ExecNonQuery();
}
dbTrans?.Commit();
}
finally
{
dbTrans?.Dispose();
}
return(count);
}
internal static Task <int> UpdateOnlyAsync <T>(this IDbCommand dbCmd, T obj,
Expression <Func <T, object> > onlyFields,
Expression <Func <T, bool> > where,
Action <IDbCommand> commandFilter,
CancellationToken token)
{
OrmLiteUtils.AssertNotAnonType <T>();
if (onlyFields == null)
{
throw new ArgumentNullException(nameof(onlyFields));
}
var q = dbCmd.GetDialectProvider().SqlExpression <T>();
q.Update(onlyFields);
q.Where(where);
return(dbCmd.UpdateOnlyAsync(obj, q, commandFilter, token));
}
public static int UpdateOnly <T>(this IDbCommand dbCmd,
Dictionary <string, object> updateFields,
Expression <Func <T, bool> > where,
Action <IDbCommand> commandFilter = null)
{
OrmLiteUtils.AssertNotAnonType <T>();
if (updateFields == null)
{
throw new ArgumentNullException(nameof(updateFields));
}
OrmLiteConfig.UpdateFilter?.Invoke(dbCmd, updateFields.ToFilterType <T>());
var q = dbCmd.GetDialectProvider().SqlExpression <T>();
q.Where(where);
q.PrepareUpdateStatement(dbCmd, updateFields);
return(dbCmd.UpdateAndVerify <T>(commandFilter, updateFields.ContainsKey(ModelDefinition.RowVersionName)));
}
public static Task <List <T> > ConvertToListAsync <T>(this IDbCommand dbCmd, string sql, CancellationToken token)
{
if (sql != null)
{
dbCmd.CommandText = sql;
}
if (OrmLiteConfig.ResultsFilter != null)
{
return(OrmLiteConfig.ResultsFilter.GetList <T>(dbCmd).InTask());
}
var dialectProvider = dbCmd.GetDialectProvider();
return(dbCmd.ExecReaderAsync(dbCmd.CommandText, token)
.Then(reader =>
OrmLiteUtils.IsScalar <T>()
? reader.ColumnAsync <T>(dialectProvider, token)
: reader.ConvertToListAsync <T>(dialectProvider, null, token)).Unwrap());
}
public static List <T> ConvertToList <T>(this IDbCommand dbCmd, string sql = null)
{
if (sql != null)
{
dbCmd.CommandText = sql;
}
var isScalar = OrmLiteUtils.IsScalar <T>();
if (OrmLiteConfig.ResultsFilter != null)
{
return(isScalar
? OrmLiteConfig.ResultsFilter.GetColumn <T>(dbCmd)
: OrmLiteConfig.ResultsFilter.GetList <T>(dbCmd));
}
using var reader = dbCmd.ExecReader(dbCmd.CommandText);
return(isScalar
? reader.Column <T>(dbCmd.GetDialectProvider())
: reader.ConvertToList <T>(dbCmd.GetDialectProvider()));
}
private static async Task <int> DeleteAllAsync <T>(IDbCommand dbCmd, IEnumerable <T> objs, Func <object, Dictionary <string, object> > fieldValuesFn = null,
Action <IDbCommand> commandFilter = null, CancellationToken token = default)
{
OrmLiteUtils.AssertNotAnonType <T>();
IDbTransaction dbTrans = null;
int count = 0;
if (dbCmd.Transaction == null)
{
dbCmd.Transaction = dbTrans = dbCmd.Connection.BeginTransaction();
}
var dialectProvider = dbCmd.GetDialectProvider();
using (dbTrans)
{
foreach (var obj in objs)
{
var fieldValues = fieldValuesFn != null
? fieldValuesFn(obj)
: obj.AllFieldsMap <T>();
dialectProvider.PrepareParameterizedDeleteStatement <T>(dbCmd, fieldValues);
dialectProvider.SetParameterValues <T>(dbCmd, obj);
commandFilter?.Invoke(dbCmd); //filters can augment SQL & only should be invoked once
commandFilter = null;
var rowsAffected = await dbCmd.ExecNonQueryAsync(token);
count += rowsAffected;
}
dbTrans?.Commit();
}
return(count);
}
public static int UpdateOnly <T>(this IDbCommand dbCmd,
Dictionary <string, object> updateFields,
Expression <Func <T, bool> > where,
Action <IDbCommand> commandFilter = null)
{
OrmLiteUtils.AssertNotAnonType <T>();
if (updateFields == null)
{
throw new ArgumentNullException(nameof(updateFields));
}
OrmLiteConfig.UpdateFilter?.Invoke(dbCmd, updateFields.FromObjectDictionary <T>());
var q = dbCmd.GetDialectProvider().SqlExpression <T>();
q.Where(where);
q.PrepareUpdateStatement(dbCmd, updateFields);
commandFilter?.Invoke(dbCmd);
return(dbCmd.ExecNonQuery());
}
internal static string DeleteByIdSql <T>(this IDbCommand dbCmd, object id, ulong rowVersion)
{
OrmLiteUtils.AssertNotAnonType <T>();
var modelDef = ModelDefinition <T> .Definition;
var dialectProvider = dbCmd.GetDialectProvider();
dbCmd.Parameters.Clear();
var idParam = dbCmd.CreateParameter();
idParam.ParameterName = dialectProvider.GetParam();
idParam.Value = id;
dbCmd.Parameters.Add(idParam);
var rowVersionField = modelDef.RowVersion;
if (rowVersionField == null)
{
throw new InvalidOperationException(
"Cannot use DeleteById with rowVersion for model type without a row version column");
}
var rowVersionParam = dbCmd.CreateParameter();
rowVersionParam.ParameterName = dialectProvider.GetParam("rowVersion");
var converter = dialectProvider.GetConverterBestMatch(typeof(RowVersionConverter));
converter.InitDbParam(rowVersionParam, typeof(ulong));
rowVersionParam.Value = converter.ToDbValue(typeof(ulong), rowVersion);
dbCmd.Parameters.Add(rowVersionParam);
var sql = $"DELETE FROM {dialectProvider.GetQuotedTableName(modelDef)} " +
$"WHERE {dialectProvider.GetQuotedColumnName(modelDef.PrimaryKey.FieldName)} = {idParam.ParameterName} " +
$"AND {dialectProvider.GetRowVersionColumn(rowVersionField)} = {rowVersionParam.ParameterName}";
return(sql);
}
internal static long Insert <T>(this IDbCommand dbCmd, T obj, Action <IDbCommand> commandFilter, bool selectIdentity = false)
{
OrmLiteConfig.InsertFilter?.Invoke(dbCmd, obj);
var dialectProvider = dbCmd.GetDialectProvider();
dialectProvider.PrepareParameterizedInsertStatement <T>(dbCmd,
insertFields: OrmLiteUtils.GetNonDefaultValueInsertFields(obj));
dialectProvider.SetParameterValues <T>(dbCmd, obj);
commandFilter?.Invoke(dbCmd); //dbCmd.OnConflictInsert() needs to be applied before last insert id
if (selectIdentity)
{
dbCmd.CommandText += dialectProvider.GetLastInsertIdSqlSuffix <T>();
return(dbCmd.ExecLongScalar());
}
return(dbCmd.ExecNonQuery());
}
