Implemented an UpdateIncrement API

Implement an UpdateIncrement API similar to UpdateOnly, that generates
SQL to add the value to the existing database field instead of doing
attribution.

db.UpdateIncrement(new Person { Age = 5 }, db.From<Person>().Update(p =>
p.Age).Where(x => x.FirstName == "Jimi"));
will generate this SQL:
UPDATE "Person" SET "Age" = "Age" + 5 WHERE ("FirstName" = 'Jimi')

This is usefull to increment counter, totals, etc. without having to
load the object from the BD first and avoinding concurrency conflicts.

Author: madaleno

src/ServiceStack.OrmLite/Expressions/WriteExpressionCommandExtensions.cs

@@ -51,6 +51,38 @@ public static int UpdateOnly<T, TKey>(this IDbCommand dbCmd, T obj,
             return dbCmd.UpdateOnly(obj, q);
         }
 
+        public static int UpdateIncrement<T>(this IDbCommand dbCmd, T model, SqlExpression<T> fields)
+        {
+            UpdateIncrementSql(dbCmd, model, fields);
+            return dbCmd.ExecNonQuery();
+        }
+
+        internal static void UpdateIncrementSql<T>(this IDbCommand dbCmd, T model, SqlExpression<T> fields)
+        {
+            if (OrmLiteConfig.UpdateFilter != null)
+                OrmLiteConfig.UpdateFilter(dbCmd, model);
+
+            fields.CopyParamsTo(dbCmd);
+
+            dbCmd.GetDialectProvider().PrepareUpdateRowIncrementStatement(dbCmd, model, fields.UpdateFields);
+
+            if (!fields.WhereExpression.IsNullOrEmpty())
+                dbCmd.CommandText += " " + fields.WhereExpression;
+        }
+
+        public static int UpdateIncrement<T, TKey>(this IDbCommand dbCmd, T obj,
+            Expression<Func<T, TKey>> fields = null,
+            Expression<Func<T, bool>> where = null)
+        {
+            if (fields == null)
+                throw new ArgumentNullException("fields");
+
+            var q = dbCmd.GetDialectProvider().SqlExpression<T>();
+            q.Update(fields);
+            q.Where(where);
+            return dbCmd.UpdateIncrement(obj, q);
+        }
+
         public static int UpdateNonDefaults<T>(this IDbCommand dbCmd, T item, Expression<Func<T, bool>> obj)
         {
             if (OrmLiteConfig.UpdateFilter != null)

src/ServiceStack.OrmLite/IOrmLiteDialectProvider.cs

@@ -121,6 +121,8 @@ string GetColumnDefinition(
 
         void PrepareUpdateRowStatement(IDbCommand dbCmd, object objWithProperties, ICollection<string> UpdateFields = null);
 
+        void PrepareUpdateRowIncrementStatement(IDbCommand dbCmd, object objWithProperties, ICollection<string> UpdateFields);
+
         string ToDeleteStatement(Type tableType, string sqlFilter, params object[] filterParams);
 
         IDbCommand CreateParameterizedDeleteStatement(IDbConnection connection, object objWithProperties);

src/ServiceStack.OrmLite/OrmLiteDialectProviderBase.cs

@@ -949,6 +949,59 @@ public virtual void PrepareUpdateRowStatement(IDbCommand dbCmd, object objWithPr
                 throw new Exception("No valid update properties provided (e.g. p => p.FirstName): " + dbCmd.CommandText);
         }
 
+        public virtual void PrepareUpdateRowIncrementStatement(IDbCommand dbCmd, object objWithProperties, ICollection<string> updateFields)
+        {
+            if (updateFields.Count == 0)
+                throw new Exception("No valid update properties provided (e.g. p => p.FirstName): " + dbCmd.CommandText);
+
+            var sqlFilter = new StringBuilder();
+            var sql = new StringBuilder();
+            var modelDef = objWithProperties.GetType().GetModelDefinition();
+            var quotedFieldName = string.Empty;
+
+            foreach (var fieldDef in modelDef.FieldDefinitions)
+            {
+                if (!updateFields.Contains(fieldDef.FieldName))
+                    continue;
+
+                if (fieldDef.AutoIncrement || fieldDef.IsComputed || fieldDef.IsPrimaryKey ||
+                    fieldDef.IsRowVersion || fieldDef.Name == OrmLiteConfig.IdField)
+                    continue;
+
+                try
+                {
+                    if (sql.Length > 0)
+                        sql.Append(", ");
+
+                    quotedFieldName = GetQuotedColumnName(fieldDef.FieldName);
+
+                    if (fieldDef.FieldType.IsNumericType())
+                    {
+                        sql
+                            .Append(quotedFieldName)
+                            .Append("=")
+                            .Append(quotedFieldName)
+                            .Append("+")
+                            .Append(this.AddParam(dbCmd, fieldDef.GetValue(objWithProperties), fieldDef.ColumnType).ParameterName);
+                    }
+                    else
+                    {
+                        sql
+                            .Append(quotedFieldName)
+                            .Append("=")
+                            .Append(this.AddParam(dbCmd, fieldDef.GetValue(objWithProperties), fieldDef.ColumnType).ParameterName);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Log.Error("ERROR in ToUpdateIncrementRowStatement(): " + ex.Message, ex);
+                }
+            }
+
+            dbCmd.CommandText = string.Format("UPDATE {0} SET {1}{2}",
+                GetQuotedTableName(modelDef), sql, (sqlFilter.Length > 0 ? " WHERE " + sqlFilter : ""));
+        }
+
         public virtual string ToDeleteStatement(Type tableType, string sqlFilter, params object[] filterParams)
         {
             var sql = new StringBuilder();

src/ServiceStack.OrmLite/OrmLiteWriteExpressionsApi.cs

@@ -56,6 +56,43 @@ public static int UpdateOnly<T, TKey>(this IDbConnection dbConn, T obj,
             return dbConn.Exec(dbCmd => dbCmd.UpdateOnly(obj, onlyFields, where));
         }
 
+        /// <summary>
+        /// Use an SqlExpression to select which fields to update and construct the where expression, E.g: 
+        /// Numeric fields generates an increment sql which is usefull to increment counters, etc...
+        /// avoiding concurrency conflicts
+        /// 
+        ///   var q = db.From&gt;Person&lt;());
+        ///   db.UpdateIncrement(new Person { Age = 5 }, db.From<Person>().Update(p => p.Age).Where(x => x.FirstName == "Jimi"));
+        ///   UPDATE "Person" SET "Age" = "Age" + 5 WHERE ("FirstName" = 'Jimi')
+        /// 
+        ///   What's not in the update expression doesn't get updated. No where expression updates all rows. E.g:
+        /// 
+        ///   db.UpdateIncrement(new Person { Age = 5, FirstName = "JJ", LastName = "Hendo" }, ev.Update(p => p.Age));
+        ///   UPDATE "Person" SET "Age" = "Age" + 5
+        /// </summary>
+        public static int UpdateIncrement<T>(this IDbConnection dbConn, T model, SqlExpression<T> fields)
+        {
+            return dbConn.Exec(dbCmd => dbCmd.UpdateIncrement(model, fields));
+        }
+
+        /// <summary>
+        /// Update record, updating only fields specified in updateOnly that matches the where condition (if any), E.g:
+        /// Numeric fields generates an increment sql which is usefull to increment counters, etc...
+        /// avoiding concurrency conflicts
+        /// 
+        ///   db.UpdateIncrement(new Person { Age = 5 }, p => p.Age, p => p.LastName == "Hendrix");
+        ///   UPDATE "Person" SET "Age" = "Age" + 5 WHERE ("LastName" = 'Hendrix')
+        ///
+        ///   db.UpdateIncrement(new Person { Age = 5 }, p => p.FirstName);
+        ///   UPDATE "Person" SET "Age" = "Age" + 5
+        /// </summary>
+        public static int UpdateIncrement<T, TKey>(this IDbConnection dbConn, T obj,
+            Expression<Func<T, TKey>> fields = null,
+            Expression<Func<T, bool>> where = null)
+        {
+            return dbConn.Exec(dbCmd => dbCmd.UpdateIncrement(obj, fields, where));
+        }
+
         /// <summary>
         /// Updates all non-default values set on item matching the where condition (if any). E.g
         /// 

tests/ServiceStack.OrmLite.Tests/ApiSqlServerTests.cs

@@ -324,6 +324,18 @@ public void API_SqlServer_Parameterized_Examples()
             db.UpdateOnly(new Person { FirstName = "JJ" }, q => q.Update(x => x.FirstName).Where(x => x.FirstName == "Jimi"));
             Assert.That(db.GetLastSql(), Is.EqualTo("UPDATE \"Person\" SET \"FirstName\"=@1 WHERE (\"FirstName\" = @0)"));
 
+            db.UpdateIncrement(new Person { Age = 3 }, x => x.Age);
+            Assert.That(db.GetLastSql(), Is.EqualTo("UPDATE \"Person\" SET \"Age\"=\"Age\"+@0"));
+
+            db.UpdateIncrement(new Person { Age = 5 }, x => x.Age, x => x.LastName == "Presley");
+            Assert.That(db.GetLastSql(), Is.EqualTo("UPDATE \"Person\" SET \"Age\"=\"Age\"+@1 WHERE (\"LastName\" = @0)"));
+
+            db.UpdateIncrement(new Person { Age = -2, LastName = "Hendo" }, db.From<Person>().Update(x => new { x.Age, x.LastName }));
+            Assert.That(db.GetLastSql(), Is.EqualTo("UPDATE \"Person\" SET \"LastName\"=@0, \"Age\"=\"Age\"+@1"));
+
+            db.UpdateIncrement(new Person { Age = 10}, db.From<Person>().Update(x => x.Age).Where(x => x.FirstName == "JJ"));
+            Assert.That(db.GetLastSql(), Is.EqualTo("UPDATE \"Person\" SET \"Age\"=\"Age\"+@1 WHERE (\"FirstName\" = @0)"));
+
             db.UpdateFmt<Person>(set: "FirstName = {0}".SqlFmt("JJ"), where: "LastName = {0}".SqlFmt("Hendrix"));
             Assert.That(db.GetLastSql(), Is.EqualTo("UPDATE \"Person\" SET FirstName = 'JJ' WHERE LastName = 'Hendrix'"));
 

tests/ServiceStack.OrmLite.Tests/ApiSqliteTests.cs

@@ -328,6 +328,18 @@ public void API_Sqlite_Parameterized_Examples()
             db.UpdateOnly(new Person { FirstName = "JJ" }, q => q.Update(p => p.FirstName).Where(x => x.FirstName == "Jimi"));
             Assert.That(db.GetLastSql(), Is.EqualTo("UPDATE \"Person\" SET \"FirstName\"=@1 WHERE (\"FirstName\" = @0)"));
 
+            db.UpdateIncrement(new Person { Age = 3 }, x => x.Age);
+            Assert.That(db.GetLastSql(), Is.EqualTo("UPDATE \"Person\" SET \"Age\"=\"Age\"+@0"));
+
+            db.UpdateIncrement(new Person { Age = 5 }, x => x.Age, x => x.LastName == "Presley");
+            Assert.That(db.GetLastSql(), Is.EqualTo("UPDATE \"Person\" SET \"Age\"=\"Age\"+@1 WHERE (\"LastName\" = @0)"));
+
+            db.UpdateIncrement(new Person { Age = -2, LastName = "Hendo" }, db.From<Person>().Update(x => new { x.Age, x.LastName }));
+            Assert.That(db.GetLastSql(), Is.EqualTo("UPDATE \"Person\" SET \"LastName\"=@0, \"Age\"=\"Age\"+@1"));
+
+            db.UpdateIncrement(new Person { Age = 10 }, db.From<Person>().Update(x => x.Age).Where(x => x.FirstName == "JJ"));
+            Assert.That(db.GetLastSql(), Is.EqualTo("UPDATE \"Person\" SET \"Age\"=\"Age\"+@1 WHERE (\"FirstName\" = @0)"));
+
             db.UpdateFmt<Person>(set: "FirstName = {0}".SqlFmt("JJ"), where: "LastName = {0}".SqlFmt("Hendrix"));
             Assert.That(db.GetLastSql(), Is.EqualTo("UPDATE \"Person\" SET FirstName = 'JJ' WHERE LastName = 'Hendrix'"));