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)); }