Basic Update working

src/FluentDML.Tests/MsSqlUpdateFixture.cs

@@ -50,7 +50,7 @@ public void it_generates_where_clause()
         {
             var cmd = GetBasicCommand();
             var sql = cmd.CommandText;
-            Assert.That(sql, Is.StringContaining("WHERE t.[Name] = @p3"));
+            Assert.That(sql, Is.StringContaining("WHERE (t.[Name] = @p3)"));
         }
 
         [Test]

src/FluentDML/Dialect/BaseSqlUpdate.cs

@@ -16,19 +16,19 @@ public abstract class BaseSqlUpdate<T> :
     {
 
         private readonly Dictionary<string, object> _setMap;
-        private readonly List<MyExpression> _predicates;
-        private readonly ClassMap _map;
+        private readonly List<SimpleExpression> _predicates;
+        protected readonly ClassMap Map;
 
         protected BaseSqlUpdate(ClassMap map)
         {
-            _map = map;
+            Map = map;
             _setMap = new Dictionary<string, object>();
-            _predicates = new List<MyExpression>();
+            _predicates = new List<SimpleExpression>();
         }
 
         public IUpdateSet<T> Set<TProperty>(Expression<Func<T, TProperty>> property, TProperty value)
         {
-            _setMap.Add(_map.GetColumnName(property), value);
+            _setMap.Add(Map.GetColumnName(property), value);
             return this;
         }
 
@@ -46,14 +46,14 @@ public IUpdateWhere<T> And(Expression<Func<T, bool>> predicate)
 
         public IDbCommand ToCommand()
         {
-            return ToCommand(_map.TableName, _setMap, And(_predicates));
+            return ToCommand(Map.TableName, _setMap, And(_predicates));
         }
 
-        protected virtual MyExpression And(IEnumerable<MyExpression> predicatesEnum)
+        protected virtual SimpleExpression And(IEnumerable<SimpleExpression> predicatesEnum)
         {
             if (!predicatesEnum.Any())
                 return null;
-            var q = new Queue<MyExpression>(predicatesEnum);
+            var q = new Queue<SimpleExpression>(predicatesEnum);
             var root = q.Dequeue();
             while (q.Any())
                 root = new Binary(root, q.Dequeue(), ExpressionType.AndAlso);
@@ -63,7 +63,7 @@ protected virtual MyExpression And(IEnumerable<MyExpression> predicatesEnum)
         protected abstract IDbCommand ToCommand(
             string tableName,
             Dictionary<string, object> set,
-            MyExpression predicate);
+            SimpleExpression predicate);
 
     }
 }

src/FluentDML/Dialect/MsSqlUpdate.cs

@@ -20,18 +20,19 @@ public MsSqlUpdate(Func<IDbCommand> commandConstructor, ClassMap map) : base(map
         protected override IDbCommand ToCommand(
             string tableName,
             Dictionary<string, object> set, 
-            MyExpression predicate)
+            SimpleExpression predicate)
         {
             var cmd = _commandConstructor();
             cmd.CommandType = CommandType.Text;
-            BuildSql(cmd, tableName, set);
+            BuildSql(cmd, tableName, set, predicate);
             return cmd;
         }
 
         protected virtual void BuildSql(
             IDbCommand command, 
             string tableName,
-            Dictionary<string, object> set)
+            Dictionary<string, object> set,
+            SimpleExpression predicate)
         {
             var sb = new StringBuilder();
             sb.AppendFormat("UPDATE [{0}] t SET", tableName);
@@ -40,21 +41,174 @@ public MsSqlUpdate(Func<IDbCommand> commandConstructor, ClassMap map) : base(map
             foreach (var item in set)
             {
                 sb.AppendLine(paramIndex == 0 ? "" : ",");
-                sb.AppendFormat("t.[{0}] = @p{1}", item.Key, paramIndex);
-                SetParameter(command, paramIndex++, item.Value);
+                sb.AppendFormat("t.[{0}] = @p{1}", item.Key, command.Parameters.Count);
+                SetParameter(command, item.Value);
             }
-
+            sb.AppendLine();
+            sb.Append(Convert(predicate, command));
             command.CommandText = sb.ToString();
         }
 
-        protected virtual void SetParameter(IDbCommand command, int paramIndex, object value)
+        protected virtual string SetParameter(IDbCommand command, object value)
         {
             var param = command.CreateParameter();
-            param.ParameterName = "p" + paramIndex;
+            param.ParameterName = "p" + command.Parameters.Count;
             param.Value = value;
             command.Parameters.Add(param);
+            return param.ParameterName;
+        }
+
+        protected virtual string Convert(SimpleExpression predicate, IDbCommand command)
+        {
+            var sql = new StringBuilder();
+            sql.Append("WHERE ");
+            Convert(predicate, command, sql);
+            return sql.ToString();
+        }
+
+        protected virtual void Convert(SimpleExpression predicate,  IDbCommand command, StringBuilder sql)
+        {
+            if (predicate as Binary != null)
+                Convert((Binary)predicate, command, sql);
+            if (predicate as Unary != null)
+                Convert((Unary)predicate, command, sql);
+            if (predicate as Property != null)
+                Convert((Property)predicate, command, sql);
+            if (predicate as Constant != null)
+                Convert((Constant)predicate, command, sql);
+        }
+
+        protected virtual void Convert(Binary binary, IDbCommand command, StringBuilder sql)
+        {
+            switch (binary.Operation)
+            {
+                case ExpressionType.Add:
+                case ExpressionType.AddChecked:
+                    Convert(" + ", binary.Left, binary.Right, command, sql);
+                    return;
+                case ExpressionType.Subtract:
+                case ExpressionType.SubtractChecked:
+                    Convert(" - ", binary.Left, binary.Right, command, sql);
+                    return;
+                case ExpressionType.Multiply:
+                case ExpressionType.MultiplyChecked:
+                    Convert(" * ", binary.Left, binary.Right, command, sql);
+                    return;
+                case ExpressionType.Divide:
+                    Convert(" / ", binary.Left, binary.Right, command, sql);
+                    return;
+                case ExpressionType.Modulo:
+                    Convert(" % ", binary.Left, binary.Right, command, sql);
+                    return;
+                case ExpressionType.And:
+                case ExpressionType.AndAlso:
+                    Convert(" AND ", binary.Left, binary.Right, command, sql);
+                    return;
+                case ExpressionType.Or:
+                case ExpressionType.OrElse:
+                    Convert(" OR ", binary.Left, binary.Right, command, sql);
+                    return;
+                case ExpressionType.LessThan:
+                    Convert(" < ", binary.Left, binary.Right, command, sql);
+                    return;
+                case ExpressionType.LessThanOrEqual:
+                    Convert(" <= ", binary.Left, binary.Right, command, sql);
+                    return;
+                case ExpressionType.GreaterThan:
+                    Convert(" > ", binary.Left, binary.Right, command, sql);
+                    return;
+                case ExpressionType.GreaterThanOrEqual:
+                    Convert(" >= ", binary.Left, binary.Right, command, sql);
+                    return;
+                case ExpressionType.Equal:
+                    Equality(true, binary.Left, binary.Right, command, sql);
+                    return;
+                case ExpressionType.NotEqual:
+                    Equality(false, binary.Left, binary.Right, command, sql);
+                    return;
+                case ExpressionType.Coalesce:
+                case ExpressionType.ArrayIndex:
+                case ExpressionType.RightShift:
+                case ExpressionType.LeftShift:
+                case ExpressionType.ExclusiveOr:
+                    throw new NotSupportedException();
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+
+        protected virtual void Equality(bool equality, SimpleExpression left, SimpleExpression right, IDbCommand command, StringBuilder sql)
+        {
+            var op = equality ? " = " : " <> ";
+            if (left.IsDBNull() && right.IsDBNull())
+            {
+                sql.Append(equality ? "(NULL IS NULL)" : "(NULL IS NOT NULL)");
+            }
+            else if (left.IsDBNull())
+            {
+                // Switch them so NULL is on the right.
+                sql.Append("(");
+                Convert(right, command, sql);
+                sql.Append(equality ? " IS NULL)" : " IS NOT NULL)");
+            }
+            else if (right.IsDBNull())
+            {
+                sql.Append("(");
+                Convert(left, command, sql);
+                sql.Append(equality ? " IS NULL)" : " IS NOT NULL)");
+            }
+            else
+            {
+                Convert(op, left, right, command, sql);
+            }
+        }
+
+        protected virtual void Convert(string operation, SimpleExpression left, SimpleExpression right, IDbCommand command, StringBuilder sql)
+        {
+            sql.Append("(");
+            Convert(left, command, sql);
+            sql.Append(operation);
+            Convert(right, command, sql);
+            sql.Append(")");
+        }
+
+        protected virtual void Convert(Unary unary, IDbCommand command, StringBuilder sql)
+        {
+            switch (unary.Operation)
+            {
+                case ExpressionType.Negate:
+                case ExpressionType.NegateChecked:
+                    sql.Append("-1 * ");
+                    Convert(unary.Expression, command, sql);
+                    return;
+                case ExpressionType.Not:
+                    sql.Append("NOT ");
+                    Convert(unary.Expression, command, sql);
+                    return;
+                case ExpressionType.Convert:
+                case ExpressionType.ConvertChecked:
+                case ExpressionType.ArrayLength:
+                case ExpressionType.Quote:
+                case ExpressionType.TypeAs:
+                    throw new NotSupportedException();
+                default:
+                    throw new NotSupportedException();
+            }
         }
 
+        protected virtual void Convert(Property property, IDbCommand command, StringBuilder sql)
+        {
+            sql.Append("t.[");
+            sql.Append(Map.GetColumnName(property.PropertyPath));
+            sql.Append("]");
+        }
+
+        protected virtual void Convert(Constant constant, IDbCommand command, StringBuilder sql)
+        {
+            var paramName = SetParameter(command, constant.Value);
+            sql.Append("@");
+            sql.Append(paramName);
+        }
 
 
     }

src/FluentDML/Expressions/AST/Binary.cs

@@ -3,10 +3,10 @@
 namespace FluentDML.Expressions.AST
 {
 
-    public class Binary : MyExpression
+    public class Binary : SimpleExpression
     {
 
-        public Binary(MyExpression left, MyExpression right, ExpressionType operation)
+        public Binary(SimpleExpression left, SimpleExpression right, ExpressionType operation)
         {
             Left = left;
             Right = right;
@@ -20,8 +20,8 @@ public Binary(BinaryExpression binaryExpression)
             Operation = binaryExpression.NodeType;
         }
 
-        public MyExpression Left { get; set; }
-        public MyExpression Right { get; set; }
+        public SimpleExpression Left { get; set; }
+        public SimpleExpression Right { get; set; }
         public ExpressionType Operation { get; set; }
 
         //public enum BinaryOperations

src/FluentDML/Expressions/AST/Constant.cs

@@ -1,13 +1,15 @@
-namespace FluentDML.Expressions.AST
+using System;
+
+namespace FluentDML.Expressions.AST
 {
-    public class Constant : MyExpression
+    public class Constant : SimpleExpression
     {
 
         public object Value { get; set; }
 
         public Constant(object constant)
         {
-            Value = constant;
+            Value = constant ?? DBNull.Value;
         }
     }
 }

src/FluentDML/Expressions/AST/Property.cs

@@ -2,7 +2,7 @@
 
 namespace FluentDML.Expressions.AST
 {
-    public class Property : MyExpression
+    public class Property : SimpleExpression
     {
 
         public Property(Expression expression)

src/FluentDML/Expressions/AST/MyExpression.cs → src/FluentDML/Expressions/AST/SimpleExpression.cs

@@ -1,6 +1,6 @@
 namespace FluentDML.Expressions.AST
 {
-    public abstract class MyExpression
+    public abstract class SimpleExpression
     {
     }
 }