Add RowVersion support to Delete, import Jesse's other RowVersionTests

Author: mythz

src/ServiceStack.OrmLite/IOrmLiteDialectProvider.cs

@@ -80,7 +80,7 @@ string GetColumnDefinition(
 
         bool PrepareParameterizedUpdateStatement<T>(IDbCommand cmd, ICollection<string> updateFields = null);
 
-        void PrepareParameterizedDeleteStatement<T>(IDbCommand cmd, ICollection<string> deleteFields = null);
+        bool PrepareParameterizedDeleteStatement<T>(IDbCommand cmd, ICollection<string> deleteFields = null);
 
         void SetParameterValues<T>(IDbCommand dbCmd, object obj);
 

src/ServiceStack.OrmLite/OrmLiteDialectProviderBase.cs

@@ -637,22 +637,27 @@ public virtual void AppendFieldConditionFmt(StringBuilder sqlFilter, FieldDefini
                 fieldDef.GetQuotedValue(objWithProperties));
         }
 
-        public virtual void PrepareParameterizedDeleteStatement<T>(IDbCommand cmd, ICollection<string> deleteFields = null)
+        public virtual bool PrepareParameterizedDeleteStatement<T>(IDbCommand cmd, ICollection<string> deleteFields = null)
         {
             var sqlFilter = new StringBuilder();
             var modelDef = typeof(T).GetModelDefinition();
+            var hadRowVesion = false;
             var hasSpecificFilter = deleteFields != null && deleteFields.Count > 0;
 
             cmd.Parameters.Clear();
             cmd.CommandTimeout = OrmLiteConfig.CommandTimeout;
 
             foreach (var fieldDef in modelDef.FieldDefinitions)
             {
-                if (fieldDef.IsComputed) continue;
+                if (fieldDef.IsComputed) 
+                    continue;
 
-                if (hasSpecificFilter && !deleteFields.Contains(fieldDef.Name))
+                if (!fieldDef.IsRowVersion && (hasSpecificFilter && !deleteFields.Contains(fieldDef.Name)))
                     continue;
 
+                if (fieldDef.IsRowVersion)
+                    hadRowVesion = true;
+
                 try
                 {
                     if (sqlFilter.Length > 0)
@@ -668,6 +673,8 @@ public virtual void PrepareParameterizedDeleteStatement<T>(IDbCommand cmd, IColl
 
             cmd.CommandText = string.Format("DELETE FROM {0} WHERE {1}",
                 GetQuotedTableName(modelDef), sqlFilter);
+
+            return hadRowVesion;
         }
 
         protected void AddParameter(IDbCommand cmd, FieldDefinition fieldDef)

src/ServiceStack.OrmLite/OrmLiteWriteConnectionExtensions.cs

@@ -267,6 +267,17 @@ public static int DeleteById<T>(this IDbConnection dbConn, object id)
             return dbConn.Exec(dbCmd => dbCmd.DeleteById<T>(id));
         }
 
+        /// <summary>
+        /// Delete 1 row by the PrimaryKey where the rowVersion matches the optimistic concurrency field. 
+        /// Will throw <exception cref="RowModifiedException">RowModefiedExeption</exception> if the 
+        /// row does not exist or has a different row version.
+        /// E.g: <para>db.DeleteById&lt;Person&gt;(1)</para>
+        /// </summary>
+        public static void DeleteById<T>(this IDbConnection dbConn, object id, ulong rowVersion)
+        {
+            dbConn.Exec(dbCmd => dbCmd.DeleteById<T>(id, rowVersion));
+        }
+
         /// <summary>
         /// Delete all rows identified by the PrimaryKeys. E.g:
         /// <para>db.DeleteById&lt;Person&gt;(new[] { 1, 2, 3 })</para>

src/ServiceStack.OrmLite/OrmLiteWriteExtensions.cs

@@ -414,7 +414,7 @@ internal static int UpdateAll<T>(this IDbCommand dbCmd, IEnumerable<T> objs)
 
                 var dialectProvider = OrmLiteConfig.DialectProvider;
 
-                dialectProvider.PrepareParameterizedUpdateStatement<T>(dbCmd);
+                var hadRowVersion = dialectProvider.PrepareParameterizedUpdateStatement<T>(dbCmd);
                 if (string.IsNullOrEmpty(dbCmd.CommandText))
                     return 0;
 
@@ -425,7 +425,11 @@ internal static int UpdateAll<T>(this IDbCommand dbCmd, IEnumerable<T> objs)
 
                     dialectProvider.SetParameterValues<T>(dbCmd, obj);
 
-                    count += dbCmd.ExecNonQuery();
+                    var rowsUpdated = dbCmd.ExecNonQuery();
+                    if (hadRowVersion && rowsUpdated == 0) 
+                        throw new RowModifiedException();
+
+                    count += rowsUpdated;                
                 }
 
                 if (dbTrans != null)
@@ -440,22 +444,31 @@ internal static int UpdateAll<T>(this IDbCommand dbCmd, IEnumerable<T> objs)
             return count;
         }
 
+        private static int AssertRowsUpdated(IDbCommand dbCmd, bool hadRowVersion)
+        {
+            var rowsUpdated = dbCmd.ExecNonQuery();
+            if (hadRowVersion && rowsUpdated == 0)
+                throw new RowModifiedException();
+
+            return rowsUpdated;
+        }
+
         internal static int Delete<T>(this IDbCommand dbCmd, object anonType)
         {
-            OrmLiteConfig.DialectProvider.PrepareParameterizedDeleteStatement<T>(dbCmd, anonType.AllFields<T>());
+            var hadRowVersion = OrmLiteConfig.DialectProvider.PrepareParameterizedDeleteStatement<T>(dbCmd, anonType.AllFields<T>());
 
             OrmLiteConfig.DialectProvider.SetParameterValues<T>(dbCmd, anonType);
 
-            return dbCmd.ExecNonQuery();
+            return AssertRowsUpdated(dbCmd, hadRowVersion);
         }
 
         internal static int DeleteNonDefaults<T>(this IDbCommand dbCmd, T filter)
         {
-            OrmLiteConfig.DialectProvider.PrepareParameterizedDeleteStatement<T>(dbCmd, filter.NonDefaultFields<T>());
+            var hadRowVersion = OrmLiteConfig.DialectProvider.PrepareParameterizedDeleteStatement<T>(dbCmd, filter.NonDefaultFields<T>());
 
             OrmLiteConfig.DialectProvider.SetParameterValues<T>(dbCmd, filter);
 
-            return dbCmd.ExecNonQuery();
+            return AssertRowsUpdated(dbCmd, hadRowVersion);
         }
 
         internal static int Delete<T>(this IDbCommand dbCmd, params object[] objs)
@@ -523,6 +536,38 @@ internal static int DeleteById<T>(this IDbCommand dbCmd, object id)
             return dbCmd.ExecuteSql(sql);
         }
 
+        internal static void DeleteById<T>(this IDbCommand dbCmd, object id, ulong rowVersion)
+        {
+            var modelDef = ModelDefinition<T>.Definition;
+
+            dbCmd.Parameters.Clear();
+
+            var idParam = dbCmd.CreateParameter();
+            idParam.ParameterName = OrmLiteConfig.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 = OrmLiteConfig.DialectProvider.GetParam("rowVersion");
+            rowVersionParam.Value = rowVersion;
+            dbCmd.Parameters.Add(rowVersionParam);
+
+            var sql = string.Format("DELETE FROM {0} WHERE {1} = {2} AND {3} = {4}",
+                OrmLiteConfig.DialectProvider.GetQuotedTableName(modelDef),
+                OrmLiteConfig.DialectProvider.GetQuotedColumnName(modelDef.PrimaryKey.FieldName),
+                idParam.ParameterName,
+                OrmLiteConfig.DialectProvider.GetQuotedColumnName(rowVersionField.FieldName),
+                rowVersionParam.ParameterName);
+
+            var rowsAffected = dbCmd.ExecuteSql(sql);
+            if (rowsAffected == 0)
+                throw new RowModifiedException("The row was modified or deleted since the last read");
+        }
+
         internal static int DeleteByIds<T>(this IDbCommand dbCmd, IEnumerable idValues)
         {
             var sqlIn = idValues.GetIdsInSql();

tests/ServiceStack.OrmLite.Tests/RowVersionTests.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Data;
+using System.Linq;
 using NUnit.Framework;
 using ServiceStack.DataAnnotations;
 using ServiceStack.Logging;
@@ -7,9 +9,10 @@ namespace ServiceStack.OrmLite.Tests
 {
     public class ModelWithRowVersion
     {
-        public int Id { get; set; }
+        [AutoIncrement]
+        public long Id { get; set; }
 
-        public string Name { get; set; }
+        public string Text { get; set; }
 
         public ulong RowVersion { get; set; }
     }
@@ -21,37 +24,177 @@ public RowVersionTests()
             //Dialect = Dialect.Sqlite;
         }
 
+        private IDbConnection db;
+
+        [TestFixtureSetUp]
+        public void FixtureSetUp()
+        {
+            using (var dbConn = OpenDbConnection())
+            {
+                dbConn.DropAndCreateTable<ModelWithRowVersion>();
+            }
+        }
+
+        [SetUp]
+        public void SetUp()
+        {
+            db = OpenDbConnection();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            db.Dispose();
+        }
+
         [Test]
         public void Can_create_table_with_RowVersion()
         {
-            LogManager.LogFactory = new ConsoleLogFactory();
-            using (var db = OpenDbConnection())
+            db.DropAndCreateTable<ModelWithRowVersion>();
+
+            db.Insert(new ModelWithRowVersion { Text = "Text" });
+
+            var row = db.SingleById<ModelWithRowVersion>(1);
+
+            row.Text += " Updated";
+
+            db.Update(row);
+
+            var updatedRow = db.SingleById<ModelWithRowVersion>(1);
+
+            Assert.That(updatedRow.Text, Is.EqualTo("Text Updated"));
+            Assert.That(updatedRow.RowVersion, Is.GreaterThan(0));
+
+            row.Text += " Again";
+
+            //Can't update old record
+            Assert.Throws<RowModifiedException>(() =>
+                db.Update(row));
+
+            //Can update latest version
+            updatedRow.Text += " Again";
+            db.Update(updatedRow);
+        }
+
+        [Test]
+        public void Select_retrieves_rowversion()
+        {
+            var rowId = db.Insert(new ModelWithRowVersion { Text = "One" }, selectIdentity: true);
+            TouchRow(rowId);
+
+            var row = db.SingleById<ModelWithRowVersion>(rowId);
+
+            Assert.That(row.RowVersion, Is.Not.EqualTo(0));
+        }
+
+        [Test]
+        public void Can_update_with_current_rowversion()
+        {
+            var rowId = db.Insert(new ModelWithRowVersion { Text = "Two" }, selectIdentity: true);
+            var row = db.SingleById<ModelWithRowVersion>(rowId);
+
+            row.Text = "Three";
+            db.Update(row);
+
+            var actual = db.SingleById<ModelWithRowVersion>(rowId);
+            Assert.That(actual.Text, Is.EqualTo("Three"));
+            Assert.That(actual.RowVersion, Is.Not.EqualTo(row.RowVersion));
+        }
+
+        [Test]
+        public void Can_update_multiple_with_current_rowversions()
+        {
+            var rowIds = new[]
             {
-                db.DropAndCreateTable<ModelWithRowVersion>();
+                db.Insert(new ModelWithRowVersion { Text = "Eleven" }, selectIdentity: true),
+                db.Insert(new ModelWithRowVersion { Text = "Twelve" }, selectIdentity: true)
+            };
+            var rows = rowIds
+                .Select(id => db.SingleById<ModelWithRowVersion>(id))
+                .ToArray();
 
-                db.Insert(new ModelWithRowVersion { Id = 1, Name = "Name" });
+            rows[0].Text = "Thirteen";
+            rows[1].Text = "Fourteen";
+            db.UpdateAll(rows);
 
-                var row = db.SingleById<ModelWithRowVersion>(1);
+            var actualRows = rowIds
+                .Select(id => db.SingleById<ModelWithRowVersion>(id))
+                .ToArray();
+            Assert.That(actualRows[0].Text, Is.EqualTo("Thirteen"));
+            Assert.That(actualRows[1].Text, Is.EqualTo("Fourteen"));
+        }
 
-                row.Name += " Updated";
+        [Test]
+        public void Can_delete_with_current_rowversion()
+        {
+            var rowId = db.Insert(new ModelWithRowVersion { Text = "Four" }, selectIdentity: true);
+            var row = db.SingleById<ModelWithRowVersion>(rowId);
 
-                db.Update(row);
+            db.Delete(row);
 
-                var updatedRow = db.SingleById<ModelWithRowVersion>(1);
+            var count = db.Count<ModelWithRowVersion>(m => m.Id == rowId);
+            Assert.That(count, Is.EqualTo(0));
+        }
 
-                Assert.That(updatedRow.Name, Is.EqualTo("Name Updated"));
-                Assert.That(updatedRow.RowVersion, Is.GreaterThan(0));
+        [Test]
+        public void Update_with_outdated_rowversion_throws()
+        {
+            var rowId = db.Insert(new ModelWithRowVersion { Text = "Five" }, selectIdentity: true);
+            var row = db.SingleById<ModelWithRowVersion>(rowId);
+            TouchRow(rowId);
 
-                row.Name += " Again";
+            row.Text = "Six";
+            Assert.Throws<RowModifiedException>(() => db.Update(row));
 
-                //Can't update old record
-                Assert.Throws<RowModifiedException>(() => 
-                    db.Update(row));
+            var actual = db.SingleById<ModelWithRowVersion>(rowId);
+            Assert.That(actual.Text, Is.Not.EqualTo("Six"));
+        }
 
-                //Can update latest version
-                updatedRow.Name += " Again";
-                db.Update(updatedRow);
-            }
+        [Test]
+        public void Update_multiple_with_single_outdated_rowversion_throws_and_all_changes_are_rejected()
+        {
+            var rowIds = new[]
+            {
+                db.Insert(new ModelWithRowVersion { Text = "Fifteen" }, selectIdentity: true),
+                db.Insert(new ModelWithRowVersion { Text = "Sixteen" }, selectIdentity: true)
+            };
+            var rows = rowIds
+                .Select(id => db.SingleById<ModelWithRowVersion>(id))
+                .ToArray();
+            TouchRow(rowIds[1]);
+
+            rows[0].Text = "Seventeen";
+            rows[1].Text = "Eighteen";
+            Assert.Throws<RowModifiedException>(() => 
+                db.UpdateAll(rows));
+
+            var actualRows = rowIds
+                .Select(id => db.SingleById<ModelWithRowVersion>(id))
+                .ToArray();
+
+            Assert.That(actualRows[0].Text, Is.EqualTo("Fifteen"));
+            Assert.That(actualRows[1].Text, Is.Not.EqualTo("Eighteen"));
+        }
+
+        [Test]
+        public void Delete_with_outdated_rowversion_throws()
+        {
+            var rowId = db.Insert(new ModelWithRowVersion { Text = "Seven" }, selectIdentity: true);
+            var row = db.SingleById<ModelWithRowVersion>(rowId);
+            TouchRow(rowId);
+
+            Assert.Throws<RowModifiedException>(() => 
+                db.Delete(row));
+
+            var count = db.Count<ModelWithRowVersion>(m => m.Id == rowId);
+            Assert.That(count, Is.EqualTo(1));
+        }
+
+        private void TouchRow(long rowId)
+        {
+            var row = db.SingleById<ModelWithRowVersion>(rowId);
+            row.Text = "Touched";
+            db.Update(row);
         }
     }
 }