Added ability to update and delete with strong types

src/NPoco.Tests/FluentTests/QueryTests/ExpressionFluentTests.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Text;
 using NPoco.Expressions;
 using NPoco.Tests.Common;
@@ -153,5 +154,84 @@ public void FetchWithWhereExpressionInAsStaticMethod()
             }
         }
 
+        [Test]
+        public void UpdateWhere()
+        {
+            var list = new[] { 1, 2, 3, 4 };
+
+            Database.UpdateWhere(new User() {Name = "test"}, x => x.Name, x => x.UserId.In(list));
+
+            var users = Database.Fetch<User>();
+
+            for (int i = 0; i < 4; i++)
+            {
+                Assert.AreEqual("test", users[i].Name);
+            }
+            for (int i = 4; i < 15; i++)
+            {
+                Assert.AreEqual("Name"+(i+1), users[i].Name);
+            }
+        }
+
+        [Test]
+        public void DeleteWhere()
+        {
+            var list = new[] { 1, 2, 3, 4 };
+
+            Database.DeleteWhere<User>(x => x.UserId.In(list));
+
+            var users = Database.Fetch<User>();
+
+            Assert.AreEqual(11, users.Count);
+        }
+    }
+
+    public static class ss
+    {
+        public static int UpdateWhere<T, TKey>(this IDatabase database, T obj, Expression<Func<T, TKey>> onlyFields = null, Expression<Func<T, bool>> where = null)
+        {
+            if (onlyFields == null)
+                throw new ArgumentNullException("onlyFields");
+
+            var ev =  database.DatabaseType.ExpressionVisitor<T>(database, PocoData.ForType(typeof(T), database.PocoDataFactory));
+            ev.Update(onlyFields);
+            ev.Where(where);
+            var updateStatement = ev.Context.ToUpdateStatement(obj);
+            return database.Execute(updateStatement, ev.Context.Params);
+        }
+
+        public static int UpdateWhere<T>(this IDatabase database, string where, params object[] parameters)
+        {
+            var ev = database.DatabaseType.ExpressionVisitor<T>(database, PocoData.ForType(typeof(T), database.PocoDataFactory));
+            ev.Where(where, parameters);
+            var sql = ev.Context.ToDeleteStatement();
+            return database.Execute(sql, ev.Context.Params);
+        }
+
+        public static int UpdateBy<T>(this IDatabase database, T obj, Func<SqlExpression<T>, SqlExpression<T>> sqlExpression)
+        {
+            var ev = database.DatabaseType.ExpressionVisitor<T>(database, PocoData.ForType(typeof(T), database.PocoDataFactory));
+            return database.Execute(sqlExpression(ev).Context.ToUpdateStatement(obj), ev.Context.Params);
+        }
+
+        public static int DeleteWhere<T>(this IDatabase database, Expression<Func<T, bool>> where)
+        {
+            var ev = database.DatabaseType.ExpressionVisitor<T>(database, PocoData.ForType(typeof(T), database.PocoDataFactory));
+            ev.Where(where);
+            return database.Execute(ev.Context.ToDeleteStatement(), ev.Context.Params);
+        }
+
+        public static int DeleteWhere<T>(this IDatabase database, string where, params object[] parameters)
+        {
+            var ev = database.DatabaseType.ExpressionVisitor<T>(database, PocoData.ForType(typeof(T), database.PocoDataFactory));
+            ev.Where(where, parameters);
+            return database.Execute(ev.Context.ToDeleteStatement(), ev.Context.Params);
+        }
+
+        public static int DeleteBy<T>(this IDatabase database, Func<SqlExpression<T>, SqlExpression<T>> sqlExpression)
+        {
+            var ev = database.DatabaseType.ExpressionVisitor<T>(database, PocoData.ForType(typeof(T), database.PocoDataFactory));
+            return database.Execute(sqlExpression(ev).Context.ToDeleteStatement(), ev.Context.Params);
+        }
     }
 }

src/NPoco/Database.cs

@@ -586,15 +586,15 @@ public List<T> Fetch<T>()
         public List<T> FetchWhere<T>(Expression<Func<T, bool>> expression)
         {
             var ev = _dbType.ExpressionVisitor<T>(this, PocoData.ForType(typeof(T), PocoDataFactory));
-            var sql = ev.Where(expression).ToWhereStatement();
-            return Fetch<T>(sql, ev.Params.ToArray());
+            var sql = ev.Where(expression).Context.ToWhereStatement();
+            return Fetch<T>(sql, ev.Context.Params.ToArray());
         }
 
         public List<T> FetchBy<T>(Func<SqlExpression<T>, SqlExpression<T>> expression)
         {
             var ev = _dbType.ExpressionVisitor<T>(this, PocoData.ForType(typeof(T), PocoDataFactory));
-            var sql = expression(ev).ToSelectStatement();
-            return Fetch<T>(sql, ev.Params.ToArray());
+            var sql = expression(ev).Context.ToSelectStatement();
+            return Fetch<T>(sql, ev.Context.Params.ToArray());
         }
 
         public void BuildPageQueries<T>(long skip, long take, string sql, ref object[] args, out string sqlCount, out string sqlPage)
@@ -1556,7 +1556,7 @@ public Func<Type, PocoData> PocoDataFactory
             set { _pocoDataFactory = value; }
         }
 
-        internal string ConnectionString { get { return _connectionString; } }
+        public string ConnectionString { get { return _connectionString; } }
 
         // Member variables
         private readonly string _connectionString;

src/NPoco/DatabaseType.cs

@@ -227,7 +227,7 @@ public virtual string GetSQLForTransactionLevel(IsolationLevel isolationLevel)
             }
         }
 
-        public virtual SqlExpression<T> ExpressionVisitor<T>(Database db, PocoData pocoData)
+        public virtual SqlExpression<T> ExpressionVisitor<T>(IDatabase db, PocoData pocoData)
         {
             return new DefaultSqlExpression<T>(db, pocoData);
         }

src/NPoco/Expressions/DefaultSqlExpression.cs

@@ -2,7 +2,7 @@ namespace NPoco.Expressions
 {
     public class DefaultSqlExpression<T> : SqlExpression<T>
     {
-        public DefaultSqlExpression(Database database, PocoData pocoData) : base(database, pocoData)
+        public DefaultSqlExpression(IDatabase database, PocoData pocoData) : base(database, pocoData)
         {
         }
     }