public static void InsertOnly<T>(this IDbCommand dbCmd, T obj, SqlExpression<T> onlyFields)
{
if (OrmLiteConfig.InsertFilter != null)
OrmLiteConfig.InsertFilter(dbCmd, obj);
var sql = dbCmd.GetDialectProvider().ToInsertRowStatement(dbCmd, obj, onlyFields.InsertFields);
dbCmd.ExecuteSql(sql);
}
internal static Task <int> UpdateAllAsync <T>(this IDbCommand dbCmd, IEnumerable <T> objs, CancellationToken token)
{
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(TaskResult.Zero);
}
return(objs.EachAsync((obj, i) =>
{
if (OrmLiteConfig.UpdateFilter != null)
{
OrmLiteConfig.UpdateFilter(dbCmd, obj);
}
dialectProvider.SetParameterValues <T>(dbCmd, obj);
return dbCmd.ExecNonQueryAsync(token).Then(rowsUpdated =>
{
if (hadRowVersion && rowsUpdated == 0)
{
throw new OptimisticConcurrencyException();
}
count += rowsUpdated;
return count;
});
}).ContinueWith(t =>
{
if (dbTrans != null && t.IsSuccess())
{
dbTrans.Commit();
}
dbTrans?.Dispose();
if (t.IsFaulted)
{
throw t.Exception;
}
return count;
}, token));
}
public static int Update<T>(this IDbCommand dbCmd, T item, Expression<Func<T, bool>> expression)
{
if (OrmLiteConfig.UpdateFilter != null)
OrmLiteConfig.UpdateFilter(dbCmd, item);
var q = dbCmd.GetDialectProvider().SqlExpression<T>();
q.Where(expression);
q.PrepareUpdateStatement(dbCmd, item);
return dbCmd.ExecNonQuery();
}
internal static int UpdateAll <T>(this IDbCommand dbCmd, IEnumerable <T> objs)
{
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)
{
if (OrmLiteConfig.UpdateFilter != null)
{
OrmLiteConfig.UpdateFilter(dbCmd, obj);
}
dialectProvider.SetParameterValues <T>(dbCmd, obj);
var rowsUpdated = dbCmd.ExecNonQuery();
if (hadRowVersion && rowsUpdated == 0)
{
throw new OptimisticConcurrencyException();
}
count += rowsUpdated;
}
if (dbTrans != null)
{
dbTrans.Commit();
}
}
finally
{
if (dbTrans != null)
{
dbTrans.Dispose();
}
}
return(count);
}
internal static Task InsertOnlyAsync <T>(this IDbCommand dbCmd, T obj, string[] onlyFields, CancellationToken token)
{
if (OrmLiteConfig.InsertFilter != null)
{
OrmLiteConfig.InsertFilter(dbCmd, obj);
}
var sql = dbCmd.GetDialectProvider().ToInsertRowStatement(dbCmd, obj, onlyFields);
return(dbCmd.ExecuteSqlAsync(sql, token));
}
internal static int Update <T>(this IDbCommand dbCmd, T obj)
{
if (OrmLiteConfig.UpdateFilter != null)
{
OrmLiteConfig.UpdateFilter(dbCmd, obj);
}
OrmLiteConfig.DialectProvider.PrepareParameterizedUpdateStatement <T>(dbCmd);
OrmLiteConfig.DialectProvider.SetParameterValues <T>(dbCmd, obj);
return(dbCmd.ExecNonQuery());
}
public static int UpdateNonDefaults <T>(this IDbCommand dbCmd, T item, Expression <Func <T, bool> > obj)
{
if (OrmLiteConfig.UpdateFilter != null)
{
OrmLiteConfig.UpdateFilter(dbCmd, item);
}
var q = dbCmd.GetDialectProvider().SqlExpression <T>();
q.Where(obj);
q.PrepareUpdateStatement(dbCmd, item, excludeDefaults: true);
return(dbCmd.ExecNonQuery());
}
internal static Task <int> UpdateNonDefaultsAsync <T>(this IDbCommand dbCmd, T item, Expression <Func <T, bool> > obj, CancellationToken token)
{
if (OrmLiteConfig.UpdateFilter != null)
{
OrmLiteConfig.UpdateFilter(dbCmd, item);
}
var q = dbCmd.GetDialectProvider().SqlExpression <T>();
q.Where(obj);
q.PrepareUpdateStatement(dbCmd, item, excludeDefaults: true);
return(dbCmd.ExecNonQueryAsync(token));
}
internal static Task <int> UpdateAsync <T>(this IDbCommand dbCmd, T item, Expression <Func <T, bool> > expression, CancellationToken token)
{
if (OrmLiteConfig.UpdateFilter != null)
{
OrmLiteConfig.UpdateFilter(dbCmd, item);
}
var q = dbCmd.GetDialectProvider().SqlExpression <T>();
q.Where(expression);
var sql = q.ToUpdateStatement(item);
return(dbCmd.ExecuteSqlAsync(sql, token));
}
public static int Update <T>(this IDbCommand dbCmd, T item, Expression <Func <T, bool> > expression)
{
if (OrmLiteConfig.UpdateFilter != null)
{
OrmLiteConfig.UpdateFilter(dbCmd, item);
}
var q = dbCmd.GetDialectProvider().SqlExpression <T>();
q.Where(expression);
var sql = q.ToUpdateStatement(item);
return(dbCmd.ExecuteSql(sql));
}
/// <summary>
/// Updates all non-default values set on item matching the where condition (if any). E.g
///
/// dbCmd.UpdateNonDefaults(new Person { FirstName = "JJ" }, p => p.FirstName == "Jimi");
/// UPDATE "Person" SET "FirstName" = 'JJ' WHERE ("FirstName" = 'Jimi')
/// </summary>
public static int UpdateNonDefaults <T>(this IDbCommand dbCmd, T item, Expression <Func <T, bool> > obj)
{
if (OrmLiteConfig.UpdateFilter != null)
{
OrmLiteConfig.UpdateFilter(dbCmd, item);
}
var ev = OrmLiteConfig.DialectProvider.SqlExpression <T>();
ev.Where(obj);
var sql = ev.ToUpdateStatement(item, excludeDefaults: true);
return(dbCmd.ExecuteSql(sql));
}
internal static Task <int> UpdateNonDefaultsAsync <T>(this IDbCommand dbCmd, T item, Expression <Func <T, bool> > obj, CancellationToken token)
{
if (OrmLiteConfig.UpdateFilter != null)
{
OrmLiteConfig.UpdateFilter(dbCmd, item);
}
var q = OrmLiteConfig.DialectProvider.SqlExpression <T>();
q.Where(obj);
var sql = q.ToUpdateStatement(item, excludeDefaults: true);
return(dbCmd.ExecuteSqlAsync(sql, token));
}
internal static void InsertAll <T>(this IDbCommand dbCmd, IEnumerable <T> objs)
{
IDbTransaction dbTrans = null;
try
{
if (dbCmd.Transaction == null)
{
dbCmd.Transaction = dbTrans = dbCmd.Connection.BeginTransaction();
}
var dialectProvider = dbCmd.GetDialectProvider();
dialectProvider.PrepareParameterizedInsertStatement <T>(dbCmd);
foreach (var obj in objs)
{
if (OrmLiteConfig.InsertFilter != null)
{
OrmLiteConfig.InsertFilter(dbCmd, obj);
}
dialectProvider.SetParameterValues <T>(dbCmd, obj);
try
{
dbCmd.ExecNonQuery();
}
catch (Exception ex)
{
Log.Error("SQL ERROR: {0}".Fmt(dbCmd.GetLastSqlAndParams()), ex);
throw;
}
}
if (dbTrans != null)
{
dbTrans.Commit();
}
}
finally
{
if (dbTrans != null)
{
dbTrans.Dispose();
}
}
}
internal static bool Save <T>(this IDbCommand dbCmd, T obj)
{
var id = obj.GetId();
var existingRow = id != null?dbCmd.SingleById <T>(id) : default(T);
var modelDef = typeof(T).GetModelDefinition();
if (Equals(existingRow, default(T)))
{
if (modelDef.HasAutoIncrementId)
{
var newId = dbCmd.Insert(obj, selectIdentity: true);
var safeId = OrmLiteConfig.DialectProvider.ConvertDbValue(newId, modelDef.PrimaryKey.FieldType);
modelDef.PrimaryKey.SetValueFn(obj, safeId);
id = newId;
}
else
{
if (OrmLiteConfig.InsertFilter != null)
{
OrmLiteConfig.InsertFilter(dbCmd, obj);
}
dbCmd.Insert(obj);
}
if (modelDef.RowVersion != null)
{
modelDef.RowVersion.SetValueFn(obj, dbCmd.GetRowVersion(modelDef, id));
}
return(true);
}
if (OrmLiteConfig.UpdateFilter != null)
{
OrmLiteConfig.UpdateFilter(dbCmd, obj);
}
dbCmd.Update(obj);
if (modelDef.RowVersion != null)
{
modelDef.RowVersion.SetValueFn(obj, dbCmd.GetRowVersion(modelDef, id));
}
return(false);
}
internal static int UpdateAll <T>(this IDbCommand dbCmd, IEnumerable <T> objs)
{
IDbTransaction dbTrans = null;
int count = 0;
try
{
if (dbCmd.Transaction == null)
{
dbCmd.Transaction = dbTrans = dbCmd.Connection.BeginTransaction();
}
var dialectProvider = OrmLiteConfig.DialectProvider;
dialectProvider.PrepareParameterizedUpdateStatement <T>(dbCmd);
if (string.IsNullOrEmpty(dbCmd.CommandText))
{
return(0);
}
foreach (var obj in objs)
{
if (OrmLiteConfig.UpdateFilter != null)
{
OrmLiteConfig.UpdateFilter(dbCmd, obj);
}
dialectProvider.SetParameterValues <T>(dbCmd, obj);
count += dbCmd.ExecNonQuery();
}
if (dbTrans != null)
{
dbTrans.Commit();
}
}
finally
{
if (dbTrans != null)
{
dbTrans.Dispose();
}
}
return(count);
}
internal static void UpdateOnlySql<T>(this IDbCommand dbCmd, T model, SqlExpression<T> onlyFields)
{
if (OrmLiteConfig.UpdateFilter != null)
OrmLiteConfig.UpdateFilter(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;
}
internal static void UpdateAddSql <T>(this IDbCommand dbCmd, T model, SqlExpression <T> fields)
{
if (OrmLiteConfig.UpdateFilter != null)
{
OrmLiteConfig.UpdateFilter(dbCmd, model);
}
fields.CopyParamsTo(dbCmd);
dbCmd.GetDialectProvider().PrepareUpdateRowAddStatement(dbCmd, model, fields.UpdateFields);
if (!fields.WhereExpression.IsNullOrEmpty())
{
dbCmd.CommandText += " " + fields.WhereExpression;
}
}
public static T PopulateWithSqlReader <T>(this T objWithProperties,
IOrmLiteDialectProvider dialectProvider, IDataReader reader,
Tuple <FieldDefinition, int, IOrmLiteConverter>[] indexCache, object[] values)
{
try
{
if (values == null)
{
values = new object[reader.FieldCount];
}
reader.GetValues(values);
foreach (var fieldCache in indexCache)
{
var fieldDef = fieldCache.Item1;
var index = fieldCache.Item2;
var converter = fieldCache.Item3;
if (values[index] == DBNull.Value)
{
var value = fieldDef.IsNullable ? null : fieldDef.FieldTypeDefaultValue;
if (OrmLiteConfig.OnDbNullFilter != null)
{
var useValue = OrmLiteConfig.OnDbNullFilter(fieldDef);
if (useValue != null)
{
value = useValue;
}
}
fieldDef.SetValueFn(objWithProperties, value);
}
else
{
var value = converter.GetValue(reader, index, values);
var fieldValue = converter.FromDbValue(fieldDef.FieldType, value);
fieldDef.SetValueFn(objWithProperties, fieldValue);
}
}
}
catch (Exception ex)
{
Log.Error(ex);
}
return(objWithProperties);
}
public static int UpdateAdd<T>(this IDbCommand dbCmd,
Expression<Func<T>> updateFields,
SqlExpression<T> q)
{
if (updateFields == null)
throw new ArgumentNullException("updateFields");
if (OrmLiteConfig.UpdateFilter != null)
OrmLiteConfig.UpdateFilter(dbCmd, CachedExpressionCompiler.Evaluate(updateFields));
q.CopyParamsTo(dbCmd);
var updateFieldValues = updateFields.AssignedValues();
dbCmd.GetDialectProvider().PrepareUpdateRowAddStatement<T>(dbCmd, updateFieldValues, q.WhereExpression);
return dbCmd.ExecNonQuery();
}
internal static Task <long> InsertAsync <T>(this IDbCommand dbCmd, T obj, bool selectIdentity, CancellationToken token)
{
if (OrmLiteConfig.InsertFilter != null)
{
OrmLiteConfig.InsertFilter(dbCmd, obj);
}
OrmLiteConfig.DialectProvider.PrepareParameterizedInsertStatement <T>(dbCmd);
OrmLiteConfig.DialectProvider.SetParameterValues <T>(dbCmd, obj);
if (selectIdentity)
{
return(OrmLiteConfig.DialectProvider.InsertAndGetLastInsertIdAsync <T>(dbCmd, token));
}
return(dbCmd.ExecNonQueryAsync(token).Then(i => (long)i));
}
internal static long Insert <T>(this IDbCommand dbCmd, T obj, bool selectIdentity = false)
{
if (OrmLiteConfig.InsertFilter != null)
{
OrmLiteConfig.InsertFilter(dbCmd, obj);
}
OrmLiteConfig.DialectProvider.PrepareParameterizedInsertStatement <T>(dbCmd);
OrmLiteConfig.DialectProvider.SetParameterValues <T>(dbCmd, obj);
if (selectIdentity)
{
return(OrmLiteConfig.DialectProvider.InsertAndGetLastInsertId <T>(dbCmd));
}
return(dbCmd.ExecNonQuery());
}
internal static string UpdateOnlySql <T>(this IDbCommand dbCmd, T model, SqlExpression <T> onlyFields)
{
if (OrmLiteConfig.UpdateFilter != null)
{
OrmLiteConfig.UpdateFilter(dbCmd, model);
}
var fieldsToUpdate = onlyFields.UpdateFields.Count == 0
? onlyFields.GetAllFields()
: onlyFields.UpdateFields;
var sql = dbCmd.GetDialectProvider().ToUpdateRowStatement(model, fieldsToUpdate);
if (!onlyFields.WhereExpression.IsNullOrEmpty())
{
sql += " " + onlyFields.WhereExpression;
}
return(sql);
}
internal static Task InsertAllAsync <T>(this IDbCommand dbCmd, IEnumerable <T> objs, CancellationToken token)
{
IDbTransaction dbTrans = null;
if (dbCmd.Transaction == null)
{
dbCmd.Transaction = dbTrans = dbCmd.Connection.BeginTransaction();
}
var dialectProvider = dbCmd.GetDialectProvider();
dialectProvider.PrepareParameterizedInsertStatement <T>(dbCmd);
return(objs.EachAsync((obj, i) =>
{
if (OrmLiteConfig.InsertFilter != null)
{
OrmLiteConfig.InsertFilter(dbCmd, obj);
}
dialectProvider.SetParameterValues <T>(dbCmd, obj);
return dbCmd.ExecNonQueryAsync(token);
})
.ContinueWith(t =>
{
if (dbTrans != null && t.IsSuccess())
{
dbTrans.Commit();
}
if (dbTrans != null)
{
dbTrans.Dispose();
}
if (t.IsFaulted)
{
throw t.Exception;
}
}));
}
public static Task <int> InsertOnlyAsync <T>(this IDbCommand dbCmd, Expression <Func <T> > insertFields, CancellationToken token)
{
if (insertFields == null)
{
throw new ArgumentNullException("insertFields");
}
if (OrmLiteConfig.InsertFilter != null)
{
OrmLiteConfig.InsertFilter(dbCmd, CachedExpressionCompiler.Evaluate(insertFields));
}
var insertFieldsValues = insertFields.AssignedValues();
dbCmd.GetDialectProvider().PrepareParameterizedInsertStatement <T>(dbCmd, insertFieldsValues.Keys);
dbCmd.SetParameters(insertFieldsValues, excludeDefaults: false);
return(dbCmd.ExecNonQueryAsync(token));
}
internal static long Insert <T>(this IDbCommand dbCmd, T obj, bool selectIdentity = false)
{
if (OrmLiteConfig.InsertFilter != null)
{
OrmLiteConfig.InsertFilter(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 void InsertAll <T>(this IDbCommand dbCmd, IEnumerable <T> objs)
{
IDbTransaction dbTrans = null;
try
{
if (dbCmd.Transaction == null)
{
dbCmd.Transaction = dbTrans = dbCmd.Connection.BeginTransaction();
}
var dialectProvider = dbCmd.GetDialectProvider();
dialectProvider.PrepareParameterizedInsertStatement <T>(dbCmd);
foreach (var obj in objs)
{
if (OrmLiteConfig.InsertFilter != null)
{
OrmLiteConfig.InsertFilter(dbCmd, obj);
}
dialectProvider.SetParameterValues <T>(dbCmd, obj);
dbCmd.ExecNonQuery();
}
if (dbTrans != null)
{
dbTrans.Commit();
}
}
finally
{
if (dbTrans != null)
{
dbTrans.Dispose();
}
}
}
public virtual void Exec(IDbConnection dbConn, Action <IDbCommand> filter)
{
var dbCmd = CreateCommand(dbConn);
try
{
filter(dbCmd);
}
catch (Exception ex)
{
if (OrmLiteConfig.ExceptionFilter != null)
{
OrmLiteConfig.ExceptionFilter(dbCmd, ex);
}
throw;
}
finally
{
DisposeCommand(dbCmd, dbConn);
}
}
public static bool HandledDbNullValue(FieldDefinition fieldDef, IDataReader dataReader, int colIndex, object instance)
{
if (fieldDef == null || fieldDef.SetValueFn == null || colIndex == NotFound)
{
return(true);
}
if (dataReader.IsDBNull(colIndex))
{
var value = fieldDef.IsNullable ? null : fieldDef.FieldTypeDefaultValue;
if (OrmLiteConfig.OnDbNullFilter != null)
{
var useValue = OrmLiteConfig.OnDbNullFilter(fieldDef);
if (useValue != null)
{
value = useValue;
}
}
fieldDef.SetValueFn(instance, value);
return(true);
}
return(false);
}
internal static Task <int> UpdateOnlyAsync <T>(this IDbCommand dbCmd,
Expression <Func <T> > updateFields,
SqlExpression <T> q,
CancellationToken token)
{
if (updateFields == null)
{
throw new ArgumentNullException("updateFields");
}
if (OrmLiteConfig.UpdateFilter != null)
{
OrmLiteConfig.UpdateFilter(dbCmd, CachedExpressionCompiler.Evaluate(updateFields));
}
q.CopyParamsTo(dbCmd);
var updateFieldValues = updateFields.AssignedValues();
dbCmd.GetDialectProvider().PrepareUpdateRowStatement <T>(dbCmd, updateFieldValues, q.WhereExpression);
return(dbCmd.ExecNonQueryAsync(token));
}
public virtual T Exec <T>(IDbConnection dbConn, Func <IDbCommand, T> filter)
{
var dbCmd = CreateCommand(dbConn);
try
{
var ret = filter(dbCmd);
return(ret);
}
catch (Exception ex)
{
if (OrmLiteConfig.ExceptionFilter != null)
{
OrmLiteConfig.ExceptionFilter(dbCmd, ex);
}
throw;
}
finally
{
DisposeCommand(dbCmd, dbConn);
}
}
