Fix Single Type Reference for Where clause, Added Test cases

Author: ernestoherrera

FluentSql.Tests/SelectStatement/SelectStatementTest.cs

@@ -381,6 +381,26 @@ public void GetSelectQueryWithJoin2()
             Xunit.Assert.IsType<Employee>(employeeSet.FirstOrDefault());
         }
 
+        [Fact]
+        public void GetSelectQueryWith4Joins()
+        {
+            var store = new EntityStore(_dbConnection);
+            var startingOrderDate = new DateTime(2015, 12, 1);
+            var selectQuery = store.GetSelectQuery<Employee>()
+                        .JoinOn<Order>((e, o) => e.Id == o.EmployeeId && o.Id >= 1)
+                        .JoinOn<Order, Customer>((o, c) => o.CustomerId == c.Id)
+                        .JoinOn<Order, OrderDetail>((o, od) => o.Id == od.OrderId)
+                        .Where<Order, Customer, OrderDetail, Employee>((o, c, od, e) => o.OrderDate > startingOrderDate
+                                                && c.City == "Gainesville" && e.Id >= 1 && od.Quantity > 1)
+                        .OrderBy(e => e.Username);
+
+            var employeeSet = store.ExecuteQuery(selectQuery);
+
+            Xunit.Assert.NotNull(employeeSet);
+            Xunit.Assert.True(employeeSet.Count() >= 2);
+            Xunit.Assert.IsType<Employee>(employeeSet.FirstOrDefault());
+        }
+
         [Fact]
         public void GetSelectQueryWithJoin3()
         {
@@ -416,6 +436,24 @@ public async void GetSelectQueryWithJoin2Async()
             Xunit.Assert.IsType<Employee>(employeeSet.FirstOrDefault());
         }
 
+        [Fact]
+        public async void GetSelectQueryWithOneWhereTypeReferenceAsync()
+        {
+            var store = new EntityStore(_dbConnection);
+            var startingOrderDate = new DateTime(2015, 12, 1);
+            var selectQuery = store.GetSelectQuery<Employee>()
+                        .JoinOn<Order>((e, o) => e.Id == o.EmployeeId && o.Id >= 1)
+                        .JoinOn<Order, Customer>((o, c) => o.CustomerId == c.Id)
+                        .Where<Order>(o => o.OrderDate > startingOrderDate)
+                        .OrderBy(e => e.Username);
+
+            var employeeSet = await store.ExecuteQueryAsync(selectQuery);
+
+            Xunit.Assert.NotNull(employeeSet);
+            Xunit.Assert.True(employeeSet.Count() >= 2);
+            Xunit.Assert.IsType<Employee>(employeeSet.FirstOrDefault());
+        }
+
         [Fact]
         public void GetSelectQueryWithLeftJoin()
         {
@@ -829,6 +867,7 @@ public void WhereClauseWithGetDatePartWeek()
             var singleEmployee = store.GetSingle<Employee>(e => SqlFunctions.GetWeek(e.Birthdate) >= 5);
 
             Xunit.Assert.NotNull(singleEmployee);
+            
         }
 
         [Fact]
@@ -876,6 +915,20 @@ public void WhereClauseWithGetDatePartMillisecond()
             Xunit.Assert.NotNull(singleEmployee);
         }
 
+        [Fact]
+        public void WhereClauseThrowsException()
+        {
+            var store = new EntityStore(_dbConnection);
+            string NO_DATETIME_SUPPORT = "SqlFunction does not support DateTime functions or variables. It supports DateTime Entity Types";
+
+            var singleEmployee = store.GetSingle<Order>(o => SqlFunctions.GetMillisecond(o.OrderDate) >= 0);
+
+            var ex = Xunit.Assert.Throws<Exception>(() 
+                => store.GetSingle<Order>(o => SqlFunctions.GetMillisecond(DateTime.Now) >= 0));
+
+            Xunit.Assert.Equal(NO_DATETIME_SUPPORT, ex.Message);
+        }
+
         public void Dispose()
         {
             _dbConnection.Close();

FluentSql/SqlGenerators/IQuery.cs

@@ -33,13 +33,21 @@ public interface IQuery<L> : IToSql
 
         IQuery<L> Where(Expression<Func<L, bool>> expression);
 
+        IQuery<L> Where<T>(Expression<Func<T, bool>> expression) where T : new();
+
         IQuery<L> Where<T1, T2>(Expression<Func<T1, T2, bool>> expression) where T1 : new() where T2 : new();
 
         IQuery<L> Where<T1, T2, T3>(Expression<Func<T1, T2, T3, bool>> expression) 
             where T1 : new() 
             where T2 : new()
             where T3 : new();
 
+        IQuery<L> Where<T1, T2, T3, T4>(Expression<Func<T1, T2, T3, T4, bool>> expression)
+            where T1 : new()
+            where T2 : new()
+            where T3 : new()
+            where T4 : new();
+
         IQuery<L> GetTopRows(int topNumberOfRows);
 
         IQuery<L> OrderBy(Expression<Func<L, object>> expression);

FluentSql/SqlGenerators/Query.cs

@@ -93,6 +93,20 @@ public virtual IQuery<TEntity> Where(Expression<Func<TEntity, bool>> expression)
             return this;
         }
 
+        public IQuery<TEntity> Where<T>(Expression<Func<T, bool>> expression) where T : new()
+        {
+            if (expression == null) return this;
+
+            Predicate = new ExpressionHelper(expression, ParameterNameGenerator);
+
+            if (Parameters.ParameterNames.Any())
+                Parameters.AddDynamicParams(Predicate.QueryParameters);
+            else
+                Parameters = Predicate.QueryParameters;
+
+            return this;
+        }
+
         public IQuery<TEntity> Where<T1, T2>(Expression<Func<T1, T2, bool>> expression) where T1 : new() where T2 : new()
         {
             if (expression == null) return this;
@@ -124,6 +138,25 @@ public IQuery<TEntity> Where<T1, T2, T3>(Expression<Func<T1, T2, T3, bool>> expr
             return this;
         }
 
+
+        public IQuery<TEntity> Where<T1, T2, T3, T4>(Expression<Func<T1, T2, T3, T4, bool>> expression)
+            where T1 : new()
+            where T2 : new()
+            where T3 : new()
+            where T4 : new()
+        {
+            if (expression == null) return this;
+
+            Predicate = new ExpressionHelper(expression, ParameterNameGenerator);
+
+            if (Parameters.ParameterNames.Any())
+                Parameters.AddDynamicParams(Predicate.QueryParameters);
+            else
+                Parameters = Predicate.QueryParameters;
+
+            return this;
+        }
+
         internal IQuery<TEntity> Where(string leftOperand, ExpressionType predicateOperator, string rightOperand, bool isParametized = false, ExpressionType? linkingOperator = null)
         {
             if (this.PredicateParts == null)

FluentSql/Support/Helpers/ExpressionHelper.cs

@@ -26,6 +26,10 @@ public ExpressionHelper(Expression predicateExpression, SqlGeneratorHelper param
         }
         #endregion
 
+        #region Constants
+        private readonly string NO_DATETIME_SUPPORT = "SqlFunction does not support DateTime functions or variables. It supports DateTime Entity Types";
+        #endregion
+
         #region Private Properties
         private static readonly char[] _period = new char[] { '.' };
         private IComparer<ExpressionType> _comparer = new OperatorPrecedenceComparer();
@@ -481,6 +485,10 @@ private MethodCallExpression ParseSqlFunctions(MethodCallExpression methodCall)
                     throw new Exception(string.Format("Method not implemented: {0}", methodName ?? "Undetermined method name."));
 
                 var fieldTypeExpression = methodCall.Arguments[0];
+
+                if (fieldTypeExpression.NodeType == ExpressionType.Convert)
+                    throw new Exception(NO_DATETIME_SUPPORT);
+
                 var functionArgument = methodCall.Arguments[1];
                 var memberExpression = (MemberExpression)fieldTypeExpression;
 
@@ -512,7 +520,7 @@ private MethodCallExpression ParseSqlFunctions(MethodCallExpression methodCall)
                 GetDateOperands(methodCall, 0, ref operandType, ref operand);
 
                 if (operandType == typeof(DateTime) || operandType == typeof(DateTime?))
-                    throw new Exception("Expression Helper does not support DateTime functions or variables. It supports DateTime Entity Types");
+                    throw new Exception(NO_DATETIME_SUPPORT);
 
                 var datePartFuntion = EntityMapper.SqlGenerator.GetDatePartFunction(methodName, operandType, operand);