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