Add different Soft Delete examples

Author: mythz

src/ServiceStack.OrmLite/Expressions/SqlExpression.cs

@@ -44,6 +44,7 @@ public abstract partial class SqlExpression<T> : ISqlExpression, IHasUntypedSqlE
         public IOrmLiteDialectProvider DialectProvider { get; set; }
         public List<IDbDataParameter> Params { get; set; }
         public Func<string,string> SqlFilter { get; set; }
+        public static Action<SqlExpression<T>> SelectFilter { get; set; }
 
         protected string Sep => sep;
 
@@ -1070,6 +1071,9 @@ public virtual void PrepareUpdateStatement(IDbCommand dbCmd, T item, bool exclud
 
         public virtual string ToSelectStatement()
         {
+            SelectFilter?.Invoke(this);
+            OrmLiteConfig.SqlExpressionSelectFilter?.Invoke(GetUntyped());
+
             var sql = DialectProvider
                 .ToSelectStatement(modelDef, SelectExpression, BodyExpression, OrderByExpression, Offset, Rows);
 
@@ -1080,6 +1084,9 @@ public virtual string ToSelectStatement()
 
         public virtual string ToCountStatement()
         {
+            SelectFilter?.Invoke(this);
+            OrmLiteConfig.SqlExpressionSelectFilter?.Invoke(GetUntyped());
+
             var sql = "SELECT COUNT(*)" + BodyExpression;
 
             return SqlFilter != null

src/ServiceStack.OrmLite/OrmLiteConfig.cs

@@ -180,6 +180,7 @@ public static IOrmLiteExecFilter ExecFilter
 
         public static Action<IDbCommand, object> InsertFilter { get; set; }
         public static Action<IDbCommand, object> UpdateFilter { get; set; }
+        public static Action<IUntypedSqlExpression> SqlExpressionSelectFilter { get; set; }
 
         public static Func<string, string> StringFilter { get; set; }
 

tests/ServiceStack.OrmLite.Tests/UseCase/SoftDeleteUseCase.cs

@@ -48,5 +48,62 @@ public void Can_add_generic_soft_delete_filter_to_SqlExpression()
                 Assert.That(result, Is.Null);
             }
         }
+
+        [Test]
+        public void Can_add_generic_soft_delete_filter_to_SqlExpression_using_SelectFilter()
+        {
+            using (var db = OpenDbConnection())
+            {
+                SqlExpression<ModelWithSoftDelete>.SelectFilter = q => q.Where(x => x.IsDeleted != true);
+
+                db.DropAndCreateTable<ModelWithSoftDelete>();
+
+                db.Insert(new ModelWithSoftDelete { Name = "foo" });
+                db.Insert(new ModelWithSoftDelete { Name = "bar", IsDeleted = true });
+
+                var results = db.Select(db.From<ModelWithSoftDelete>());
+
+                Assert.That(results.Count, Is.EqualTo(1));
+                Assert.That(results[0].Name, Is.EqualTo("foo"));
+
+                var result = db.Single(db.From<ModelWithSoftDelete>().Where(x => x.Name == "foo"));
+                Assert.That(result.Name, Is.EqualTo("foo"));
+                result = db.Single(db.From<ModelWithSoftDelete>().Where(x => x.Name == "bar"));
+                Assert.That(result, Is.Null);
+
+                SqlExpression<ModelWithSoftDelete>.SelectFilter = null;
+            }
+        }
+
+        [Test]
+        public void Can_add_generic_soft_delete_filter_to_SqlExpression_using_SqlExpressionSelectFilter()
+        {
+            using (var db = OpenDbConnection())
+            {
+                OrmLiteConfig.SqlExpressionSelectFilter = q =>
+                {
+                    if (q.ModelDef.ModelType.HasInterface(typeof(ISoftDelete)))
+                    {
+                        q.Where<ISoftDelete>(x => x.IsDeleted != true);
+                    }
+                };
+
+                db.DropAndCreateTable<ModelWithSoftDelete>();
+                db.Insert(new ModelWithSoftDelete { Name = "foo" });
+                db.Insert(new ModelWithSoftDelete { Name = "bar", IsDeleted = true });
+
+                var results = db.Select(db.From<ModelWithSoftDelete>());
+
+                Assert.That(results.Count, Is.EqualTo(1));
+                Assert.That(results[0].Name, Is.EqualTo("foo"));
+
+                var result = db.Single(db.From<ModelWithSoftDelete>().Where(x => x.Name == "foo"));
+                Assert.That(result.Name, Is.EqualTo("foo"));
+                result = db.Single(db.From<ModelWithSoftDelete>().Where(x => x.Name == "bar"));
+                Assert.That(result, Is.Null);
+
+                OrmLiteConfig.SqlExpressionSelectFilter = null;
+            }
+        }
     }
 }