Add commandFilter support for async Delete APIs as well

mythz · mythz · commit e818b16722b3 · 2020-05-15T12:07:41.000+08:00
diff --git a/src/ServiceStack.OrmLite/Async/OrmLiteWriteCommandExtensionsAsync.cs b/src/ServiceStack.OrmLite/Async/OrmLiteWriteCommandExtensionsAsync.cs
@@ -19,15 +19,25 @@ internal static class OrmLiteWriteCommandExtensionsAsync
     {
         internal static ILog Log = LogManager.GetLogger(typeof(OrmLiteWriteCommandExtensionsAsync));
 
-        internal static Task<int> ExecuteSqlAsync(this IDbCommand dbCmd, string sql, IEnumerable<IDbDataParameter> sqlParams, CancellationToken token)
+        internal static Task<int> ExecuteSqlAsync(this IDbCommand dbCmd, string sql, IEnumerable<IDbDataParameter> sqlParams, CancellationToken token) =>
+            dbCmd.SetParameters(sqlParams).ExecuteSqlAsync(sql, (Action<IDbCommand>) null, token);
+        
+        internal static Task<int> ExecuteSqlAsync(this IDbCommand dbCmd, string sql, IEnumerable<IDbDataParameter> sqlParams, 
+            Action<IDbCommand> commandFilter, CancellationToken token)
         {
-            return dbCmd.SetParameters(sqlParams).ExecuteSqlAsync(sql, token);
+            return dbCmd.SetParameters(sqlParams).ExecuteSqlAsync(sql, commandFilter, token);
         }
 
-        internal static Task<int> ExecuteSqlAsync(this IDbCommand dbCmd, string sql, CancellationToken token)
+        internal static Task<int> ExecuteSqlAsync(this IDbCommand dbCmd, string sql, CancellationToken token) =>
+            dbCmd.ExecuteSqlAsync(sql,(Action<IDbCommand>)null, token);
+
+        internal static Task<int> ExecuteSqlAsync(this IDbCommand dbCmd, string sql, 
+            Action<IDbCommand> commandFilter, CancellationToken token)
         {
             dbCmd.CommandText = sql;
 
+            commandFilter?.Invoke(dbCmd);
+
             if (Log.IsDebugEnabled)
                 Log.DebugCommand(dbCmd);
 
@@ -39,13 +49,19 @@ internal static Task<int> ExecuteSqlAsync(this IDbCommand dbCmd, string sql, Can
             return dbCmd.GetDialectProvider().ExecuteNonQueryAsync(dbCmd, token);
         }
 
-        internal static Task<int> ExecuteSqlAsync(this IDbCommand dbCmd, string sql, object anonType, CancellationToken token)
+        internal static Task<int> ExecuteSqlAsync(this IDbCommand dbCmd, string sql, object anonType, CancellationToken token) =>
+            dbCmd.ExecuteSqlAsync(sql, anonType, null, token);
+
+        internal static Task<int> ExecuteSqlAsync(this IDbCommand dbCmd, string sql, object anonType, 
+            Action<IDbCommand> commandFilter, CancellationToken token)
         {
             if (anonType != null)
                 dbCmd.SetParameters(anonType.ToObjectDictionary(), excludeDefaults: false, sql:ref sql);
 
             dbCmd.CommandText = sql;
 
+            commandFilter?.Invoke(dbCmd);
+
             if (Log.IsDebugEnabled)
                 Log.DebugCommand(dbCmd);
 
@@ -122,7 +138,8 @@ internal static async Task<int> UpdateAllAsync<T>(this IDbCommand dbCmd, IEnumer
                     OrmLiteConfig.UpdateFilter?.Invoke(dbCmd, obj);
     
                     dialectProvider.SetParameterValues<T>(dbCmd, obj);
-                    commandFilter?.Invoke(dbCmd);
+
+                    commandFilter?.Invoke(dbCmd); //filters can augment SQL & only should be invoked once
                     commandFilter = null;
     
                     var rowsUpdated = await dbCmd.ExecNonQueryAsync(token);
@@ -192,10 +209,11 @@ internal static Task<int> DeleteNonDefaultsAsync<T>(this IDbCommand dbCmd, Cance
             if (filters.Length == 0)
                 return TaskResult.Zero;
 
-            return DeleteAllAsync(dbCmd, filters, o => o.AllFieldsMap<T>().NonDefaultsOnly(), token);
+            return DeleteAllAsync(dbCmd, filters, o => o.AllFieldsMap<T>().NonDefaultsOnly(), token:token);
         }
 
-        private static async Task<int> DeleteAllAsync<T>(IDbCommand dbCmd, IEnumerable<T> objs, Func<object, Dictionary<string, object>> fieldValuesFn = null, CancellationToken token=default(CancellationToken))
+        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>();
             
@@ -218,6 +236,9 @@ private static async Task<int> DeleteAllAsync<T>(IDbCommand dbCmd, IEnumerable<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;
@@ -228,34 +249,37 @@ private static async Task<int> DeleteAllAsync<T>(IDbCommand dbCmd, IEnumerable<T
             return count;
         }
 
-        internal static Task<int> DeleteByIdAsync<T>(this IDbCommand dbCmd, object id, CancellationToken token)
+        internal static Task<int> DeleteByIdAsync<T>(this IDbCommand dbCmd, object id, 
+            Action<IDbCommand> commandFilter, CancellationToken token)
         {
             OrmLiteUtils.AssertNotAnonType<T>();
             
             var sql = dbCmd.DeleteByIdSql<T>(id);
-            return dbCmd.ExecuteSqlAsync(sql, token);
+            return dbCmd.ExecuteSqlAsync(sql, commandFilter, token);
         }
 
-        internal static async Task DeleteByIdAsync<T>(this IDbCommand dbCmd, object id, ulong rowVersion, CancellationToken token)
+        internal static async Task DeleteByIdAsync<T>(this IDbCommand dbCmd, object id, ulong rowVersion, 
+            Action<IDbCommand> commandFilter, CancellationToken token)
         {
             OrmLiteUtils.AssertNotAnonType<T>();
             
             var sql = dbCmd.DeleteByIdSql<T>(id, rowVersion);
 
-            var rowsAffected = await dbCmd.ExecuteSqlAsync(sql, token);
+            var rowsAffected = await dbCmd.ExecuteSqlAsync(sql, commandFilter, token);
             if (rowsAffected == 0)
                 throw new OptimisticConcurrencyException("The row was modified or deleted since the last read");
         }
 
-        internal static Task<int> DeleteByIdsAsync<T>(this IDbCommand dbCmd, IEnumerable idValues, CancellationToken token)
+        internal static Task<int> DeleteByIdsAsync<T>(this IDbCommand dbCmd, IEnumerable idValues, 
+            Action<IDbCommand> commandFilter, CancellationToken token)
         {
             var sqlIn = dbCmd.SetIdsInSqlParams(idValues);
             if (string.IsNullOrEmpty(sqlIn))
                 return TaskResult.Zero;
 
             var sql = OrmLiteWriteCommandExtensions.GetDeleteByIdsSql<T>(sqlIn, dbCmd.GetDialectProvider());
 
-            return dbCmd.ExecuteSqlAsync(sql, token);
+            return dbCmd.ExecuteSqlAsync(sql, commandFilter, token);
         }
 
         internal static Task<int> DeleteAllAsync<T>(this IDbCommand dbCmd, CancellationToken token)
@@ -405,8 +429,6 @@ internal static async Task InsertAllAsync<T>(this IDbCommand dbCmd, IEnumerable<
 
             dialectProvider.PrepareParameterizedInsertStatement<T>(dbCmd);
 
-            commandFilter?.Invoke(dbCmd);
-
             using (dbTrans)
             {
                 foreach (var obj in objs)
@@ -415,6 +437,9 @@ internal static async Task InsertAllAsync<T>(this IDbCommand dbCmd, IEnumerable<
 
                     dialectProvider.SetParameterValues<T>(dbCmd, obj);
 
+                    commandFilter?.Invoke(dbCmd); //filters can augment SQL & only should be invoked once
+                    commandFilter = null;
+
                     await dbCmd.ExecNonQueryAsync(token);
                 }
                 dbTrans?.Commit();
diff --git a/src/ServiceStack.OrmLite/Async/WriteExpressionCommandExtensionsAsync.cs b/src/ServiceStack.OrmLite/Async/WriteExpressionCommandExtensionsAsync.cs
@@ -205,25 +205,28 @@ public static Task<int> InsertOnlyAsync<T>(this IDbCommand dbCmd, Expression<Fun
             return dbCmd.InitInsertOnly(insertFields).ExecNonQueryAsync(token);
         }
 
-        internal static Task<int> DeleteAsync<T>(this IDbCommand dbCmd, Expression<Func<T, bool>> where, CancellationToken token)
+        internal static Task<int> DeleteAsync<T>(this IDbCommand dbCmd, Expression<Func<T, bool>> where, 
+            Action<IDbCommand> commandFilter, CancellationToken token)
         {
             var q = dbCmd.GetDialectProvider().SqlExpression<T>();
             q.Where(where);
-            return dbCmd.DeleteAsync(q, token);
+            return dbCmd.DeleteAsync(q, commandFilter, token);
         }
 
-        internal static Task<int> DeleteAsync<T>(this IDbCommand dbCmd, SqlExpression<T> q, CancellationToken token)
+        internal static Task<int> DeleteAsync<T>(this IDbCommand dbCmd, SqlExpression<T> q, 
+            Action<IDbCommand> commandFilter, CancellationToken token)
         {
             var sql = q.ToDeleteRowStatement();
-            return dbCmd.ExecuteSqlAsync(sql, q.Params, token);
+            return dbCmd.ExecuteSqlAsync(sql, q.Params, commandFilter, token);
         }
 
-        internal static Task<int> DeleteWhereAsync<T>(this IDbCommand dbCmd, string whereFilter, object[] whereParams, CancellationToken token)
+        internal static Task<int> DeleteWhereAsync<T>(this IDbCommand dbCmd, string whereFilter, object[] whereParams, 
+            Action<IDbCommand> commandFilter, CancellationToken token)
         {
             var q = dbCmd.GetDialectProvider().SqlExpression<T>();
             q.Where(whereFilter, whereParams);
             var sql = q.ToDeleteRowStatement();
-            return dbCmd.ExecuteSqlAsync(sql, q.Params, token);
+            return dbCmd.ExecuteSqlAsync(sql, q.Params, commandFilter, token);
         }
     }
 }
diff --git a/src/ServiceStack.OrmLite/Legacy/WriteExpressionCommandExtensionsAsyncLegacy.cs b/src/ServiceStack.OrmLite/Legacy/WriteExpressionCommandExtensionsAsyncLegacy.cs
@@ -36,7 +36,7 @@ internal static Task<int> UpdateFmtAsync(this IDbCommand dbCmd, string table, st
         [Obsolete("Use db.DeleteAsync(db.From<T>())")]
         internal static Task<int> DeleteAsync<T>(this IDbCommand dbCmd, Func<SqlExpression<T>, SqlExpression<T>> where, CancellationToken token)
         {
-            return dbCmd.DeleteAsync(where(dbCmd.GetDialectProvider().SqlExpression<T>()), token);
+            return dbCmd.DeleteAsync(where(dbCmd.GetDialectProvider().SqlExpression<T>()), null, token);
         }
 
         internal static Task<int> DeleteFmtAsync<T>(this IDbCommand dbCmd, string where, CancellationToken token)
diff --git a/src/ServiceStack.OrmLite/OrmLiteUtils.cs b/src/ServiceStack.OrmLite/OrmLiteUtils.cs
@@ -987,6 +987,9 @@ public static void AssertNotAnonType<T>()
             
             if (typeof(T) == typeof(Dictionary<string,object>))
                 throw new ArgumentException("T generic argument should be a Table but was typeof(Dictionary<string,object>)");
+            
+            if (typeof(ISqlExpression).IsAssignableFrom(typeof(T)))
+                throw new ArgumentException("T generic argument should be a Table but was an ISqlExpression");
         }
 
         public static List<string> GetNonDefaultValueInsertFields<T>(this IOrmLiteDialectProvider dialectProvider, object obj)
diff --git a/src/ServiceStack.OrmLite/OrmLiteWriteApi.cs b/src/ServiceStack.OrmLite/OrmLiteWriteApi.cs
@@ -280,7 +280,7 @@ public static int DeleteById<T>(this IDbConnection dbConn, object id, Action<IDb
 
         /// <summary>
         /// Delete 1 row by the PrimaryKey where the rowVersion matches the optimistic concurrency field. 
-        /// Will throw <exception cref="OptimisticConcurrencyException">RowModefiedExeption</exception> if the 
+        /// Will throw <exception cref="OptimisticConcurrencyException">RowModifiedException</exception> if the 
         /// row does not exist or has a different row version.
         /// E.g: <para>db.DeleteById&lt;Person&gt;(1)</para>
         /// </summary>
diff --git a/src/ServiceStack.OrmLite/OrmLiteWriteApiAsync.cs b/src/ServiceStack.OrmLite/OrmLiteWriteApiAsync.cs
@@ -196,7 +196,8 @@ public static Task<int> UpdateAllAsync<T>(this IDbConnection dbConn, IEnumerable
         /// <para>db.DeleteAsync&lt;Person&gt;(new { FirstName = "Jimi", Age = 27 })</para>
         /// </summary>
         /// <returns>number of rows deleted</returns>
-        public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, object anonFilter, CancellationToken token = default)
+        public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, object anonFilter, 
+            Action<IDbCommand> commandFilter = null, CancellationToken token = default)
         {
             return dbConn.Exec(dbCmd => dbCmd.DeleteAsync<T>(anonFilter, token));
         }
@@ -206,7 +207,8 @@ public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, object anonFil
         /// <para>db.DeleteAsync&lt;Person&gt;(new Dictionary&lt;string,object&gt; { ["FirstName"] = "Jimi", ["Age"] = 27 })</para>
         /// </summary>
         /// <returns>number of rows deleted</returns>
-        public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, Dictionary<string, object> filters, CancellationToken token = default)
+        public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, Dictionary<string, object> filters, 
+            Action<IDbCommand> commandFilter = null, CancellationToken token = default)
         {
             return dbConn.Exec(dbCmd => dbCmd.DeleteAsync<T>(filters, token));
         }
@@ -216,7 +218,8 @@ public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, Dictionary<str
         /// <para>db.DeleteAsync(new Person { Id = 1, FirstName = "Jimi", LastName = "Hendrix", Age = 27 })</para>
         /// </summary>
         /// <returns>number of rows deleted</returns>
-        public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, T allFieldsFilter, CancellationToken token = default)
+        public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, T allFieldsFilter, 
+            Action<IDbCommand> commandFilter = null, CancellationToken token = default)
         {
             return dbConn.Exec(dbCmd => dbCmd.DeleteAsync(allFieldsFilter, token));
         }
@@ -225,11 +228,13 @@ public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, T allFieldsFil
         /// Delete 1 or more rows in a transaction using all fields in the commandFilter. E.g:
         /// <para>db.DeleteAsync(new Person { Id = 1, FirstName = "Jimi", LastName = "Hendrix", Age = 27 })</para>
         /// </summary>
-        public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, CancellationToken token = default, params T[] allFieldsFilters)
+        public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, 
+            Action<IDbCommand> commandFilter = null, CancellationToken token = default, params T[] allFieldsFilters)
         {
             return dbConn.Exec(dbCmd => dbCmd.DeleteAsync(token, allFieldsFilters));
         }
-        public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, params T[] allFieldsFilters)
+        public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, 
+            Action<IDbCommand> commandFilter = null, params T[] allFieldsFilters)
         {
             return dbConn.Exec(dbCmd => dbCmd.DeleteAsync(default, allFieldsFilters));
         }
@@ -256,38 +261,41 @@ public static Task<int> DeleteNonDefaultsAsync<T>(this IDbConnection dbConn, Can
         }
         public static Task<int> DeleteNonDefaultsAsync<T>(this IDbConnection dbConn, params T[] nonDefaultsFilters)
         {
-            return dbConn.Exec(dbCmd => dbCmd.DeleteNonDefaultsAsync(default(CancellationToken), nonDefaultsFilters));
+            return dbConn.Exec(dbCmd => dbCmd.DeleteNonDefaultsAsync(default, nonDefaultsFilters));
         }
 
         /// <summary>
         /// Delete 1 row by the PrimaryKey. E.g:
         /// <para>db.DeleteByIdAsync&lt;Person&gt;(1)</para>
         /// </summary>
         /// <returns>number of rows deleted</returns>
-        public static Task<int> DeleteByIdAsync<T>(this IDbConnection dbConn, object id, CancellationToken token = default)
+        public static Task<int> DeleteByIdAsync<T>(this IDbConnection dbConn, object id, 
+            Action<IDbCommand> commandFilter = null, CancellationToken token = default)
         {
-            return dbConn.Exec(dbCmd => dbCmd.DeleteByIdAsync<T>(id, token));
+            return dbConn.Exec(dbCmd => dbCmd.DeleteByIdAsync<T>(id, commandFilter, token));
         }
 
         /// <summary>
         /// Delete 1 row by the PrimaryKey where the rowVersion matches the optimistic concurrency field. 
-        /// Will throw <exception cref="OptimisticConcurrencyException">RowModefiedExeption</exception> if the 
+        /// Will throw <exception cref="OptimisticConcurrencyException">RowModifiedException</exception> if the 
         /// row does not exist or has a different row version.
         /// E.g: <para>db.DeleteByIdAsync&lt;Person&gt;(1)</para>
         /// </summary>
-        public static Task DeleteByIdAsync<T>(this IDbConnection dbConn, object id, ulong rowVersion, CancellationToken token = default)
+        public static Task DeleteByIdAsync<T>(this IDbConnection dbConn, object id, ulong rowVersion, 
+            Action<IDbCommand> commandFilter = null, CancellationToken token = default)
         {
-            return dbConn.Exec(dbCmd => dbCmd.DeleteByIdAsync<T>(id, rowVersion, token));
+            return dbConn.Exec(dbCmd => dbCmd.DeleteByIdAsync<T>(id, rowVersion, commandFilter, token));
         }
 
         /// <summary>
         /// Delete all rows identified by the PrimaryKeys. E.g:
         /// <para>db.DeleteByIdsAsync&lt;Person&gt;(new[] { 1, 2, 3 })</para>
         /// </summary>
         /// <returns>number of rows deleted</returns>
-        public static Task<int> DeleteByIdsAsync<T>(this IDbConnection dbConn, IEnumerable idValues, CancellationToken token = default)
+        public static Task<int> DeleteByIdsAsync<T>(this IDbConnection dbConn, IEnumerable idValues, 
+            Action<IDbCommand> commandFilter = null, CancellationToken token = default)
         {
-            return dbConn.Exec(dbCmd => dbCmd.DeleteByIdsAsync<T>(idValues, token));
+            return dbConn.Exec(dbCmd => dbCmd.DeleteByIdsAsync<T>(idValues, commandFilter, token));
         }
 
         /// <summary>
diff --git a/src/ServiceStack.OrmLite/OrmLiteWriteCommandExtensions.cs b/src/ServiceStack.OrmLite/OrmLiteWriteCommandExtensions.cs
@@ -486,8 +486,9 @@ internal static int UpdateAll<T>(this IDbCommand dbCmd, IEnumerable<T> objs, Act
 
                     dialectProvider.SetParameterValues<T>(dbCmd, obj);
 
-                    commandFilter?.Invoke(dbCmd);
+                    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();
@@ -559,7 +560,8 @@ internal static int DeleteNonDefaults<T>(this IDbCommand dbCmd, T[] filters)
             return DeleteAll(dbCmd, filters, o => o.AllFieldsMap<T>().NonDefaultsOnly());
         }
 
-        private static int DeleteAll<T>(IDbCommand dbCmd, IEnumerable<T> objs, Func<object,Dictionary<string,object>> fieldValuesFn=null, Action<IDbCommand> commandFilter = null)
+        private static int DeleteAll<T>(IDbCommand dbCmd, IEnumerable<T> objs, 
+            Func<object,Dictionary<string,object>> fieldValuesFn, Action<IDbCommand> commandFilter = null)
         {
             OrmLiteUtils.AssertNotAnonType<T>();
             
@@ -583,7 +585,7 @@ private static int DeleteAll<T>(IDbCommand dbCmd, IEnumerable<T> objs, Func<obje
 
                     dialectProvider.SetParameterValues<T>(dbCmd, obj);
 
-                    commandFilter?.Invoke(dbCmd);
+                    commandFilter?.Invoke(dbCmd); //filters can augment SQL & only should be invoked once
                     commandFilter = null;
 
                     count += dbCmd.ExecNonQuery();
@@ -864,13 +866,14 @@ internal static void InsertAll<T>(this IDbCommand dbCmd, IEnumerable<T> objs, Ac
 
                 dialectProvider.PrepareParameterizedInsertStatement<T>(dbCmd);
 
-                commandFilter?.Invoke(dbCmd);
-
                 foreach (var obj in objs)
                 {
                     OrmLiteConfig.InsertFilter?.Invoke(dbCmd, obj);
                     dialectProvider.SetParameterValues<T>(dbCmd, obj);
 
+                    commandFilter?.Invoke(dbCmd); //filters can augment SQL & only should be invoked once
+                    commandFilter = null;
+
                     try
                     {
                         dbCmd.ExecNonQuery();
diff --git a/src/ServiceStack.OrmLite/OrmLiteWriteExpressionsApi.cs b/src/ServiceStack.OrmLite/OrmLiteWriteExpressionsApi.cs
diff --git a/src/ServiceStack.OrmLite/OrmLiteWriteExpressionsApiAsync.cs b/src/ServiceStack.OrmLite/OrmLiteWriteExpressionsApiAsync.cs

Original file line number	Diff line number	Diff line change
`@@ -205,25 +205,28 @@ public static Task<int> InsertOnlyAsync<T>(this IDbCommand dbCmd, Expression<Fun`
`205`	`205`	`return dbCmd.InitInsertOnly(insertFields).ExecNonQueryAsync(token);`
`206`	`206`	`}`
`207`	`207`
`208`		`- internal static Task<int> DeleteAsync<T>(this IDbCommand dbCmd, Expression<Func<T, bool>> where, CancellationToken token)`
	`208`	`+ internal static Task<int> DeleteAsync<T>(this IDbCommand dbCmd, Expression<Func<T, bool>> where,`
	`209`	`+ Action<IDbCommand> commandFilter, CancellationToken token)`
`209`	`210`	`{`
`210`	`211`	`var q = dbCmd.GetDialectProvider().SqlExpression<T>();`
`211`	`212`	`q.Where(where);`
`212`		`- return dbCmd.DeleteAsync(q, token);`
	`213`	`+ return dbCmd.DeleteAsync(q, commandFilter, token);`
`213`	`214`	`}`
`214`	`215`
`215`		`- internal static Task<int> DeleteAsync<T>(this IDbCommand dbCmd, SqlExpression<T> q, CancellationToken token)`
	`216`	`+ internal static Task<int> DeleteAsync<T>(this IDbCommand dbCmd, SqlExpression<T> q,`
	`217`	`+ Action<IDbCommand> commandFilter, CancellationToken token)`
`216`	`218`	`{`
`217`	`219`	`var sql = q.ToDeleteRowStatement();`
`218`		`- return dbCmd.ExecuteSqlAsync(sql, q.Params, token);`
	`220`	`+ return dbCmd.ExecuteSqlAsync(sql, q.Params, commandFilter, token);`
`219`	`221`	`}`
`220`	`222`
`221`		`- internal static Task<int> DeleteWhereAsync<T>(this IDbCommand dbCmd, string whereFilter, object[] whereParams, CancellationToken token)`
	`223`	`+ internal static Task<int> DeleteWhereAsync<T>(this IDbCommand dbCmd, string whereFilter, object[] whereParams,`
	`224`	`+ Action<IDbCommand> commandFilter, CancellationToken token)`
`222`	`225`	`{`
`223`	`226`	`var q = dbCmd.GetDialectProvider().SqlExpression<T>();`
`224`	`227`	`q.Where(whereFilter, whereParams);`
`225`	`228`	`var sql = q.ToDeleteRowStatement();`
`226`		`- return dbCmd.ExecuteSqlAsync(sql, q.Params, token);`
	`229`	`+ return dbCmd.ExecuteSqlAsync(sql, q.Params, commandFilter, token);`
`227`	`230`	`}`
`228`	`231`	`}`
`229`	`232`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ internal static Task<int> UpdateFmtAsync(this IDbCommand dbCmd, string table, st`
`36`	`36`	`[Obsolete("Use db.DeleteAsync(db.From<T>())")]`
`37`	`37`	`internal static Task<int> DeleteAsync<T>(this IDbCommand dbCmd, Func<SqlExpression<T>, SqlExpression<T>> where, CancellationToken token)`
`38`	`38`	`{`
`39`		`- return dbCmd.DeleteAsync(where(dbCmd.GetDialectProvider().SqlExpression<T>()), token);`
	`39`	`+ return dbCmd.DeleteAsync(where(dbCmd.GetDialectProvider().SqlExpression<T>()), null, token);`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`internal static Task<int> DeleteFmtAsync<T>(this IDbCommand dbCmd, string where, CancellationToken token)`
Original file line number	Diff line number	Diff line change
`@@ -987,6 +987,9 @@ public static void AssertNotAnonType<T>()`
`987`	`987`
`988`	`988`	`if (typeof(T) == typeof(Dictionary<string,object>))`
`989`	`989`	`throw new ArgumentException("T generic argument should be a Table but was typeof(Dictionary<string,object>)");`
	`990`	`+`
	`991`	`+ if (typeof(ISqlExpression).IsAssignableFrom(typeof(T)))`
	`992`	`+ throw new ArgumentException("T generic argument should be a Table but was an ISqlExpression");`
`990`	`993`	`}`
`991`	`994`
`992`	`995`	`public static List<string> GetNonDefaultValueInsertFields<T>(this IOrmLiteDialectProvider dialectProvider, object obj)`
Original file line number	Diff line number	Diff line change
`@@ -196,7 +196,8 @@ public static Task<int> UpdateAllAsync<T>(this IDbConnection dbConn, IEnumerable`
`196`	`196`	`/// <para>db.DeleteAsync<Person>(new { FirstName = "Jimi", Age = 27 })</para>`
`197`	`197`	`/// </summary>`
`198`	`198`	`/// <returns>number of rows deleted</returns>`
`199`		`- public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, object anonFilter, CancellationToken token = default)`
	`199`	`+ public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, object anonFilter,`
	`200`	`+ Action<IDbCommand> commandFilter = null, CancellationToken token = default)`
`200`	`201`	`{`
`201`	`202`	`return dbConn.Exec(dbCmd => dbCmd.DeleteAsync<T>(anonFilter, token));`
`202`	`203`	`}`
`@@ -206,7 +207,8 @@ public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, object anonFil`
`206`	`207`	`/// <para>db.DeleteAsync<Person>(new Dictionary<string,object> { ["FirstName"] = "Jimi", ["Age"] = 27 })</para>`
`207`	`208`	`/// </summary>`
`208`	`209`	`/// <returns>number of rows deleted</returns>`
`209`		`- public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, Dictionary<string, object> filters, CancellationToken token = default)`
	`210`	`+ public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, Dictionary<string, object> filters,`
	`211`	`+ Action<IDbCommand> commandFilter = null, CancellationToken token = default)`
`210`	`212`	`{`
`211`	`213`	`return dbConn.Exec(dbCmd => dbCmd.DeleteAsync<T>(filters, token));`
`212`	`214`	`}`
`@@ -216,7 +218,8 @@ public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, Dictionary<str`
`216`	`218`	`/// <para>db.DeleteAsync(new Person { Id = 1, FirstName = "Jimi", LastName = "Hendrix", Age = 27 })</para>`
`217`	`219`	`/// </summary>`
`218`	`220`	`/// <returns>number of rows deleted</returns>`
`219`		`- public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, T allFieldsFilter, CancellationToken token = default)`
	`221`	`+ public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, T allFieldsFilter,`
	`222`	`+ Action<IDbCommand> commandFilter = null, CancellationToken token = default)`
`220`	`223`	`{`
`221`	`224`	`return dbConn.Exec(dbCmd => dbCmd.DeleteAsync(allFieldsFilter, token));`
`222`	`225`	`}`
`@@ -225,11 +228,13 @@ public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, T allFieldsFil`
`225`	`228`	`/// Delete 1 or more rows in a transaction using all fields in the commandFilter. E.g:`
`226`	`229`	`/// <para>db.DeleteAsync(new Person { Id = 1, FirstName = "Jimi", LastName = "Hendrix", Age = 27 })</para>`
`227`	`230`	`/// </summary>`
`228`		`- public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, CancellationToken token = default, params T[] allFieldsFilters)`
	`231`	`+ public static Task<int> DeleteAsync<T>(this IDbConnection dbConn,`
	`232`	`+ Action<IDbCommand> commandFilter = null, CancellationToken token = default, params T[] allFieldsFilters)`
`229`	`233`	`{`
`230`	`234`	`return dbConn.Exec(dbCmd => dbCmd.DeleteAsync(token, allFieldsFilters));`
`231`	`235`	`}`
`232`		`- public static Task<int> DeleteAsync<T>(this IDbConnection dbConn, params T[] allFieldsFilters)`
	`236`	`+ public static Task<int> DeleteAsync<T>(this IDbConnection dbConn,`
	`237`	`+ Action<IDbCommand> commandFilter = null, params T[] allFieldsFilters)`
`233`	`238`	`{`
`234`	`239`	`return dbConn.Exec(dbCmd => dbCmd.DeleteAsync(default, allFieldsFilters));`
`235`	`240`	`}`
`@@ -256,38 +261,41 @@ public static Task<int> DeleteNonDefaultsAsync<T>(this IDbConnection dbConn, Can`
`256`	`261`	`}`
`257`	`262`	`public static Task<int> DeleteNonDefaultsAsync<T>(this IDbConnection dbConn, params T[] nonDefaultsFilters)`
`258`	`263`	`{`
`259`		`- return dbConn.Exec(dbCmd => dbCmd.DeleteNonDefaultsAsync(default(CancellationToken), nonDefaultsFilters));`
	`264`	`+ return dbConn.Exec(dbCmd => dbCmd.DeleteNonDefaultsAsync(default, nonDefaultsFilters));`
`260`	`265`	`}`
`261`	`266`
`262`	`267`	`/// <summary>`
`263`	`268`	`/// Delete 1 row by the PrimaryKey. E.g:`
`264`	`269`	`/// <para>db.DeleteByIdAsync<Person>(1)</para>`
`265`	`270`	`/// </summary>`
`266`	`271`	`/// <returns>number of rows deleted</returns>`
`267`		`- public static Task<int> DeleteByIdAsync<T>(this IDbConnection dbConn, object id, CancellationToken token = default)`
	`272`	`+ public static Task<int> DeleteByIdAsync<T>(this IDbConnection dbConn, object id,`
	`273`	`+ Action<IDbCommand> commandFilter = null, CancellationToken token = default)`
`268`	`274`	`{`
`269`		`- return dbConn.Exec(dbCmd => dbCmd.DeleteByIdAsync<T>(id, token));`
	`275`	`+ return dbConn.Exec(dbCmd => dbCmd.DeleteByIdAsync<T>(id, commandFilter, token));`
`270`	`276`	`}`
`271`	`277`
`272`	`278`	`/// <summary>`
`273`	`279`	`/// Delete 1 row by the PrimaryKey where the rowVersion matches the optimistic concurrency field.`
`274`		`- /// Will throw <exception cref="OptimisticConcurrencyException">RowModefiedExeption</exception> if the`
	`280`	`+ /// Will throw <exception cref="OptimisticConcurrencyException">RowModifiedException</exception> if the`
`275`	`281`	`/// row does not exist or has a different row version.`
`276`	`282`	`/// E.g: <para>db.DeleteByIdAsync<Person>(1)</para>`
`277`	`283`	`/// </summary>`
`278`		`- public static Task DeleteByIdAsync<T>(this IDbConnection dbConn, object id, ulong rowVersion, CancellationToken token = default)`
	`284`	`+ public static Task DeleteByIdAsync<T>(this IDbConnection dbConn, object id, ulong rowVersion,`
	`285`	`+ Action<IDbCommand> commandFilter = null, CancellationToken token = default)`
`279`	`286`	`{`
`280`		`- return dbConn.Exec(dbCmd => dbCmd.DeleteByIdAsync<T>(id, rowVersion, token));`
	`287`	`+ return dbConn.Exec(dbCmd => dbCmd.DeleteByIdAsync<T>(id, rowVersion, commandFilter, token));`
`281`	`288`	`}`
`282`	`289`
`283`	`290`	`/// <summary>`
`284`	`291`	`/// Delete all rows identified by the PrimaryKeys. E.g:`
`285`	`292`	`/// <para>db.DeleteByIdsAsync<Person>(new[] { 1, 2, 3 })</para>`
`286`	`293`	`/// </summary>`
`287`	`294`	`/// <returns>number of rows deleted</returns>`
`288`		`- public static Task<int> DeleteByIdsAsync<T>(this IDbConnection dbConn, IEnumerable idValues, CancellationToken token = default)`
	`295`	`+ public static Task<int> DeleteByIdsAsync<T>(this IDbConnection dbConn, IEnumerable idValues,`
	`296`	`+ Action<IDbCommand> commandFilter = null, CancellationToken token = default)`
`289`	`297`	`{`
`290`		`- return dbConn.Exec(dbCmd => dbCmd.DeleteByIdsAsync<T>(idValues, token));`
	`298`	`+ return dbConn.Exec(dbCmd => dbCmd.DeleteByIdsAsync<T>(idValues, commandFilter, token));`
`291`	`299`	`}`
`292`	`300`
`293`	`301`	`/// <summary>`