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 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).ConfigAwait());
}
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));
}
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;
}
}
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)));
}
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);
}
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); //filters can augment SQL & only should be invoked once
commandFilter = null;
var rowsUpdated = await dbCmd.ExecNonQueryAsync(token);
if (hadRowVersion && rowsUpdated == 0)
throw new OptimisticConcurrencyException();
count += rowsUpdated;
}
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());
}
public static Task <int> UpdateOnlyAsync <T>(this IDbCommand dbCmd,
Dictionary <string, object> updateFields,
string whereExpression,
object[] whereParams,
Action <IDbCommand> commandFilter = null,
CancellationToken token = default)
{
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(whereExpression, whereParams);
q.PrepareUpdateStatement(dbCmd, updateFields);
return(dbCmd.UpdateAndVerifyAsync <T>(commandFilter, updateFields.ContainsKey(ModelDefinition.RowVersionName), token));
}
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);
}
public static Task <int> UpdateOnlyAsync <T>(this IDbCommand cmd,
Dictionary <string, object> updateFields,
Expression <Func <T, bool> > where,
Action <IDbCommand> commandFilter = null,
CancellationToken token = default)
{
OrmLiteUtils.AssertNotAnonType <T>();
if (updateFields == null)
{
throw new ArgumentNullException(nameof(updateFields));
}
OrmLiteConfig.UpdateFilter?.Invoke(cmd, updateFields.ToFilterType <T>());
var q = cmd.GetDialectProvider().SqlExpression <T>();
q.Where(where);
q.PrepareUpdateStatement(cmd, updateFields);
commandFilter?.Invoke(cmd);
return(cmd.ExecNonQueryAsync(token));
}
private static long InsertInternal <T>(IOrmLiteDialectProvider dialectProvider, IDbCommand dbCmd, object obj, Action <IDbCommand> commandFilter, bool selectIdentity)
{
OrmLiteUtils.AssertNotAnonType <T>();
dialectProvider.SetParameterValues <T>(dbCmd, obj);
commandFilter?.Invoke(dbCmd); //dbCmd.OnConflictInsert() needs to be applied before last insert id
if (dialectProvider.HasInsertReturnValues(ModelDefinition <T> .Definition))
{
using var reader = dbCmd.ExecReader(dbCmd.CommandText);
return(reader.PopulateReturnValues <T>(dialectProvider, obj));
}
if (selectIdentity)
{
dbCmd.CommandText += dialectProvider.GetLastInsertIdSqlSuffix <T>();
return(dbCmd.ExecLongScalar());
}
return(dbCmd.ExecNonQuery());
}
private static async Task <long> InsertInternalAsync <T>(IOrmLiteDialectProvider dialectProvider,
IDbCommand dbCmd, object obj, Action <IDbCommand> commandFilter, bool selectIdentity, CancellationToken token)
{
OrmLiteUtils.AssertNotAnonType <T>();
dialectProvider.SetParameterValues <T>(dbCmd, obj);
commandFilter?.Invoke(dbCmd);
if (dialectProvider.HasInsertReturnValues(ModelDefinition <T> .Definition))
{
using var reader = await dbCmd.ExecReaderAsync(dbCmd.CommandText, token);
return(reader.PopulateReturnValues <T>(dialectProvider, obj));
}
if (selectIdentity)
{
return(await dialectProvider.InsertAndGetLastInsertIdAsync <T>(dbCmd, token));
}
return(await dbCmd.ExecNonQueryAsync(token));
}
internal static long Insert <T>(this IDbCommand dbCmd, Dictionary <string, object> obj, Action <IDbCommand> commandFilter, bool selectIdentity = false)
{
OrmLiteUtils.AssertNotAnonType <T>();
OrmLiteConfig.InsertFilter?.Invoke(dbCmd, obj.ToFilterType <T>());
var dialectProvider = dbCmd.GetDialectProvider();
var pkField = ModelDefinition <T> .Definition.PrimaryKey;
object id = null;
var enableIdentityInsert = pkField?.AutoIncrement == true && obj.TryGetValue(pkField.Name, out id);
try
{
if (enableIdentityInsert)
{
dialectProvider.EnableIdentityInsert <T>(dbCmd);
}
dialectProvider.PrepareParameterizedInsertStatement <T>(dbCmd,
insertFields: dialectProvider.GetNonDefaultValueInsertFields <T>(obj),
shouldInclude: f => obj.ContainsKey(f.Name));
var ret = InsertInternal <T>(dialectProvider, dbCmd, obj, commandFilter, selectIdentity);
if (enableIdentityInsert)
{
return(Convert.ToInt64(id));
}
return(ret);
}
finally
{
if (enableIdentityInsert)
{
dialectProvider.DisableIdentityInsert <T>(dbCmd);
}
}
}
public static async Task <int> UpdateOnlyReferencesAsync <T>(this IDbCommand dbCmd,
Dictionary <string, object> updateFields, Func <Dictionary <string, object>, Task <int> > fn, CancellationToken token = default)
{
OrmLiteUtils.AssertNotAnonType <T>();
if (updateFields == null)
{
throw new ArgumentNullException(nameof(updateFields));
}
OrmLiteConfig.UpdateFilter?.Invoke(dbCmd, updateFields.ToFilterType <T>());
var dbFields = updateFields;
var modelDef = ModelDefinition <T> .Definition;
var hasReferences = modelDef.HasAnyReferences(updateFields.Keys);
if (hasReferences)
{
dbFields = new Dictionary <string, object>();
foreach (var entry in updateFields)
{
if (!modelDef.IsReference(entry.Key))
{
dbFields[entry.Key] = entry.Value;
}
}
}
var ret = await fn(dbFields).ConfigAwait();
if (hasReferences)
{
var instance = updateFields.FromObjectDictionary <T>();
await dbCmd.SaveAllReferencesAsync(instance, token).ConfigAwait();
}
return(ret);
}
internal static int DeleteAll <T>(this IDbCommand dbCmd)
{
OrmLiteUtils.AssertNotAnonType <T>();
return(DeleteAll(dbCmd, typeof(T)));
}
internal static async Task <int> SaveAllAsync <T>(this IDbCommand dbCmd, IEnumerable <T> objs, CancellationToken token)
{
OrmLiteUtils.AssertNotAnonType <T>();
var saveRows = objs.ToList();
var firstRow = saveRows.FirstOrDefault();
if (Equals(firstRow, default(T)))
{
return(0);
}
var modelDef = typeof(T).GetModelDefinition();
var firstRowId = modelDef.GetPrimaryKey(firstRow);
var defaultIdValue = firstRowId?.GetType().GetDefaultValue();
var idMap = defaultIdValue != null
? saveRows.Where(x => !defaultIdValue.Equals(modelDef.GetPrimaryKey(x))).ToSafeDictionary(x => modelDef.GetPrimaryKey(x))
: saveRows.Where(x => modelDef.GetPrimaryKey(x) != null).ToSafeDictionary(x => modelDef.GetPrimaryKey(x));
var existingRowsMap = (await dbCmd.SelectByIdsAsync <T>(idMap.Keys, token)).ToDictionary(x => modelDef.GetPrimaryKey(x));
var rowsAdded = 0;
IDbTransaction dbTrans = null;
if (dbCmd.Transaction == null)
{
dbCmd.Transaction = dbTrans = dbCmd.Connection.BeginTransaction();
}
var dialectProvider = dbCmd.GetDialectProvider();
using (dbTrans)
{
foreach (var row in saveRows)
{
var id = modelDef.GetPrimaryKey(row);
if (id != defaultIdValue && existingRowsMap.ContainsKey(id))
{
await dbCmd.UpdateAsync(row, token, null);
}
else
{
if (modelDef.HasAutoIncrementId)
{
var newId = await dbCmd.InsertAsync(row, commandFilter : null, selectIdentity : true, token : token);
var safeId = dialectProvider.FromDbValue(newId, modelDef.PrimaryKey.FieldType);
modelDef.PrimaryKey.SetValue(row, safeId);
id = newId;
}
else
{
await dbCmd.InsertAsync(row, commandFilter : null, selectIdentity : false, token : token);
}
rowsAdded++;
}
modelDef.RowVersion?.SetValue(row, await dbCmd.GetRowVersionAsync(modelDef, id, token));
}
dbTrans?.Commit();
}
return(rowsAdded);
}
public static Task <int> InsertOnlyAsync <T>(this IDbCommand dbCmd, Expression <Func <T> > insertFields, CancellationToken token)
{
OrmLiteUtils.AssertNotAnonType <T>();
return(dbCmd.InitInsertOnly(insertFields).ExecNonQueryAsync(token));
}
