From 280ae1b3a2e8d72df79823aeb8ff7346e4468db5 Mon Sep 17 00:00:00 2001
From: MscrmTools <tanguy92@hotmail.com>
Date: Thu, 1 Dec 2022 17:12:46 +0100
Subject: [PATCH 1/5] Initial commit for version 2

---
 .../FilterTest.cs                             | 3279 ++++++++-----
 .../LinkTest.cs                               | 2517 +++++-----
 .../QueryExpressionTest.cs                    | 4051 +++++++++-------
 ...scrmTools.FluentQueryExpressions.v8.csproj |    2 +
 .../Properties/AssemblyInfo.cs                |    4 +-
 .../MscrmTools.FluentQueryExpressions.csproj  |    2 +
 .../Properties/AssemblyInfo.cs                |    4 +-
 MscrmTools.Shared/AppCode/Comparer.cs         |  243 +-
 MscrmTools.Shared/Extensions.cs               |   10 +
 MscrmTools.Shared/Filter.cs                   | 3429 ++++++++++++--
 .../Helpers/AnonymousTypeHelper.cs            |   22 +-
 MscrmTools.Shared/Link.cs                     | 2661 +++++++----
 MscrmTools.Shared/Query.cs                    | 4105 ++++++++++++-----
 13 files changed, 13798 insertions(+), 6531 deletions(-)

diff --git a/MscrmTools.FluentQueryExpressions.Test/FilterTest.cs b/MscrmTools.FluentQueryExpressions.Test/FilterTest.cs
index 461567a..eb22136 100644
--- a/MscrmTools.FluentQueryExpressions.Test/FilterTest.cs
+++ b/MscrmTools.FluentQueryExpressions.Test/FilterTest.cs
@@ -14,1976 +14,3031 @@ namespace MscrmTools.FluentQueryExpressions.Test
     public class FilterTest
     {
         [TestMethod]
+        [Obsolete("See ShouldAddFilterWithoutOperator instead")]
         public void ShouldAddFilter()
         {
-            var query = new Query<Account>()
+            var query = new Query("account")
                 .AddFilters(LogicalOperator.Or, new Filter(LogicalOperator.Or).AddFilters(new Filter(LogicalOperator.Or)));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.FilterOperator, LogicalOperator.Or);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.Count, 1);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Filters.First().FilterOperator, LogicalOperator.Or);
+            Assert.AreEqual(LogicalOperator.Or, query.QueryExpression.Criteria.FilterOperator);
+            Assert.AreEqual(1, query.QueryExpression.Criteria.Filters.Count);
+            Assert.AreEqual(LogicalOperator.Or, query.QueryExpression.Criteria.Filters.First().Filters.First().FilterOperator);
+
+            var query2 = new Query<Account>()
+             .AddFilters(new Filter<Account>(LogicalOperator.Or).AddFilters(new Filter<Account>(LogicalOperator.Or))).SetLogicalOperator(LogicalOperator.Or);
+
+            Assert.AreEqual(LogicalOperator.Or, query2.QueryExpression.Criteria.FilterOperator);
+            Assert.AreEqual(1, query2.QueryExpression.Criteria.Filters.Count);
+            Assert.AreEqual(LogicalOperator.Or, query2.QueryExpression.Criteria.Filters.First().Filters.First().FilterOperator);
         }
 
         [TestMethod]
         public void ShouldAddFilterWithoutOperator()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter()
-                    .AddFilters(new Filter()));
+            var query = new Query("account")
+               .AddFilters(new Filter().AddFilters(new Filter())).SetLogicalOperator(LogicalOperator.Or);
+
+            Assert.AreEqual(LogicalOperator.Or, query.QueryExpression.Criteria.FilterOperator);
+            Assert.AreEqual(1, query.QueryExpression.Criteria.Filters.Count);
+            Assert.AreEqual(LogicalOperator.And, query.QueryExpression.Criteria.Filters.First().FilterOperator);
+            Assert.AreEqual(LogicalOperator.And, query.QueryExpression.Criteria.Filters.First().Filters.First().FilterOperator);
+
+            var query2 = new Query<Account>()
+                .AddFilters(new Filter<Account>()
+                    .AddFilters(new Filter<Account>()));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.FilterOperator, LogicalOperator.And);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.Count, 1);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().FilterOperator, LogicalOperator.And);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Filters.First().FilterOperator, LogicalOperator.And);
+            Assert.AreEqual(LogicalOperator.And, query2.QueryExpression.Criteria.FilterOperator);
+            Assert.AreEqual(1, query2.QueryExpression.Criteria.Filters.Count);
+            Assert.AreEqual(LogicalOperator.And, query2.QueryExpression.Criteria.Filters.First().FilterOperator);
+            Assert.AreEqual(LogicalOperator.And, query2.QueryExpression.Criteria.Filters.First().Filters.First().FilterOperator);
         }
 
         [TestMethod]
         public void ShouldCreateFilter()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .AddFilters(new Filter()
                     .AddFilters(new Filter()));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.FilterOperator, LogicalOperator.And);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.Count, 1);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().FilterOperator, LogicalOperator.And);
+            Assert.AreEqual(LogicalOperator.And, query.QueryExpression.Criteria.Filters.First().FilterOperator);
+            Assert.AreEqual(1, query.QueryExpression.Criteria.Filters.First().Filters.Count);
+            Assert.AreEqual(LogicalOperator.And, query.QueryExpression.Criteria.Filters.First().Filters.First().FilterOperator);
+
+            var query2 = new Query<Account>()
+               .AddFilters(new Filter<Account>()
+                   .AddFilters(new Filter<Account>()));
+
+            Assert.AreEqual(LogicalOperator.And, query2.QueryExpression.Criteria.Filters.First().FilterOperator);
+            Assert.AreEqual(1, query2.QueryExpression.Criteria.Filters.First().Filters.Count);
+            Assert.AreEqual(LogicalOperator.And, query2.QueryExpression.Criteria.Filters.First().Filters.First().FilterOperator);
+
+            var query3 = new Query<Account>()
+               .AddFilters(new Filter<Account>()
+                   .AddFilter(f => f));
+
+            Assert.AreEqual(LogicalOperator.And, query3.QueryExpression.Criteria.Filters.First().FilterOperator);
+            Assert.AreEqual(1, query3.QueryExpression.Criteria.Filters.First().Filters.Count);
+            Assert.AreEqual(LogicalOperator.And, query3.QueryExpression.Criteria.Filters.First().Filters.First().FilterOperator);
         }
 
         [TestMethod]
+        [Obsolete("See ShouldSetLogicalOperatorOr instead")]
         public void ShouldCreateFilterWithOr()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter(LogicalOperator.Or));
+            var query = new Query(Account.EntityLogicalName)
+                .AddFilters(new Filter()
+                    .AddFilters(LogicalOperator.Or, new Filter()));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.Count, 1);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().FilterOperator, LogicalOperator.Or);
+            Assert.AreEqual(LogicalOperator.Or, query.QueryExpression.Criteria.Filters.First().FilterOperator);
+            Assert.AreEqual(1, query.QueryExpression.Criteria.Filters.First().Filters.Count);
+            Assert.AreEqual(LogicalOperator.And, query.QueryExpression.Criteria.Filters.First().Filters.First().FilterOperator);
+
+            var query2 = new Query<Account>()
+               .AddFilters(new Filter<Account>()
+                   .AddFilters(LogicalOperator.Or, new Filter<Account>()));
+
+            Assert.AreEqual(LogicalOperator.Or, query2.QueryExpression.Criteria.Filters.First().FilterOperator);
+            Assert.AreEqual(1, query2.QueryExpression.Criteria.Filters.First().Filters.Count);
+            Assert.AreEqual(LogicalOperator.And, query2.QueryExpression.Criteria.Filters.First().Filters.First().FilterOperator);
+
+            var query3 = new Query<Account>()
+          .AddFilters(new Filter<Account>()
+              .AddFilter(LogicalOperator.Or, f => f));
+
+            Assert.AreEqual(LogicalOperator.And, query3.QueryExpression.Criteria.Filters.First().FilterOperator);
+            Assert.AreEqual(1, query3.QueryExpression.Criteria.Filters.First().Filters.Count);
+            Assert.AreEqual(LogicalOperator.Or, query3.QueryExpression.Criteria.Filters.First().Filters.First().FilterOperator);
         }
 
         [TestMethod]
         public void ShouldSetLogicalOperatorOr()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .AddFilters(new Filter(LogicalOperator.Or)
                     .AddFilters(new Filter()
-                        .SetDefaultFilterOperator(LogicalOperator.Or)));
+                        .SetLogicalOperator(LogicalOperator.Or)));
+
+            Assert.AreEqual(LogicalOperator.Or, query.QueryExpression.Criteria.Filters.First().Filters.First().FilterOperator);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Filters.First().FilterOperator, LogicalOperator.Or);
+            var query2 = new Query<Account>()
+               .AddFilters(new Filter<Account>(LogicalOperator.Or)
+                   .AddFilters(new Filter<Account>()
+                       .SetLogicalOperator(LogicalOperator.Or)));
+
+            Assert.AreEqual(LogicalOperator.Or, query2.QueryExpression.Criteria.Filters.First().Filters.First().FilterOperator);
         }
 
-        #region Conditions
+        #region Compare
 
         [TestMethod]
         public void ShouldCompareWhereEqual()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .AddFilters(new Filter().Compare(Account.Fields.NumberOfEmployees).Equal(Account.Fields.Revenue));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Equal);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .AddFilters(new Filter().Compare(Account.EntityLogicalName, Account.Fields.NumberOfEmployees).Equal(Account.Fields.Revenue));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Equal);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns);
+
+            var query3 = new Query<Account>()
+               .AddFilters(new Filter<Account>().Compare(a => a.NumberOfEmployees).Equal(a => a.Revenue));
+
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+            Assert.AreEqual(true, query3.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns);
+
+            var query4 = new Query<Account>()
+                .AddFilters(new Filter<Account>().Compare(Account.EntityLogicalName, a => a.NumberOfEmployees).Equal(a => a.Revenue));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+            Assert.AreEqual(true, query4.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns);
         }
 
         [TestMethod]
         public void ShouldCompareWhereGreaterOrEqualThan()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .AddFilters(new Filter().Compare(Account.Fields.NumberOfEmployees).GreaterOrEqualThan(Account.Fields.Revenue));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.GreaterEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .AddFilters(new Filter().Compare(Account.EntityLogicalName, Account.Fields.NumberOfEmployees).GreaterOrEqualThan(Account.Fields.Revenue));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.GreaterEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns);
         }
 
         [TestMethod]
         public void ShouldCompareWhereGreaterThan()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .AddFilters(new Filter().Compare(Account.Fields.NumberOfEmployees).GreaterThan(Account.Fields.Revenue));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.GreaterThan);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .AddFilters(new Filter().Compare(Account.EntityLogicalName, Account.Fields.NumberOfEmployees).GreaterThan(Account.Fields.Revenue));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.GreaterThan);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns);
         }
 
         [TestMethod]
         public void ShouldCompareWhereLessOrEqualThan()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .AddFilters(new Filter().Compare(Account.Fields.NumberOfEmployees).LessOrEqualThan(Account.Fields.Revenue));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LessEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .AddFilters(new Filter().Compare(Account.EntityLogicalName, Account.Fields.NumberOfEmployees).LessOrEqualThan(Account.Fields.Revenue));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LessEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns);
         }
 
         [TestMethod]
         public void ShouldCompareWhereLessThan()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .AddFilters(new Filter().Compare(Account.Fields.NumberOfEmployees).LessThan(Account.Fields.Revenue));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LessThan);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .AddFilters(new Filter().Compare(Account.EntityLogicalName, Account.Fields.NumberOfEmployees).LessThan(Account.Fields.Revenue));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LessThan);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns);
         }
 
         [TestMethod]
         public void ShouldCompareWhereNotEqual()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .AddFilters(new Filter().Compare(Account.Fields.NumberOfEmployees).NotEqual(Account.Fields.Revenue));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .AddFilters(new Filter().Compare(Account.EntityLogicalName, Account.Fields.NumberOfEmployees).NotEqual(Account.Fields.Revenue));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Filters.First().Conditions.First().CompareColumns);
         }
 
+        #endregion Compare
+
+        #region Conditions
+
         [TestMethod]
         public void ShouldSetWhere()
         {
             var guid = Guid.NewGuid();
-            var query = new Query<Account>()
-                .AddFilters(new Filter().Where(Account.Fields.AccountId, ConditionOperator.Above, guid));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().Where(Account.Fields.AccountId, ConditionOperator.Above, guid));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Above);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().Where(Account.EntityLogicalName, Account.Fields.AccountId, ConditionOperator.Above, guid));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().Where(Account.EntityLogicalName, Account.Fields.AccountId, ConditionOperator.Above, guid));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().Where(a => a.AccountId, ConditionOperator.Above, guid));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Above);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().Where<Contact>(Contact.EntityLogicalName, a => a.FirstName, ConditionOperator.Equal, "Tanguy"));
+
+            Assert.AreEqual(Contact.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Contact.Fields.FirstName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("Tanguy", query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereAbove()
         {
             var guid = Guid.NewGuid();
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereAbove(Account.Fields.AccountId, guid));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereAbove(Account.Fields.AccountId, guid));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Above);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereAbove(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereAbove(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereAbove(a => a.AccountId, guid));
+
+            Assert.AreEqual(Account.Fields.AccountId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereAbove<Account>(Account.EntityLogicalName, a => a.AccountId, guid));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Above);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereAboveOrEqual()
         {
             var guid = Guid.NewGuid();
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereAboveOrEqual(Account.Fields.AccountId, guid));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereAboveOrEqual(Account.Fields.AccountId, guid));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.AboveOrEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.AboveOrEqual, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereAboveOrEqual(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereAboveOrEqual(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.AboveOrEqual, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereAboveOrEqual(a => a.AccountId, guid));
+
+            Assert.AreEqual(Account.Fields.AccountId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.AboveOrEqual, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.AboveOrEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), guid);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereAboveOrEqual<Account>(Account.EntityLogicalName, a => a.AccountId, guid));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.AboveOrEqual, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereBeginsWith()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereBeginsWith(Account.Fields.Name, "test"));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereBeginsWith(Account.Fields.Name, "test"));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.BeginsWith);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.BeginsWith, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereBeginsWith(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereBeginsWith(Account.Fields.Name, "test", Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.BeginsWith, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereBeginsWith(a => a.Name, "test"));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.BeginsWith);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.BeginsWith, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereBeginsWith<Account>(Account.EntityLogicalName, a => a.Name, "test"));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.BeginsWith, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereBetween()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereBetween(Account.Fields.NumberOfEmployees, 10, 50));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereBetween(Account.Fields.NumberOfEmployees, 10, 50));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Between);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0], 10);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1], 50);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Between, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(50, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereBetween(Account.Fields.NumberOfEmployees, 10, 50, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereBetween(Account.Fields.NumberOfEmployees, 10, 50, Account.EntityLogicalName));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Between);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0], 10);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1], 50);
-        }
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Between, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(50, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
 
-        [TestMethod]
-        public void ShouldSetWhereChildOf()
-        {
-            var guid = Guid.NewGuid();
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereChildOf(Account.Fields.AccountId, guid));
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereBetween(a => a.NumberOfEmployees, 10, 50));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.ChildOf);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Between, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(50, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereChildOf(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereBetween<Account>(Account.EntityLogicalName, a => a.NumberOfEmployees, 10, 50));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.ChildOf);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Between, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(50, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
         }
 
         [TestMethod]
         public void ShouldSetWhereContains()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereContains(Account.Fields.Name, "test"));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereContains(Account.Fields.Name, "test"));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Contains);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Contains, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereContains(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereContains(Account.Fields.Name, "test", Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Contains, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereContains(a => a.Name, "test"));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Contains);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Contains, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereContains<Account>(Account.EntityLogicalName, a => a.Name, "test"));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Contains, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereContainValues()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereContainValues(Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereContainValues(Account.Fields.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.ContainValues);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ContainValues, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereContainValues(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereContainValues(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.ContainValues);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ContainValues, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
             Assert.IsTrue(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
             Assert.IsTrue(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
             Assert.IsTrue(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereContainValues(a => a.CustomerTypeCode, 1, 2, 3));
+
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ContainValues, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.IsTrue(query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
+            Assert.IsTrue(query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
+            Assert.IsTrue(query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereContainValues<Account>(Account.EntityLogicalName, a => a.CustomerTypeCode, 1, 2, 3));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ContainValues, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.IsTrue(query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
+            Assert.IsTrue(query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
+            Assert.IsTrue(query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
         }
 
         [TestMethod]
         public void ShouldSetWhereDoesNotBeginWith()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereDoesNotBeginWith(Account.Fields.Name, "test"));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereDoesNotBeginWith(Account.Fields.Name, "test"));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.DoesNotBeginWith);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotBeginWith, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereDoesNotBeginWith(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereDoesNotBeginWith(Account.Fields.Name, "test", Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotBeginWith, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereDoesNotBeginWith(a => a.Name, "test"));
+
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotBeginWith, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereDoesNotBeginWith<Account>(Account.EntityLogicalName, a => a.Name, "test"));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.DoesNotBeginWith);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotBeginWith, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereDoesNotContain()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereDoesNotContain(Account.Fields.Name, "test"));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereDoesNotContain(Account.Fields.Name, "test"));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.DoesNotContain);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContain, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereDoesNotContain(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereDoesNotContain(Account.Fields.Name, "test", Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContain, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereDoesNotContain(a => a.Name, "test"));
+
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContain, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.DoesNotContain);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), "test");
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereDoesNotContain<Account>(Account.EntityLogicalName, a => a.Name, "test"));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContain, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereDoesNotContainValues()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereDoesNotContainValues(Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereDoesNotContainValues(Account.Fields.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.DoesNotContainValues);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContainValues, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereDoesNotContainValues(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereDoesNotContainValues(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.DoesNotContainValues);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContainValues, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
             Assert.IsTrue(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
             Assert.IsTrue(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
             Assert.IsTrue(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereDoesNotContainValues(a => a.CustomerTypeCode, 1, 2, 3));
+
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContainValues, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.IsTrue(query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
+            Assert.IsTrue(query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
+            Assert.IsTrue(query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereDoesNotContainValues<Account>(Account.EntityLogicalName, a => a.CustomerTypeCode, 1, 2, 3));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContainValues, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.IsTrue(query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
+            Assert.IsTrue(query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
+            Assert.IsTrue(query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
         }
 
         [TestMethod]
         public void ShouldSetWhereDoesNotEndWith()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereDoesNotEndWith(Account.Fields.Name, "test"));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereDoesNotEndWith(Account.Fields.Name, "test"));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.DoesNotEndWith);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotEndWith, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereDoesNotEndWith(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereDoesNotEndWith(Account.Fields.Name, "test", Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotEndWith, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereDoesNotEndWith(a => a.Name, "test"));
+
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotEndWith, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereDoesNotEndWith<Account>(Account.EntityLogicalName, a => a.Name, "test"));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.DoesNotEndWith);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotEndWith, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereEndsWith()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereEndsWith(Account.Fields.Name, "test"));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEndsWith(Account.Fields.Name, "test"));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EndsWith);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EndsWith, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereEndsWith(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEndsWith(Account.Fields.Name, "test", Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EndsWith, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereEndsWith(a => a.Name, "test"));
+
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EndsWith, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EndsWith);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), "test");
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereEndsWith<Account>(Account.EntityLogicalName, a => a.Name, "test"));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EndsWith, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereEqual()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereEqual(Account.Fields.Name, "test"));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqual(Account.Fields.Name, "test"));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Equal);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereEqual(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqual(Account.Fields.Name, "test", Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqual(a => a.Name, "test"));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Equal);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqual<Account>(Account.EntityLogicalName, a => a.Name, "test"));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualBusinessId()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereEqualBusinessId(Account.Fields.OwningBusinessUnit));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqualBusinessId(Account.Fields.OwningBusinessUnit));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EqualBusinessId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualBusinessId, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereEqualBusinessId(Account.Fields.OwningBusinessUnit, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqualBusinessId(Account.Fields.OwningBusinessUnit, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualBusinessId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqualBusinessId(a => a.OwningBusinessUnit));
+
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualBusinessId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqualBusinessId<Account>(Account.EntityLogicalName, a => a.OwningBusinessUnit));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EqualBusinessId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualBusinessId, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserId()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereEqualUserId(Account.Fields.OwnerId));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqualUserId(Account.Fields.OwnerId));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EqualUserId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserId, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereEqualUserId(Account.Fields.OwnerId, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqualUserId(Account.Fields.OwnerId, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqualUserId(a => a.OwnerId));
+
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EqualUserId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqualUserId<Account>(Account.EntityLogicalName, a => a.OwnerId));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserId, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserLanguage()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereEqualUserLanguage("no_language_attribute"));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqualUserLanguage("no_language_attribute"));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, "no_language_attribute");
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EqualUserLanguage);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual("no_language_attribute", query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserLanguage, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereEqualUserLanguage("no_language_attribute", Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqualUserLanguage("no_language_attribute", Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual("no_language_attribute", query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserLanguage, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqualUserLanguage(a => a.NumberOfEmployees));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, "no_language_attribute");
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EqualUserLanguage);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserLanguage, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqualUserLanguage<Account>(Account.EntityLogicalName, a => a.NumberOfEmployees));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserLanguage, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserOrUserHierarchy()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereEqualUserOrUserHierarchy(Account.Fields.OwnerId));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqualUserOrUserHierarchy(Account.Fields.OwnerId));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchy);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchy, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereEqualUserOrUserHierarchy(Account.Fields.OwnerId, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqualUserOrUserHierarchy(Account.Fields.OwnerId, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchy, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqualUserOrUserHierarchy(a => a.OwnerId));
+
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchy, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqualUserOrUserHierarchy<Account>(Account.EntityLogicalName, a => a.OwnerId));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchy);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchy, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserOrUserHierarchyAndTeams()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereEqualUserOrUserHierarchyAndTeams(Account.Fields.OwnerId));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqualUserOrUserHierarchyAndTeams(Account.Fields.OwnerId));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchyAndTeams);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchyAndTeams, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereEqualUserOrUserHierarchyAndTeams(Account.Fields.OwnerId, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqualUserOrUserHierarchyAndTeams(Account.Fields.OwnerId, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchyAndTeams, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqualUserOrUserHierarchyAndTeams(a => a.OwnerId));
+
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchyAndTeams, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchyAndTeams);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqualUserOrUserHierarchyAndTeams<Account>(Account.EntityLogicalName, a => a.OwnerId));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchyAndTeams, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserOrUserTeams()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereEqualUserOrUserTeams(Account.Fields.OwnerId));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqualUserOrUserTeams(Account.Fields.OwnerId));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EqualUserOrUserTeams);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserTeams, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereEqualUserOrUserTeams(Account.Fields.OwnerId, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqualUserOrUserTeams(Account.Fields.OwnerId, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserTeams, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqualUserOrUserTeams(a => a.OwnerId));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EqualUserOrUserTeams);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserTeams, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqualUserOrUserTeams<Account>(Account.EntityLogicalName, a => a.OwnerId));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserTeams, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserTeams()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereEqualUserTeams(Account.Fields.OwnerId));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqualUserTeams(Account.Fields.OwnerId));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EqualUserTeams);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserTeams, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereEqualUserTeams(Account.Fields.OwnerId, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereEqualUserTeams(Account.Fields.OwnerId, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserTeams, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.EqualUserTeams);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqualUserTeams(a => a.OwnerId));
+
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserTeams, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereEqualUserTeams<Account>(Account.EntityLogicalName, a => a.OwnerId));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserTeams, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereGreaterEqual()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereGreaterEqual(Account.Fields.NumberOfEmployees, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereGreaterEqual(Account.Fields.NumberOfEmployees, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.GreaterEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereGreaterEqual(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereGreaterEqual(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.GreaterEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereGreaterEqual(a => a.NumberOfEmployees, 10));
+
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereGreaterEqual<Account>(Account.EntityLogicalName, a => a.NumberOfEmployees, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereGreaterThan()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereGreaterThan(Account.Fields.NumberOfEmployees, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereGreaterThan(Account.Fields.NumberOfEmployees, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.GreaterThan);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereGreaterThan(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereGreaterThan(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereGreaterThan(a => a.NumberOfEmployees, 10));
+
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.GreaterThan);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereGreaterThan<Account>(Account.EntityLogicalName, a => a.NumberOfEmployees, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereIn()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereIn(Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereIn(Account.Fields.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.In);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.In);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
             Assert.IsTrue(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
             Assert.IsTrue(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
             Assert.IsTrue(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereIn(a => a.CustomerTypeCode, 1, 2, 3));
+
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.IsTrue(query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
+            Assert.IsTrue(query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
+            Assert.IsTrue(query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereIn(Account.EntityLogicalName, a => a.CustomerTypeCode, 1, 2, 3));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.IsTrue(query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
+            Assert.IsTrue(query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
+            Assert.IsTrue(query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
         }
 
         [TestMethod]
         public void ShouldSetWhereInFiscalPeriod()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereInFiscalPeriod(Account.Fields.CreatedOn, 1));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereInFiscalPeriod(Account.Fields.CreatedOn, 1));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.InFiscalPeriod);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 1);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriod, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereInFiscalPeriod(Account.Fields.CreatedOn, 1, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereInFiscalPeriod(Account.Fields.CreatedOn, 1, Account.EntityLogicalName));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.InFiscalPeriod);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 1);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriod, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereInFiscalPeriod(a => a.CreatedOn, 1));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriod, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereInFiscalPeriod<Account>(Account.EntityLogicalName, a => a.CreatedOn, 1));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriod, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereInFiscalPeriodAndYear()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereInFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereInFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.InFiscalPeriodAndYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0], 1);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriodAndYear, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereInFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereInFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriodAndYear, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereInFiscalPeriodAndYear(a => a.CreatedOn, 1, 2018));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriodAndYear, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.InFiscalPeriodAndYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0], 1);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1], 2018);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereInFiscalPeriodAndYear<Account>(Account.EntityLogicalName, a => a.CreatedOn, 1, 2018));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriodAndYear, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
         }
 
         [TestMethod]
         public void ShouldSetWhereInFiscalYear()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereInFiscalYear(Account.Fields.CreatedOn, 2018));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereInFiscalYear(Account.Fields.CreatedOn, 2018));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.InFiscalYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 2018);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalYear, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(2018, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereInFiscalYear(Account.Fields.CreatedOn, 2018, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereInFiscalYear(Account.Fields.CreatedOn, 2018, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalYear, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(2018, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereInFiscalYear(a => a.CreatedOn, 2018));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.InFiscalYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 2018);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalYear, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(2018, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereInFiscalYear<Account>(Account.EntityLogicalName, a => a.CreatedOn, 2018));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalYear, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(2018, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereInList()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereIn(Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 }));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereIn(Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 }));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.In);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values is IList);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 }));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 }));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.In);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values is IList);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereIn(a => a.CustomerTypeCode, new List<int> { 1, 2, 3 }));
+
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.IsTrue(query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values is IList);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereIn<Account>(Account.EntityLogicalName, a => a.CustomerTypeCode, new List<int> { 1, 2, 3 }));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.IsTrue(query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values is IList);
         }
 
         [TestMethod]
         public void ShouldSetWhereInOrAfterFiscalPeriodAndYear()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereInOrAfterFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereInOrAfterFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.InOrAfterFiscalPeriodAndYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0], 1);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrAfterFiscalPeriodAndYear, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereInOrAfterFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereInOrAfterFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrAfterFiscalPeriodAndYear, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereInOrAfterFiscalPeriodAndYear(a => a.CreatedOn, 1, 2018));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrAfterFiscalPeriodAndYear, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.InOrAfterFiscalPeriodAndYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0], 1);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1], 2018);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereInOrAfterFiscalPeriodAndYear<Account>(Account.EntityLogicalName, a => a.CreatedOn, 1, 2018));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrAfterFiscalPeriodAndYear, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
         }
 
         [TestMethod]
         public void ShouldSetWhereInOrBeforeFiscalPeriodAndYear()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereInOrBeforeFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereInOrBeforeFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.InOrBeforeFiscalPeriodAndYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0], 1);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrBeforeFiscalPeriodAndYear, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereInOrBeforeFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereInOrBeforeFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrBeforeFiscalPeriodAndYear, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereInOrBeforeFiscalPeriodAndYear(a => a.CreatedOn, 1, 2018));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.InOrBeforeFiscalPeriodAndYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0], 1);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrBeforeFiscalPeriodAndYear, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereInOrBeforeFiscalPeriodAndYear<Account>(Account.EntityLogicalName, a => a.CreatedOn, 1, 2018));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrBeforeFiscalPeriodAndYear, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(1, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
         }
 
         [TestMethod]
         public void ShouldSetWhereLast7Days()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLast7Days(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLast7Days(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Last7Days);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Last7Days, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLast7Days(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLast7Days(Account.Fields.CreatedOn, Account.EntityLogicalName));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Last7Days);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Last7Days, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLast7Days(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Last7Days, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLast7Days<Account>(Account.EntityLogicalName, a => a.CreatedOn));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Last7Days, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLastFiscalPeriod()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLastFiscalPeriod(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastFiscalPeriod(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastFiscalPeriod);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalPeriod, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLastFiscalPeriod(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastFiscalPeriod(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalPeriod, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastFiscalPeriod(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalPeriod, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastFiscalPeriod);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastFiscalPeriod<Account>(Account.EntityLogicalName, a => a.CreatedOn));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalPeriod, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLastFiscalYear()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLastFiscalYear(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastFiscalYear(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastFiscalYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalYear, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLastFiscalYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastFiscalYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalYear, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastFiscalYear(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastFiscalYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalYear, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastFiscalYear<Account>(Account.EntityLogicalName, a => a.CreatedOn));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalYear, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLastMonth()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLastMonth(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastMonth(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastMonth);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastMonth, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLastMonth(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastMonth(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastMonth, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastMonth);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastMonth(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastMonth, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastMonth<Account>(Account.EntityLogicalName, a => a.CreatedOn));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastMonth, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLastWeek()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLastWeek(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastWeek(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastWeek);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastWeek, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLastWeek(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastWeek(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastWeek, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastWeek(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastWeek, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastWeek<Account>(Account.EntityLogicalName, a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastWeek);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastWeek, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXDays()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLastXDays(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastXDays(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastXDays);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXDays, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLastXDays(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastXDays(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXDays, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastXDays(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXDays, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastXDays);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastXDays<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXDays, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXFiscalPeriods()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLastXFiscalPeriods(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastXFiscalPeriods(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastXFiscalPeriods);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalPeriods, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLastXFiscalPeriods(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastXFiscalPeriods(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalPeriods, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastXFiscalPeriods);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastXFiscalPeriods(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalPeriods, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastXFiscalPeriods<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalPeriods, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXFiscalYears()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLastXFiscalYears(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastXFiscalYears(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastXFiscalYears);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalYears, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLastXFiscalYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastXFiscalYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalYears, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastXFiscalYears(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalYears, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastXFiscalYears<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastXFiscalYears);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalYears, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXHours()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLastXHours(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastXHours(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastXHours);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXHours, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLastXHours(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastXHours(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXHours, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastXHours(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXHours, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastXHours);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastXHours<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXHours, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXMonths()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLastXMonths(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastXMonths(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastXMonths);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXMonths, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLastXMonths(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastXMonths(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXMonths, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastXMonths);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastXMonths(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXMonths, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastXMonths<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXMonths, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXWeeks()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLastXWeeks(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastXWeeks(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastXWeeks);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXWeeks, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLastXWeeks(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastXWeeks(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXWeeks, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastXWeeks(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXWeeks, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastXWeeks<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastXWeeks);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXWeeks, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXYears()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLastXYears(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastXYears(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastXYears);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXYears, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLastXYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastXYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXYears, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastXYears(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXYears, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastXYears);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastXYears<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXYears, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastYear()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLastYear(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastYear(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastYear, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLastYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLastYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastYear, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LastYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastYear(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastYear, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLastYear<Account>(Account.EntityLogicalName, a => a.CreatedOn));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastYear, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLessEqual()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLessEqual(Account.Fields.NumberOfEmployees, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLessEqual(Account.Fields.NumberOfEmployees, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LessEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLessEqual(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLessEqual(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLessEqual(a => a.NumberOfEmployees, 10));
+
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLessEqual<Account>(Account.EntityLogicalName, a => a.NumberOfEmployees, 10));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LessEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLessThan()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLessThan(Account.Fields.NumberOfEmployees, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLessThan(Account.Fields.NumberOfEmployees, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LessThan);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLessThan(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLessThan(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLessThan(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.LessThan);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLessThan<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLike()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereLike(Account.Fields.Name, "%test%"));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLike(Account.Fields.Name, "%test%"));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Like);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Like, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("%test%", query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereLike(Account.Fields.Name, "%test%", Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereLike(Account.Fields.Name, "%test%", Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Like, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("%test%", query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereLike(a => a.Name, "%test%"));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Like);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Like, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("%test%", query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereLike<Account>(Account.EntityLogicalName, a => a.Name, "%test%"));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Like, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("%test%", query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereMask()
         {
             var obj = new object();
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereMask(Account.Fields.Name, obj));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereMask(Account.Fields.Name, obj));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Mask);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Mask, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(obj, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereMask(Account.Fields.Name, obj, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereMask(Account.Fields.Name, obj, Account.EntityLogicalName));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Mask);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), obj);
-        }
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Mask, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(obj, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-        [TestMethod]
-        public void ShouldSetWhereMasksSelect()
-        {
-            var obj = new object();
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereMasksSelect(Account.Fields.Name, obj));
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereMask(a => a.Name, obj));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.MasksSelect);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Mask, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(obj, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereMasksSelect(Account.Fields.Name, obj, Account.EntityLogicalName));
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereMask<Account>(Account.EntityLogicalName, a => a.Name, obj));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.MasksSelect);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Mask, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(obj, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNext7Days()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNext7Days(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNext7Days(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Next7Days);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Next7Days, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNext7Days(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNext7Days(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Next7Days, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNext7Days(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Next7Days, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Next7Days);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNext7Days<Account>(Account.EntityLogicalName, a => a.CreatedOn));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Next7Days, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNextFiscalPeriod()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNextFiscalPeriod(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextFiscalPeriod(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextFiscalPeriod);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalPeriod, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNextFiscalPeriod(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextFiscalPeriod(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalPeriod, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextFiscalPeriod);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextFiscalPeriod(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalPeriod, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextFiscalPeriod<Account>(Account.EntityLogicalName, a => a.CreatedOn));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalPeriod, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNextFiscalYear()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNextFiscalYear(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextFiscalYear(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextFiscalYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalYear, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNextFiscalYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextFiscalYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalYear, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextFiscalYear(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalYear, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextFiscalYear<Account>(Account.EntityLogicalName, a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextFiscalYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalYear, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNextMonth()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNextMonth(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextMonth(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextMonth);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextMonth, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNextMonth(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextMonth(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextMonth, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextMonth(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextMonth, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextMonth);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextMonth<Account>(Account.EntityLogicalName, a => a.CreatedOn));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextMonth, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNextWeek()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNextWeek(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextWeek(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextWeek);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextWeek, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNextWeek(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextWeek(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextWeek, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextWeek);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextWeek(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextWeek, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextWeek<Account>(Account.EntityLogicalName, a => a.CreatedOn));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextWeek, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXDays()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNextXDays(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextXDays(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextXDays);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXDays, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNextXDays(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextXDays(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXDays, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextXDays(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXDays, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextXDays<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextXDays);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXDays, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXFiscalPeriods()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNextXFiscalPeriods(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextXFiscalPeriods(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextXFiscalPeriods);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalPeriods, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNextXFiscalPeriods(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextXFiscalPeriods(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalPeriods, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextXFiscalPeriods(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalPeriods, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextXFiscalPeriods);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextXFiscalPeriods<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalPeriods, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXFiscalYears()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNextXFiscalYears(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextXFiscalYears(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextXFiscalYears);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalYears, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNextXFiscalYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextXFiscalYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalYears, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextXFiscalYears);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextXFiscalYears(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalYears, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextXFiscalYears<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalYears, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXHours()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNextXHours(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextXHours(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextXHours);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXHours, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNextXHours(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextXHours(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXHours, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextXHours(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXHours, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextXHours<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextXHours);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXHours, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXMonths()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNextXMonths(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextXMonths(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextXMonths);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXMonths, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNextXMonths(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextXMonths(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXMonths, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextXMonths(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXMonths, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextXMonths);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextXMonths<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXMonths, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXWeeks()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNextXWeeks(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextXWeeks(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextXWeeks);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXWeeks, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNextXWeeks(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextXWeeks(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXWeeks, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextXWeeks(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextXWeeks);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXWeeks, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextXWeeks<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXWeeks, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXYears()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNextXYears(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextXYears(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextXYears);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXYears, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNextXYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextXYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXYears, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextXYears);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextXYears(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXYears, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextXYears<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXYears, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextYear()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNextYear(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextYear(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextYear, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNextYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNextYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NextYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextYear, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextYear(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextYear, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNextYear<Account>(Account.EntityLogicalName, a => a.CreatedOn));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextYear, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotBetween()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNotBetween(Account.Fields.NumberOfEmployees, 10, 50));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotBetween(Account.Fields.NumberOfEmployees, 10, 50));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotBetween);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0], 10);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1], 50);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotBetween, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(50, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNotBetween(Account.Fields.NumberOfEmployees, 10, 50, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotBetween(Account.Fields.NumberOfEmployees, 10, 50, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotBetween, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(50, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotBetween(a => a.CreatedOn, 10, 50));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotBetween);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0], 10);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1], 50);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotBetween, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(50, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotBetween<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10, 50));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotBetween, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values[0]);
+            Assert.AreEqual(50, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values[1]);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotEqual()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNotEqual(Account.Fields.Name, "test"));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotEqual(Account.Fields.Name, "test"));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNotEqual(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotEqual(Account.Fields.Name, "test", Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), "test");
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotEqual(a => a.Name, "test"));
+
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotEqual<Account>(Account.EntityLogicalName, a => a.Name, "test"));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNotEqualBusinessId()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNotEqualBusinessId(Account.Fields.OwningBusinessUnit));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotEqualBusinessId(Account.Fields.OwningBusinessUnit));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotEqualBusinessId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualBusinessId, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNotEqualBusinessId(Account.Fields.OwningBusinessUnit, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotEqualBusinessId(Account.Fields.OwningBusinessUnit, Account.EntityLogicalName));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotEqualBusinessId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualBusinessId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotEqualBusinessId(a => a.OwningBusinessUnit));
+
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualBusinessId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotEqualBusinessId<Account>(Account.EntityLogicalName, a => a.OwningBusinessUnit));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualBusinessId, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotEqualUserId()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNotEqualUserId(Account.Fields.OwnerId));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotEqualUserId(Account.Fields.OwnerId));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotEqualUserId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualUserId, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNotEqualUserId(Account.Fields.OwnerId, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotEqualUserId(Account.Fields.OwnerId, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualUserId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotEqualUserId(a => a.OwnerId));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotEqualUserId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualUserId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotEqualUserId<Account>(Account.EntityLogicalName, a => a.OwnerId));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualUserId, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotIn()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNotIn(Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotIn(Account.Fields.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotIn);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNotIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotIn);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
             Assert.IsTrue(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
             Assert.IsTrue(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
             Assert.IsTrue(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotIn(a => a.CustomerTypeCode, 1, 2, 3));
+
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.IsTrue(query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
+            Assert.IsTrue(query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
+            Assert.IsTrue(query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotIn(Account.EntityLogicalName, a => a.CustomerTypeCode, 1, 2, 3));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.IsTrue(query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(1));
+            Assert.IsTrue(query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(2));
+            Assert.IsTrue(query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Contains(3));
         }
 
         [TestMethod]
         public void ShouldSetWhereNotInList()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNotIn(Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 }));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotIn(Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 }));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotIn);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values is IList);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNotIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 }));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 }));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotIn);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values is IList);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotIn(a => a.CustomerTypeCode, new List<int> { 1, 2, 3 }));
+
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.IsTrue(query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values is IList);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotIn(Account.EntityLogicalName, a => a.CustomerTypeCode, new List<int> { 1, 2, 3 }));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.IsTrue(query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values is IList);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotLike()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNotLike(Account.Fields.Name, "%test%"));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotLike(Account.Fields.Name, "%test%"));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotLike);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotLike, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("%test%", query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNotLike(Account.Fields.Name, "%test%", Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotLike(Account.Fields.Name, "%test%", Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotLike, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("%test%", query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotLike(a => a.Name, "%test%"));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotLike);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotLike, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("%test%", query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotLike<Account>(Account.EntityLogicalName, a => a.Name, "%test%"));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotLike, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual("%test%", query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNotMask()
         {
             var obj = new object();
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNotMask(Account.Fields.Name, obj));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotMask(Account.Fields.Name, obj));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotMask);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotMask, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(obj, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                 .AddFilters(new Filter().WhereNotMask(Account.Fields.Name, obj, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotMask(Account.Fields.Name, obj, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotMask, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(obj, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotMask);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), obj);
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotMask(a => a.Name, obj));
+
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotMask, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(obj, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotMask<Account>(Account.EntityLogicalName, a => a.Name, obj));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotMask, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(obj, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNotNull()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNotNull(Account.Fields.Name));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotNull(Account.Fields.Name));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotNull);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotNull, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNotNull(Account.Fields.Name, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotNull(Account.Fields.Name, Account.EntityLogicalName));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotNull);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotNull, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotNull(a => a.Name));
+
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotNull, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotNull<Account>(Account.EntityLogicalName, a => a.Name));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotNull, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotOn()
         {
             var date = new DateTime();
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNotOn(Account.Fields.CreatedOn, date));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotOn(Account.Fields.CreatedOn, date));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNotOn(Account.Fields.CreatedOn, date, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotOn(Account.Fields.CreatedOn, date, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotOn(a => a.CreatedOn, date));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), date);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotOn<Account>(Account.EntityLogicalName, a => a.CreatedOn, date));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNotUnder()
         {
-            var guid = new Guid();
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNotUnder(Account.Fields.AccountId, guid));
+            var guid = Guid.Empty;
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotUnder(Account.Fields.AccountId, guid));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotUnder);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotUnder, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNotUnder(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNotUnder(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotUnder, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotUnder(a => a.AccountId, guid));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.NotUnder);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotUnder, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNotUnder<Account>(Account.EntityLogicalName, a => a.AccountId, guid));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotUnder, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNull()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereNull(Account.Fields.Name));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNull(Account.Fields.Name));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Null);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Null, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereNull(Account.Fields.Name, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereNull(Account.Fields.Name, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Null, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Null);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereNull(a => a.Name));
+
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Null, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereNull<Account>(Account.EntityLogicalName, a => a.Name));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Null, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXDays()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereOlderThanXDays(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOlderThanXDays(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OlderThanXDays);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXDays, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereOlderThanXDays(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOlderThanXDays(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXDays, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereOlderThanXDays(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXDays, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OlderThanXDays);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereOlderThanXDays<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXDays, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXHours()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereOlderThanXHours(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOlderThanXHours(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OlderThanXHours);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXHours, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereOlderThanXHours(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOlderThanXHours(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXHours, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereOlderThanXHours(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OlderThanXHours);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXHours, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereOlderThanXHours<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXHours, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXMinutes()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereOlderThanXMinutes(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOlderThanXMinutes(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OlderThanXMinutes);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMinutes, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereOlderThanXMinutes(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOlderThanXMinutes(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMinutes, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OlderThanXMinutes);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereOlderThanXMinutes(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMinutes, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereOlderThanXMinutes<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMinutes, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXMonths()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereOlderThanXMonths(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOlderThanXMonths(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OlderThanXMonths);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMonths, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereOlderThanXMonths(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOlderThanXMonths(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMonths, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereOlderThanXMonths(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMonths, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OlderThanXMonths);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereOlderThanXMonths<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMonths, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXWeeks()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereOlderThanXWeeks(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOlderThanXWeeks(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OlderThanXWeeks);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXWeeks, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereOlderThanXWeeks(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOlderThanXWeeks(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXWeeks, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereOlderThanXWeeks(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OlderThanXWeeks);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXWeeks, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereOlderThanXWeeks<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXWeeks, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXYears()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereOlderThanXYears(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOlderThanXYears(Account.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OlderThanXYears);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXYears, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereOlderThanXYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOlderThanXYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXYears, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OlderThanXYears);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), 10);
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereOlderThanXYears(a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXYears, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereOlderThanXYears<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXYears, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOn()
         {
             var date = new DateTime();
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereOn(Account.Fields.CreatedOn, date));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOn(Account.Fields.CreatedOn, date));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.On);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.On, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereOn(Account.Fields.CreatedOn, date, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOn(Account.Fields.CreatedOn, date, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.On, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereOn(a => a.CreatedOn, date));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.On, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.On);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), date);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereOn<Account>(Account.EntityLogicalName, a => a.CreatedOn, date));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.On, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOnOrAfter()
         {
             var date = new DateTime();
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereOnOrAfter(Account.Fields.CreatedOn, date));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOnOrAfter(Account.Fields.CreatedOn, date));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OnOrAfter);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrAfter, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereOnOrAfter(Account.Fields.CreatedOn, date, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOnOrAfter(Account.Fields.CreatedOn, date, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrAfter, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereOnOrAfter(a => a.CreatedOn, date));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OnOrAfter);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrAfter, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereOnOrAfter<Account>(Account.EntityLogicalName, a => a.CreatedOn, date));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrAfter, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOnOrBefore()
         {
             var date = new DateTime();
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereOnOrBefore(Account.Fields.CreatedOn, date));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOnOrBefore(Account.Fields.CreatedOn, date));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OnOrBefore);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrBefore, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereOnOrBefore(Account.Fields.CreatedOn, date, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereOnOrBefore(Account.Fields.CreatedOn, date, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrBefore, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.OnOrBefore);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), date);
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereOnOrBefore(a => a.CreatedOn, date));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrBefore, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereOnOrBefore<Account>(Account.EntityLogicalName, a => a.CreatedOn, date));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrBefore, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(date, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereThisFiscalPeriod()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereThisFiscalPeriod(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereThisFiscalPeriod(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.ThisFiscalPeriod);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalPeriod, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereThisFiscalPeriod(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereThisFiscalPeriod(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalPeriod, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereThisFiscalPeriod(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalPeriod, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereThisFiscalPeriod<Account>(Account.EntityLogicalName, a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.ThisFiscalPeriod);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalPeriod, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereThisFiscalYear()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereThisFiscalYear(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereThisFiscalYear(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.ThisFiscalYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalYear, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereThisFiscalYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereThisFiscalYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalYear, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereThisFiscalYear(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalYear, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.ThisFiscalYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereThisFiscalYear<Account>(Account.EntityLogicalName, a => a.CreatedOn));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalYear, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereThisMonth()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereThisMonth(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereThisMonth(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.ThisMonth);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisMonth, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereThisMonth(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereThisMonth(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisMonth, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereThisMonth(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.ThisMonth);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisMonth, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereThisMonth<Account>(Account.EntityLogicalName, a => a.CreatedOn));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisMonth, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereThisWeek()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereThisWeek(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereThisWeek(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.ThisWeek);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisWeek, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereThisWeek(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereThisWeek(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisWeek, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereThisWeek(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisWeek, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereThisWeek<Account>(Account.EntityLogicalName, a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.ThisWeek);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisWeek, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereThisYear()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereThisYear(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereThisYear(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.ThisYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisYear, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereThisYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereThisYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisYear, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereThisYear(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisYear, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.ThisYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereThisYear<Account>(Account.EntityLogicalName, a => a.CreatedOn));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisYear, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereToday()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereToday(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereToday(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Today);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Today, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereToday(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereToday(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Today, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereToday(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Today);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Today, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereToday<Account>(Account.EntityLogicalName, a => a.CreatedOn));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Today, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereTomorrow()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereTomorrow(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereTomorrow(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Tomorrow);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Tomorrow, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereTomorrow(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereTomorrow(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Tomorrow, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereTomorrow(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Tomorrow, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereTomorrow<Account>(Account.EntityLogicalName, a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Tomorrow);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Tomorrow, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereUnder()
         {
-            Guid guid = new Guid();
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereUnder(Account.Fields.AccountId, guid));
+            Guid guid = Guid.NewGuid();
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereUnder(Account.Fields.AccountId, guid));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Under);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Under, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereUnder(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereUnder(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Under, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereUnder(a => a.AccountId, guid));
+
+            Assert.AreEqual(Account.Fields.AccountId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Under, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Under);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), guid);
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereUnder<Account>(Account.EntityLogicalName, a => a.AccountId, guid));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Under, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereUnderOrEqual()
         {
-            Guid guid = new Guid();
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereUnderOrEqual(Account.Fields.AccountId, guid));
+            Guid guid = Guid.NewGuid();
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereUnderOrEqual(Account.Fields.AccountId, guid));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.UnderOrEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.UnderOrEqual, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereUnderOrEqual(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereUnderOrEqual(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.UnderOrEqual, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereUnderOrEqual(a => a.AccountId, guid));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.UnderOrEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.UnderOrEqual, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereUnderOrEqual<Account>(Account.EntityLogicalName, a => a.AccountId, guid));
+
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.UnderOrEqual, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(guid, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereYesterday()
         {
-            var query = new Query<Account>()
-                .AddFilters(new Filter().WhereYesterday(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereYesterday(Account.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Yesterday);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Yesterday, query.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddFilters(new Filter().WhereYesterday(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query2 = new Query(Account.EntityLogicalName).AddFilters(new Filter().WhereYesterday(Account.Fields.CreatedOn, Account.EntityLogicalName));
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Yesterday, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query3 = new Query<Account>().AddFilters(new Filter<Account>().WhereYesterday(a => a.CreatedOn));
+
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Yesterday, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
+
+            var query4 = new Query<Account>().AddFilters(new Filter<Account>().WhereYesterday<Account>(Account.EntityLogicalName, a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Operator, ConditionOperator.Yesterday);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Filters.First().Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Filters.First().Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Yesterday, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Filters.First().Conditions.First().Values.Count);
         }
 
         #endregion Conditions
diff --git a/MscrmTools.FluentQueryExpressions.Test/LinkTest.cs b/MscrmTools.FluentQueryExpressions.Test/LinkTest.cs
index 0a28025..9852a3d 100644
--- a/MscrmTools.FluentQueryExpressions.Test/LinkTest.cs
+++ b/MscrmTools.FluentQueryExpressions.Test/LinkTest.cs
@@ -13,2085 +13,2130 @@ namespace MscrmTools.FluentQueryExpressions.Test
     [ExcludeFromCodeCoverage]
     public class LinkTest
     {
+        #region Link
+
         [TestMethod]
-        public void ShouldAddFilter()
+        public void ShouldAddLinkWithPublicMethods()
         {
             var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId, JoinOperator.LeftOuter)
-                    .AddFilters(LogicalOperator.Or, new Filter()));
+                .AddLink<Contact>(l => l
+                    .From(a => a.AccountId)
+                    .To(c => c.ParentCustomerId)
+                    .AddLink<Task>(lt => lt
+                        .From(c => c.ContactId)
+                        .To(t => t.RegardingObjectId)
+                        .SetJoin(JoinOperator.LeftOuter)
+                        .SetAlias("fakeAlias")
+                        .SetLogicalOperator(LogicalOperator.Or)
+                    )
+                );
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.FilterOperator, LogicalOperator.Or);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Filters.Count, 1);
+            var le = query.QueryExpression.LinkEntities.First().LinkEntities.First();
+            Assert.AreEqual(Contact.EntityLogicalName, le.LinkFromEntityName);
+            Assert.AreEqual(Contact.Fields.ContactId, le.LinkFromAttributeName);
+            Assert.AreEqual(Task.EntityLogicalName, le.LinkToEntityName);
+            Assert.AreEqual(Task.Fields.RegardingObjectId, le.LinkToAttributeName);
+            Assert.AreEqual(JoinOperator.LeftOuter, le.JoinOperator);
+            Assert.AreEqual("fakeAlias", le.EntityAlias);
+            Assert.AreEqual(LogicalOperator.Or, le.LinkCriteria.FilterOperator);
         }
 
+        #endregion Link
+
+        #region Attributes
+
         [TestMethod]
-        public void ShouldAddFilters()
+        public void ShouldSelectAllAttributes()
         {
             var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId, JoinOperator.LeftOuter)
-                    .AddFilters(
-                        new Filter(),
-                        new Filter()
-                    )
+                .AddLink<Contact>(l => l
+                    .Select(true)
                 );
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.FilterOperator, LogicalOperator.And);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Filters.Count, 2);
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(true, le.Columns.AllColumns);
         }
 
         [TestMethod]
-        public void ShouldAddLink()
+        public void ShouldSelectOneAttributeWithLambda()
         {
             var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId, JoinOperator.LeftOuter)
-                    .AddLink(new Link<Task>(Task.Fields.RegardingObjectId, Contact.Fields.ContactId)));
+                .AddLink<Contact>(l => l
+                    .Select(c => c.FirstName)
+                );
+
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(false, le.Columns.AllColumns);
+            Assert.AreEqual(1, le.Columns.Columns.Count);
+            Assert.IsTrue(le.Columns.Columns.Contains(Contact.Fields.FirstName));
+
+            var query2 = new Query<Account>()
+                .AddLink<Contact>(l => l
+                    .Select(c => c.ContactId)
+                );
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkEntities.Count, 1);
+            var le2 = query2.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(false, le2.Columns.AllColumns);
+            Assert.AreEqual(1, le2.Columns.Columns.Count);
+            Assert.IsTrue(le2.Columns.Columns.Contains(Contact.Fields.ContactId));
         }
 
         [TestMethod]
-        public void ShouldAddLink2()
+        public void ShouldSelectThreeAttributes()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId, JoinOperator.LeftOuter)
-                    .AddLink(new Link(Task.EntityLogicalName, Task.Fields.RegardingObjectId, Contact.Fields.ContactId)));
+            var query = new Query(Account.EntityLogicalName)
+                .AddLink(new Link(Contact.EntityLogicalName, Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
+                    .Select(Contact.Fields.FirstName, Contact.Fields.LastName, Contact.Fields.ContactId)
+                );
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkEntities.Count, 1);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkEntities.First().LinkFromEntityName, Contact.EntityLogicalName);
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(false, le.Columns.AllColumns);
+            Assert.AreEqual(3, le.Columns.Columns.Count);
+            Assert.IsTrue(le.Columns.Columns.Contains(Contact.Fields.FirstName));
+            Assert.IsTrue(le.Columns.Columns.Contains(Contact.Fields.LastName));
+            Assert.IsTrue(le.Columns.Columns.Contains(Contact.Fields.ContactId));
         }
 
         [TestMethod]
-        public void ShouldAddOrder()
+        public void ShouldSelectThreeAttributesWithLambda()
         {
             var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId,
-                        JoinOperator.LeftOuter)
-                    .Order(Contact.Fields.FullName, OrderType.Ascending));
+                .AddLink<Contact>(l => l
+                    .Select(c => new { c.FirstName, c.LastName, c.ContactId })
+                );
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().Orders.First().AttributeName, Contact.Fields.FullName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().Orders.First().OrderType, OrderType.Ascending);
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(false, le.Columns.AllColumns);
+            Assert.AreEqual(3, le.Columns.Columns.Count);
+            Assert.IsTrue(le.Columns.Columns.Contains(Contact.Fields.FirstName));
+            Assert.IsTrue(le.Columns.Columns.Contains(Contact.Fields.LastName));
+            Assert.IsTrue(le.Columns.Columns.Contains(Contact.Fields.ContactId));
         }
 
+        #endregion Attributes
+
+        #region Filters
+
         [TestMethod]
-        public void ShouldCreateLink()
+        public void ShouldAddEarlyBoundFilter()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId, JoinOperator.LeftOuter));
+            var query = new Query<Account>().AddLink<Contact>(l => l
+                    .AddFilter(new Filter<Contact>(LogicalOperator.Or))
+                );
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.Count, 1);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkFromEntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkFromAttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkToAttributeName, Contact.Fields.ParentCustomerId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkToEntityName, Contact.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().EntityAlias, Contact.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().JoinOperator, JoinOperator.LeftOuter);
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(LogicalOperator.And, le.LinkCriteria.FilterOperator);
+            Assert.AreEqual(1, le.LinkCriteria.Filters.Count);
+            Assert.AreEqual(LogicalOperator.Or, le.LinkCriteria.Filters.First().FilterOperator);
         }
 
         [TestMethod]
-        public void ShouldCreateLink2()
+        public void ShouldAddEarlyBoundFilters()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId, JoinOperator.LeftOuter)
-                    .SetAlias("toto")
-                    .SetDefaultFilterOperator(LogicalOperator.Or)
-                    .Select(true));
+            var query = new Query<Account>().AddLink<Contact>(l => l.AddFilters(new Filter<Contact>(LogicalOperator.Or), new Filter<Contact>(LogicalOperator.And)));
+
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(LogicalOperator.And, le.LinkCriteria.FilterOperator);
+            Assert.AreEqual(2, le.LinkCriteria.Filters.Count);
+            Assert.AreEqual(LogicalOperator.Or, le.LinkCriteria.Filters[0].FilterOperator);
+            Assert.AreEqual(LogicalOperator.And, le.LinkCriteria.Filters[1].FilterOperator);
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.Count, 1);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkFromEntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkFromAttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkToAttributeName, Contact.Fields.ParentCustomerId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkToEntityName, Contact.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().EntityAlias, "toto");
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().JoinOperator, JoinOperator.LeftOuter);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.FilterOperator, LogicalOperator.Or);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().Columns.AllColumns, true);
+            var query2 = new Query<Account>().AddLink<Contact>(l => l.AddFilters(new Filter<Contact>(LogicalOperator.Or), new Filter<Contact>(LogicalOperator.And)).SetLogicalOperator(LogicalOperator.Or));
+
+            var le2 = query2.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(LogicalOperator.Or, le2.LinkCriteria.FilterOperator);
+            Assert.AreEqual(2, le2.LinkCriteria.Filters.Count);
+            Assert.AreEqual(LogicalOperator.Or, le2.LinkCriteria.Filters[0].FilterOperator);
+            Assert.AreEqual(LogicalOperator.And, le2.LinkCriteria.Filters[1].FilterOperator);
         }
 
         [TestMethod]
-        public void ShouldCreateLink3()
+        public void ShouldAddEarlyBoundFiltersWithAnonymous()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId, JoinOperator.LeftOuter)
-                    .SetAlias("toto")
-                    .SetDefaultFilterOperator(LogicalOperator.Or)
-                    .Select());
+            var query = new Query<Account>().AddLink<Contact>(l => l.AddFilters(f1 => f1, f2 => f2));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.Count, 1);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkFromEntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkFromAttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkToAttributeName, Contact.Fields.ParentCustomerId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkToEntityName, Contact.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().EntityAlias, "toto");
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().JoinOperator, JoinOperator.LeftOuter);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.FilterOperator, LogicalOperator.Or);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().Columns.Columns.Count, 0);
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(LogicalOperator.And, le.LinkCriteria.FilterOperator);
+            Assert.AreEqual(2, le.LinkCriteria.Filters.Count);
+            Assert.AreEqual(LogicalOperator.And, le.LinkCriteria.Filters[0].FilterOperator);
+            Assert.AreEqual(LogicalOperator.And, le.LinkCriteria.Filters[1].FilterOperator);
         }
 
         [TestMethod]
-        public void ShouldCreateLink4()
+        public void ShouldAddEarlyBoundFilterWithAnonymous()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId, JoinOperator.LeftOuter)
-                    .SetAlias("toto")
-                    .SetDefaultFilterOperator(LogicalOperator.Or)
-                    .Select(Contact.Fields.FullName));
+            var query = new Query<Account>().AddLink<Contact>(l => l.AddFilter(f => f));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.Count, 1);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkFromEntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkFromAttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkToAttributeName, Contact.Fields.ParentCustomerId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkToEntityName, Contact.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().EntityAlias, "toto");
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().JoinOperator, JoinOperator.LeftOuter);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.FilterOperator, LogicalOperator.Or);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().Columns.Columns.First(), Contact.Fields.FullName);
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(LogicalOperator.And, le.LinkCriteria.FilterOperator);
+            Assert.AreEqual(1, le.LinkCriteria.Filters.Count);
+            Assert.AreEqual(LogicalOperator.And, le.LinkCriteria.Filters.First().FilterOperator);
         }
 
         [TestMethod]
-        public void ShouldCreateLinkNotGeneric()
+        public void ShouldAddLateBoundFilter()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link(Contact.EntityLogicalName, Contact.Fields.ParentCustomerId, Account.Fields.AccountId, JoinOperator.LeftOuter));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "accountid", "parentcustomerid").AddFilter(new Filter(LogicalOperator.Or)));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.Count, 1);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkFromEntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkFromAttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkToAttributeName, Contact.Fields.ParentCustomerId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkToEntityName, Contact.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().EntityAlias, Contact.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().JoinOperator, JoinOperator.LeftOuter);
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(LogicalOperator.And, le.LinkCriteria.FilterOperator);
+            Assert.AreEqual(1, le.LinkCriteria.Filters.Count);
+            Assert.AreEqual(LogicalOperator.Or, le.LinkCriteria.Filters.First().FilterOperator);
         }
 
-        #region Conditions
+        [TestMethod]
+        public void ShouldAddLateBoundFilters()
+        {
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "accountid", "parentcustomerid").AddFilters(new Filter(LogicalOperator.Or), new Filter(LogicalOperator.And)));
+
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(LogicalOperator.And, le.LinkCriteria.FilterOperator);
+            Assert.AreEqual(2, le.LinkCriteria.Filters.Count);
+            Assert.AreEqual(LogicalOperator.Or, le.LinkCriteria.Filters[0].FilterOperator);
+            Assert.AreEqual(LogicalOperator.And, le.LinkCriteria.Filters[1].FilterOperator);
+
+            var query2 = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "accountid", "parentcustomerid").AddFilters(new Filter(LogicalOperator.Or), new Filter(LogicalOperator.And)).SetLogicalOperator(LogicalOperator.Or));
+
+            var le2 = query2.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(LogicalOperator.Or, le2.LinkCriteria.FilterOperator);
+            Assert.AreEqual(2, le2.LinkCriteria.Filters.Count);
+            Assert.AreEqual(LogicalOperator.Or, le2.LinkCriteria.Filters[0].FilterOperator);
+            Assert.AreEqual(LogicalOperator.And, le2.LinkCriteria.Filters[1].FilterOperator);
+        }
+
+        [TestMethod]
+        public void ShouldAddMixEarlyLateBoundFilters()
+        {
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "accountid", "parentcustomerid").AddFilters(new Filter(LogicalOperator.Or), new Filter(LogicalOperator.And)));
+
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(LogicalOperator.And, le.LinkCriteria.FilterOperator);
+            Assert.AreEqual(2, le.LinkCriteria.Filters.Count);
+            Assert.AreEqual(LogicalOperator.Or, le.LinkCriteria.Filters[0].FilterOperator);
+            Assert.AreEqual(LogicalOperator.And, le.LinkCriteria.Filters[1].FilterOperator);
+        }
 
         [TestMethod]
-        public void ShouldCompareWhereEqual()
+        public void ShouldAddMixEarlyLateBoundFiltersWithObsoleteOperator()
+        {
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "accountid", "parentcustomerid").AddFilters(new Filter(LogicalOperator.Or), new Filter(LogicalOperator.And)).SetLogicalOperator(LogicalOperator.Or));
+
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(LogicalOperator.Or, le.LinkCriteria.FilterOperator);
+            Assert.AreEqual(2, le.LinkCriteria.Filters.Count);
+            Assert.AreEqual(LogicalOperator.Or, le.LinkCriteria.Filters[0].FilterOperator);
+            Assert.AreEqual(LogicalOperator.And, le.LinkCriteria.Filters[1].FilterOperator);
+        }
+
+        [TestMethod]
+        public void ShouldSetLogicalOperatorOr()
+        {
+            var query = new Query<Account>().AddLink<Contact>(l => l.SetLogicalOperator(LogicalOperator.Or));
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(LogicalOperator.Or, le.LinkCriteria.FilterOperator);
+
+            var query2 = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "accountid", "parentcustomerid").SetLogicalOperator(LogicalOperator.Or));
+            var le2 = query2.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(LogicalOperator.Or, le2.LinkCriteria.FilterOperator);
+        }
+
+        #endregion Filters
+
+        #region Columns Comparer
+
+        [TestMethod]
+        public void ShouldCompareWhereEqualEarlyBound()
+        {
+            var query = new Query<Account>().AddLink<Contact>(l => l.Compare(c => c.CreatedOn).Equal(c => c.ModifiedOn));
+
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.CreatedOn, le.LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, le.LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(Contact.Fields.ModifiedOn, le.LinkCriteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, le.LinkCriteria.Conditions.First().CompareColumns);
+        }
+
+        [TestMethod]
+        public void ShouldCompareWhereEqualLateBound()
+        {
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "accountid", "parentcustomerid").Compare(Contact.Fields.CreatedOn).Equal(Contact.Fields.ModifiedOn));
+
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.CreatedOn, le.LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, le.LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(Contact.Fields.ModifiedOn, le.LinkCriteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, le.LinkCriteria.Conditions.First().CompareColumns);
+        }
+
+        [TestMethod]
+        public void ShouldCompareWhereGreaterOrEqualThanEarlyBound()
+        {
+            var query = new Query<Account>().AddLink<Contact>(l => l.Compare(c => c.CreatedOn).GreaterOrEqualThan(c => c.ModifiedOn));
+
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.CreatedOn, le.LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, le.LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(Contact.Fields.ModifiedOn, le.LinkCriteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, le.LinkCriteria.Conditions.First().CompareColumns);
+        }
+
+        [TestMethod]
+        public void ShouldCompareWhereGreaterOrEqualThanLateBound()
+        {
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "accountid", "parentcustomerid").Compare(Contact.Fields.CreatedOn).GreaterOrEqualThan(Contact.Fields.ModifiedOn));
+
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.CreatedOn, le.LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, le.LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(Contact.Fields.ModifiedOn, le.LinkCriteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, le.LinkCriteria.Conditions.First().CompareColumns);
+        }
+
+        [TestMethod]
+        public void ShouldCompareWhereGreaterThanEarlyBound()
         {
             var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                    .Compare(Contact.Fields.NumberOfChildren).Equal(Contact.Fields.AnnualIncome));
+                .AddLink<Contact>(l => l.Compare(c => c.CreatedOn).GreaterThan(c => c.ModifiedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Contact.Fields.NumberOfChildren);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Equal);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), Contact.Fields.AnnualIncome);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().CompareColumns, true);
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.CreatedOn, le.LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, le.LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(Contact.Fields.ModifiedOn, le.LinkCriteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, le.LinkCriteria.Conditions.First().CompareColumns);
+        }
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                    .Compare(Contact.EntityLogicalName, Contact.Fields.NumberOfChildren).Equal(Contact.Fields.AnnualIncome));
+        [TestMethod]
+        public void ShouldCompareWhereGreaterThanLateBound()
+        {
+            var query = new Query(Account.EntityLogicalName)
+                .AddLink(new Link("contact", "accountid", "parentcustomerid").Compare(Contact.Fields.CreatedOn).GreaterThan(Contact.Fields.ModifiedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Contact.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Contact.Fields.NumberOfChildren);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Equal);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), Contact.Fields.AnnualIncome);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().CompareColumns, true);
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.CreatedOn, le.LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, le.LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(Contact.Fields.ModifiedOn, le.LinkCriteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, le.LinkCriteria.Conditions.First().CompareColumns);
         }
 
         [TestMethod]
-        public void ShouldCompareWhereGreaterOrEqualThan()
+        public void ShouldCompareWhereLessOrEqualThanEarlyBound()
         {
             var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                    .Compare(Contact.Fields.NumberOfChildren).GreaterOrEqualThan(Contact.Fields.AnnualIncome));
+                .AddLink<Contact>(l => l.Compare(c => c.CreatedOn).LessOrEqualThan(c => c.ModifiedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Contact.Fields.NumberOfChildren);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.GreaterEqual);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), Contact.Fields.AnnualIncome);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().CompareColumns, true);
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.CreatedOn, le.LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, le.LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(Contact.Fields.ModifiedOn, le.LinkCriteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, le.LinkCriteria.Conditions.First().CompareColumns);
+        }
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                    .Compare(Contact.EntityLogicalName, Contact.Fields.NumberOfChildren).GreaterOrEqualThan(Contact.Fields.AnnualIncome));
+        [TestMethod]
+        public void ShouldCompareWhereLessOrEqualThanLateBound()
+        {
+            var query = new Query(Account.EntityLogicalName)
+                .AddLink(new Link("contact", "accountid", "parentcustomerid").Compare(Contact.Fields.CreatedOn).LessOrEqualThan(Contact.Fields.ModifiedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Contact.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Contact.Fields.NumberOfChildren);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.GreaterEqual);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), Contact.Fields.AnnualIncome);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().CompareColumns, true);
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.CreatedOn, le.LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, le.LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(Contact.Fields.ModifiedOn, le.LinkCriteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, le.LinkCriteria.Conditions.First().CompareColumns);
         }
 
         [TestMethod]
-        public void ShouldCompareWhereGreaterThan()
+        public void ShouldCompareWhereLessThanEarlyBound()
         {
             var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                    .Compare(Contact.Fields.NumberOfChildren).GreaterThan(Contact.Fields.AnnualIncome));
+                .AddLink<Contact>(l => l.Compare(c => c.CreatedOn).LessThan(c => c.ModifiedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Contact.Fields.NumberOfChildren);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.GreaterThan);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), Contact.Fields.AnnualIncome);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().CompareColumns, true);
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.CreatedOn, le.LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, le.LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(Contact.Fields.ModifiedOn, le.LinkCriteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, le.LinkCriteria.Conditions.First().CompareColumns);
+        }
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                    .Compare(Contact.EntityLogicalName, Contact.Fields.NumberOfChildren).GreaterThan(Contact.Fields.AnnualIncome));
+        [TestMethod]
+        public void ShouldCompareWhereLessThanLateBound()
+        {
+            var query = new Query(Account.EntityLogicalName)
+                .AddLink(new Link("contact", "accountid", "parentcustomerid").Compare(Contact.Fields.CreatedOn).LessThan(Contact.Fields.ModifiedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Contact.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Contact.Fields.NumberOfChildren);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.GreaterThan);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), Contact.Fields.AnnualIncome);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().CompareColumns, true);
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.CreatedOn, le.LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, le.LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(Contact.Fields.ModifiedOn, le.LinkCriteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, le.LinkCriteria.Conditions.First().CompareColumns);
         }
 
         [TestMethod]
-        public void ShouldCompareWhereLessOrEqualThan()
+        public void ShouldCompareWhereNotEqualEarlyBound()
         {
             var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                    .Compare(Contact.Fields.NumberOfChildren).LessOrEqualThan(Contact.Fields.AnnualIncome));
+                .AddLink<Contact>(l => l.Compare(c => c.CreatedOn).NotEqual(c => c.ModifiedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Contact.Fields.NumberOfChildren);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LessEqual);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), Contact.Fields.AnnualIncome);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().CompareColumns, true);
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.CreatedOn, le.LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, le.LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(Contact.Fields.ModifiedOn, le.LinkCriteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, le.LinkCriteria.Conditions.First().CompareColumns);
+        }
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                    .Compare(Contact.EntityLogicalName, Contact.Fields.NumberOfChildren).LessOrEqualThan(Contact.Fields.AnnualIncome));
+        [TestMethod]
+        public void ShouldCompareWhereNotEqualLateBound()
+        {
+            var query = new Query(Account.EntityLogicalName)
+                .AddLink(new Link("contact", "accountid", "parentcustomerid").Compare(Contact.Fields.CreatedOn).NotEqual(Contact.Fields.ModifiedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Contact.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Contact.Fields.NumberOfChildren);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LessEqual);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), Contact.Fields.AnnualIncome);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().CompareColumns, true);
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.CreatedOn, le.LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, le.LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(Contact.Fields.ModifiedOn, le.LinkCriteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, le.LinkCriteria.Conditions.First().CompareColumns);
         }
 
+        #endregion Columns Comparer
+
+        #region Link Entities
+
         [TestMethod]
-        public void ShouldCompareWhereLessThan()
+        public void ShouldAddLinkEarlyBound()
         {
             var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                    .Compare(Contact.Fields.NumberOfChildren).LessThan(Contact.Fields.AnnualIncome));
+                .AddLink<Contact>(
+                    a => a.AccountId,
+                    c => c.ParentCustomerId,
+                    l => l
+                        .Select(c => new { c.FirstName, c.LastName })
+                        .AddLink<Task>(
+                            c => c.ContactId,
+                            t => t.RegardingObjectId,
+                            l2 => l2.Select(c => new { c.Subject }),
+                        JoinOperator.LeftOuter
+                    )
+                );
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Contact.Fields.NumberOfChildren);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LessThan);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), Contact.Fields.AnnualIncome);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().CompareColumns, true);
+            var innerLe = query.QueryExpression.LinkEntities.First().LinkEntities.First();
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.First().LinkEntities.Count);
+            Assert.AreEqual(Task.EntityLogicalName, innerLe.LinkToEntityName);
+            Assert.AreEqual(Task.Fields.RegardingObjectId, innerLe.LinkToAttributeName);
+            Assert.AreEqual(Contact.Fields.ContactId, innerLe.LinkFromAttributeName);
+            Assert.AreEqual(Contact.EntityLogicalName, innerLe.LinkFromEntityName);
+            Assert.AreEqual(Task.EntityLogicalName, innerLe.EntityAlias);
+            Assert.AreEqual(JoinOperator.LeftOuter, innerLe.JoinOperator);
+        }
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                    .Compare(Contact.EntityLogicalName, Contact.Fields.NumberOfChildren).LessThan(Contact.Fields.AnnualIncome));
+        [TestMethod]
+        public void ShouldAddLinkEarlyBoundWithLink()
+        {
+            var query = new Query<Account>()
+                .AddLink<Contact>(
+                    a => a.AccountId,
+                    c => c.ParentCustomerId,
+                    l => l
+                        .Select(c => new { c.FirstName, c.LastName })
+                        .AddLink(new Link<Contact, Task>(c => c.ContactId, t => t.RegardingObjectId)
+                    )
+                );
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Contact.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Contact.Fields.NumberOfChildren);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LessThan);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), Contact.Fields.AnnualIncome);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().CompareColumns, true);
+            var innerLe = query.QueryExpression.LinkEntities.First().LinkEntities.First();
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.First().LinkEntities.Count);
+            Assert.AreEqual(Task.EntityLogicalName, innerLe.LinkToEntityName);
+            Assert.AreEqual(Task.Fields.RegardingObjectId, innerLe.LinkToAttributeName);
+            Assert.AreEqual(Contact.Fields.ContactId, innerLe.LinkFromAttributeName);
+            Assert.AreEqual(Contact.EntityLogicalName, innerLe.LinkFromEntityName);
+            Assert.AreEqual(Task.EntityLogicalName, innerLe.EntityAlias);
+            Assert.AreEqual(JoinOperator.Inner, innerLe.JoinOperator);
         }
 
         [TestMethod]
-        public void ShouldCompareWhereNotEqual()
+        public void ShouldAddLinkEarlyBoundWithOuterLink()
         {
             var query = new Query<Account>()
-                    .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                        .Compare(Contact.Fields.NumberOfChildren).NotEqual(Contact.Fields.AnnualIncome));
+                 .AddLink<Contact>(
+                     a => a.AccountId,
+                     c => c.ParentCustomerId,
+                     l => l
+                         .Select(c => new { c.FirstName, c.LastName })
+                         .AddLink(new Link<Contact, Task>(c => c.ContactId, t => t.RegardingObjectId, JoinOperator.LeftOuter)
+                     )
+                 );
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Contact.Fields.NumberOfChildren);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotEqual);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), Contact.Fields.AnnualIncome);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().CompareColumns, true);
+            var innerLe = query.QueryExpression.LinkEntities.First().LinkEntities.First();
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.First().LinkEntities.Count);
+            Assert.AreEqual(Task.EntityLogicalName, innerLe.LinkToEntityName);
+            Assert.AreEqual(Task.Fields.RegardingObjectId, innerLe.LinkToAttributeName);
+            Assert.AreEqual(Contact.Fields.ContactId, innerLe.LinkFromAttributeName);
+            Assert.AreEqual(Contact.EntityLogicalName, innerLe.LinkFromEntityName);
+            Assert.AreEqual(Task.EntityLogicalName, innerLe.EntityAlias);
+            Assert.AreEqual(JoinOperator.LeftOuter, innerLe.JoinOperator);
+        }
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                    .Compare(Contact.EntityLogicalName, Contact.Fields.NumberOfChildren).NotEqual(Contact.Fields.AnnualIncome));
+        [TestMethod]
+        public void ShouldAddLinkEarlyBoundWithoutReturnedLink()
+        {
+            var query = new Query<Account>()
+                .AddLink<Contact>(
+                    a => a.AccountId,
+                    c => c.ParentCustomerId,
+                    l => l.AddLink<Task>(
+                            c => c.ContactId,
+                            t => t.RegardingObjectId,
+                            JoinOperator.LeftOuter
+                    )
+                );
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Contact.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Contact.Fields.NumberOfChildren);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotEqual);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), Contact.Fields.AnnualIncome);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().CompareColumns, true);
+            var innerLe = query.QueryExpression.LinkEntities.First().LinkEntities.First();
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.First().LinkEntities.Count);
+            Assert.AreEqual(Task.EntityLogicalName, innerLe.LinkToEntityName);
+            Assert.AreEqual(Task.Fields.RegardingObjectId, innerLe.LinkToAttributeName);
+            Assert.AreEqual(Contact.Fields.ContactId, innerLe.LinkFromAttributeName);
+            Assert.AreEqual(Contact.EntityLogicalName, innerLe.LinkFromEntityName);
+            Assert.AreEqual(Task.EntityLogicalName, innerLe.EntityAlias);
+            Assert.AreEqual(JoinOperator.LeftOuter, innerLe.JoinOperator);
         }
 
         [TestMethod]
-        public void ShouldSetWhere()
+        public void ShouldAddLinkLateBoundWithLink()
+        {
+            var query = new Query(Account.EntityLogicalName)
+                .AddLink(
+                    new Link(Contact.EntityLogicalName, Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
+                        .AddLink(Contact.Fields.ContactId, Task.EntityLogicalName, Task.Fields.RegardingObjectId)
+                );
+
+            var innerLe = query.QueryExpression.LinkEntities.First().LinkEntities.First();
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.First().LinkEntities.Count);
+            Assert.AreEqual(Task.EntityLogicalName, innerLe.LinkToEntityName);
+            Assert.AreEqual(Task.Fields.RegardingObjectId, innerLe.LinkToAttributeName);
+            Assert.AreEqual(Contact.Fields.ContactId, innerLe.LinkFromAttributeName);
+            Assert.AreEqual(Contact.EntityLogicalName, innerLe.LinkFromEntityName);
+            Assert.AreEqual(Task.EntityLogicalName, innerLe.EntityAlias);
+            Assert.AreEqual(JoinOperator.Inner, innerLe.JoinOperator);
+
+            var query2 = new Query(Account.EntityLogicalName)
+                .AddLink(
+                    new Link(Contact.EntityLogicalName, Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
+                        .AddLink(new Link(Task.EntityLogicalName, Task.Fields.RegardingObjectId, Contact.Fields.ContactId))
+                );
+
+            var innerLe2 = query2.QueryExpression.LinkEntities.First().LinkEntities.First();
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.First().LinkEntities.Count);
+            Assert.AreEqual(Task.EntityLogicalName, innerLe2.LinkToEntityName);
+            Assert.AreEqual(Task.Fields.RegardingObjectId, innerLe2.LinkToAttributeName);
+            Assert.AreEqual(Contact.Fields.ContactId, innerLe2.LinkFromAttributeName);
+            Assert.AreEqual(Contact.EntityLogicalName, innerLe2.LinkFromEntityName);
+            Assert.AreEqual(Task.EntityLogicalName, innerLe2.EntityAlias);
+            Assert.AreEqual(JoinOperator.Inner, innerLe2.JoinOperator);
+        }
+
+        [TestMethod]
+        public void ShouldAddLinkLateBoundWithOuterLink()
+        {
+            var query = new Query(Account.EntityLogicalName)
+                .AddLink(
+                    new Link(Contact.EntityLogicalName, Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
+                        .AddLink(Contact.Fields.ContactId, Task.EntityLogicalName, Task.Fields.RegardingObjectId, JoinOperator.LeftOuter)
+                );
+
+            var innerLe = query.QueryExpression.LinkEntities.First().LinkEntities.First();
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.First().LinkEntities.Count);
+            Assert.AreEqual(Task.EntityLogicalName, innerLe.LinkToEntityName);
+            Assert.AreEqual(Task.Fields.RegardingObjectId, innerLe.LinkToAttributeName);
+            Assert.AreEqual(Contact.Fields.ContactId, innerLe.LinkFromAttributeName);
+            Assert.AreEqual(Contact.EntityLogicalName, innerLe.LinkFromEntityName);
+            Assert.AreEqual(Task.EntityLogicalName, innerLe.EntityAlias);
+            Assert.AreEqual(JoinOperator.LeftOuter, innerLe.JoinOperator);
+        }
+
+        [TestMethod]
+        public void ShouldAddLinks()
         {
-            var guid = Guid.NewGuid();
             var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).Where(Account.Fields.AccountId, ConditionOperator.Above, guid));
+               .AddLink<Contact>(
+                   a => a.AccountId,
+                   c => c.ParentCustomerId,
+                   l => l
+                    .AddLink<Task>(
+                           c => c.ContactId,
+                           t => t.RegardingObjectId,
+                           JoinOperator.LeftOuter
+                    )
+                    .AddLink<Contact>(
+                           c => c.ContactId,
+                           parent => parent.ParentCustomerId,
+                           JoinOperator.LeftOuter
+                    )
+               );
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Above);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), guid);
+            var innerLes = query.QueryExpression.LinkEntities.First().LinkEntities;
+            Assert.AreEqual(2, innerLes.Count);
+            Assert.AreEqual(Task.EntityLogicalName, innerLes[0].LinkToEntityName);
+            Assert.AreEqual(Task.Fields.RegardingObjectId, innerLes[0].LinkToAttributeName);
+            Assert.AreEqual(Contact.Fields.ContactId, innerLes[0].LinkFromAttributeName);
+            Assert.AreEqual(Contact.EntityLogicalName, innerLes[0].LinkFromEntityName);
+            Assert.AreEqual(Task.EntityLogicalName, innerLes[0].EntityAlias);
+            Assert.AreEqual(Contact.EntityLogicalName, innerLes[1].LinkToEntityName);
+            Assert.AreEqual(Contact.Fields.ParentCustomerId, innerLes[1].LinkToAttributeName);
+            Assert.AreEqual(Contact.Fields.ContactId, innerLes[1].LinkFromAttributeName);
+            Assert.AreEqual(Contact.EntityLogicalName, innerLes[1].LinkFromEntityName);
+            Assert.AreEqual(Contact.EntityLogicalName, innerLes[1].EntityAlias);
+        }
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).Where(Account.EntityLogicalName, Account.Fields.AccountId, ConditionOperator.Above, guid));
+        #endregion Link Entities
+
+        #region Order
+
+        [TestMethod]
+        public void ShouldAddOrderEarlyBound()
+        {
+            var query = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.OrderBy(a => a.LastName));
+
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.LastName, le.Orders.First().AttributeName);
+            Assert.AreEqual(OrderType.Ascending, le.Orders.First().OrderType);
+
+            var query2 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.OrderByDescending(a => a.LastName));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Above);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), guid);
+            var le2 = query2.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.LastName, le2.Orders.First().AttributeName);
+            Assert.AreEqual(OrderType.Descending, le2.Orders.First().OrderType);
         }
 
         [TestMethod]
-        public void ShouldSetWhereAbove()
+        public void ShouldAddOrderLateBound()
+        {
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").OrderBy(Contact.Fields.LastName));
+
+            var le = query.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.LastName, le.Orders.First().AttributeName);
+            Assert.AreEqual(OrderType.Ascending, le.Orders.First().OrderType);
+
+            var query2 = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").OrderByDescending(Contact.Fields.LastName));
+
+            var le2 = query2.QueryExpression.LinkEntities.First();
+            Assert.AreEqual(Contact.Fields.LastName, le2.Orders.First().AttributeName);
+            Assert.AreEqual(OrderType.Descending, le2.Orders.First().OrderType);
+        }
+
+        #endregion Order
+
+        #region Conditions
+
+        [TestMethod]
+        public void ShouldSetWhere()
         {
             var guid = Guid.NewGuid();
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereAbove(Account.Fields.AccountId, guid));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").Where(Contact.Fields.ContactId, ConditionOperator.Above, guid));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Above);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Contact.Fields.ContactId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereAbove(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.Where(c => c.ContactId, ConditionOperator.Above, guid));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Above);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Contact.Fields.ContactId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
-        public void ShouldSetWhereAboveOrEqual()
+        public void ShouldSetWhereAbove()
         {
             var guid = Guid.NewGuid();
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereAboveOrEqual(Account.Fields.AccountId, guid));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereAbove(Contact.Fields.ContactId, guid));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.AboveOrEqual);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Contact.Fields.ContactId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereAboveOrEqual(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereAbove(c => c.ContactId, guid));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.AboveOrEqual);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Contact.Fields.ContactId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
-        public void ShouldSetWhereBeginsWith()
+        public void ShouldSetWhereAboveOrEqual()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereBeginsWith(Account.Fields.Name, "test"));
+            var guid = Guid.NewGuid();
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereAboveOrEqual(Contact.Fields.ContactId, guid));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.BeginsWith);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Contact.Fields.ContactId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.AboveOrEqual, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereBeginsWith(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereAboveOrEqual(c => c.ContactId, guid));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.BeginsWith);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Contact.Fields.ContactId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.AboveOrEqual, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
-        public void ShouldSetWhereBetween()
+        public void ShouldSetWhereBeginsWith()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereBetween(Account.Fields.NumberOfEmployees, 10, 50));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereBeginsWith(Contact.Fields.FirstName, "test"));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Between);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0], 10);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1], 50);
+            Assert.AreEqual(Contact.Fields.FirstName, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.BeginsWith, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereBetween(Account.Fields.NumberOfEmployees, 10, 50, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereBeginsWith(a => a.LastName, "test"));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Between);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0], 10);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1], 50);
+            Assert.AreEqual(Contact.Fields.LastName, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.BeginsWith, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
-        public void ShouldSetWhereChildOf()
+        public void ShouldSetWhereBetween()
         {
-            var guid = Guid.NewGuid();
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereChildOf(Account.Fields.AccountId, guid));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereBetween(Contact.Fields.AnnualIncome, 10, 50));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.ChildOf);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Contact.Fields.AnnualIncome, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Between, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0]);
+            Assert.AreEqual(50, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereChildOf(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereBetween(a => a.AnnualIncome, 10, 50));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.ChildOf);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Contact.Fields.AnnualIncome, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Between, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0]);
+            Assert.AreEqual(50, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1]);
         }
 
         [TestMethod]
         public void ShouldSetWhereContains()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereContains(Account.Fields.Name, "test"));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereContains(Contact.Fields.FirstName, "test"));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Contains);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Contact.Fields.FirstName, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Contains, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereContains(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereContains(a => a.FirstName, "test"));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Contains);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Contact.Fields.FirstName, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Contains, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereContainValues()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereContainValues(Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereContainValues(Account.Fields.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.ContainValues);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ContainValues, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(3));
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereContainValues(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereContainValues(a => a.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.ContainValues);
-            Assert.IsTrue(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(1));
-            Assert.IsTrue(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(2));
-            Assert.IsTrue(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(3));
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ContainValues, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.IsTrue(query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(1));
+            Assert.IsTrue(query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(2));
+            Assert.IsTrue(query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(3));
         }
 
         [TestMethod]
         public void ShouldSetWhereDoesNotBeginWith()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereDoesNotBeginWith(Account.Fields.Name, "test"));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereDoesNotBeginWith(Contact.Fields.FirstName, "test"));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.DoesNotBeginWith);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Contact.Fields.FirstName, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotBeginWith, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereDoesNotBeginWith(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereDoesNotBeginWith(a => a.FirstName, "test"));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.DoesNotBeginWith);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Contact.Fields.FirstName, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotBeginWith, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereDoesNotContain()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereDoesNotContain(Account.Fields.Name, "test"));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereDoesNotContain(Contact.Fields.FirstName, "test"));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.DoesNotContain);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Contact.Fields.FirstName, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContain, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereDoesNotContain(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereDoesNotContain(c => c.FirstName, "test"));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.DoesNotContain);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Contact.Fields.FirstName, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContain, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereDoesNotContainValues()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereDoesNotContainValues(Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereDoesNotContainValues(Contact.Fields.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.DoesNotContainValues);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContainValues, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(3));
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereDoesNotContainValues(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereDoesNotContainValues(a => a.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.DoesNotContainValues);
-            Assert.IsTrue(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(1));
-            Assert.IsTrue(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(2));
-            Assert.IsTrue(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(3));
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContainValues, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.IsTrue(query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(1));
+            Assert.IsTrue(query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(2));
+            Assert.IsTrue(query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(3));
         }
 
         [TestMethod]
         public void ShouldSetWhereDoesNotEndWith()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereDoesNotEndWith(Account.Fields.Name, "test"));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereDoesNotEndWith(Contact.Fields.FirstName, "test"));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.DoesNotEndWith);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Contact.Fields.FirstName, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotEndWith, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereDoesNotEndWith(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereDoesNotEndWith(c => c.FirstName, "test"));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.DoesNotEndWith);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Contact.Fields.FirstName, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotEndWith, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereEndsWith()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEndsWith(Account.Fields.Name, "test"));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereEndsWith(Contact.Fields.FirstName, "test"));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EndsWith);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Contact.Fields.FirstName, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EndsWith, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEndsWith(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereEndsWith(c => c.FirstName, "test"));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EndsWith);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Contact.Fields.FirstName, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EndsWith, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereEqual()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqual(Account.Fields.Name, "test"));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereEqual(Contact.Fields.FirstName, "test"));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Equal);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Contact.Fields.FirstName, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqual(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereEqual(c => c.FirstName, "test"));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Equal);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Contact.Fields.FirstName, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualBusinessId()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqualBusinessId(Account.Fields.OwningBusinessUnit));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereEqualBusinessId(Account.Fields.OwningBusinessUnit));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EqualBusinessId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualBusinessId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqualBusinessId(Account.Fields.OwningBusinessUnit, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereEqualBusinessId(a => a.OwningBusinessUnit));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EqualBusinessId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualBusinessId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserId()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqualUserId(Account.Fields.OwnerId));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereEqualUserId(Account.Fields.OwnerId));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EqualUserId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqualUserId(Account.Fields.OwnerId, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereEqualUserId(a => a.OwnerId));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EqualUserId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserLanguage()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqualUserLanguage("no_language_attribute"));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereEqualUserLanguage("no_language_attribute"));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, "no_language_attribute");
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EqualUserLanguage);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual("no_language_attribute", query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserLanguage, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqualUserLanguage("no_language_attribute", Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereEqualUserLanguage(c => c.AnnualIncome));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, "no_language_attribute");
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EqualUserLanguage);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.AnnualIncome, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserLanguage, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserOrUserHierarchy()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqualUserOrUserHierarchy(Account.Fields.OwnerId));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereEqualUserOrUserHierarchy(Account.Fields.OwnerId));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchy);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchy, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqualUserOrUserHierarchy(Account.Fields.OwnerId, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereEqualUserOrUserHierarchy(a => a.OwnerId));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchy);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchy, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserOrUserHierarchyAndTeams()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqualUserOrUserHierarchyAndTeams(Account.Fields.OwnerId));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereEqualUserOrUserHierarchyAndTeams(Account.Fields.OwnerId));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchyAndTeams);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchyAndTeams, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqualUserOrUserHierarchyAndTeams(Account.Fields.OwnerId, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereEqualUserOrUserHierarchyAndTeams(a => a.OwnerId));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchyAndTeams);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchyAndTeams, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserOrUserTeams()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqualUserOrUserTeams(Account.Fields.OwnerId));
-
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserTeams);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereEqualUserOrUserTeams(Account.Fields.OwnerId));
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqualUserOrUserTeams(Account.Fields.OwnerId, Account.EntityLogicalName));
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserTeams, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereEqualUserOrUserTeams(a => a.OwnerId));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserTeams);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserTeams, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserTeams()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqualUserTeams(Account.Fields.OwnerId));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereEqualUserTeams(Account.Fields.OwnerId));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EqualUserTeams);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserTeams, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereEqualUserTeams(Account.Fields.OwnerId, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereEqualUserTeams(a => a.OwnerId));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.EqualUserTeams);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserTeams, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereGreaterEqual()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereGreaterEqual(Account.Fields.NumberOfEmployees, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereGreaterEqual(Contact.Fields.AnnualIncome, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.GreaterEqual);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.AnnualIncome, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereGreaterEqual(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereGreaterEqual(c => c.AnnualIncome, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.GreaterEqual);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.AnnualIncome, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereGreaterThan()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereGreaterThan(Account.Fields.NumberOfEmployees, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereGreaterThan(Contact.Fields.AnnualIncome, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.GreaterThan);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.AnnualIncome, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereGreaterThan(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereGreaterThan(c => c.AnnualIncome, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.GreaterThan);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.AnnualIncome, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereIn()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereIn(Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereIn(Account.Fields.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.In);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(3));
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereIn(a => a.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.In);
-            Assert.IsTrue(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(1));
-            Assert.IsTrue(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(2));
-            Assert.IsTrue(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(3));
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.IsTrue(query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(1));
+            Assert.IsTrue(query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(2));
+            Assert.IsTrue(query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(3));
         }
 
         [TestMethod]
         public void ShouldSetWhereInFiscalPeriod()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereInFiscalPeriod(Account.Fields.CreatedOn, 1));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereInFiscalPeriod(Contact.Fields.CreatedOn, 1));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.InFiscalPeriod);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 1);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriod, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereInFiscalPeriod(Account.Fields.CreatedOn, 1, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereInFiscalPeriod(a => a.CreatedOn, 1));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.InFiscalPeriod);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 1);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriod, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereInFiscalPeriodAndYear()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereInFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereInFiscalPeriodAndYear(Contact.Fields.CreatedOn, 1, 2018));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.InFiscalPeriodAndYear);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriodAndYear, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereInFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereInFiscalPeriodAndYear(a => a.CreatedOn, 1, 2018));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.InFiscalPeriodAndYear);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriodAndYear, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1]);
         }
 
         [TestMethod]
         public void ShouldSetWhereInFiscalYear()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereInFiscalYear(Account.Fields.CreatedOn, 2018));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereInFiscalYear(Contact.Fields.CreatedOn, 2018));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.InFiscalYear);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 2018);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalYear, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(2018, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereInFiscalYear(Account.Fields.CreatedOn, 2018, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereInFiscalYear(a => a.CreatedOn, 2018));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.InFiscalYear);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 2018);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalYear, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(2018, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereInList()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                    .WhereIn(Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 }));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereIn(Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 }));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.In);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values is IList);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                    .WhereIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 }));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereIn(a => a.CustomerTypeCode, new List<int> { 1, 2, 3 }));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.In);
-            Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values is IList);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.IsTrue(query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values is IList);
         }
 
         [TestMethod]
         public void ShouldSetWhereInOrAfterFiscalPeriodAndYear()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereInOrAfterFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereInOrAfterFiscalPeriodAndYear(Contact.Fields.CreatedOn, 1, 2018));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.InOrAfterFiscalPeriodAndYear);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrAfterFiscalPeriodAndYear, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereInOrAfterFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereInOrAfterFiscalPeriodAndYear(a => a.CreatedOn, 1, 2018));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.InOrAfterFiscalPeriodAndYear);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrAfterFiscalPeriodAndYear, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1]);
         }
 
         [TestMethod]
         public void ShouldSetWhereInOrBeforeFiscalPeriodAndYear()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereInOrBeforeFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereInOrBeforeFiscalPeriodAndYear(Contact.Fields.CreatedOn, 1, 2018));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.InOrBeforeFiscalPeriodAndYear);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrBeforeFiscalPeriodAndYear, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereInOrBeforeFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereInOrBeforeFiscalPeriodAndYear(a => a.CreatedOn, 1, 2018));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.InOrBeforeFiscalPeriodAndYear);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrBeforeFiscalPeriodAndYear, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1]);
         }
 
         [TestMethod]
         public void ShouldSetWhereLast7Days()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLast7Days(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereLast7Days(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Last7Days);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Last7Days, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLast7Days(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLast7Days(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Last7Days);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Last7Days, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLastFiscalPeriod()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastFiscalPeriod(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereLastFiscalPeriod(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastFiscalPeriod);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalPeriod, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastFiscalPeriod(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLastFiscalPeriod(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastFiscalPeriod);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalPeriod, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLastFiscalYear()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastFiscalYear(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereLastFiscalYear(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastFiscalYear);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalYear, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastFiscalYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLastFiscalYear(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastFiscalYear);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalYear, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLastMonth()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastMonth(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereLastMonth(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastMonth);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastMonth, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastMonth(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLastMonth(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastMonth);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastMonth, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLastWeek()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastWeek(Account.Fields.CreatedOn));
-
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastWeek);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereLastWeek(Contact.Fields.CreatedOn));
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastWeek(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastWeek, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLastWeek(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastWeek);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastWeek, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXDays()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastXDays(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereLastXDays(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastXDays);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXDays, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastXDays(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLastXDays(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastXDays);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXDays, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXFiscalPeriods()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastXFiscalPeriods(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereLastXFiscalPeriods(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastXFiscalPeriods);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalPeriods, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastXFiscalPeriods(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLastXFiscalPeriods(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastXFiscalPeriods);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalPeriods, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXFiscalYears()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastXFiscalYears(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereLastXFiscalYears(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastXFiscalYears);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalYears, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastXFiscalYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLastXFiscalYears(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastXFiscalYears);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalYears, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXHours()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastXHours(Account.Fields.CreatedOn, 10));
-
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastXHours);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereLastXHours(Contact.Fields.CreatedOn, 10));
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastXHours(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXHours, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLastXHours(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastXHours);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXHours, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXMonths()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastXMonths(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereLastXMonths(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastXMonths);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXMonths, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastXMonths(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLastXMonths(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastXMonths);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXMonths, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXWeeks()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastXWeeks(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereLastXWeeks(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastXWeeks);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXWeeks, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastXWeeks(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLastXWeeks(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastXWeeks);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXWeeks, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXYears()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastXYears(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereLastXYears(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastXYears);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXYears, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastXYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLastXYears(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastXYears);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXYears, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastYear()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastYear(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereLastYear(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastYear);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastYear, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLastYear(a => a.CreatedOn));
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLastYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
-
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LastYear);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastYear, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLessEqual()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLessEqual(Account.Fields.NumberOfEmployees, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereLessEqual(Contact.Fields.AnnualIncome, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LessEqual);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.AnnualIncome, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLessEqual(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLessEqual(c => c.AnnualIncome, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LessEqual);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.AnnualIncome, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLessThan()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLessThan(Account.Fields.NumberOfEmployees, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereLessThan(Contact.Fields.AnnualIncome, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LessThan);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.AnnualIncome, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLessThan(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLessThan(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.LessThan);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLike()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLike(Account.Fields.Name, "%test%"));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereLike(Contact.Fields.FirstName, "%test%"));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Like);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Contact.Fields.FirstName, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Like, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("%test%", query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereLike(Account.Fields.Name, "%test%", Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereLike(c => c.FirstName, "%test%"));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Like);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Contact.Fields.FirstName, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Like, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("%test%", query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereMask()
         {
             var obj = new object();
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereMask(Account.Fields.Name, obj));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereMask(Contact.Fields.FirstName, obj));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Mask);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Contact.Fields.FirstName, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Mask, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(obj, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereMask(Account.Fields.Name, obj, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereMask(c => c.FirstName, obj));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Mask);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), obj);
-        }
-
-        [TestMethod]
-        public void ShouldSetWhereMasksSelect()
-        {
-            var obj = new object();
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereMasksSelect(Account.Fields.Name, obj));
-
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.MasksSelect);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), obj);
-
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereMasksSelect(Account.Fields.Name, obj, Account.EntityLogicalName));
-
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.MasksSelect);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Contact.Fields.FirstName, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Mask, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(obj, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNext7Days()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNext7Days(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereNext7Days(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Next7Days);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Next7Days, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNext7Days(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNext7Days(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Next7Days);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Next7Days, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNextFiscalPeriod()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextFiscalPeriod(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereNextFiscalPeriod(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextFiscalPeriod);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalPeriod, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextFiscalPeriod(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNextFiscalPeriod(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextFiscalPeriod);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalPeriod, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNextFiscalYear()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextFiscalYear(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereNextFiscalYear(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextFiscalYear);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalYear, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextFiscalYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNextFiscalYear(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextFiscalYear);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalYear, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNextMonth()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextMonth(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNextMonth(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextMonth);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextMonth, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextMonth(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNextMonth(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextMonth);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextMonth, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNextWeek()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextWeek(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereNextWeek(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextWeek);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextWeek, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextWeek(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNextWeek(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextWeek);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextWeek, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXDays()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextXDays(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereNextXDays(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextXDays);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXDays, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextXDays(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNextXDays(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextXDays);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXDays, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXFiscalPeriods()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextXFiscalPeriods(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid").WhereNextXFiscalPeriods(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextXFiscalPeriods);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalPeriods, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextXFiscalPeriods(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNextXFiscalPeriods(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextXFiscalPeriods);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalPeriods, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXFiscalYears()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextXFiscalYears(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNextXFiscalYears(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextXFiscalYears);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalYears, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextXFiscalYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNextXFiscalYears(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextXFiscalYears);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalYears, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXHours()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextXHours(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNextXHours(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextXHours);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXHours, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextXHours(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNextXHours(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextXHours);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXHours, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXMonths()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextXMonths(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNextXMonths(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextXMonths);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXMonths, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextXMonths(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNextXMonths(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextXMonths);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXMonths, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXWeeks()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextXWeeks(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNextXWeeks(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextXWeeks);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXWeeks, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextXWeeks(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNextXWeeks(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextXWeeks);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXWeeks, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXYears()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextXYears(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNextXYears(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextXYears);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXYears, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextXYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNextXYears(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextXYears);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXYears, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextYear()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextYear(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNextYear(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextYear);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextYear, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNextYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNextYear(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NextYear);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextYear, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotBetween()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotBetween(Account.Fields.NumberOfEmployees, 10, 50));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNotBetween(Contact.Fields.AnnualIncome, 10, 50));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotBetween);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0], 10);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1], 50);
+            Assert.AreEqual(Contact.Fields.AnnualIncome, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotBetween, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0]);
+            Assert.AreEqual(50, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotBetween(Account.Fields.NumberOfEmployees, 10, 50, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNotBetween(a => a.CreatedOn, 10, 50));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotBetween);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0], 10);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1], 50);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotBetween, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[0]);
+            Assert.AreEqual(50, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values[1]);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotEqual()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotEqual(Account.Fields.Name, "test"));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNotEqual(Contact.Fields.FirstName, "test"));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotEqual);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), "test");
+            Assert.AreEqual(Contact.Fields.FirstName, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotEqual(Account.Fields.Name, "test", Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNotEqual(c => c.FirstName, "test"));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotEqual);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), "test");
+            Assert.AreEqual(Contact.Fields.FirstName, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNotEqualBusinessId()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotEqualBusinessId(Account.Fields.OwningBusinessUnit));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNotEqualBusinessId(Account.Fields.OwningBusinessUnit));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotEqualBusinessId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualBusinessId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotEqualBusinessId(Account.Fields.OwningBusinessUnit, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNotEqualBusinessId(a => a.OwningBusinessUnit));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotEqualBusinessId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualBusinessId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotEqualUserId()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotEqualUserId(Account.Fields.OwnerId));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNotEqualUserId(Account.Fields.OwnerId));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotEqualUserId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualUserId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotEqualUserId(Account.Fields.OwnerId, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNotEqualUserId(a => a.OwnerId));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotEqualUserId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualUserId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotIn()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotIn(Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNotIn(Account.Fields.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotIn);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(3));
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNotIn(a => a.CustomerTypeCode, 1, 2, 3));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotIn);
-            Assert.IsTrue(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(1));
-            Assert.IsTrue(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(2));
-            Assert.IsTrue(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(3));
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.IsTrue(query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(1));
+            Assert.IsTrue(query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(2));
+            Assert.IsTrue(query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Contains(3));
         }
 
         [TestMethod]
         public void ShouldSetWhereNotInList()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                    .WhereNotIn(Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 }));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNotIn(Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 }));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotIn);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values is IList);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
-                    .WhereNotIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 }));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNotIn(a => a.CustomerTypeCode, new List<int> { 1, 2, 3 }));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotIn);
-            Assert.IsTrue(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values is IList);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.IsTrue(query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values is IList);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotLike()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotLike(Account.Fields.Name, "%test%"));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNotLike(Contact.Fields.FirstName, "%test%"));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotLike);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Contact.Fields.FirstName, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotLike, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("%test%", query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotLike(Account.Fields.Name, "%test%", Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNotLike(c => c.FirstName, "%test%"));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotLike);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Contact.Fields.FirstName, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotLike, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual("%test%", query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNotMask()
         {
             var obj = new object();
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotMask(Account.Fields.Name, obj));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNotMask(Contact.Fields.FirstName, obj));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotMask);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Contact.Fields.FirstName, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotMask, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(obj, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                 .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotMask(Account.Fields.Name, obj, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNotMask(c => c.FirstName, obj));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotMask);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Contact.Fields.FirstName, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotMask, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(obj, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNotNull()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotNull(Account.Fields.Name));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNotNull(Contact.Fields.FirstName));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotNull);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.FirstName, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotNull, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotNull(Account.Fields.Name, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNotNull(c => c.FirstName));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotNull);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.FirstName, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotNull, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotOn()
         {
             var date = new DateTime();
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotOn(Account.Fields.CreatedOn, date));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNotOn(Contact.Fields.CreatedOn, date));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotOn(Account.Fields.CreatedOn, date, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNotOn(a => a.CreatedOn, date));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNotUnder()
         {
-            var guid = new Guid();
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotUnder(Account.Fields.AccountId, guid));
+            var guid = Guid.NewGuid();
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNotUnder(Account.Fields.AccountId, guid));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotUnder);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotUnder, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNotUnder(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNotUnder(a => a.AccountId, guid));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.NotUnder);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotUnder, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNull()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNull(Account.Fields.Name));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereNull(Contact.Fields.FirstName));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Null);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.FirstName, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Null, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereNull(Account.Fields.Name, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereNull(c => c.FirstName));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Null);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.FirstName, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Null, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXDays()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOlderThanXDays(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereOlderThanXDays(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OlderThanXDays);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXDays, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOlderThanXDays(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereOlderThanXDays(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OlderThanXDays);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXDays, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXHours()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOlderThanXHours(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereOlderThanXHours(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OlderThanXHours);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXHours, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOlderThanXHours(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereOlderThanXHours(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OlderThanXHours);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXHours, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXMinutes()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOlderThanXMinutes(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereOlderThanXMinutes(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OlderThanXMinutes);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMinutes, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOlderThanXMinutes(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereOlderThanXMinutes(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OlderThanXMinutes);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMinutes, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXMonths()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOlderThanXMonths(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereOlderThanXMonths(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OlderThanXMonths);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMonths, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOlderThanXMonths(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereOlderThanXMonths(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OlderThanXMonths);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMonths, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXWeeks()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOlderThanXWeeks(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereOlderThanXWeeks(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OlderThanXWeeks);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXWeeks, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOlderThanXWeeks(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereOlderThanXWeeks(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OlderThanXWeeks);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXWeeks, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXYears()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOlderThanXYears(Account.Fields.CreatedOn, 10));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereOlderThanXYears(Contact.Fields.CreatedOn, 10));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OlderThanXYears);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXYears, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOlderThanXYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereOlderThanXYears(a => a.CreatedOn, 10));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OlderThanXYears);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXYears, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOn()
         {
             var date = new DateTime();
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOn(Account.Fields.CreatedOn, date));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereOn(Contact.Fields.CreatedOn, date));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.On);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.On, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOn(Account.Fields.CreatedOn, date, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereOn(a => a.CreatedOn, date));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.On);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.On, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOnOrAfter()
         {
             var date = new DateTime();
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOnOrAfter(Account.Fields.CreatedOn, date));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereOnOrAfter(Contact.Fields.CreatedOn, date));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OnOrAfter);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrAfter, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOnOrAfter(Account.Fields.CreatedOn, date, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereOnOrAfter(a => a.CreatedOn, date));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OnOrAfter);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrAfter, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOnOrBefore()
         {
             var date = new DateTime();
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOnOrBefore(Account.Fields.CreatedOn, date));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereOnOrBefore(Contact.Fields.CreatedOn, date));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OnOrBefore);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrBefore, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereOnOrBefore(Account.Fields.CreatedOn, date, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereOnOrBefore(a => a.CreatedOn, date));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.OnOrBefore);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrBefore, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereThisFiscalPeriod()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereThisFiscalPeriod(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereThisFiscalPeriod(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.ThisFiscalPeriod);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalPeriod, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereThisFiscalPeriod(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereThisFiscalPeriod(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.ThisFiscalPeriod);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalPeriod, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereThisFiscalYear()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereThisFiscalYear(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereThisFiscalYear(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.ThisFiscalYear);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalYear, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereThisFiscalYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereThisFiscalYear(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.ThisFiscalYear);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalYear, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereThisMonth()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereThisMonth(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereThisMonth(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.ThisMonth);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisMonth, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereThisMonth(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereThisMonth(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.ThisMonth);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisMonth, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereThisWeek()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereThisWeek(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereThisWeek(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.ThisWeek);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisWeek, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereThisWeek(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereThisWeek(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.ThisWeek);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisWeek, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereThisYear()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereThisYear(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereThisYear(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.ThisYear);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisYear, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereThisYear(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereThisYear(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.ThisYear);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisYear, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereToday()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereToday(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereToday(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Today);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Today, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereToday(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereToday(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Today);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Today, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereTomorrow()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereTomorrow(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereTomorrow(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Tomorrow);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Tomorrow, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereTomorrow(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereTomorrow(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Tomorrow);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Tomorrow, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereUnder()
         {
-            Guid guid = new Guid();
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereUnder(Account.Fields.AccountId, guid));
+            Guid guid = Guid.NewGuid();
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereUnder(Account.Fields.AccountId, guid));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Under);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Under, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereUnder(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereUnder(a => a.AccountId, guid));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Under);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Under, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereUnderOrEqual()
         {
-            Guid guid = new Guid();
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereUnderOrEqual(Account.Fields.AccountId, guid));
+            Guid guid = Guid.NewGuid();
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereUnderOrEqual(Account.Fields.AccountId, guid));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.UnderOrEqual);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.UnderOrEqual, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereUnderOrEqual(Account.Fields.AccountId, guid, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereUnderOrEqual(a => a.AccountId, guid));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.UnderOrEqual);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.UnderOrEqual, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereYesterday()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereYesterday(Account.Fields.CreatedOn));
+            var query = new Query(Account.EntityLogicalName).AddLink(new Link("contact", "parentcustomerid", "accountid")
+                .WhereYesterday(Contact.Fields.CreatedOn));
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Yesterday);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Yesterday, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId).WhereYesterday(Account.Fields.CreatedOn, Account.EntityLogicalName));
+            var query3 = new Query<Account>().AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l.WhereYesterday(a => a.CreatedOn));
 
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator, ConditionOperator.Yesterday);
-            Assert.AreEqual(query2.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Contact.Fields.CreatedOn, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Yesterday, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.LinkEntities.First().LinkCriteria.Conditions.First().Values.Count);
         }
 
         #endregion Conditions
diff --git a/MscrmTools.FluentQueryExpressions.Test/QueryExpressionTest.cs b/MscrmTools.FluentQueryExpressions.Test/QueryExpressionTest.cs
index 126195f..c1b8452 100644
--- a/MscrmTools.FluentQueryExpressions.Test/QueryExpressionTest.cs
+++ b/MscrmTools.FluentQueryExpressions.Test/QueryExpressionTest.cs
@@ -14,590 +14,887 @@ namespace MscrmTools.FluentQueryExpressions.Test
     [TestClass]
     [ExcludeFromCodeCoverage]
     public class QueryExpressionTest
+
     {
+        #region Query
+
         [TestMethod]
-        public void ShouldAddAllAttributes()
+        public void ShouldBeAccountQueryExpression()
         {
-            var query = new Query<Account>()
-                .Select(true);
+            var query = new Query<Account>();
 
-            Assert.AreEqual(query.QueryExpression.ColumnSet.AllColumns, true);
+            Assert.AreEqual(Account.EntityLogicalName, query.QueryExpression.EntityName);
         }
 
         [TestMethod]
-        public void ShouldAddAttributesWithAnonymousType()
+        public void ShouldBeDistinct()
         {
             var query = new Query<Account>()
-                .Select(a => new { a.Name, a.AccountNumber });
+                .Distinct();
 
-            Assert.IsTrue(query.QueryExpression.ColumnSet.Columns.Contains(Account.Fields.Name));
-            Assert.IsTrue(query.QueryExpression.ColumnSet.Columns.Contains(Account.Fields.AccountNumber));
+            Assert.AreEqual(true, query.QueryExpression.Distinct);
         }
 
         [TestMethod]
-        public void ShouldAddFilter()
+        public void ShouldCreateLateBound()
         {
-            var query = new Query<Account>()
-                .AddFilters(LogicalOperator.Or, new Filter(LogicalOperator.Or));
+            var query = new Query(Account.EntityLogicalName);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.FilterOperator, LogicalOperator.Or);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.Count, 1);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().FilterOperator, LogicalOperator.Or);
+            Assert.AreEqual(Account.EntityLogicalName, query.QueryExpression.EntityName);
         }
 
         [TestMethod]
-        public void ShouldAddFilterWithoutOperator()
+        public void ShouldHaveNoLock()
         {
             var query = new Query<Account>()
-                .AddFilters(new Filter(LogicalOperator.Or));
+                .NoLock();
 
-            Assert.AreEqual(query.QueryExpression.Criteria.FilterOperator, LogicalOperator.And);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.Count, 1);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().FilterOperator, LogicalOperator.Or);
+            Assert.AreEqual(true, query.QueryExpression.NoLock);
         }
 
         [TestMethod]
-        public void ShouldAddLink()
+        public void ShouldSetTop()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId));
+            var query = new Query<Account>().Top(100);
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.Count, 1);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkToEntityName, Contact.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkToAttributeName, Contact.Fields.ParentCustomerId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkFromAttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().LinkFromEntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities.First().EntityAlias, Contact.EntityLogicalName);
+            Assert.AreEqual(100, query.QueryExpression.TopCount);
         }
 
+        #endregion Query
+
+        #region Attributes
+
         [TestMethod]
-        public void ShouldAddLinks()
+        public void ShouldAddAllAttributes()
         {
-            var query = new Query<Account>()
-                .AddLink(new Link<Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId))
-                .AddLink(new Link<Task>(Task.Fields.RegardingObjectId, Account.Fields.AccountId));
+            var query = new Query<Account>().Select(true);
 
-            Assert.AreEqual(query.QueryExpression.LinkEntities.Count, 2);
-            Assert.AreEqual(query.QueryExpression.LinkEntities[0].LinkToEntityName, Contact.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities[0].LinkToAttributeName, Contact.Fields.ParentCustomerId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities[0].LinkFromAttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities[0].LinkFromEntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities[0].EntityAlias, Contact.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities[1].LinkToEntityName, Task.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities[1].LinkToAttributeName, Task.Fields.RegardingObjectId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities[1].LinkFromAttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.LinkEntities[1].LinkFromEntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query.QueryExpression.LinkEntities[1].EntityAlias, Task.EntityLogicalName);
+            Assert.AreEqual(true, query.QueryExpression.ColumnSet.AllColumns);
         }
 
         [TestMethod]
-        public void ShouldAddNoAttribute()
+        public void ShouldAddAttributesEarlyBound()
         {
-            var query = new Query<Account>()
-                .Select();
+            var query = new Query<Account>().Select(a => new { a.Name, a.AccountNumber });
 
-            Assert.AreEqual(query.QueryExpression.ColumnSet.AllColumns, false);
+            Assert.IsTrue(query.QueryExpression.ColumnSet.Columns.Contains(Account.Fields.Name));
+            Assert.IsTrue(query.QueryExpression.ColumnSet.Columns.Contains(Account.Fields.AccountNumber));
         }
 
         [TestMethod]
-        public void ShouldAddOneAttribute()
+        public void ShouldAddAttributesLateBound()
         {
-            var query = new Query<Account>()
-                .Select(Account.Fields.Name);
+            var query = new Query(Account.EntityLogicalName).Select(Account.Fields.Name, Account.Fields.AccountNumber);
 
             Assert.IsTrue(query.QueryExpression.ColumnSet.Columns.Contains(Account.Fields.Name));
+            Assert.IsTrue(query.QueryExpression.ColumnSet.Columns.Contains(Account.Fields.AccountNumber));
         }
 
         [TestMethod]
-        public void ShouldAddOrder()
+        public void ShouldAddNoAttributeEarlyBound()
         {
-            var query = new Query<Account>()
-                .Order(Account.Fields.Name, OrderType.Ascending);
+            var query = new Query<Account>().Select();
 
-            Assert.AreEqual(query.QueryExpression.Orders.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Orders.First().OrderType, OrderType.Ascending);
+            Assert.AreEqual(false, query.QueryExpression.ColumnSet.AllColumns);
         }
 
         [TestMethod]
-        public void ShouldAddPaging()
+        public void ShouldAddNoAttributeLateBound()
         {
-            var query = new Query<Account>()
-                .SetPagingInfo(1, 100, true);
+            var query = new Query(Account.EntityLogicalName).Select();
 
-            Assert.AreEqual(query.QueryExpression.PageInfo.PageNumber, 1);
-            Assert.AreEqual(query.QueryExpression.PageInfo.Count, 100);
-            Assert.AreEqual(query.QueryExpression.PageInfo.ReturnTotalRecordCount, true);
+            Assert.AreEqual(false, query.QueryExpression.ColumnSet.AllColumns);
         }
 
         [TestMethod]
-        public void ShouldAddTwoAttributes()
+        public void ShouldAddOneAttributeEarlyBound()
         {
-            var query = new Query<Account>()
-                .Select(Account.Fields.Name)
-                .Select(Account.Fields.AccountNumber);
+            var query = new Query<Account>().Select(a => a.Name);
+            Assert.IsTrue(query.QueryExpression.ColumnSet.Columns.Contains(Account.Fields.Name));
+
+            var query2 = new Query<Account>().Select(a => a.AccountId);
+            Assert.IsTrue(query2.QueryExpression.ColumnSet.Columns.Contains(Account.Fields.AccountId));
+        }
+
+        [TestMethod]
+        public void ShouldAddOneAttributeLateBound()
+        {
+            var query = new Query(Account.EntityLogicalName).Select(Account.Fields.Name);
 
             Assert.IsTrue(query.QueryExpression.ColumnSet.Columns.Contains(Account.Fields.Name));
-            Assert.IsTrue(query.QueryExpression.ColumnSet.Columns.Contains(Account.Fields.AccountNumber));
         }
 
+        #endregion Attributes
+
+        #region Filters
+
         [TestMethod]
-        public void ShouldAddTwoFilters()
+        public void ShouldAddEarlyBoundFilter()
         {
-            var query = new Query<Account>()
-                .AddFilters(LogicalOperator.Or,
-                    new Filter(LogicalOperator.Or),
-                    new Filter());
+            var query = new Query<Account>().AddFilter(new Filter<Account>(LogicalOperator.Or));
 
-            Assert.AreEqual(query.QueryExpression.Criteria.FilterOperator, LogicalOperator.Or);
-            Assert.AreEqual(query.QueryExpression.Criteria.Filters.Count, 2);
+            Assert.AreEqual(query.QueryExpression.Criteria.FilterOperator, LogicalOperator.And);
+            Assert.AreEqual(1, query.QueryExpression.Criteria.Filters.Count);
+            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().FilterOperator, LogicalOperator.Or);
+        }
+
+        [TestMethod]
+        public void ShouldAddEarlyBoundFilters()
+        {
+            var query = new Query<Account>().AddFilters(new Filter<Account>(LogicalOperator.Or), new Filter<Account>(LogicalOperator.And));
+
+            Assert.AreEqual(query.QueryExpression.Criteria.FilterOperator, LogicalOperator.And);
+            Assert.AreEqual(2, query.QueryExpression.Criteria.Filters.Count);
             Assert.AreEqual(query.QueryExpression.Criteria.Filters[0].FilterOperator, LogicalOperator.Or);
             Assert.AreEqual(query.QueryExpression.Criteria.Filters[1].FilterOperator, LogicalOperator.And);
         }
 
         [TestMethod]
-        public void ShouldBeAccountQueryExpression()
+        public void ShouldAddEarlyBoundFiltersWithAnonymous()
         {
-            var query = new Query<Account>();
+            var query = new Query<Account>().AddFilters(f1 => f1, f2 => f2);
 
-            Assert.AreEqual(query.QueryExpression.EntityName, Account.EntityLogicalName);
+            Assert.AreEqual(query.QueryExpression.Criteria.FilterOperator, LogicalOperator.And);
+            Assert.AreEqual(2, query.QueryExpression.Criteria.Filters.Count);
+            Assert.AreEqual(query.QueryExpression.Criteria.Filters[0].FilterOperator, LogicalOperator.And);
+            Assert.AreEqual(query.QueryExpression.Criteria.Filters[1].FilterOperator, LogicalOperator.And);
         }
 
         [TestMethod]
-        public void ShouldBeDistinct()
+        public void ShouldAddEarlyBoundFilterWithAnonymous()
         {
-            var query = new Query<Account>()
-                .Distinct();
+            var query = new Query<Account>().AddFilter(f => f);
 
-            Assert.AreEqual(query.QueryExpression.Distinct, true);
+            Assert.AreEqual(query.QueryExpression.Criteria.FilterOperator, LogicalOperator.And);
+            Assert.AreEqual(1, query.QueryExpression.Criteria.Filters.Count);
+            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().FilterOperator, LogicalOperator.And);
         }
 
         [TestMethod]
-        public void ShouldCreateLateBound()
+        public void ShouldAddLateBoundFilter()
         {
-            var query = new Query(Account.EntityLogicalName);
+            var query = new Query(Account.EntityLogicalName).AddFilter(new Filter(LogicalOperator.Or));
 
-            Assert.AreEqual(query.QueryExpression.EntityName, Account.EntityLogicalName);
+            Assert.AreEqual(query.QueryExpression.Criteria.FilterOperator, LogicalOperator.And);
+            Assert.AreEqual(1, query.QueryExpression.Criteria.Filters.Count);
+            Assert.AreEqual(query.QueryExpression.Criteria.Filters.First().FilterOperator, LogicalOperator.Or);
         }
 
         [TestMethod]
-        public void ShouldHaveNoLock()
+        public void ShouldAddLateBoundFilters()
         {
-            var query = new Query<Account>()
-                .NoLock();
+            var query = new Query(Account.EntityLogicalName).AddFilters(new Filter(LogicalOperator.Or), new Filter(LogicalOperator.And));
 
-            Assert.AreEqual(query.QueryExpression.NoLock, true);
+            Assert.AreEqual(query.QueryExpression.Criteria.FilterOperator, LogicalOperator.And);
+            Assert.AreEqual(2, query.QueryExpression.Criteria.Filters.Count);
+            Assert.AreEqual(query.QueryExpression.Criteria.Filters[0].FilterOperator, LogicalOperator.Or);
+            Assert.AreEqual(query.QueryExpression.Criteria.Filters[1].FilterOperator, LogicalOperator.And);
         }
 
         [TestMethod]
         public void ShouldSetLogicalOperatorOr()
         {
-            var query = new Query<Account>()
-                .SetDefaultFilterOperator(LogicalOperator.Or);
-
+            var query = new Query<Account>().SetLogicalOperator(LogicalOperator.Or);
             Assert.AreEqual(query.QueryExpression.Criteria.FilterOperator, LogicalOperator.Or);
+
+            var query2 = new Query(Account.EntityLogicalName).SetLogicalOperator(LogicalOperator.Or);
+            Assert.AreEqual(query2.QueryExpression.Criteria.FilterOperator, LogicalOperator.Or);
         }
 
+        #endregion Filters
+
+        #region Columns Comparer
+
         [TestMethod]
-        public void ShouldSetNextPage()
+        public void ShouldCompareWhereEqualEarlyBound()
         {
-            var query = new Query<Account>()
-                .SetPagingInfo(1, 100, true)
-                .NextPage("<fakePagingCookie>");
+            var query = new Query<Account>().Compare(a => a.NumberOfEmployees).Equal(a => a.Revenue);
+
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Conditions.First().CompareColumns);
+
+            var query2 = new Query<Account>().Compare(Account.EntityLogicalName, a => a.NumberOfEmployees).Equal(a => a.Revenue);
 
-            Assert.AreEqual(query.QueryExpression.PageInfo.PageNumber, 2);
-            Assert.AreEqual(query.QueryExpression.PageInfo.Count, 100);
-            Assert.AreEqual(query.QueryExpression.PageInfo.ReturnTotalRecordCount, true);
-            Assert.AreEqual(query.QueryExpression.PageInfo.PagingCookie, "<fakePagingCookie>");
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Conditions.First().CompareColumns);
         }
 
         [TestMethod]
-        public void ShouldSetTop()
+        public void ShouldCompareWhereEqualLateBound()
         {
-            var query = new Query<Account>()
-                .Top(100);
+            var query = new Query(Account.EntityLogicalName).Compare(Account.Fields.NumberOfEmployees).Equal(Account.Fields.Revenue);
 
-            Assert.AreEqual(query.QueryExpression.TopCount, 100);
-        }
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Conditions.First().CompareColumns);
 
-        #region Conditions
+            var query2 = new Query(Account.EntityLogicalName).Compare(Account.EntityLogicalName, Account.Fields.NumberOfEmployees).Equal(Account.Fields.Revenue);
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Conditions.First().CompareColumns);
+        }
 
         [TestMethod]
-        public void ShouldCompareWhereEqual()
+        public void ShouldCompareWhereGreaterOrEqualThanEarlyBound()
         {
-            var query = new Query<Account>()
-                .Compare(Account.Fields.NumberOfEmployees).Equal(Account.Fields.Revenue);
+            var query = new Query<Account>().Compare(a => a.NumberOfEmployees).GreaterOrEqualThan(a => a.Revenue);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Equal);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Conditions.First().CompareColumns);
 
-            var query2 = new Query<Account>()
-                .Compare(Account.EntityLogicalName, Account.Fields.NumberOfEmployees).Equal(Account.Fields.Revenue);
+            var query2 = new Query<Account>().Compare(Account.EntityLogicalName, a => a.NumberOfEmployees).GreaterOrEqualThan(a => a.Revenue);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Equal);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Conditions.First().CompareColumns);
         }
 
         [TestMethod]
-        public void ShouldCompareWhereGreaterOrEqualThan()
+        public void ShouldCompareWhereGreaterOrEqualThanLateBound()
         {
-            var query = new Query<Account>()
-                .Compare(Account.Fields.NumberOfEmployees).GreaterOrEqualThan(Account.Fields.Revenue);
+            var query = new Query(Account.EntityLogicalName).Compare(Account.Fields.NumberOfEmployees).GreaterOrEqualThan(Account.Fields.Revenue);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.GreaterEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Conditions.First().CompareColumns);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .Compare(Account.EntityLogicalName, Account.Fields.NumberOfEmployees).GreaterOrEqualThan(Account.Fields.Revenue);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.GreaterEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Conditions.First().CompareColumns);
         }
 
         [TestMethod]
-        public void ShouldCompareWhereGreaterThan()
+        public void ShouldCompareWhereGreaterThanEarlyBound()
         {
-            var query = new Query<Account>()
-                .Compare(Account.Fields.NumberOfEmployees).GreaterThan(Account.Fields.Revenue);
+            var query = new Query<Account>().Compare(a => a.NumberOfEmployees).GreaterThan(a => a.Revenue);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.GreaterThan);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Conditions.First().CompareColumns);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query<Account>().Compare(Account.EntityLogicalName, a => a.NumberOfEmployees).GreaterThan(a => a.Revenue);
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Conditions.First().CompareColumns);
+        }
+
+        [TestMethod]
+        public void ShouldCompareWhereGreaterThanLateBound()
+        {
+            var query = new Query(Account.EntityLogicalName).Compare(Account.EntityLogicalName, Account.Fields.NumberOfEmployees).GreaterThan(Account.Fields.Revenue);
+
+            Assert.AreEqual(Account.EntityLogicalName, query.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Conditions.First().CompareColumns);
+
+            var query2 = new Query(Account.EntityLogicalName)
                 .Compare(Account.EntityLogicalName, Account.Fields.NumberOfEmployees).GreaterThan(Account.Fields.Revenue);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.GreaterThan);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Conditions.First().CompareColumns);
         }
 
         [TestMethod]
-        public void ShouldCompareWhereLessOrEqualThan()
+        public void ShouldCompareWhereLessOrEqualThanEarlyBound()
         {
             var query = new Query<Account>()
-                .Compare(Account.Fields.NumberOfEmployees).LessOrEqualThan(Account.Fields.Revenue);
+                .Compare(a => a.NumberOfEmployees).LessOrEqualThan(a => a.Revenue);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LessEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Conditions.First().CompareColumns);
 
             var query2 = new Query<Account>()
-                .Compare(Account.EntityLogicalName, Account.Fields.NumberOfEmployees).LessOrEqualThan(Account.Fields.Revenue);
+                .Compare(Account.EntityLogicalName, a => a.NumberOfEmployees).LessOrEqualThan(a => a.Revenue);
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Conditions.First().CompareColumns);
+        }
+
+        [TestMethod]
+        public void ShouldCompareWhereLessOrEqualThanLateBound()
+        {
+            var query = new Query(Account.EntityLogicalName).Compare(Account.Fields.NumberOfEmployees).LessOrEqualThan(Account.Fields.Revenue);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LessEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Conditions.First().CompareColumns);
+
+            var query2 = new Query(Account.EntityLogicalName).Compare(Account.EntityLogicalName, Account.Fields.NumberOfEmployees).LessOrEqualThan(Account.Fields.Revenue);
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Conditions.First().CompareColumns);
         }
 
         [TestMethod]
-        public void ShouldCompareWhereLessThan()
+        public void ShouldCompareWhereLessThanEarlyBound()
         {
             var query = new Query<Account>()
-                .Compare(Account.Fields.NumberOfEmployees).LessThan(Account.Fields.Revenue);
+                .Compare(a => a.NumberOfEmployees).LessThan(a => a.Revenue);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LessThan);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Conditions.First().CompareColumns);
 
             var query2 = new Query<Account>()
+                .Compare(Account.EntityLogicalName, a => a.NumberOfEmployees).LessThan(a => a.Revenue);
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Conditions.First().CompareColumns);
+        }
+
+        [TestMethod]
+        public void ShouldCompareWhereLessThanLateBound()
+        {
+            var query = new Query(Account.EntityLogicalName)
+                .Compare(Account.Fields.NumberOfEmployees).LessThan(Account.Fields.Revenue);
+
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Conditions.First().CompareColumns);
+
+            var query2 = new Query(Account.EntityLogicalName)
                 .Compare(Account.EntityLogicalName, Account.Fields.NumberOfEmployees).LessThan(Account.Fields.Revenue);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LessThan);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Conditions.First().CompareColumns);
         }
 
         [TestMethod]
-        public void ShouldCompareWhereNotEqual()
+        public void ShouldCompareWhereNotEqualEarlyBound()
         {
             var query = new Query<Account>()
-                .Compare(Account.Fields.NumberOfEmployees).NotEqual(Account.Fields.Revenue);
+                .Compare(a => a.NumberOfEmployees).NotEqual(a => a.Revenue);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Conditions.First().CompareColumns);
 
             var query2 = new Query<Account>()
+                .Compare(Account.EntityLogicalName, a => a.NumberOfEmployees).NotEqual(a => a.Revenue);
+
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Conditions.First().CompareColumns);
+        }
+
+        [TestMethod]
+        public void ShouldCompareWhereNotEqualLateBound()
+        {
+            var query = new Query(Account.EntityLogicalName)
+                .Compare(Account.Fields.NumberOfEmployees).NotEqual(Account.Fields.Revenue);
+
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query.QueryExpression.Criteria.Conditions.First().CompareColumns);
+
+            var query2 = new Query(Account.EntityLogicalName)
                 .Compare(Account.EntityLogicalName, Account.Fields.NumberOfEmployees).NotEqual(Account.Fields.Revenue);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), Account.Fields.Revenue);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().CompareColumns, true);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(Account.Fields.Revenue, query2.QueryExpression.Criteria.Conditions.First().Values.First());
+            Assert.AreEqual(true, query2.QueryExpression.Criteria.Conditions.First().CompareColumns);
         }
 
+        #endregion Columns Comparer
+
+        #region Link Entities
+
+        [TestMethod]
+        public void ShouldAddLinkEarlyBound()
+        {
+            var query = new Query<Account>()
+                .AddLink<Contact>(
+                    a => a.AccountId,
+                    c => c.ParentCustomerId,
+                    l => l.Select(c => new { c.FirstName, c.LastName }),
+                    JoinOperator.LeftOuter
+                );
+
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.Count);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkToEntityName);
+            Assert.AreEqual(Contact.Fields.ParentCustomerId, query.QueryExpression.LinkEntities.First().LinkToAttributeName);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.LinkEntities.First().LinkFromAttributeName);
+            Assert.AreEqual(Account.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkFromEntityName);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().EntityAlias);
+            Assert.AreEqual(JoinOperator.LeftOuter, query.QueryExpression.LinkEntities.First().JoinOperator);
+        }
+
+        [TestMethod]
+        public void ShouldAddLinkEarlyBoundWithLink()
+        {
+            var query = new Query<Account>()
+                .AddLink(new Link<Account, Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
+                );
+
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.Count);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkToEntityName);
+            Assert.AreEqual(Contact.Fields.ParentCustomerId, query.QueryExpression.LinkEntities.First().LinkToAttributeName);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.LinkEntities.First().LinkFromAttributeName);
+            Assert.AreEqual(Account.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkFromEntityName);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().EntityAlias);
+            Assert.AreEqual(JoinOperator.Inner, query.QueryExpression.LinkEntities.First().JoinOperator);
+        }
+
+        [TestMethod]
+        public void ShouldAddLinkEarlyBoundWithOuterLink()
+        {
+            var query = new Query<Account>()
+                .AddLink(new Link<Account, Contact>(Contact.Fields.ParentCustomerId, Account.Fields.AccountId, JoinOperator.LeftOuter)
+                );
+
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.Count);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkToEntityName);
+            Assert.AreEqual(Contact.Fields.ParentCustomerId, query.QueryExpression.LinkEntities.First().LinkToAttributeName);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.LinkEntities.First().LinkFromAttributeName);
+            Assert.AreEqual(Account.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkFromEntityName);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().EntityAlias);
+            Assert.AreEqual(JoinOperator.LeftOuter, query.QueryExpression.LinkEntities.First().JoinOperator);
+        }
+
+        [TestMethod]
+        public void ShouldAddLinkEarlyBoundWithoutReturnedLink()
+        {
+            var query = new Query<Account>()
+                .AddLink<Contact>(
+                    a => a.AccountId,
+                    c => c.ParentCustomerId,
+                    JoinOperator.LeftOuter
+                );
+
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.Count);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkToEntityName);
+            Assert.AreEqual(Contact.Fields.ParentCustomerId, query.QueryExpression.LinkEntities.First().LinkToAttributeName);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.LinkEntities.First().LinkFromAttributeName);
+            Assert.AreEqual(Account.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkFromEntityName);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().EntityAlias);
+            Assert.AreEqual(JoinOperator.LeftOuter, query.QueryExpression.LinkEntities.First().JoinOperator);
+        }
+
+        [TestMethod]
+        public void ShouldAddLinkLateBoundWithLink()
+        {
+            var query = new Query(Account.EntityLogicalName)
+                .AddLink(
+                    new Link(Contact.EntityLogicalName, Contact.Fields.ParentCustomerId, Account.Fields.AccountId)
+                );
+
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.Count);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkToEntityName);
+            Assert.AreEqual(Contact.Fields.ParentCustomerId, query.QueryExpression.LinkEntities.First().LinkToAttributeName);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.LinkEntities.First().LinkFromAttributeName);
+            Assert.AreEqual(Account.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkFromEntityName);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().EntityAlias);
+            Assert.AreEqual(JoinOperator.Inner, query.QueryExpression.LinkEntities.First().JoinOperator);
+        }
+
+        [TestMethod]
+        public void ShouldAddLinkLateBoundWithOuterLink()
+        {
+            var query = new Query(Account.EntityLogicalName)
+                .AddLink(
+                    new Link(Contact.EntityLogicalName, Contact.Fields.ParentCustomerId, Account.Fields.AccountId, JoinOperator.LeftOuter)
+                );
+
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.Count);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkToEntityName);
+            Assert.AreEqual(Contact.Fields.ParentCustomerId, query.QueryExpression.LinkEntities.First().LinkToAttributeName);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.LinkEntities.First().LinkFromAttributeName);
+            Assert.AreEqual(Account.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkFromEntityName);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().EntityAlias);
+            Assert.AreEqual(JoinOperator.LeftOuter, query.QueryExpression.LinkEntities.First().JoinOperator);
+        }
+
+        [TestMethod]
+        public void ShouldAddLinkLateBoundWithParameters()
+        {
+            var query = new Query(Account.EntityLogicalName)
+                .AddLink(Account.Fields.AccountId, Contact.EntityLogicalName, Contact.Fields.ParentCustomerId);
+
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.Count);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkToEntityName);
+            Assert.AreEqual(Contact.Fields.ParentCustomerId, query.QueryExpression.LinkEntities.First().LinkToAttributeName);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.LinkEntities.First().LinkFromAttributeName);
+            Assert.AreEqual(Account.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkFromEntityName);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().EntityAlias);
+            Assert.AreEqual(JoinOperator.Inner, query.QueryExpression.LinkEntities.First().JoinOperator);
+        }
+
+        [TestMethod]
+        public void ShouldAddLinkLateBoundWithParametersOuter()
+        {
+            var query = new Query(Account.EntityLogicalName)
+                .AddLink(Account.Fields.AccountId, Contact.EntityLogicalName, Contact.Fields.ParentCustomerId, JoinOperator.LeftOuter);
+
+            Assert.AreEqual(1, query.QueryExpression.LinkEntities.Count);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkToEntityName);
+            Assert.AreEqual(Contact.Fields.ParentCustomerId, query.QueryExpression.LinkEntities.First().LinkToAttributeName);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.LinkEntities.First().LinkFromAttributeName);
+            Assert.AreEqual(Account.EntityLogicalName, query.QueryExpression.LinkEntities.First().LinkFromEntityName);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities.First().EntityAlias);
+            Assert.AreEqual(JoinOperator.LeftOuter, query.QueryExpression.LinkEntities.First().JoinOperator);
+        }
+
+        [TestMethod]
+        public void ShouldAddLinks()
+        {
+            var query = new Query<Account>()
+                 .AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId,
+                     l => l.Select(c => new { c.FirstName, c.LastName }),
+                     JoinOperator.LeftOuter
+                 )
+                 .AddLink<Task>(a => a.AccountId, t => t.RegardingObjectId,
+                     l => l.Select(t => new { t.Subject }),
+                     JoinOperator.LeftOuter
+                 );
+
+            Assert.AreEqual(2, query.QueryExpression.LinkEntities.Count);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities[0].LinkToEntityName);
+            Assert.AreEqual(Contact.Fields.ParentCustomerId, query.QueryExpression.LinkEntities[0].LinkToAttributeName);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.LinkEntities[0].LinkFromAttributeName);
+            Assert.AreEqual(Account.EntityLogicalName, query.QueryExpression.LinkEntities[0].LinkFromEntityName);
+            Assert.AreEqual(Contact.EntityLogicalName, query.QueryExpression.LinkEntities[0].EntityAlias);
+            Assert.AreEqual(Task.EntityLogicalName, query.QueryExpression.LinkEntities[1].LinkToEntityName);
+            Assert.AreEqual(Task.Fields.RegardingObjectId, query.QueryExpression.LinkEntities[1].LinkToAttributeName);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.LinkEntities[1].LinkFromAttributeName);
+            Assert.AreEqual(Account.EntityLogicalName, query.QueryExpression.LinkEntities[1].LinkFromEntityName);
+            Assert.AreEqual(Task.EntityLogicalName, query.QueryExpression.LinkEntities[1].EntityAlias);
+        }
+
+        #endregion Link Entities
+
+        #region Order
+
+        [TestMethod]
+        public void ShouldAddOrderEarlyBound()
+        {
+            var query = new Query<Account>().OrderByDescending(a => a.Name);
+
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Orders.First().AttributeName);
+            Assert.AreEqual(OrderType.Descending, query.QueryExpression.Orders.First().OrderType);
+
+            var query2 = new Query<Account>().OrderBy(a => a.Name);
+
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Orders.First().AttributeName);
+            Assert.AreEqual(OrderType.Ascending, query2.QueryExpression.Orders.First().OrderType);
+        }
+
+        [TestMethod]
+        public void ShouldAddOrderLateBound()
+        {
+            var query = new Query(Account.EntityLogicalName).OrderBy(Account.Fields.Name);
+
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Orders.First().AttributeName);
+            Assert.AreEqual(OrderType.Ascending, query.QueryExpression.Orders.First().OrderType);
+
+            var query2 = new Query(Account.EntityLogicalName).OrderByDescending(Account.Fields.Name);
+
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Orders.First().AttributeName);
+            Assert.AreEqual(OrderType.Descending, query2.QueryExpression.Orders.First().OrderType);
+        }
+
+        #endregion Order
+
+        #region Paging
+
+        [TestMethod]
+        public void ShouldAddPaging()
+        {
+            var query = new Query<Account>()
+                .SetPagingInfo(1, 100, true);
+
+            Assert.AreEqual(1, query.QueryExpression.PageInfo.PageNumber);
+            Assert.AreEqual(100, query.QueryExpression.PageInfo.Count);
+            Assert.AreEqual(true, query.QueryExpression.PageInfo.ReturnTotalRecordCount);
+        }
+
+        [TestMethod]
+        public void ShouldSetNextPage()
+        {
+            var query = new Query<Account>()
+                .SetPagingInfo(1, 100, true)
+                .NextPage("<fakePagingCookie>");
+
+            Assert.AreEqual(2, query.QueryExpression.PageInfo.PageNumber);
+            Assert.AreEqual(100, query.QueryExpression.PageInfo.Count);
+            Assert.AreEqual(true, query.QueryExpression.PageInfo.ReturnTotalRecordCount);
+            Assert.AreEqual("<fakePagingCookie>", query.QueryExpression.PageInfo.PagingCookie);
+        }
+
+        #endregion Paging
+
+        #region Conditions
+
         [TestMethod]
         public void ShouldSetWhere()
         {
             var guid = Guid.NewGuid();
-            var query = new Query<Account>().Where(Account.Fields.AccountId, ConditionOperator.Above, guid);
+            var query = new Query(Account.EntityLogicalName).Where(Account.Fields.AccountId, ConditionOperator.Above, guid);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Above);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.Criteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>().Where(Account.EntityLogicalName, Account.Fields.AccountId, ConditionOperator.Above, guid);
+            var query2 = new Query(Account.EntityLogicalName).Where(Account.EntityLogicalName, Account.Fields.AccountId, ConditionOperator.Above, guid);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Above);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query2.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query3 = new Query<Account>().Where(a => a.AccountId, ConditionOperator.Above, guid);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Above);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query4 = new Query<Account>().Where<Contact>(Contact.EntityLogicalName, a => a.FirstName, ConditionOperator.Equal, "Tanguy");
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Contact.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Contact.Fields.FirstName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Equal);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Single(), "Tanguy");
+            Assert.AreEqual(Contact.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Contact.Fields.FirstName, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("Tanguy", query4.QueryExpression.Criteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereAbove()
         {
             var guid = Guid.NewGuid();
-            var query = new Query<Account>().WhereAbove(Account.Fields.AccountId, guid);
+            var query = new Query(Account.EntityLogicalName).WhereAbove(Account.Fields.AccountId, guid);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Above);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.Criteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>().WhereAbove(Account.Fields.AccountId, guid, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereAbove(Account.Fields.AccountId, guid, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Above);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query2.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query3 = new Query<Account>().WhereAbove(a => a.AccountId, guid);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Above);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query4 = new Query<Account>().WhereAbove<Account>(Account.EntityLogicalName, a => a.AccountId, guid);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Above);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Above, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query4.QueryExpression.Criteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereAboveOrEqual()
         {
             var guid = Guid.NewGuid();
-            var query = new Query<Account>().WhereAboveOrEqual(Account.Fields.AccountId, guid);
+            var query = new Query(Account.EntityLogicalName).WhereAboveOrEqual(Account.Fields.AccountId, guid);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.AboveOrEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.AboveOrEqual, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.Criteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>().WhereAboveOrEqual(Account.Fields.AccountId, guid, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereAboveOrEqual(Account.Fields.AccountId, guid, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.AboveOrEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.AboveOrEqual, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query2.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query3 = new Query<Account>().WhereAboveOrEqual(a => a.AccountId, guid);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.AboveOrEqual);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.AboveOrEqual, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query4 = new Query<Account>().WhereAboveOrEqual<Account>(Account.EntityLogicalName, a => a.AccountId, guid);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.AboveOrEqual);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.AboveOrEqual, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query4.QueryExpression.Criteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereBeginsWith()
         {
-            var query = new Query<Account>().WhereBeginsWith(Account.Fields.Name, "test");
+            var query = new Query(Account.EntityLogicalName).WhereBeginsWith(Account.Fields.Name, "test");
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.BeginsWith);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.BeginsWith, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>().WhereBeginsWith(Account.Fields.Name, "test", Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereBeginsWith(Account.Fields.Name, "test", Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.BeginsWith);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.BeginsWith, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query3 = new Query<Account>().WhereBeginsWith(a => a.Name, "test");
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.BeginsWith);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.BeginsWith, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query4 = new Query<Account>().WhereBeginsWith<Account>(Account.EntityLogicalName, a => a.Name, "test");
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.BeginsWith);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.BeginsWith, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereBetween()
         {
-            var query = new Query<Account>().WhereBetween(Account.Fields.NumberOfEmployees, 10, 50);
+            var query = new Query(Account.EntityLogicalName).WhereBetween(Account.Fields.NumberOfEmployees, 10, 50);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Between);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values[0], 10);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values[1], 50);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Between, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(50, query.QueryExpression.Criteria.Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>().WhereBetween(Account.Fields.NumberOfEmployees, 10, 50, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereBetween(Account.Fields.NumberOfEmployees, 10, 50, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Between);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values[0], 10);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values[1], 50);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Between, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(50, query2.QueryExpression.Criteria.Conditions.First().Values[1]);
 
             var query3 = new Query<Account>().WhereBetween(a => a.NumberOfEmployees, 10, 50);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Between);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values[0], 10);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values[1], 50);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Between, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(50, query3.QueryExpression.Criteria.Conditions.First().Values[1]);
 
             var query4 = new Query<Account>().WhereBetween<Account>(Account.EntityLogicalName, a => a.NumberOfEmployees, 10, 50);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Between);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values[0], 10);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values[1], 50);
-        }
-
-        [TestMethod]
-        public void ShouldSetWhereChildOf()
-        {
-            var guid = Guid.NewGuid();
-            var query = new Query<Account>().WhereChildOf(Account.Fields.AccountId, guid);
-
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ChildOf);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Single(), guid);
-
-            var query2 = new Query<Account>().WhereChildOf(Account.Fields.AccountId, guid, Account.EntityLogicalName);
-
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ChildOf);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Single(), guid);
-
-            var query3 = new Query<Account>().WhereChildOf(a => a.AccountId, guid);
-
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ChildOf);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Single(), guid);
-
-            var query4 = new Query<Account>().WhereChildOf<Account>(Account.EntityLogicalName, a => a.AccountId, guid);
-
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ChildOf);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Single(), guid);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Between, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(50, query4.QueryExpression.Criteria.Conditions.First().Values[1]);
         }
 
         [TestMethod]
         public void ShouldSetWhereContains()
         {
-            var query = new Query<Account>().WhereContains(Account.Fields.Name, "test");
+            var query = new Query(Account.EntityLogicalName).WhereContains(Account.Fields.Name, "test");
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Contains);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Contains, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>().WhereContains(Account.Fields.Name, "test", Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereContains(Account.Fields.Name, "test", Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Contains);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Contains, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query3 = new Query<Account>().WhereContains(a => a.Name, "test");
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Contains);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Contains, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query4 = new Query<Account>().WhereContains<Account>(Account.EntityLogicalName, a => a.Name, "test");
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Contains);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Contains, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereContainValues()
         {
-            var query = new Query<Account>().WhereContainValues(Account.Fields.CustomerTypeCode, 1, 2, 3);
+            var query = new Query(Account.EntityLogicalName).WhereContainValues(Account.Fields.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ContainValues);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ContainValues, query.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
 
-            var query2 = new Query<Account>().WhereContainValues(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3);
+            var query2 = new Query(Account.EntityLogicalName).WhereContainValues(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ContainValues);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ContainValues, query2.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query2.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query2.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query2.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
 
             var query3 = new Query<Account>().WhereContainValues(a => a.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ContainValues);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ContainValues, query3.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query3.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query3.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query3.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
 
             var query4 = new Query<Account>().WhereContainValues<Account>(Account.EntityLogicalName, a => a.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ContainValues);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ContainValues, query4.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query4.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query4.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query4.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
@@ -606,96 +903,96 @@ public void ShouldSetWhereContainValues()
         [TestMethod]
         public void ShouldSetWhereDoesNotBeginWith()
         {
-            var query = new Query<Account>().WhereDoesNotBeginWith(Account.Fields.Name, "test");
+            var query = new Query(Account.EntityLogicalName).WhereDoesNotBeginWith(Account.Fields.Name, "test");
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotBeginWith);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotBeginWith, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>().WhereDoesNotBeginWith(Account.Fields.Name, "test", Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereDoesNotBeginWith(Account.Fields.Name, "test", Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotBeginWith);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotBeginWith, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query3 = new Query<Account>().WhereDoesNotBeginWith(a => a.Name, "test");
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotBeginWith);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotBeginWith, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query4 = new Query<Account>().WhereDoesNotBeginWith<Account>(Account.EntityLogicalName, a => a.Name, "test");
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotBeginWith);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotBeginWith, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereDoesNotContain()
         {
-            var query = new Query<Account>().WhereDoesNotContain(Account.Fields.Name, "test");
+            var query = new Query(Account.EntityLogicalName).WhereDoesNotContain(Account.Fields.Name, "test");
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotContain);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContain, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>().WhereDoesNotContain(Account.Fields.Name, "test", Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereDoesNotContain(Account.Fields.Name, "test", Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotContain);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContain, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query3 = new Query<Account>().WhereDoesNotContain(a => a.Name, "test");
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotContain);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContain, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query4 = new Query<Account>().WhereDoesNotContain<Account>(Account.EntityLogicalName, a => a.Name, "test");
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotContain);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContain, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereDoesNotContainValues()
         {
-            var query = new Query<Account>().WhereDoesNotContainValues(Account.Fields.CustomerTypeCode, 1, 2, 3);
+            var query = new Query(Account.EntityLogicalName).WhereDoesNotContainValues(Account.Fields.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotContainValues);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContainValues, query.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
 
-            var query2 = new Query<Account>().WhereDoesNotContainValues(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3);
+            var query2 = new Query(Account.EntityLogicalName).WhereDoesNotContainValues(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotContainValues);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContainValues, query2.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query2.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query2.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query2.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
 
             var query3 = new Query<Account>().WhereDoesNotContainValues(a => a.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotContainValues);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContainValues, query3.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query3.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query3.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query3.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
 
             var query4 = new Query<Account>().WhereDoesNotContainValues<Account>(Account.EntityLogicalName, a => a.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotContainValues);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotContainValues, query4.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query4.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query4.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query4.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
@@ -704,396 +1001,396 @@ public void ShouldSetWhereDoesNotContainValues()
         [TestMethod]
         public void ShouldSetWhereDoesNotEndWith()
         {
-            var query = new Query<Account>().WhereDoesNotEndWith(Account.Fields.Name, "test");
+            var query = new Query(Account.EntityLogicalName).WhereDoesNotEndWith(Account.Fields.Name, "test");
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotEndWith);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotEndWith, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>().WhereDoesNotEndWith(Account.Fields.Name, "test", Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereDoesNotEndWith(Account.Fields.Name, "test", Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotEndWith);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotEndWith, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query3 = new Query<Account>().WhereDoesNotEndWith(a => a.Name, "test");
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotEndWith);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotEndWith, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query4 = new Query<Account>().WhereDoesNotEndWith<Account>(Account.EntityLogicalName, a => a.Name, "test");
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.DoesNotEndWith);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.DoesNotEndWith, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereEndsWith()
         {
-            var query = new Query<Account>().WhereEndsWith(Account.Fields.Name, "test");
+            var query = new Query(Account.EntityLogicalName).WhereEndsWith(Account.Fields.Name, "test");
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EndsWith);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EndsWith, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>().WhereEndsWith(Account.Fields.Name, "test", Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereEndsWith(Account.Fields.Name, "test", Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EndsWith);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EndsWith, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query3 = new Query<Account>().WhereEndsWith(a => a.Name, "test");
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EndsWith);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EndsWith, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query4 = new Query<Account>().WhereEndsWith<Account>(Account.EntityLogicalName, a => a.Name, "test");
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EndsWith);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EndsWith, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereEqual()
         {
-            var query = new Query<Account>().WhereEqual(Account.Fields.Name, "test");
+            var query = new Query(Account.EntityLogicalName).WhereEqual(Account.Fields.Name, "test");
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Equal);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Conditions.First().Values.Single());
 
-            var query2 = new Query<Account>().WhereEqual(Account.Fields.Name, "test", Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereEqual(Account.Fields.Name, "test", Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Equal);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query3 = new Query<Account>().WhereEqual(a => a.Name, "test");
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Equal);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query4 = new Query<Account>().WhereEqual<Account>(Account.EntityLogicalName, a => a.Name, "test");
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Equal);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Single(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Equal, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualBusinessId()
         {
-            var query = new Query<Account>().WhereEqualBusinessId(Account.Fields.OwningBusinessUnit);
+            var query = new Query(Account.EntityLogicalName).WhereEqualBusinessId(Account.Fields.OwningBusinessUnit);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualBusinessId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualBusinessId, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereEqualBusinessId(Account.Fields.OwningBusinessUnit, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereEqualBusinessId(Account.Fields.OwningBusinessUnit, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualBusinessId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualBusinessId, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereEqualBusinessId(a => a.OwningBusinessUnit);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualBusinessId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualBusinessId, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereEqualBusinessId<Account>(Account.EntityLogicalName, a => a.OwningBusinessUnit);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualBusinessId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualBusinessId, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserId()
         {
-            var query = new Query<Account>().WhereEqualUserId(Account.Fields.OwnerId);
+            var query = new Query(Account.EntityLogicalName).WhereEqualUserId(Account.Fields.OwnerId);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserId, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereEqualUserId(Account.Fields.OwnerId, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereEqualUserId(Account.Fields.OwnerId, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserId, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereEqualUserId(a => a.OwnerId);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserId, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereEqualUserId<Account>(Account.EntityLogicalName, a => a.OwnerId);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserId, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserLanguage()
         {
-            var query = new Query<Account>().WhereEqualUserLanguage("no_language_attribute");
+            var query = new Query(Account.EntityLogicalName).WhereEqualUserLanguage("no_language_attribute");
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, "no_language_attribute");
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserLanguage);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual("no_language_attribute", query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserLanguage, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereEqualUserLanguage("no_language_attribute", Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereEqualUserLanguage("no_language_attribute", Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, "no_language_attribute");
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserLanguage);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual("no_language_attribute", query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserLanguage, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereEqualUserLanguage(a => a.NumberOfEmployees);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserLanguage);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserLanguage, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereEqualUserLanguage<Account>(Account.EntityLogicalName, a => a.NumberOfEmployees);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserLanguage);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserLanguage, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserOrUserHierarchy()
         {
-            var query = new Query<Account>().WhereEqualUserOrUserHierarchy(Account.Fields.OwnerId);
+            var query = new Query(Account.EntityLogicalName).WhereEqualUserOrUserHierarchy(Account.Fields.OwnerId);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchy);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchy, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereEqualUserOrUserHierarchy(Account.Fields.OwnerId, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereEqualUserOrUserHierarchy(Account.Fields.OwnerId, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchy);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchy, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereEqualUserOrUserHierarchy(a => a.OwnerId);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchy);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchy, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereEqualUserOrUserHierarchy<Account>(Account.EntityLogicalName, a => a.OwnerId);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchy);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchy, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserOrUserHierarchyAndTeams()
         {
-            var query = new Query<Account>().WhereEqualUserOrUserHierarchyAndTeams(Account.Fields.OwnerId);
+            var query = new Query(Account.EntityLogicalName).WhereEqualUserOrUserHierarchyAndTeams(Account.Fields.OwnerId);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchyAndTeams);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchyAndTeams, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereEqualUserOrUserHierarchyAndTeams(Account.Fields.OwnerId, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereEqualUserOrUserHierarchyAndTeams(Account.Fields.OwnerId, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchyAndTeams);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchyAndTeams, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereEqualUserOrUserHierarchyAndTeams(a => a.OwnerId);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchyAndTeams);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchyAndTeams, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereEqualUserOrUserHierarchyAndTeams<Account>(Account.EntityLogicalName, a => a.OwnerId);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserHierarchyAndTeams);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserHierarchyAndTeams, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserOrUserTeams()
         {
-            var query = new Query<Account>().WhereEqualUserOrUserTeams(Account.Fields.OwnerId);
+            var query = new Query(Account.EntityLogicalName).WhereEqualUserOrUserTeams(Account.Fields.OwnerId);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserTeams);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserTeams, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereEqualUserOrUserTeams(Account.Fields.OwnerId, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereEqualUserOrUserTeams(Account.Fields.OwnerId, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserTeams);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserTeams, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereEqualUserOrUserTeams(a => a.OwnerId);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserTeams);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserTeams, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereEqualUserOrUserTeams<Account>(Account.EntityLogicalName, a => a.OwnerId);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserOrUserTeams);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserOrUserTeams, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereEqualUserTeams()
         {
-            var query = new Query<Account>().WhereEqualUserTeams(Account.Fields.OwnerId);
+            var query = new Query(Account.EntityLogicalName).WhereEqualUserTeams(Account.Fields.OwnerId);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserTeams);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserTeams, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereEqualUserTeams(Account.Fields.OwnerId, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereEqualUserTeams(Account.Fields.OwnerId, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserTeams);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserTeams, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereEqualUserTeams(a => a.OwnerId);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserTeams);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserTeams, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereEqualUserTeams<Account>(Account.EntityLogicalName, a => a.OwnerId);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.EqualUserTeams);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.EqualUserTeams, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereGreaterEqual()
         {
-            var query = new Query<Account>().WhereGreaterEqual(Account.Fields.NumberOfEmployees, 10);
+            var query = new Query(Account.EntityLogicalName).WhereGreaterEqual(Account.Fields.NumberOfEmployees, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.GreaterEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>().WhereGreaterEqual(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereGreaterEqual(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.GreaterEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereGreaterEqual(a => a.NumberOfEmployees, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.GreaterEqual);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Single(), 10);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query4 = new Query<Account>().WhereGreaterEqual<Account>(Account.EntityLogicalName, a => a.NumberOfEmployees, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.GreaterEqual);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Single(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterEqual, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereGreaterThan()
         {
-            var query = new Query<Account>().WhereGreaterThan(Account.Fields.NumberOfEmployees, 10);
+            var query = new Query(Account.EntityLogicalName).WhereGreaterThan(Account.Fields.NumberOfEmployees, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.GreaterThan);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>().WhereGreaterThan(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereGreaterThan(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.GreaterThan);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereGreaterThan(a => a.NumberOfEmployees, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.GreaterThan);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Single(), 10);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.Single());
 
             var query4 = new Query<Account>().WhereGreaterThan<Account>(Account.EntityLogicalName, a => a.NumberOfEmployees, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.GreaterThan);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Single(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.GreaterThan, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.Single());
         }
 
         [TestMethod]
         public void ShouldSetWhereIn()
         {
-            var query = new Query<Account>().WhereIn(Account.Fields.CustomerTypeCode, 1, 2, 3);
+            var query = new Query(Account.EntityLogicalName).WhereIn(Account.Fields.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.In);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
 
-            var query2 = new Query<Account>().WhereIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3);
+            var query2 = new Query(Account.EntityLogicalName).WhereIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.In);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query2.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query2.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query2.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query2.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
 
             var query3 = new Query<Account>().WhereIn(a => a.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.In);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query3.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query3.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query3.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query3.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
 
-            var query4 = new Query<Account>().WhereIn<Account>(Account.EntityLogicalName, a => a.CustomerTypeCode, 1, 2, 3);
+            var query4 = new Query<Account>().WhereIn(Account.EntityLogicalName, a => a.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.In);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query4.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query4.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query4.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query4.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
@@ -1102,1314 +1399,1281 @@ public void ShouldSetWhereIn()
         [TestMethod]
         public void ShouldSetWhereInFiscalPeriod()
         {
-            var query = new Query<Account>().WhereInFiscalPeriod(Account.Fields.CreatedOn, 1);
+            var query = new Query(Account.EntityLogicalName).WhereInFiscalPeriod(Account.Fields.CreatedOn, 1);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InFiscalPeriod);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 1);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriod, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>().WhereInFiscalPeriod(Account.Fields.CreatedOn, 1, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereInFiscalPeriod(Account.Fields.CreatedOn, 1, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InFiscalPeriod);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 1);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriod, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereInFiscalPeriod(a => a.CreatedOn, 1);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InFiscalPeriod);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 1);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriod, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereInFiscalPeriod<Account>(Account.EntityLogicalName, a => a.CreatedOn, 1);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InFiscalPeriod);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 1);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriod, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereInFiscalPeriodAndYear()
         {
-            var query = new Query<Account>()
-                .WhereInFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018);
+            var query = new Query(Account.EntityLogicalName).WhereInFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InFiscalPeriodAndYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriodAndYear, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query.QueryExpression.Criteria.Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>()
-                .WhereInFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereInFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InFiscalPeriodAndYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriodAndYear, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query2.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query2.QueryExpression.Criteria.Conditions.First().Values[1]);
 
             var query3 = new Query<Account>().WhereInFiscalPeriodAndYear(a => a.CreatedOn, 1, 2018);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InFiscalPeriodAndYear);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriodAndYear, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query3.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query3.QueryExpression.Criteria.Conditions.First().Values[1]);
 
             var query4 = new Query<Account>().WhereInFiscalPeriodAndYear<Account>(Account.EntityLogicalName, a => a.CreatedOn, 1, 2018);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InFiscalPeriodAndYear);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalPeriodAndYear, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query4.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query4.QueryExpression.Criteria.Conditions.First().Values[1]);
         }
 
         [TestMethod]
         public void ShouldSetWhereInFiscalYear()
         {
-            var query = new Query<Account>().WhereInFiscalYear(Account.Fields.CreatedOn, 2018);
+            var query = new Query(Account.EntityLogicalName).WhereInFiscalYear(Account.Fields.CreatedOn, 2018);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InFiscalYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 2018);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalYear, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(2018, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>().WhereInFiscalYear(Account.Fields.CreatedOn, 2018, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereInFiscalYear(Account.Fields.CreatedOn, 2018, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InFiscalYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 2018);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalYear, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(2018, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereInFiscalYear(a => a.CreatedOn, 2018);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InFiscalYear);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 2018);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalYear, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(2018, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereInFiscalYear<Account>(Account.EntityLogicalName, a => a.CreatedOn, 2018);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InFiscalYear);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 2018);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InFiscalYear, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(2018, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereInList()
         {
-            var query = new Query<Account>().WhereIn(Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 });
+            var query = new Query(Account.EntityLogicalName).WhereIn(Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 });
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.In);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values is IList);
 
-            var query2 = new Query<Account>().WhereIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 });
+            var query2 = new Query(Account.EntityLogicalName).WhereIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 });
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.In);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query2.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values is IList);
 
             var query3 = new Query<Account>().WhereIn(a => a.CustomerTypeCode, new List<int> { 1, 2, 3 });
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.In);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query3.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query3.QueryExpression.Criteria.Conditions.First().Values is IList);
 
             var query4 = new Query<Account>().WhereIn<Account>(Account.EntityLogicalName, a => a.CustomerTypeCode, new List<int> { 1, 2, 3 });
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.In);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.In, query4.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query4.QueryExpression.Criteria.Conditions.First().Values is IList);
         }
 
         [TestMethod]
         public void ShouldSetWhereInOrAfterFiscalPeriodAndYear()
         {
-            var query = new Query<Account>().WhereInOrAfterFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018);
+            var query = new Query(Account.EntityLogicalName).WhereInOrAfterFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InOrAfterFiscalPeriodAndYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrAfterFiscalPeriodAndYear, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query.QueryExpression.Criteria.Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>().WhereInOrAfterFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereInOrAfterFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InOrAfterFiscalPeriodAndYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrAfterFiscalPeriodAndYear, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query2.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query2.QueryExpression.Criteria.Conditions.First().Values[1]);
 
             var query3 = new Query<Account>().WhereInOrAfterFiscalPeriodAndYear(a => a.CreatedOn, 1, 2018);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InOrAfterFiscalPeriodAndYear);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrAfterFiscalPeriodAndYear, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query3.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query3.QueryExpression.Criteria.Conditions.First().Values[1]);
 
             var query4 = new Query<Account>().WhereInOrAfterFiscalPeriodAndYear<Account>(Account.EntityLogicalName, a => a.CreatedOn, 1, 2018);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InOrAfterFiscalPeriodAndYear);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrAfterFiscalPeriodAndYear, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query4.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query4.QueryExpression.Criteria.Conditions.First().Values[1]);
         }
 
         [TestMethod]
         public void ShouldSetWhereInOrBeforeFiscalPeriodAndYear()
         {
-            var query = new Query<Account>().WhereInOrBeforeFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018);
+            var query = new Query(Account.EntityLogicalName).WhereInOrBeforeFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InOrBeforeFiscalPeriodAndYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrBeforeFiscalPeriodAndYear, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query.QueryExpression.Criteria.Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>().WhereInOrBeforeFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereInOrBeforeFiscalPeriodAndYear(Account.Fields.CreatedOn, 1, 2018, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InOrBeforeFiscalPeriodAndYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrBeforeFiscalPeriodAndYear, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query2.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query2.QueryExpression.Criteria.Conditions.First().Values[1]);
 
             var query3 = new Query<Account>().WhereInOrBeforeFiscalPeriodAndYear(a => a.CreatedOn, 1, 2018);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InOrBeforeFiscalPeriodAndYear);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrBeforeFiscalPeriodAndYear, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query3.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query3.QueryExpression.Criteria.Conditions.First().Values[1]);
 
             var query4 = new Query<Account>().WhereInOrBeforeFiscalPeriodAndYear<Account>(Account.EntityLogicalName, a => a.CreatedOn, 1, 2018);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.InOrBeforeFiscalPeriodAndYear);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values[0], 1);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values[1], 2018);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.InOrBeforeFiscalPeriodAndYear, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(1, query4.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(2018, query4.QueryExpression.Criteria.Conditions.First().Values[1]);
         }
 
         [TestMethod]
         public void ShouldSetWhereLast7Days()
         {
-            var query = new Query<Account>().WhereLast7Days(Account.Fields.CreatedOn);
+            var query = new Query(Account.EntityLogicalName).WhereLast7Days(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Last7Days);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Last7Days, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereLast7Days(Account.Fields.CreatedOn, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereLast7Days(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Last7Days);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Last7Days, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereLast7Days(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Last7Days);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Last7Days, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereLast7Days<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Last7Days);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Last7Days, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLastFiscalPeriod()
         {
-            var query = new Query<Account>().WhereLastFiscalPeriod(Account.Fields.CreatedOn);
+            var query = new Query(Account.EntityLogicalName).WhereLastFiscalPeriod(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastFiscalPeriod);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalPeriod, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereLastFiscalPeriod(Account.Fields.CreatedOn, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereLastFiscalPeriod(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastFiscalPeriod);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalPeriod, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereLastFiscalPeriod(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastFiscalPeriod);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalPeriod, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereLastFiscalPeriod<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastFiscalPeriod);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalPeriod, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLastFiscalYear()
         {
-            var query = new Query<Account>().WhereLastFiscalYear(Account.Fields.CreatedOn);
+            var query = new Query(Account.EntityLogicalName).WhereLastFiscalYear(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastFiscalYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalYear, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereLastFiscalYear(Account.Fields.CreatedOn, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereLastFiscalYear(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastFiscalYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalYear, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereLastFiscalYear(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastFiscalYear);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalYear, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereLastFiscalYear<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastFiscalYear);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastFiscalYear, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLastMonth()
         {
-            var query = new Query<Account>().WhereLastMonth(Account.Fields.CreatedOn);
+            var query = new Query(Account.EntityLogicalName).WhereLastMonth(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastMonth);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastMonth, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereLastMonth(Account.Fields.CreatedOn, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereLastMonth(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastMonth);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastMonth, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereLastMonth(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastMonth);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastMonth, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereLastMonth<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastMonth);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastMonth, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLastWeek()
         {
-            var query = new Query<Account>().WhereLastWeek(Account.Fields.CreatedOn);
+            var query = new Query(Account.EntityLogicalName).WhereLastWeek(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastWeek);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastWeek, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereLastWeek(Account.Fields.CreatedOn, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereLastWeek(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastWeek);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastWeek, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereLastWeek(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastWeek);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastWeek, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereLastWeek<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastWeek);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastWeek, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXDays()
         {
-            var query = new Query<Account>().WhereLastXDays(Account.Fields.CreatedOn, 10);
+            var query = new Query(Account.EntityLogicalName).WhereLastXDays(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXDays);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXDays, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>().WhereLastXDays(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereLastXDays(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXDays);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXDays, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereLastXDays(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXDays);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXDays, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereLastXDays<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXDays);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXDays, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXFiscalPeriods()
         {
-            var query = new Query<Account>().WhereLastXFiscalPeriods(Account.Fields.CreatedOn, 10);
+            var query = new Query(Account.EntityLogicalName).WhereLastXFiscalPeriods(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXFiscalPeriods);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalPeriods, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>().WhereLastXFiscalPeriods(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereLastXFiscalPeriods(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXFiscalPeriods);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalPeriods, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereLastXFiscalPeriods(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXFiscalPeriods);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalPeriods, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereLastXFiscalPeriods<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXFiscalPeriods);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalPeriods, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXFiscalYears()
         {
-            var query = new Query<Account>().WhereLastXFiscalYears(Account.Fields.CreatedOn, 10);
+            var query = new Query(Account.EntityLogicalName).WhereLastXFiscalYears(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXFiscalYears);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalYears, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>().WhereLastXFiscalYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereLastXFiscalYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXFiscalYears);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalYears, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereLastXFiscalYears(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXFiscalYears);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalYears, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereLastXFiscalYears<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXFiscalYears);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXFiscalYears, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXHours()
         {
-            var query = new Query<Account>().WhereLastXHours(Account.Fields.CreatedOn, 10);
+            var query = new Query(Account.EntityLogicalName).WhereLastXHours(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXHours);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXHours, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>().WhereLastXHours(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereLastXHours(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXHours);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXHours, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereLastXHours(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXHours);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXHours, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereLastXHours<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXHours);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXHours, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXMonths()
         {
-            var query = new Query<Account>().WhereLastXMonths(Account.Fields.CreatedOn, 10);
+            var query = new Query(Account.EntityLogicalName).WhereLastXMonths(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXMonths);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXMonths, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>().WhereLastXMonths(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereLastXMonths(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXMonths);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXMonths, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereLastXMonths(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXMonths);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXMonths, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereLastXMonths<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXMonths);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXMonths, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXWeeks()
         {
-            var query = new Query<Account>().WhereLastXWeeks(Account.Fields.CreatedOn, 10);
+            var query = new Query(Account.EntityLogicalName).WhereLastXWeeks(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXWeeks);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXWeeks, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>().WhereLastXWeeks(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereLastXWeeks(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXWeeks);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXWeeks, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereLastXWeeks(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXWeeks);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXWeeks, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereLastXWeeks<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXWeeks);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXWeeks, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastXYears()
         {
-            var query = new Query<Account>().WhereLastXYears(Account.Fields.CreatedOn, 10);
+            var query = new Query(Account.EntityLogicalName).WhereLastXYears(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXYears);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXYears, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>().WhereLastXYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereLastXYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXYears);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXYears, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereLastXYears(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXYears);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXYears, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereLastXYears<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastXYears);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastXYears, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLastYear()
         {
-            var query = new Query<Account>().WhereLastYear(Account.Fields.CreatedOn);
+            var query = new Query(Account.EntityLogicalName).WhereLastYear(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastYear, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereLastYear(Account.Fields.CreatedOn, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereLastYear(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastYear, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereLastYear(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastYear);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastYear, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereLastYear<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LastYear);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LastYear, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereLessEqual()
         {
-            var query = new Query<Account>().WhereLessEqual(Account.Fields.NumberOfEmployees, 10);
+            var query = new Query(Account.EntityLogicalName).WhereLessEqual(Account.Fields.NumberOfEmployees, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LessEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>().WhereLessEqual(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereLessEqual(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LessEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereLessEqual(a => a.NumberOfEmployees, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LessEqual);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereLessEqual<Account>(Account.EntityLogicalName, a => a.NumberOfEmployees, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LessEqual);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessEqual, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLessThan()
         {
-            var query = new Query<Account>().WhereLessThan(Account.Fields.NumberOfEmployees, 10);
+            var query = new Query(Account.EntityLogicalName).WhereLessThan(Account.Fields.NumberOfEmployees, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LessThan);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>().WhereLessThan(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereLessThan(Account.Fields.NumberOfEmployees, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LessThan);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereLessThan(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LessThan);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereLessThan<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.LessThan);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.LessThan, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereLike()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereLike(Account.Fields.Name, "%test%");
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Like);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Like, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("%test%", query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereLike(Account.Fields.Name, "%test%", Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Like);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Like, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("%test%", query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereLike(a => a.Name, "%test%");
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Like);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Like, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("%test%", query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereLike<Account>(Account.EntityLogicalName, a => a.Name, "%test%");
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Like);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Like, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("%test%", query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereMask()
         {
             var obj = new object();
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereMask(Account.Fields.Name, obj);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Mask);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Mask, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(obj, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereMask(Account.Fields.Name, obj, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Mask);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Mask, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(obj, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereMask(a => a.Name, obj);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Mask);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Mask, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(obj, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereMask<Account>(Account.EntityLogicalName, a => a.Name, obj);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Mask);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), obj);
-        }
-
-        [TestMethod]
-        public void ShouldSetWhereMasksSelect()
-        {
-            var obj = new object();
-            var query = new Query<Account>().WhereMasksSelect(Account.Fields.Name, obj);
-
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.MasksSelect);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), obj);
-
-            var query2 = new Query<Account>().WhereMasksSelect(Account.Fields.Name, obj, Account.EntityLogicalName);
-
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.MasksSelect);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), obj);
-
-            var query3 = new Query<Account>().WhereMasksSelect(a => a.Name, obj);
-
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.MasksSelect);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), obj);
-
-            var query4 = new Query<Account>().WhereMasksSelect<Account>(Account.EntityLogicalName, a => a.Name, obj);
-
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.MasksSelect);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Mask, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(obj, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNext7Days()
         {
-            var query = new Query<Account>().WhereNext7Days(Account.Fields.CreatedOn);
+            var query = new Query(Account.EntityLogicalName).WhereNext7Days(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Next7Days);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Next7Days, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereNext7Days(Account.Fields.CreatedOn, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereNext7Days(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Next7Days);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Next7Days, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereNext7Days(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Next7Days);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Next7Days, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereNext7Days<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Next7Days);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Next7Days, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNextFiscalPeriod()
         {
-            var query = new Query<Account>().WhereNextFiscalPeriod(Account.Fields.CreatedOn);
+            var query = new Query(Account.EntityLogicalName).WhereNextFiscalPeriod(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextFiscalPeriod);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalPeriod, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereNextFiscalPeriod(Account.Fields.CreatedOn, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereNextFiscalPeriod(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextFiscalPeriod);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalPeriod, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereNextFiscalPeriod(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextFiscalPeriod);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalPeriod, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereNextFiscalPeriod<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextFiscalPeriod);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalPeriod, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNextFiscalYear()
         {
-            var query = new Query<Account>().WhereNextFiscalYear(Account.Fields.CreatedOn);
+            var query = new Query(Account.EntityLogicalName).WhereNextFiscalYear(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextFiscalYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalYear, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereNextFiscalYear(Account.Fields.CreatedOn, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereNextFiscalYear(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextFiscalYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalYear, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereNextFiscalYear(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextFiscalYear);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalYear, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereNextFiscalYear<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextFiscalYear);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextFiscalYear, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNextMonth()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNextMonth(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextMonth);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextMonth, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNextMonth(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextMonth);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextMonth, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereNextMonth(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextMonth);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextMonth, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereNextMonth<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextMonth);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextMonth, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNextWeek()
         {
-            var query = new Query<Account>().WhereNextWeek(Account.Fields.CreatedOn);
+            var query = new Query(Account.EntityLogicalName).WhereNextWeek(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextWeek);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextWeek, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>().WhereNextWeek(Account.Fields.CreatedOn, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereNextWeek(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextWeek);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextWeek, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereNextWeek(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextWeek);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextWeek, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereNextWeek<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextWeek);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextWeek, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXDays()
         {
-            var query = new Query<Account>().WhereNextXDays(Account.Fields.CreatedOn, 10);
+            var query = new Query(Account.EntityLogicalName).WhereNextXDays(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXDays);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXDays, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>().WhereNextXDays(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereNextXDays(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXDays);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXDays, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereNextXDays(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXDays);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXDays, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereNextXDays<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXDays);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXDays, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXFiscalPeriods()
         {
-            var query = new Query<Account>().WhereNextXFiscalPeriods(Account.Fields.CreatedOn, 10);
+            var query = new Query(Account.EntityLogicalName).WhereNextXFiscalPeriods(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXFiscalPeriods);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalPeriods, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>().WhereNextXFiscalPeriods(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
+            var query2 = new Query(Account.EntityLogicalName).WhereNextXFiscalPeriods(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXFiscalPeriods);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalPeriods, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereNextXFiscalPeriods(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXFiscalPeriods);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalPeriods, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereNextXFiscalPeriods<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXFiscalPeriods);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalPeriods, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXFiscalYears()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNextXFiscalYears(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXFiscalYears);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalYears, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNextXFiscalYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXFiscalYears);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalYears, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereNextXFiscalYears(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXFiscalYears);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalYears, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereNextXFiscalYears<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXFiscalYears);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXFiscalYears, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXHours()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNextXHours(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXHours);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXHours, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNextXHours(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXHours);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXHours, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereNextXHours(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXHours);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXHours, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereNextXHours<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXHours);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXHours, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXMonths()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNextXMonths(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXMonths);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXMonths, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNextXMonths(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXMonths);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXMonths, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereNextXMonths(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXMonths);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXMonths, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereNextXMonths<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXMonths);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXMonths, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXWeeks()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNextXWeeks(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXWeeks);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXWeeks, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNextXWeeks(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXWeeks);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXWeeks, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereNextXWeeks(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXWeeks);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXWeeks, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereNextXWeeks<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXWeeks);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXWeeks, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextXYears()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNextXYears(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXYears);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXYears, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNextXYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXYears);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXYears, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereNextXYears(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXYears);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXYears, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereNextXYears<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextXYears);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextXYears, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNextYear()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNextYear(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextYear, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNextYear(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextYear, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereNextYear(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextYear);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextYear, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereNextYear<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NextYear);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NextYear, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotBetween()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNotBetween(Account.Fields.NumberOfEmployees, 10, 50);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotBetween);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values[0], 10);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values[1], 50);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotBetween, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(50, query.QueryExpression.Criteria.Conditions.First().Values[1]);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNotBetween(Account.Fields.NumberOfEmployees, 10, 50, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.NumberOfEmployees);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotBetween);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values[0], 10);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values[1], 50);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.NumberOfEmployees, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotBetween, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(50, query2.QueryExpression.Criteria.Conditions.First().Values[1]);
 
             var query3 = new Query<Account>().WhereNotBetween(a => a.CreatedOn, 10, 50);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotBetween);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values[0], 10);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values[1], 50);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotBetween, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(50, query3.QueryExpression.Criteria.Conditions.First().Values[1]);
 
             var query4 = new Query<Account>().WhereNotBetween<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10, 50);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotBetween);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values[0], 10);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values[1], 50);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotBetween, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values[0]);
+            Assert.AreEqual(50, query4.QueryExpression.Criteria.Conditions.First().Values[1]);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotEqual()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNotEqual(Account.Fields.Name, "test");
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), "test");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNotEqual(Account.Fields.Name, "test", Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereNotEqual(a => a.Name, "test");
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotEqual);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), "test");
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereNotEqual<Account>(Account.EntityLogicalName, a => a.Name, "test");
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotEqual);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), "test");
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqual, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("test", query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNotEqualBusinessId()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNotEqualBusinessId(Account.Fields.OwningBusinessUnit);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotEqualBusinessId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualBusinessId, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNotEqualBusinessId(Account.Fields.OwningBusinessUnit, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotEqualBusinessId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualBusinessId, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereNotEqualBusinessId(a => a.OwningBusinessUnit);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotEqualBusinessId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualBusinessId, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereNotEqualBusinessId<Account>(Account.EntityLogicalName, a => a.OwningBusinessUnit);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwningBusinessUnit);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotEqualBusinessId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwningBusinessUnit, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualBusinessId, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotEqualUserId()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNotEqualUserId(Account.Fields.OwnerId);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotEqualUserId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualUserId, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNotEqualUserId(Account.Fields.OwnerId, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotEqualUserId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualUserId, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereNotEqualUserId(a => a.OwnerId);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotEqualUserId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.OwnerId, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualUserId, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereNotEqualUserId<Account>(Account.EntityLogicalName, a => a.OwnerId);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.OwnerId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotEqualUserId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.OwnerId, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotEqualUserId, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotIn()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNotIn(Account.Fields.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotIn);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNotIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotIn);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query2.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query2.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query2.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query2.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
 
             var query3 = new Query<Account>().WhereNotIn(a => a.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotIn);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query3.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query3.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query3.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query3.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
 
-            var query4 = new Query<Account>().WhereNotIn<Account>(Account.EntityLogicalName, a => a.CustomerTypeCode, 1, 2, 3);
+            var query4 = new Query<Account>().WhereNotIn(Account.EntityLogicalName, a => a.CustomerTypeCode, 1, 2, 3);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotIn);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query4.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query4.QueryExpression.Criteria.Conditions.First().Values.Contains(1));
             Assert.IsTrue(query4.QueryExpression.Criteria.Conditions.First().Values.Contains(2));
             Assert.IsTrue(query4.QueryExpression.Criteria.Conditions.First().Values.Contains(3));
@@ -2418,841 +2682,841 @@ public void ShouldSetWhereNotIn()
         [TestMethod]
         public void ShouldSetWhereNotInList()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNotIn(Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 });
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotIn);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values is IList);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNotIn(Account.EntityLogicalName, Account.Fields.CustomerTypeCode, new List<int> { 1, 2, 3 });
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotIn);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query2.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query.QueryExpression.Criteria.Conditions.First().Values is IList);
 
             var query3 = new Query<Account>().WhereNotIn(a => a.CustomerTypeCode, new List<int> { 1, 2, 3 });
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotIn);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query3.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query3.QueryExpression.Criteria.Conditions.First().Values is IList);
 
-            var query4 = new Query<Account>().WhereNotIn<Account>(Account.EntityLogicalName, a => a.CustomerTypeCode, new List<int> { 1, 2, 3 });
+            var query4 = new Query<Account>().WhereNotIn(Account.EntityLogicalName, a => a.CustomerTypeCode, new List<int> { 1, 2, 3 });
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CustomerTypeCode);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotIn);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CustomerTypeCode, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotIn, query4.QueryExpression.Criteria.Conditions.First().Operator);
             Assert.IsTrue(query4.QueryExpression.Criteria.Conditions.First().Values is IList);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotLike()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNotLike(Account.Fields.Name, "%test%");
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotLike);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotLike, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("%test%", query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNotLike(Account.Fields.Name, "%test%", Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotLike);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotLike, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("%test%", query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereNotLike(a => a.Name, "%test%");
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotLike);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotLike, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("%test%", query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereNotLike<Account>(Account.EntityLogicalName, a => a.Name, "%test%");
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotLike);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), "%test%");
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotLike, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual("%test%", query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNotMask()
         {
             var obj = new object();
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNotMask(Account.Fields.Name, obj);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotMask);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotMask, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(obj, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                  .WhereNotMask(Account.Fields.Name, obj, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotMask);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotMask, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(obj, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereNotMask(a => a.Name, obj);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotMask);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotMask, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(obj, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereNotMask<Account>(Account.EntityLogicalName, a => a.Name, obj);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotMask);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), obj);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotMask, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(obj, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNotNull()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNotNull(Account.Fields.Name);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotNull);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotNull, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNotNull(Account.Fields.Name, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotNull);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotNull, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereNotNull(a => a.Name);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotNull);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotNull, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereNotNull<Account>(Account.EntityLogicalName, a => a.Name);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotNull);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotNull, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereNotOn()
         {
             var date = new DateTime();
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNotOn(Account.Fields.CreatedOn, date);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotOn, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNotOn(Account.Fields.CreatedOn, date, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotOn, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereNotOn(a => a.CreatedOn, date);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotOn, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereNotOn<Account>(Account.EntityLogicalName, a => a.CreatedOn, date);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotOn, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNotUnder()
         {
-            var guid = new Guid();
-            var query = new Query<Account>()
+            var guid = Guid.NewGuid();
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNotUnder(Account.Fields.AccountId, guid);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotUnder);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotUnder, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNotUnder(Account.Fields.AccountId, guid, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotUnder);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotUnder, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereNotUnder(a => a.AccountId, guid);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotUnder);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotUnder, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereNotUnder<Account>(Account.EntityLogicalName, a => a.AccountId, guid);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.NotUnder);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.NotUnder, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereNull()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereNull(Account.Fields.Name);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Null);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.Name, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Null, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereNull(Account.Fields.Name, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Null);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Null, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereNull(a => a.Name);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Null);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.Name, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Null, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereNull<Account>(Account.EntityLogicalName, a => a.Name);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.Name);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Null);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.Name, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Null, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXDays()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereOlderThanXDays(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXDays);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXDays, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereOlderThanXDays(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXDays);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXDays, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereOlderThanXDays(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXDays);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXDays, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereOlderThanXDays<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXDays);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXDays, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXHours()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereOlderThanXHours(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXHours);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXHours, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereOlderThanXHours(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXHours);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXHours, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereOlderThanXHours(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXHours);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXHours, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereOlderThanXHours<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXHours);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXHours, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXMinutes()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereOlderThanXMinutes(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXMinutes);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMinutes, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereOlderThanXMinutes(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXMinutes);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMinutes, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereOlderThanXMinutes(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXMinutes);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMinutes, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereOlderThanXMinutes<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXMinutes);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMinutes, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXMonths()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereOlderThanXMonths(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXMonths);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMonths, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereOlderThanXMonths(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXMonths);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMonths, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereOlderThanXMonths(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXMonths);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMonths, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereOlderThanXMonths<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXMonths);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXMonths, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXWeeks()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereOlderThanXWeeks(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXWeeks);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXWeeks, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereOlderThanXWeeks(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXWeeks);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXWeeks, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereOlderThanXWeeks(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXWeeks);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXWeeks, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereOlderThanXWeeks<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXWeeks);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXWeeks, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOlderThanXYears()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereOlderThanXYears(Account.Fields.CreatedOn, 10);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXYears);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXYears, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereOlderThanXYears(Account.Fields.CreatedOn, 10, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXYears);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXYears, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereOlderThanXYears(a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXYears);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXYears, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereOlderThanXYears<Account>(Account.EntityLogicalName, a => a.CreatedOn, 10);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OlderThanXYears);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), 10);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OlderThanXYears, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(10, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOn()
         {
             var date = new DateTime();
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereOn(Account.Fields.CreatedOn, date);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.On);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.On, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereOn(Account.Fields.CreatedOn, date, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.On);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.On, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereOn(a => a.CreatedOn, date);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.On);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.On, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereOn<Account>(Account.EntityLogicalName, a => a.CreatedOn, date);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.On);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.On, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOnOrAfter()
         {
             var date = new DateTime();
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereOnOrAfter(Account.Fields.CreatedOn, date);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OnOrAfter);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrAfter, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereOnOrAfter(Account.Fields.CreatedOn, date, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OnOrAfter);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrAfter, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereOnOrAfter(a => a.CreatedOn, date);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OnOrAfter);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrAfter, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereOnOrAfter<Account>(Account.EntityLogicalName, a => a.CreatedOn, date);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OnOrAfter);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrAfter, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereOnOrBefore()
         {
             var date = new DateTime();
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereOnOrBefore(Account.Fields.CreatedOn, date);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OnOrBefore);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrBefore, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereOnOrBefore(Account.Fields.CreatedOn, date, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OnOrBefore);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrBefore, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereOnOrBefore(a => a.CreatedOn, date);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OnOrBefore);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrBefore, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereOnOrBefore<Account>(Account.EntityLogicalName, a => a.CreatedOn, date);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.OnOrBefore);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), date);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.OnOrBefore, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(date, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereThisFiscalPeriod()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereThisFiscalPeriod(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisFiscalPeriod);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalPeriod, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereThisFiscalPeriod(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisFiscalPeriod);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalPeriod, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereThisFiscalPeriod(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisFiscalPeriod);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalPeriod, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereThisFiscalPeriod<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisFiscalPeriod);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalPeriod, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereThisFiscalYear()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereThisFiscalYear(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisFiscalYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalYear, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereThisFiscalYear(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisFiscalYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalYear, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereThisFiscalYear(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisFiscalYear);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalYear, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereThisFiscalYear<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisFiscalYear);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisFiscalYear, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereThisMonth()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereThisMonth(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisMonth);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisMonth, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereThisMonth(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisMonth);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisMonth, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereThisMonth(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisMonth);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisMonth, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereThisMonth<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisMonth);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisMonth, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereThisWeek()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereThisWeek(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisWeek);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisWeek, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereThisWeek(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisWeek);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisWeek, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereThisWeek(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisWeek);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisWeek, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereThisWeek<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisWeek);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisWeek, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereThisYear()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereThisYear(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisYear);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisYear, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereThisYear(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisYear);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisYear, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereThisYear(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisYear);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisYear, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereThisYear<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.ThisYear);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.ThisYear, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereToday()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereToday(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Today);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Today, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereToday(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Today);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Today, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereToday(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Today);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Today, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereToday<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Today);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Today, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereTomorrow()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereTomorrow(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Tomorrow);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Tomorrow, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereTomorrow(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Tomorrow);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Tomorrow, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereTomorrow(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Tomorrow);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Tomorrow, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereTomorrow<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Tomorrow);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Tomorrow, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         [TestMethod]
         public void ShouldSetWhereUnder()
         {
-            Guid guid = new Guid();
-            var query = new Query<Account>()
+            Guid guid = Guid.NewGuid();
+            var query = new Query(Account.EntityLogicalName)
                 .WhereUnder(Account.Fields.AccountId, guid);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Under);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Under, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereUnder(Account.Fields.AccountId, guid, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Under);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Under, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereUnder(a => a.AccountId, guid);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Under);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Under, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereUnder<Account>(Account.EntityLogicalName, a => a.AccountId, guid);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Under);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Under, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereUnderOrEqual()
         {
-            Guid guid = new Guid();
-            var query = new Query<Account>()
+            Guid guid = Guid.NewGuid();
+            var query = new Query(Account.EntityLogicalName)
                 .WhereUnderOrEqual(Account.Fields.AccountId, guid);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.UnderOrEqual);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.UnderOrEqual, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query.QueryExpression.Criteria.Conditions.First().Values.First());
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereUnderOrEqual(Account.Fields.AccountId, guid, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.UnderOrEqual);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.UnderOrEqual, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query2.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query3 = new Query<Account>().WhereUnderOrEqual(a => a.AccountId, guid);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.UnderOrEqual);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.Fields.AccountId, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.UnderOrEqual, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query3.QueryExpression.Criteria.Conditions.First().Values.First());
 
             var query4 = new Query<Account>().WhereUnderOrEqual<Account>(Account.EntityLogicalName, a => a.AccountId, guid);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.AccountId);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.UnderOrEqual);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.First(), guid);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.AccountId, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.UnderOrEqual, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(guid, query4.QueryExpression.Criteria.Conditions.First().Values.First());
         }
 
         [TestMethod]
         public void ShouldSetWhereYesterday()
         {
-            var query = new Query<Account>()
+            var query = new Query(Account.EntityLogicalName)
                 .WhereYesterday(Account.Fields.CreatedOn);
 
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Yesterday);
-            Assert.AreEqual(query.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Yesterday, query.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query.QueryExpression.Criteria.Conditions.First().Values.Count);
 
-            var query2 = new Query<Account>()
+            var query2 = new Query(Account.EntityLogicalName)
                 .WhereYesterday(Account.Fields.CreatedOn, Account.EntityLogicalName);
 
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Yesterday);
-            Assert.AreEqual(query2.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query2.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query2.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Yesterday, query2.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query2.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query3 = new Query<Account>().WhereYesterday(a => a.CreatedOn);
 
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Yesterday);
-            Assert.AreEqual(query3.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.Fields.CreatedOn, query3.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Yesterday, query3.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query3.QueryExpression.Criteria.Conditions.First().Values.Count);
 
             var query4 = new Query<Account>().WhereYesterday<Account>(Account.EntityLogicalName, a => a.CreatedOn);
 
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().EntityName, Account.EntityLogicalName);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().AttributeName, Account.Fields.CreatedOn);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Operator, ConditionOperator.Yesterday);
-            Assert.AreEqual(query4.QueryExpression.Criteria.Conditions.First().Values.Count, 0);
+            Assert.AreEqual(Account.EntityLogicalName, query4.QueryExpression.Criteria.Conditions.First().EntityName);
+            Assert.AreEqual(Account.Fields.CreatedOn, query4.QueryExpression.Criteria.Conditions.First().AttributeName);
+            Assert.AreEqual(ConditionOperator.Yesterday, query4.QueryExpression.Criteria.Conditions.First().Operator);
+            Assert.AreEqual(0, query4.QueryExpression.Criteria.Conditions.First().Values.Count);
         }
 
         #endregion Conditions
@@ -3293,8 +3557,8 @@ public void ShouldGetAll()
                 var records = new Query<Account>()
                     .GetAll(service);
 
-                Assert.AreEqual(records.Count, 1);
-                Assert.AreEqual(records.First().Id, item1Id);
+                Assert.AreEqual(1, records.Count);
+                Assert.AreEqual(item1Id, records.First().Id);
             }
         }
 
@@ -3330,8 +3594,8 @@ public void ShouldGetAllTopCount()
                     .Top(100)
                     .GetAll(service);
 
-                Assert.AreEqual(records.Count, 1);
-                Assert.AreEqual(records.First().Id, item1Id);
+                Assert.AreEqual(1, records.Count);
+                Assert.AreEqual(item1Id, records.First().Id);
             }
         }
 
@@ -3365,8 +3629,8 @@ public void ShouldGetAllWithExtension()
 
                 var records = service.RetrieveMultiple(new Query<Account>());
 
-                Assert.AreEqual(records.Count, 1);
-                Assert.AreEqual(records.First().Id, item1Id);
+                Assert.AreEqual(1, records.Count);
+                Assert.AreEqual(item1Id, records.First().Id);
             }
         }
 
@@ -3401,8 +3665,8 @@ public void ShouldGetAllWithoutPaging()
                 var records = new Query<Account>()
                     .GetAll(service);
 
-                Assert.AreEqual(records.Count, 1);
-                Assert.AreEqual(records.First().Id, item1Id);
+                Assert.AreEqual(1, records.Count);
+                Assert.AreEqual(item1Id, records.First().Id);
             }
         }
 
@@ -3478,6 +3742,78 @@ public void ShouldGetByIdForActivity()
             }
         }
 
+        [TestMethod]
+        public void ShouldGetByIdForActivityLateBound()
+        {
+            using (ShimsContext.Create())
+            {
+                var service = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService
+                {
+                    RetrieveMultipleQueryBase = queryBase =>
+                    {
+                        if (queryBase is QueryExpression qe)
+                        {
+                            return new EntityCollection
+                            {
+                                EntityName = qe.EntityName,
+                                Entities =
+                                {
+                                    new Entity(qe.EntityName)
+                                    {
+                                        Id = item1Id
+                                    }
+                                }
+                            };
+                        }
+
+                        return new EntityCollection();
+                    }
+                };
+
+                var query = new Query(Task.EntityLogicalName);
+                var record = query.GetById(Guid.NewGuid(), service, true);
+
+                Assert.IsNotNull(record);
+                Assert.AreEqual("activityid", query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            }
+        }
+
+        [TestMethod]
+        public void ShouldGetByIdLateBound()
+        {
+            using (ShimsContext.Create())
+            {
+                var service = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService
+                {
+                    RetrieveMultipleQueryBase = queryBase =>
+                    {
+                        if (queryBase is QueryExpression qe)
+                        {
+                            return new EntityCollection
+                            {
+                                EntityName = qe.EntityName,
+                                Entities =
+                                {
+                                    new Entity(qe.EntityName)
+                                    {
+                                        Id = item1Id
+                                    }
+                                }
+                            };
+                        }
+
+                        return new EntityCollection();
+                    }
+                };
+
+                var query = new Query(Contact.EntityLogicalName);
+                var record = query.GetById(Guid.NewGuid(), service, false);
+
+                Assert.IsNotNull(record);
+                Assert.AreEqual(Contact.PrimaryIdAttribute, query.QueryExpression.Criteria.Conditions.First().AttributeName);
+            }
+        }
+
         [TestMethod]
         public void ShouldGetFirst()
         {
@@ -3514,7 +3850,7 @@ public void ShouldGetFirst()
                     .GetFirst(service);
 
                 Assert.IsNotNull(record);
-                Assert.AreEqual(record.Id, item1Id);
+                Assert.AreEqual(item1Id, record.Id);
             }
         }
 
@@ -3581,7 +3917,7 @@ public void ShouldGetFirstOrDefault()
                     .GetFirstOrDefault(service);
 
                 Assert.IsNotNull(record);
-                Assert.AreEqual(record.Id, item1Id);
+                Assert.AreEqual(item1Id, record.Id);
             }
         }
 
@@ -3614,7 +3950,48 @@ public void ShouldGetFirstOrDefaultIsNull()
         }
 
         [TestMethod]
-        public void ShouldGetLast()
+        public void ShouldGetFirstOrDefaultWithTop()
+        {
+            using (ShimsContext.Create())
+            {
+                var service = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService
+                {
+                    RetrieveMultipleQueryBase = queryBase =>
+                    {
+                        if (queryBase is QueryExpression qe)
+                        {
+                            return new EntityCollection
+                            {
+                                EntityName = qe.EntityName,
+                                Entities =
+                                {
+                                    new Entity(qe.EntityName)
+                                    {
+                                        Id = item1Id
+                                    },
+                                    new Entity(qe.EntityName)
+                                    {
+                                        Id =item2Id
+                                    }
+                                }
+                            };
+                        }
+
+                        return new EntityCollection();
+                    }
+                };
+
+                var record = new Query<Account>()
+                    .Top(10)
+                    .GetFirstOrDefault(service);
+
+                Assert.IsNotNull(record);
+                Assert.AreEqual(item1Id, record.Id);
+            }
+        }
+
+        [TestMethod]
+        public void ShouldGetFirstWithTop()
         {
             using (ShimsContext.Create())
             {
@@ -3634,8 +4011,50 @@ public void ShouldGetLast()
                                         Id = item1Id
                                     },
                                     new Entity(qe.EntityName)
+                                    {
+                                        Id = item2Id
+                                    }
+                                }
+                            };
+                        }
+
+                        return new EntityCollection();
+                    }
+                };
+
+                var record = new Query<Account>()
+                    .Top(10)
+                    .GetFirst(service);
+
+                Assert.IsNotNull(record);
+                Assert.AreEqual(item1Id, record.Id);
+            }
+        }
+
+        [TestMethod]
+        public void ShouldGetLast()
+        {
+            using (ShimsContext.Create())
+            {
+                var service = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService
+                {
+                    RetrieveMultipleQueryBase = queryBase =>
+                    {
+                        if (queryBase is QueryExpression qe)
+                        {
+                            return new EntityCollection
+                            {
+                                EntityName = qe.EntityName,
+                                Entities =
+                                {
+                                    // Data is inverted because GetLast change sort order
+                                    new Entity(qe.EntityName)
                                     {
                                         Id =item2Id
+                                    },
+                                    new Entity(qe.EntityName)
+                                    {
+                                        Id = item1Id
                                     }
                                 }
                             };
@@ -3646,10 +4065,11 @@ public void ShouldGetLast()
                 };
 
                 var record = new Query<Account>()
+                    .OrderBy(a => a.CreatedOn)
                     .GetLast(service);
 
                 Assert.IsNotNull(record);
-                Assert.AreEqual(record.Id, item2Id);
+                Assert.AreEqual(item2Id, record.Id);
             }
         }
 
@@ -3676,6 +4096,7 @@ public void ShouldGetLastNull()
                 };
 
                 new Query<Account>()
+                    .OrderBy(a => a.CreatedOn)
                     .GetLast(service);
             }
         }
@@ -3696,13 +4117,13 @@ public void ShouldGetLastOrDefault()
                                 EntityName = qe.EntityName,
                                 Entities =
                                 {
-                                    new Entity(qe.EntityName)
+                                      new Entity(qe.EntityName)
                                     {
-                                        Id = item1Id
+                                        Id =item2Id
                                     },
                                     new Entity(qe.EntityName)
                                     {
-                                        Id =item2Id
+                                        Id = item1Id
                                     }
                                 }
                             };
@@ -3713,10 +4134,11 @@ public void ShouldGetLastOrDefault()
                 };
 
                 var record = new Query<Account>()
+                    .OrderBy(a => a.CreatedOn)
                     .GetLastOrDefault(service);
 
                 Assert.IsNotNull(record);
-                Assert.AreEqual(record.Id, item2Id);
+                Assert.AreEqual(item2Id, record.Id);
             }
         }
 
@@ -3748,6 +4170,88 @@ public void ShouldGetLastOrDefaultIsNull()
             }
         }
 
+        [TestMethod]
+        public void ShouldGetLastOrDefaultWithTop()
+        {
+            using (ShimsContext.Create())
+            {
+                var service = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService
+                {
+                    RetrieveMultipleQueryBase = queryBase =>
+                    {
+                        if (queryBase is QueryExpression qe)
+                        {
+                            return new EntityCollection
+                            {
+                                EntityName = qe.EntityName,
+                                Entities =
+                                {
+                                    new Entity(qe.EntityName)
+                                    {
+                                        Id = item1Id
+                                    },
+                                    new Entity(qe.EntityName)
+                                    {
+                                        Id =item2Id
+                                    }
+                                }
+                            };
+                        }
+
+                        return new EntityCollection();
+                    }
+                };
+
+                var record = new Query<Account>()
+                    .Top(10)
+                    .GetLastOrDefault(service);
+
+                Assert.IsNotNull(record);
+                Assert.AreEqual(item2Id, record.Id);
+            }
+        }
+
+        [TestMethod]
+        public void ShouldGetLastWithTop()
+        {
+            using (ShimsContext.Create())
+            {
+                var service = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService
+                {
+                    RetrieveMultipleQueryBase = queryBase =>
+                    {
+                        if (queryBase is QueryExpression qe)
+                        {
+                            return new EntityCollection
+                            {
+                                EntityName = qe.EntityName,
+                                Entities =
+                                {
+                                    new Entity(qe.EntityName)
+                                    {
+                                        Id = item1Id
+                                    },
+                                    new Entity(qe.EntityName)
+                                    {
+                                        Id =item2Id
+                                    }
+                                }
+                            };
+                        }
+
+                        return new EntityCollection();
+                    }
+                };
+
+                var record = new Query<Account>()
+                    .Top(10)
+                    .GetLast(service);
+
+                Assert.IsNotNull(record);
+                Assert.AreEqual(item2Id, record.Id);
+            }
+        }
+
         [TestMethod]
         public void ShouldGetResults()
         {
@@ -3783,7 +4287,7 @@ public void ShouldGetResults()
                 var records = new Query<Account>()
                     .GetResults(service);
 
-                Assert.AreEqual(records.Entities.Count, 2);
+                Assert.AreEqual(2, records.Entities.Count);
             }
         }
 
@@ -3819,7 +4323,7 @@ public void ShouldGetSingle()
                     .GetSingle(service);
 
                 Assert.IsNotNull(record);
-                Assert.AreEqual(record.Id, item1Id);
+                Assert.AreEqual(item1Id, record.Id);
             }
         }
 
@@ -3919,7 +4423,7 @@ public void ShouldGetSingleOrDefault()
                     .GetSingleOrDefault(service);
 
                 Assert.IsNotNull(record);
-                Assert.AreEqual(record.Id, item1Id);
+                Assert.AreEqual(item1Id, record.Id);
             }
         }
 
@@ -3951,6 +4455,147 @@ public void ShouldGetSingleOrDefaultIsNull()
             }
         }
 
+        [TestMethod]
+        public void ShouldGetSingleOrDefaultIsNullWithTop()
+        {
+            using (ShimsContext.Create())
+            {
+                var service = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService
+                {
+                    RetrieveMultipleQueryBase = queryBase =>
+                    {
+                        if (queryBase is QueryExpression qe)
+                        {
+                            return new EntityCollection
+                            {
+                                EntityName = qe.EntityName
+                            };
+                        }
+
+                        return new EntityCollection();
+                    }
+                };
+
+                var record = new Query<Account>()
+                    .Top(10)
+                    .GetSingleOrDefault(service);
+
+                Assert.IsNull(record);
+            }
+        }
+
+        [TestMethod]
+        public void ShouldGetSingleWithTop()
+        {
+            using (ShimsContext.Create())
+            {
+                var service = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService
+                {
+                    RetrieveMultipleQueryBase = queryBase =>
+                    {
+                        if (queryBase is QueryExpression qe)
+                        {
+                            return new EntityCollection
+                            {
+                                EntityName = qe.EntityName,
+                                Entities =
+                                {
+                                    new Entity(qe.EntityName)
+                                    {
+                                        Id = item1Id
+                                    }
+                                }
+                            };
+                        }
+
+                        return new EntityCollection();
+                    }
+                };
+
+                var record = new Query<Account>()
+                    .Top(10)
+                    .GetSingle(service);
+
+                Assert.IsNotNull(record);
+                Assert.AreEqual(item1Id, record.Id);
+            }
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(InvalidOperationException))]
+        public void ShouldNotGetLastOrDefaultWithException()
+        {
+            using (ShimsContext.Create())
+            {
+                var service = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService
+                {
+                    RetrieveMultipleQueryBase = queryBase =>
+                    {
+                        if (queryBase is QueryExpression qe)
+                        {
+                            return new EntityCollection
+                            {
+                                EntityName = qe.EntityName,
+                                Entities =
+                                {
+                                }
+                            };
+                        }
+
+                        return new EntityCollection();
+                    }
+                };
+
+                var record = new Query<Account>()
+                    .GetLast(service);
+
+                Assert.IsNotNull(record);
+                Assert.AreEqual(item2Id, record.Id);
+            }
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(InvalidOperationException))]
+        public void ShouldNotGetLastWithException()
+        {
+            using (ShimsContext.Create())
+            {
+                var service = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService
+                {
+                    RetrieveMultipleQueryBase = queryBase =>
+                    {
+                        if (queryBase is QueryExpression qe)
+                        {
+                            return new EntityCollection
+                            {
+                                EntityName = qe.EntityName,
+                                Entities =
+                                {
+                                    // Data is inverted because GetLast change sort order
+                                    new Entity(qe.EntityName)
+                                    {
+                                        Id =item2Id
+                                    },
+                                    new Entity(qe.EntityName)
+                                    {
+                                        Id = item1Id
+                                    }
+                                }
+                            };
+                        }
+
+                        return new EntityCollection();
+                    }
+                };
+
+                var record = new Query<Account>()
+                    .GetLast(service);
+
+                Assert.IsNotNull(record);
+                Assert.AreEqual(item2Id, record.Id);
+            }
+        }
+
         #endregion IOrganizationService calls
     }
 }
\ No newline at end of file
diff --git a/MscrmTools.FluentQueryExpressions.v8/MscrmTools.FluentQueryExpressions.v8.csproj b/MscrmTools.FluentQueryExpressions.v8/MscrmTools.FluentQueryExpressions.v8.csproj
index 3fd4e69..c1c1d28 100644
--- a/MscrmTools.FluentQueryExpressions.v8/MscrmTools.FluentQueryExpressions.v8.csproj
+++ b/MscrmTools.FluentQueryExpressions.v8/MscrmTools.FluentQueryExpressions.v8.csproj
@@ -21,6 +21,7 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <DocumentationFile>bin\Debug\MscrmTools.FluentQueryExpressions.v8.xml</DocumentationFile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -29,6 +30,7 @@
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <DocumentationFile>bin\Release\MscrmTools.FluentQueryExpressions.v8.xml</DocumentationFile>
   </PropertyGroup>
   <PropertyGroup>
     <SignAssembly>true</SignAssembly>
diff --git a/MscrmTools.FluentQueryExpressions.v8/Properties/AssemblyInfo.cs b/MscrmTools.FluentQueryExpressions.v8/Properties/AssemblyInfo.cs
index ad944c5..762e9e2 100644
--- a/MscrmTools.FluentQueryExpressions.v8/Properties/AssemblyInfo.cs
+++ b/MscrmTools.FluentQueryExpressions.v8/Properties/AssemblyInfo.cs
@@ -31,5 +31,5 @@
 // Vous pouvez spécifier toutes les valeurs ou indiquer les numéros de build et de révision par défaut
 // en utilisant '*', comme indiqué ci-dessous :
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.5.0.0")]
-[assembly: AssemblyFileVersion("1.5.0.0")]
\ No newline at end of file
+[assembly: AssemblyVersion("2.0.0")]
+[assembly: AssemblyFileVersion("2.0.0")]
\ No newline at end of file
diff --git a/MscrmTools.FluentQueryExpressions/MscrmTools.FluentQueryExpressions.csproj b/MscrmTools.FluentQueryExpressions/MscrmTools.FluentQueryExpressions.csproj
index e1035d9..b7df952 100644
--- a/MscrmTools.FluentQueryExpressions/MscrmTools.FluentQueryExpressions.csproj
+++ b/MscrmTools.FluentQueryExpressions/MscrmTools.FluentQueryExpressions.csproj
@@ -22,6 +22,7 @@
     <DefineConstants>TRACE;DEBUG;CRMV9</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <DocumentationFile>bin\Debug\MscrmTools.FluentQueryExpressions.xml</DocumentationFile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -30,6 +31,7 @@
     <DefineConstants>TRACE;CRMV9</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <DocumentationFile>bin\Release\MscrmTools.FluentQueryExpressions.xml</DocumentationFile>
   </PropertyGroup>
   <PropertyGroup>
     <SignAssembly>true</SignAssembly>
diff --git a/MscrmTools.FluentQueryExpressions/Properties/AssemblyInfo.cs b/MscrmTools.FluentQueryExpressions/Properties/AssemblyInfo.cs
index 3714a92..77e5001 100644
--- a/MscrmTools.FluentQueryExpressions/Properties/AssemblyInfo.cs
+++ b/MscrmTools.FluentQueryExpressions/Properties/AssemblyInfo.cs
@@ -31,5 +31,5 @@
 // Vous pouvez spécifier toutes les valeurs ou indiquer les numéros de build et de révision par défaut
 // en utilisant '*', comme indiqué ci-dessous :
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.6.0.0")]
-[assembly: AssemblyFileVersion("1.6.0.0")]
\ No newline at end of file
+[assembly: AssemblyVersion("2.0.0")]
+[assembly: AssemblyFileVersion("2.0.0")]
\ No newline at end of file
diff --git a/MscrmTools.Shared/AppCode/Comparer.cs b/MscrmTools.Shared/AppCode/Comparer.cs
index 45e2f57..299198b 100644
--- a/MscrmTools.Shared/AppCode/Comparer.cs
+++ b/MscrmTools.Shared/AppCode/Comparer.cs
@@ -1,92 +1,269 @@
-using Microsoft.Xrm.Sdk.Query;
+using Microsoft.Xrm.Sdk;
+using Microsoft.Xrm.Sdk.Query;
 using MscrmTools.FluentQueryExpressions;
+using MscrmTools.FluentQueryExpressions.Helpers;
+using System;
+using System.Linq.Expressions;
 
 namespace MscrmTools.Shared.AppCode
 {
-    public class Comparer<T>
+    /// <summary>
+    /// A class to start a column comparison in Dataverse
+    /// </summary>
+    /// <typeparam name="T"><see cref="Query"/>, <see cref="Link"/> or <see cref="Filter"/></typeparam>
+    public class Comparer<T> : Comparer<T, Entity>
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Comparer{T}"/> class.
+        /// </summary>
+        /// <param name="parent">The parent.</param>
+        /// <param name="column">First column to compare.</param>
+        public Comparer(T parent, string column) : base(parent, column)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Comparer{T}"/> class.
+        /// </summary>
+        /// <param name="parent">The parent.</param>
+        /// <param name="tableAlias">Alias of the related table.</param>
+        /// <param name="column">First column to compare.</param>
+        public Comparer(T parent, string tableAlias, string column) : base(parent, tableAlias, column)
+        {
+        }
+    }
+
+    /// <summary>
+    /// A class to start a column comparison in Dataverse
+    /// </summary>
+    /// <typeparam name="T">Query, Link or Filter</typeparam>
+    /// <typeparam name="U">Strongly typed Dataverse table class</typeparam>
+    public class Comparer<T, U> where U : Entity
+    {
+        /// <summary>
+        /// The parent (<see cref="Query"/>, <see cref="Link"/> or <see cref="Filter"/>)
+        /// </summary>
         private readonly T _parent;
 
-        public Comparer(T parent, string attributeName)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Comparer{T, U}"/> class.
+        /// </summary>
+        /// <param name="parent">The parent.</param>
+        /// <param name="column">First column to compare.</param>
+        public Comparer(T parent, string column)
         {
             _parent = parent;
 
-            AttributeName = attributeName;
+            Column = column;
         }
 
-        public Comparer(T parent, string entityName, string attributeName)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Comparer{T, U}"/> class.
+        /// </summary>
+        /// <param name="parent">The parent.</param>
+        /// <param name="tableAlias">Alias of the related table.</param>
+        /// <param name="column">First column to compare.</param>
+        public Comparer(T parent, string tableAlias, string column)
         {
             _parent = parent;
 
-            AttributeName = attributeName;
-            EntityName = entityName;
+            Column = column;
+            TableAlias = tableAlias;
         }
 
-        internal string AttributeName { get; set; }
-        internal string EntityName { get; set; }
+        /// <summary>
+        /// Gets or sets the column.
+        /// </summary>
+        /// <value>
+        /// The column.
+        /// </value>
+        internal string Column { get; set; }
+
+        /// <summary>
+        /// Gets or sets the table alias.
+        /// </summary>
+        /// <value>
+        /// The table alias.
+        /// </value>
+        internal string TableAlias { get; set; }
 
 #if CRMV9
 
-        public T Equal(string attributeName)
+        /// <summary>
+        /// First column value is equal to <paramref name="column"/> value
+        /// </summary>
+        /// <param name="column">Second column to compare</param>
+        /// <returns><typeparamref name="T"/> instance</returns>
+        public T Equal(string column)
+        {
+            var ce = new ConditionExpression(Column, ConditionOperator.Equal, true, column);
+            if (!string.IsNullOrEmpty(TableAlias)) ce.EntityName = TableAlias;
+
+            return AddCondition(ce);
+        }
+
+        /// <summary>
+        /// First column value is equal to <paramref name="column"/> value
+        /// </summary>
+        /// <param name="column">Second column to compare</param>
+        /// <returns><typeparamref name="T"/> instance</returns>
+        public T Equal(Expression<Func<U, object>> column)
         {
-            var ce = new ConditionExpression(AttributeName, ConditionOperator.Equal, true, attributeName);
-            if (!string.IsNullOrEmpty(EntityName)) ce.EntityName = EntityName;
+            var ce = new ConditionExpression(Column, ConditionOperator.Equal, true, AnonymousTypeHelper.GetAttributeName(column));
+            if (!string.IsNullOrEmpty(TableAlias)) ce.EntityName = TableAlias;
 
             return AddCondition(ce);
         }
 
-        public T NotEqual(string attributeName)
+        /// <summary>
+        /// First column value is not equal to <paramref name="column"/> value
+        /// </summary>
+        /// <param name="column">Second column to compare</param>
+        /// <returns><typeparamref name="T"/> instance</returns>
+        public T NotEqual(string column)
         {
-            var ce = new ConditionExpression(AttributeName, ConditionOperator.NotEqual, true, attributeName);
-            if (!string.IsNullOrEmpty(EntityName)) ce.EntityName = EntityName;
+            var ce = new ConditionExpression(Column, ConditionOperator.NotEqual, true, column);
+            if (!string.IsNullOrEmpty(TableAlias)) ce.EntityName = TableAlias;
 
             return AddCondition(ce);
         }
 
-        public T GreaterThan(string attributeName)
+        /// <summary>
+        /// First column value is not equal to <paramref name="column"/> value
+        /// </summary>
+        /// <param name="column">Second column to compare</param>
+        /// <returns><typeparamref name="T"/> instance</returns>
+        public T NotEqual(Expression<Func<U, object>> column)
         {
-            var ce = new ConditionExpression(AttributeName, ConditionOperator.GreaterThan, true, attributeName);
-            if (!string.IsNullOrEmpty(EntityName)) ce.EntityName = EntityName;
+            var ce = new ConditionExpression(Column, ConditionOperator.NotEqual, true, AnonymousTypeHelper.GetAttributeName(column));
+            if (!string.IsNullOrEmpty(TableAlias)) ce.EntityName = TableAlias;
 
             return AddCondition(ce);
         }
 
-        public T GreaterOrEqualThan(string attributeName)
+        /// <summary>
+        /// First column value is greater than <paramref name="column"/> value
+        /// </summary>
+        /// <param name="column">Second column to compare</param>
+        /// <returns><typeparamref name="T"/> instance</returns>
+        public T GreaterThan(string column)
         {
-            var ce = new ConditionExpression(AttributeName, ConditionOperator.GreaterEqual, true, attributeName);
-            if (!string.IsNullOrEmpty(EntityName)) ce.EntityName = EntityName;
+            var ce = new ConditionExpression(Column, ConditionOperator.GreaterThan, true, column);
+            if (!string.IsNullOrEmpty(TableAlias)) ce.EntityName = TableAlias;
 
             return AddCondition(ce);
         }
 
-        public T LessThan(string attributeName)
+        /// <summary>
+        /// First column value is greater than <paramref name="column"/> value
+        /// </summary>
+        /// <param name="column">Second column to compare</param>
+        /// <returns><typeparamref name="T"/> instance</returns>
+        public T GreaterThan(Expression<Func<U, object>> column)
         {
-            var ce = new ConditionExpression(AttributeName, ConditionOperator.LessThan, true, attributeName);
-            if (!string.IsNullOrEmpty(EntityName)) ce.EntityName = EntityName;
+            var ce = new ConditionExpression(Column, ConditionOperator.GreaterThan, true, AnonymousTypeHelper.GetAttributeName(column));
+            if (!string.IsNullOrEmpty(TableAlias)) ce.EntityName = TableAlias;
 
             return AddCondition(ce);
         }
 
-        public T LessOrEqualThan(string attributeName)
+        /// <summary>
+        /// First column value is greater or equal to <paramref name="column"/> value
+        /// </summary>
+        /// <param name="column">Second column to compare</param>
+        /// <returns><typeparamref name="T"/> instance</returns>
+        public T GreaterOrEqualThan(string column)
         {
-            var ce = new ConditionExpression(AttributeName, ConditionOperator.LessEqual, true, attributeName);
-            if (!string.IsNullOrEmpty(EntityName)) ce.EntityName = EntityName;
+            var ce = new ConditionExpression(Column, ConditionOperator.GreaterEqual, true, column);
+            if (!string.IsNullOrEmpty(TableAlias)) ce.EntityName = TableAlias;
 
             return AddCondition(ce);
         }
 
+        /// <summary>
+        /// First column value is greater or equal to <paramref name="column"/> value
+        /// </summary>
+        /// <param name="column">Second column to compare</param>
+        /// <returns><typeparamref name="T"/> instance</returns>
+        public T GreaterOrEqualThan(Expression<Func<U, object>> column)
+        {
+            var ce = new ConditionExpression(Column, ConditionOperator.GreaterEqual, true, AnonymousTypeHelper.GetAttributeName(column));
+            if (!string.IsNullOrEmpty(TableAlias)) ce.EntityName = TableAlias;
+
+            return AddCondition(ce);
+        }
+
+        /// <summary>
+        /// First column value is less than <paramref name="column"/> value
+        /// </summary>
+        /// <param name="column">Second column to compare</param>
+        /// <returns><typeparamref name="T"/> instance</returns>
+        public T LessThan(string column)
+        {
+            var ce = new ConditionExpression(Column, ConditionOperator.LessThan, true, column);
+            if (!string.IsNullOrEmpty(TableAlias)) ce.EntityName = TableAlias;
+
+            return AddCondition(ce);
+        }
+
+        /// <summary>
+        /// First column value is less than <paramref name="column"/> value
+        /// </summary>
+        /// <param name="column">Second column to compare</param>
+        /// <returns><typeparamref name="T"/> instance</returns>
+        public T LessThan(Expression<Func<U, object>> column)
+        {
+            var ce = new ConditionExpression(Column, ConditionOperator.LessThan, true, AnonymousTypeHelper.GetAttributeName(column));
+            if (!string.IsNullOrEmpty(TableAlias)) ce.EntityName = TableAlias;
+
+            return AddCondition(ce);
+        }
+
+        /// <summary>
+        /// First column value is less or equal to <paramref name="column"/> value
+        /// </summary>
+        /// <param name="column">Second column to compare</param>
+        /// <returns><typeparamref name="T"/> instance</returns>
+        public T LessOrEqualThan(string column)
+        {
+            var ce = new ConditionExpression(Column, ConditionOperator.LessEqual, true, column);
+            if (!string.IsNullOrEmpty(TableAlias)) ce.EntityName = TableAlias;
+
+            return AddCondition(ce);
+        }
+
+        /// <summary>
+        /// First column value is less or equal to <paramref name="column"/> value
+        /// </summary>
+        /// <param name="column">Second column to compare</param>
+        /// <returns><typeparamref name="T"/> instance</returns>
+        public T LessOrEqualThan(Expression<Func<U, object>> column)
+        {
+            var ce = new ConditionExpression(Column, ConditionOperator.LessEqual, true, AnonymousTypeHelper.GetAttributeName(column));
+            if (!string.IsNullOrEmpty(TableAlias)) ce.EntityName = TableAlias;
+
+            return AddCondition(ce);
+        }
+
+        /// <summary>
+        /// Add the condition in the parent object
+        /// </summary>
+        /// <param name="ce">the <see cref="ConditionExpression"/></param>
+        /// <returns><typeparamref name="T"/> instance</returns>
         private T AddCondition(ConditionExpression ce)
         {
-            if (typeof(T).IsGenericType && typeof(T).GetGenericTypeDefinition() == typeof(Query<>)
-                || typeof(T) == typeof(Query))
+            if (typeof(T).IsGenericType && typeof(T).GetGenericTypeDefinition() == typeof(Query<>) || typeof(T) == typeof(Query))
             {
                 ((dynamic)_parent).QueryExpression.Criteria.AddCondition(ce);
             }
-            else if (typeof(T) == typeof(Filter))
-                ((Filter)(object)_parent).InnerFilter.AddCondition(ce);
-            else if (typeof(T).IsGenericType && typeof(T).GetGenericTypeDefinition() == typeof(Link<>)
-                     || typeof(T) == typeof(Link))
+            else if (typeof(T).IsGenericType && typeof(T).GetGenericTypeDefinition() == typeof(Filter<>) || typeof(T) == typeof(Filter))
+            {
+                ((dynamic)_parent).InnerFilter.AddCondition(ce);
+            }
+            else
+            {
                 ((dynamic)_parent).InnerLinkEntity.LinkCriteria.AddCondition(ce);
+            }
 
             return _parent;
         }
diff --git a/MscrmTools.Shared/Extensions.cs b/MscrmTools.Shared/Extensions.cs
index 62a0135..dadfa83 100644
--- a/MscrmTools.Shared/Extensions.cs
+++ b/MscrmTools.Shared/Extensions.cs
@@ -3,8 +3,18 @@
 
 namespace MscrmTools.FluentQueryExpressions
 {
+    /// <summary>
+    /// Extensions for the Dataverse <see cref="IOrganizationService"/>
+    /// </summary>
     public static class Extensions
     {
+        /// <summary>
+        /// Retrieves multiple records from a fluent query.
+        /// </summary>
+        /// <typeparam name="T">Strongly typed Dataverse table</typeparam>
+        /// <param name="service">The Dataverse service.</param>
+        /// <param name="query">The fluent query.</param>
+        /// <returns>A list of <typeparamref name="T"/> records</returns>
         public static List<T> RetrieveMultiple<T>(this IOrganizationService service, Query<T> query) where T : Entity
         {
             return query.GetAll(service);
diff --git a/MscrmTools.Shared/Filter.cs b/MscrmTools.Shared/Filter.cs
index 18c80ff..3531985 100644
--- a/MscrmTools.Shared/Filter.cs
+++ b/MscrmTools.Shared/Filter.cs
@@ -1,21 +1,31 @@
-using Microsoft.Xrm.Sdk.Query;
+using Microsoft.Xrm.Sdk;
+using Microsoft.Xrm.Sdk.Query;
+using MscrmTools.FluentQueryExpressions.Helpers;
 using System;
 using System.Collections;
 using System.Linq;
+using System.Linq.Expressions;
 
 namespace MscrmTools.FluentQueryExpressions
 {
-    public class Filter
+    /// <summary>
+    /// A filter in the query
+    /// </summary>
+    public class Filter : Filter<Entity>
     {
-        public Filter(LogicalOperator logicalOperator = LogicalOperator.And)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Filter"/> class.
+        /// </summary>
+        /// <param name="logicalOperator">Logical operator for this filter</param>
+        public Filter(LogicalOperator logicalOperator = LogicalOperator.And) : base(logicalOperator)
         {
-            InnerFilter = new FilterExpression(logicalOperator);
         }
 
-        internal FilterExpression InnerFilter { get; }
-
         #region Filters
 
+        /// <summary>Adds filter(s).</summary>
+        /// <param name="filters">The filters.</param>
+        /// <returns>This <see cref="Filter"></see></returns>
         public Filter AddFilters(params Filter[] filters)
         {
             InnerFilter.Filters.AddRange(filters.Select(f => f.InnerFilter));
@@ -23,1329 +33,1764 @@ public Filter AddFilters(params Filter[] filters)
             return this;
         }
 
-        public Filter AddFilters(LogicalOperator logicalOperator, params Filter[] filters)
-        {
-            InnerFilter.FilterOperator = logicalOperator;
-            InnerFilter.Filters.AddRange(filters.Select(f => f.InnerFilter));
-
-            return this;
-        }
-
-        public Filter SetDefaultFilterOperator(LogicalOperator logicalOperator)
-        {
-            InnerFilter.FilterOperator = logicalOperator;
-
-            return this;
-        }
-
         #endregion Filters
 
         #region Columns Comparer
 
 #if CRMV9
-        public Shared.AppCode.Comparer<Filter> Compare(string attributeName)
+        /// <summary>
+        /// Starts a column comparison
+        /// </summary>
+        /// <param name="column">First column to compare</param>
+        /// <returns>The Comparer</returns>
+        public Shared.AppCode.Comparer<Filter> Compare(string column)
         {
-            return new Shared.AppCode.Comparer<Filter>(this, attributeName);
+            return new Shared.AppCode.Comparer<Filter>(this, column);
         }
 
-        public Shared.AppCode.Comparer<Filter> Compare(string entityName, string attributeName)
+        /// <summary>
+        /// Starts a column comparison
+        /// </summary>
+        /// <param name="alias">Alias of the related table in relationship</param>
+        /// <param name="column">First column to compare</param>
+        /// <returns>The Comparer</returns>
+        public Shared.AppCode.Comparer<Filter> Compare(string alias, string column)
         {
-            return new Shared.AppCode.Comparer<Filter>(this, entityName, attributeName);
+            return new Shared.AppCode.Comparer<Filter>(this, alias, column);
         }
+
 #endif
 
         #endregion Columns Comparer
 
         #region Conditions
 
-        public Filter Where(string attributeName, ConditionOperator conditionOperator, params object[] values)
-        {
-            InnerFilter.AddCondition(attributeName, conditionOperator, values);
-
-            return this;
-        }
-
-        public Filter Where(string entityName, string attributeName, ConditionOperator conditionOperator, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> respects the <paramref name="conditionOperator"/> and the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="conditionOperator">The condition operator.</param>
+        /// <param name="values">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter Where(string column, ConditionOperator conditionOperator, params object[] values)
         {
-            InnerFilter.AddCondition(entityName, attributeName, conditionOperator, values);
+            InnerFilter.AddCondition(column, conditionOperator, values);
 
             return this;
         }
 
-        public Filter WhereAbove(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> respects the <paramref name="conditionOperator"/> and the <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="conditionOperator">The condition operator.</param>
+        /// <param name="values">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter Where(string tableAlias, string column, ConditionOperator conditionOperator, params object[] values)
         {
-            if (entityname != null)
-            {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.Above, value);
-            }
-            else
-            {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.Above, value);
-            }
+            InnerFilter.AddCondition(tableAlias, column, conditionOperator, values);
 
             return this;
         }
 
-        public Filter WhereAboveOrEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is above <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereAbove(string column, Guid value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.AboveOrEqual, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.Above, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.AboveOrEqual, value);
+                InnerFilter.AddCondition(column, ConditionOperator.Above, value);
             }
 
             return this;
         }
 
-        public Filter WhereBeginsWith(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is above or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereAboveOrEqual(string column, object value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.BeginsWith, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.AboveOrEqual, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.BeginsWith, value);
+                InnerFilter.AddCondition(column, ConditionOperator.AboveOrEqual, value);
             }
 
             return this;
         }
 
-        public Filter WhereBetween(string attributeName, object value1, object value2, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value begins with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereBeginsWith(string column, string value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.Between, value1, value2);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.BeginsWith, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.Between, value1, value2);
+                InnerFilter.AddCondition(column, ConditionOperator.BeginsWith, value);
             }
 
             return this;
         }
 
-        public Filter WhereChildOf(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereBetween(string column, object value1, object value2, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.ChildOf, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.Between, value1, value2);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.ChildOf, value);
+                InnerFilter.AddCondition(column, ConditionOperator.Between, value1, value2);
             }
 
             return this;
         }
 
-        public Filter WhereContains(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value contains <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereContains(string column, string value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.Contains, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.Contains, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.Contains, value);
+                InnerFilter.AddCondition(column, ConditionOperator.Contains, value);
             }
 
             return this;
         }
 
 #if CRMV9
-        public Filter WhereContainValues(string attributeName, params object[] values)
+
+        /// <summary>Adds a condition where <paramref name="column"/> contains <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereContainValues(string column, params object[] values)
         {
-            InnerFilter.AddCondition(attributeName, ConditionOperator.ContainValues, values);
+            InnerFilter.AddCondition(column, ConditionOperator.ContainValues, values);
 
             return this;
         }
 
-        public Filter WhereContainValues(string entityname, string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> contains <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereContainValues(string tableAlias, string column, params object[] values)
         {
-            InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.ContainValues, values);
+            InnerFilter.AddCondition(tableAlias, column, ConditionOperator.ContainValues, values);
 
             return this;
         }
+
 #endif
 
-        public Filter WhereDoesNotBeginWith(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not begin with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereDoesNotBeginWith(string column, object value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.DoesNotBeginWith, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.DoesNotBeginWith, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.DoesNotBeginWith, value);
+                InnerFilter.AddCondition(column, ConditionOperator.DoesNotBeginWith, value);
             }
 
             return this;
         }
 
-        public Filter WhereDoesNotContain(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not contain <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereDoesNotContain(string column, object value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.DoesNotContain, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.DoesNotContain, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.DoesNotContain, value);
+                InnerFilter.AddCondition(column, ConditionOperator.DoesNotContain, value);
             }
 
             return this;
         }
+
 #if CRMV9
-        public Filter WhereDoesNotContainValues(string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereDoesNotContainValues(string column, params object[] values)
         {
-            InnerFilter.AddCondition(attributeName, ConditionOperator.DoesNotContainValues, values);
+            InnerFilter.AddCondition(column, ConditionOperator.DoesNotContainValues, values);
 
             return this;
         }
 
-        public Filter WhereDoesNotContainValues(string entityname, string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereDoesNotContainValues(string tableAlias, string column, params object[] values)
         {
-            InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.DoesNotContainValues, values);
+            InnerFilter.AddCondition(tableAlias, column, ConditionOperator.DoesNotContainValues, values);
 
             return this;
         }
+
 #endif
-        public Filter WhereDoesNotEndWith(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not end with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereDoesNotEndWith(string column, string value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.DoesNotEndWith, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.DoesNotEndWith, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.DoesNotEndWith, value);
+                InnerFilter.AddCondition(column, ConditionOperator.DoesNotEndWith, value);
             }
 
             return this;
         }
 
-        public Filter WhereEndsWith(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value ends with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereEndsWith(string column, object value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.EndsWith, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.EndsWith, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.EndsWith, value);
+                InnerFilter.AddCondition(column, ConditionOperator.EndsWith, value);
             }
 
             return this;
         }
 
-        public Filter WhereEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value equals <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereEqual(string column, object value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.Equal, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.Equal, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.Equal, value);
+                InnerFilter.AddCondition(column, ConditionOperator.Equal, value);
             }
 
             return this;
         }
 
-        public Filter WhereEqualBusinessId(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user business unit</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereEqualBusinessId(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.EqualBusinessId);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.EqualBusinessId);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.EqualBusinessId);
+                InnerFilter.AddCondition(column, ConditionOperator.EqualBusinessId);
             }
 
             return this;
         }
 
-        public Filter WhereEqualUserId(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user unique identifier</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereEqualUserId(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.EqualUserId);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.EqualUserId);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.EqualUserId);
+                InnerFilter.AddCondition(column, ConditionOperator.EqualUserId);
             }
 
             return this;
         }
 
-        public Filter WhereEqualUserLanguage(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user language</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereEqualUserLanguage(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.EqualUserLanguage);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.EqualUserLanguage);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.EqualUserLanguage);
+                InnerFilter.AddCondition(column, ConditionOperator.EqualUserLanguage);
             }
 
             return this;
         }
 
-        public Filter WhereEqualUserOrUserHierarchy(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or their reporting hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereEqualUserOrUserHierarchy(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.EqualUserOrUserHierarchy);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.EqualUserOrUserHierarchy);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.EqualUserOrUserHierarchy);
+                InnerFilter.AddCondition(column, ConditionOperator.EqualUserOrUserHierarchy);
             }
 
             return this;
         }
 
-        public Filter WhereEqualUserOrUserHierarchyAndTeams(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user and his teams or their reporting hierarchy and their teams</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereEqualUserOrUserHierarchyAndTeams(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.EqualUserOrUserHierarchyAndTeams);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.EqualUserOrUserHierarchyAndTeams);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName,
+                InnerFilter.AddCondition(column,
                     ConditionOperator.EqualUserOrUserHierarchyAndTeams);
             }
 
             return this;
         }
 
-        public Filter WhereEqualUserOrUserTeams(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or a team the current user is member of</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereEqualUserOrUserTeams(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.EqualUserOrUserTeams);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.EqualUserOrUserTeams);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.EqualUserOrUserTeams);
+                InnerFilter.AddCondition(column, ConditionOperator.EqualUserOrUserTeams);
             }
 
             return this;
         }
 
-        public Filter WhereEqualUserTeams(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> equals a team the current user is member of</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereEqualUserTeams(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.EqualUserTeams);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.EqualUserTeams);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.EqualUserTeams);
+                InnerFilter.AddCondition(column, ConditionOperator.EqualUserTeams);
             }
 
             return this;
         }
 
-        public Filter WhereGreaterEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is greater or equal to <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereGreaterEqual(string column, object value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.GreaterEqual, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.GreaterEqual, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.GreaterEqual, value);
+                InnerFilter.AddCondition(column, ConditionOperator.GreaterEqual, value);
             }
 
             return this;
         }
 
-        public Filter WhereGreaterThan(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is greater than <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereGreaterThan(string column, object value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.GreaterThan, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.GreaterThan, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.GreaterThan, value);
+                InnerFilter.AddCondition(column, ConditionOperator.GreaterThan, value);
             }
 
             return this;
         }
 
-        public Filter WhereIn(string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereIn(string column, IList values)
         {
-            InnerFilter.AddCondition(attributeName, ConditionOperator.In, values);
+            InnerFilter.Conditions.Add(new ConditionExpression(column, ConditionOperator.In, values));
 
             return this;
         }
 
-        public Filter WhereIn(string entityname, string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereIn(string tableAlias, string column, IList values)
         {
-            InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.In, values);
+            InnerFilter.Conditions.Add(new ConditionExpression(tableAlias, column, ConditionOperator.In, values));
 
             return this;
         }
 
-        public Filter WhereIn(string attributeName, IList value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereIn(string column, params object[] values)
         {
-            InnerFilter.Conditions.Add(new ConditionExpression(attributeName, ConditionOperator.In, value));
+            InnerFilter.Conditions.Add(new ConditionExpression(column, ConditionOperator.In, values));
 
             return this;
         }
 
-        public Filter WhereIn(string entityname, string attributeName, IList value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereIn(string tableAlias, string column, params object[] values)
         {
-            InnerFilter.Conditions.Add(new ConditionExpression(entityname, attributeName, ConditionOperator.In, value));
+            InnerFilter.Conditions.Add(new ConditionExpression(tableAlias, column, ConditionOperator.In, values));
 
             return this;
         }
 
-        public Filter WhereInFiscalPeriod(string attributeName, int period, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereInFiscalPeriod(string column, object value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.InFiscalPeriod, period);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.InFiscalPeriod, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.InFiscalPeriod, period);
+                InnerFilter.AddCondition(column, ConditionOperator.InFiscalPeriod, value);
             }
 
             return this;
         }
 
-        public Filter WhereInFiscalPeriodAndYear(string attributeName, int period, int year, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereInFiscalPeriodAndYear(string column, int period, int year, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.InFiscalPeriodAndYear, period, year);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.InFiscalPeriodAndYear, period, year);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.InFiscalPeriodAndYear, period, year);
+                InnerFilter.AddCondition(column, ConditionOperator.InFiscalPeriodAndYear, period, year);
             }
 
             return this;
         }
 
-        public Filter WhereInFiscalYear(string attributeName, int year, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereInFiscalYear(string column, int year, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.InFiscalYear, year);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.InFiscalYear, year);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.InFiscalYear, year);
+                InnerFilter.AddCondition(column, ConditionOperator.InFiscalYear, year);
             }
 
             return this;
         }
 
-        public Filter WhereInOrAfterFiscalPeriodAndYear(string attributeName, int period, int year, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or after the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereInOrAfterFiscalPeriodAndYear(string column, int period, int year, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.InOrAfterFiscalPeriodAndYear, period, year);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.InOrAfterFiscalPeriodAndYear, period, year);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.InOrAfterFiscalPeriodAndYear,
+                InnerFilter.AddCondition(column, ConditionOperator.InOrAfterFiscalPeriodAndYear,
                     period, year);
             }
 
             return this;
         }
 
-        public Filter WhereInOrBeforeFiscalPeriodAndYear(string attributeName, int period, int year, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or before the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereInOrBeforeFiscalPeriodAndYear(string column, int period, int year, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.InOrBeforeFiscalPeriodAndYear, period, year);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.InOrBeforeFiscalPeriodAndYear, period, year);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.InOrBeforeFiscalPeriodAndYear,
+                InnerFilter.AddCondition(column, ConditionOperator.InOrBeforeFiscalPeriodAndYear,
                     period, year);
             }
 
             return this;
         }
 
-        public Filter WhereLast7Days(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on last 7 days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLast7Days(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.Last7Days);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.Last7Days);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.Last7Days);
+                InnerFilter.AddCondition(column, ConditionOperator.Last7Days);
             }
 
             return this;
         }
 
-        public Filter WhereLastFiscalPeriod(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLastFiscalPeriod(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.LastFiscalPeriod);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.LastFiscalPeriod);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.LastFiscalPeriod);
+                InnerFilter.AddCondition(column, ConditionOperator.LastFiscalPeriod);
             }
 
             return this;
         }
 
-        public Filter WhereLastFiscalYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLastFiscalYear(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.LastFiscalYear);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.LastFiscalYear);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.LastFiscalYear);
+                InnerFilter.AddCondition(column, ConditionOperator.LastFiscalYear);
             }
 
             return this;
         }
 
-        public Filter WhereLastMonth(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last month</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLastMonth(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.LastMonth);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.LastMonth);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.LastMonth);
+                InnerFilter.AddCondition(column, ConditionOperator.LastMonth);
             }
 
             return this;
         }
 
-        public Filter WhereLastWeek(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last week</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLastWeek(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.LastWeek);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.LastWeek);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.LastWeek);
+                InnerFilter.AddCondition(column, ConditionOperator.LastWeek);
             }
 
             return this;
         }
 
-        public Filter WhereLastXDays(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLastXDays(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.LastXDays, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.LastXDays, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.LastXDays, value);
+                InnerFilter.AddCondition(column, ConditionOperator.LastXDays, x);
             }
 
             return this;
         }
 
-        public Filter WhereLastXFiscalPeriods(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal periods</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal periods to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLastXFiscalPeriods(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.LastXFiscalPeriods, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.LastXFiscalPeriods, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.LastXFiscalPeriods, value);
+                InnerFilter.AddCondition(column, ConditionOperator.LastXFiscalPeriods, x);
             }
 
             return this;
         }
 
-        public Filter WhereLastXFiscalYears(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLastXFiscalYears(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.LastXFiscalYears, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.LastXFiscalYears, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.LastXFiscalYears, value);
+                InnerFilter.AddCondition(column, ConditionOperator.LastXFiscalYears, x);
             }
 
             return this;
         }
 
-        public Filter WhereLastXHours(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> hours</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLastXHours(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.LastXHours, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.LastXHours, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.LastXHours, value);
+                InnerFilter.AddCondition(column, ConditionOperator.LastXHours, x);
             }
 
             return this;
         }
 
-        public Filter WhereLastXMonths(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> months</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLastXMonths(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.LastXMonths, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.LastXMonths, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.LastXMonths, value);
+                InnerFilter.AddCondition(column, ConditionOperator.LastXMonths, x);
             }
 
             return this;
         }
 
-        public Filter WhereLastXWeeks(string attributeName, int value, string entityname = null)
-        {
-            if (entityname != null)
-            {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.LastXWeeks, value);
-            }
-            else
-            {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.LastXWeeks, value);
-            }
-
-            return this;
-        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> months</summary>
 
-        public Filter WhereLastXYears(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> weeks</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLastXWeeks(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.LastXYears, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.LastXWeeks, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.LastXYears, value);
+                InnerFilter.AddCondition(column, ConditionOperator.LastXWeeks, x);
             }
 
             return this;
         }
 
-        public Filter WhereLastYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLastXYears(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.LastYear);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.LastXYears, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.LastYear);
+                InnerFilter.AddCondition(column, ConditionOperator.LastXYears, x);
             }
 
             return this;
         }
 
-        public Filter WhereLessEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLastYear(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.LessEqual, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.LastYear);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.LessEqual, value);
+                InnerFilter.AddCondition(column, ConditionOperator.LastYear);
             }
 
             return this;
         }
 
-        public Filter WhereLessThan(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is less or equal to <paramref name="value"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLessEqual(string column, object value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.LessThan, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.LessEqual, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.LessThan, value);
+                InnerFilter.AddCondition(column, ConditionOperator.LessEqual, value);
             }
 
             return this;
         }
 
-        public Filter WhereLike(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is less than <paramref name="value"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLessThan(string column, object value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.Like, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.LessThan, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.Like, value);
+                InnerFilter.AddCondition(column, ConditionOperator.LessThan, value);
             }
 
             return this;
         }
 
-        public Filter WhereMask(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value matches the specifed <paramref name="pattern"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereLike(string column, string pattern, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.Mask, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.Like, pattern);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.Mask, value);
+                InnerFilter.AddCondition(column, ConditionOperator.Like, pattern);
             }
 
             return this;
         }
 
-        public Filter WhereMasksSelect(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereMask(string column, object bitmask, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.MasksSelect, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.Mask, bitmask);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.MasksSelect, value);
+                InnerFilter.AddCondition(column, ConditionOperator.Mask, bitmask);
             }
 
             return this;
         }
 
-        public Filter WhereNext7Days(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next 7 days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNext7Days(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.Next7Days);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.Next7Days);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.Next7Days);
+                InnerFilter.AddCondition(column, ConditionOperator.Next7Days);
             }
 
             return this;
         }
 
-        public Filter WhereNextFiscalPeriod(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNextFiscalPeriod(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NextFiscalPeriod);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NextFiscalPeriod);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NextFiscalPeriod);
+                InnerFilter.AddCondition(column, ConditionOperator.NextFiscalPeriod);
             }
 
             return this;
         }
 
-        public Filter WhereNextFiscalYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNextFiscalYear(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NextFiscalYear);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NextFiscalYear);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NextFiscalYear);
+                InnerFilter.AddCondition(column, ConditionOperator.NextFiscalYear);
             }
 
             return this;
         }
 
-        public Filter WhereNextMonth(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next month</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNextMonth(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NextMonth);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NextMonth);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NextMonth);
+                InnerFilter.AddCondition(column, ConditionOperator.NextMonth);
             }
 
             return this;
         }
 
-        public Filter WhereNextWeek(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next week</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNextWeek(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NextWeek);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NextWeek);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NextWeek);
+                InnerFilter.AddCondition(column, ConditionOperator.NextWeek);
             }
 
             return this;
         }
 
-        public Filter WhereNextXDays(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNextXDays(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NextXDays, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NextXDays, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NextXDays, value);
+                InnerFilter.AddCondition(column, ConditionOperator.NextXDays, x);
             }
 
             return this;
         }
 
-        public Filter WhereNextXFiscalPeriods(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal periods</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal perdiods to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNextXFiscalPeriods(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NextXFiscalPeriods, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NextXFiscalPeriods, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NextXFiscalPeriods, value);
+                InnerFilter.AddCondition(column, ConditionOperator.NextXFiscalPeriods, x);
             }
 
             return this;
         }
 
-        public Filter WhereNextXFiscalYears(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNextXFiscalYears(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NextXFiscalYears, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NextXFiscalYears, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NextXFiscalYears, value);
+                InnerFilter.AddCondition(column, ConditionOperator.NextXFiscalYears, x);
             }
 
             return this;
         }
 
-        public Filter WhereNextXHours(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> hours</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNextXHours(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NextXHours, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NextXHours, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NextXHours, value);
+                InnerFilter.AddCondition(column, ConditionOperator.NextXHours, x);
             }
 
             return this;
         }
 
-        public Filter WhereNextXMonths(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> months</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNextXMonths(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NextXMonths, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NextXMonths, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NextXMonths, value);
+                InnerFilter.AddCondition(column, ConditionOperator.NextXMonths, x);
             }
 
             return this;
         }
 
-        public Filter WhereNextXWeeks(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> weeks</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNextXWeeks(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NextXWeeks, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NextXWeeks, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NextXWeeks, value);
+                InnerFilter.AddCondition(column, ConditionOperator.NextXWeeks, x);
             }
 
             return this;
         }
 
-        public Filter WhereNextXYears(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNextXYears(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NextXYears, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NextXYears, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NextXYears, value);
+                InnerFilter.AddCondition(column, ConditionOperator.NextXYears, x);
             }
 
             return this;
         }
 
-        public Filter WhereNextYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNextYear(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NextYear);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NextYear);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NextYear);
+                InnerFilter.AddCondition(column, ConditionOperator.NextYear);
             }
 
             return this;
         }
 
-        public Filter WhereNotBetween(string attributeName, object value1, object value2, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNotBetween(string column, object value1, object value2, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NotBetween, value1, value2);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NotBetween, value1, value2);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NotBetween, value1, value2);
+                InnerFilter.AddCondition(column, ConditionOperator.NotBetween, value1, value2);
             }
 
             return this;
         }
 
-        public Filter WhereNotEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not equal <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNotEqual(string column, object value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NotEqual, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NotEqual, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NotEqual, value);
+                InnerFilter.AddCondition(column, ConditionOperator.NotEqual, value);
             }
 
             return this;
         }
 
-        public Filter WhereNotEqualBusinessId(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user business unit</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNotEqualBusinessId(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NotEqualBusinessId);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NotEqualBusinessId);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NotEqualBusinessId);
+                InnerFilter.AddCondition(column, ConditionOperator.NotEqualBusinessId);
             }
 
             return this;
         }
 
-        public Filter WhereNotEqualUserId(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user unique identifier</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNotEqualUserId(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NotEqualUserId);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NotEqualUserId);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NotEqualUserId);
+                InnerFilter.AddCondition(column, ConditionOperator.NotEqualUserId);
             }
 
             return this;
         }
 
-        public Filter WhereNotIn(string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNotIn(string tableAlias, string column, IList values)
         {
-            InnerFilter.AddCondition(attributeName, ConditionOperator.NotIn, values);
+            InnerFilter.Conditions.Add(new ConditionExpression(tableAlias, column, ConditionOperator.NotIn, values));
 
             return this;
         }
 
-        public Filter WhereNotIn(string entityname, string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNotIn(string column, IList values)
         {
-            InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NotIn, values);
+            InnerFilter.Conditions.Add(new ConditionExpression(column, ConditionOperator.NotIn, values));
 
             return this;
         }
 
-        public Filter WhereNotIn(string attributeName, IList value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNotIn(string column, params object[] values)
         {
-            InnerFilter.AddCondition(attributeName, ConditionOperator.NotIn, value);
+            InnerFilter.AddCondition(column, ConditionOperator.NotIn, values);
 
             return this;
         }
 
-        public Filter WhereNotIn(string entityname, string attributeName, IList value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNotIn(string tableAlias, string column, params object[] values)
         {
-            InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NotIn, value);
+            InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NotIn, values);
 
             return this;
         }
 
-        public Filter WhereNotLike(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not match the specifed <paramref name="pattern"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNotLike(string column, string pattern, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NotLike, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NotLike, pattern);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NotLike, value);
+                InnerFilter.AddCondition(column, ConditionOperator.NotLike, pattern);
             }
 
             return this;
         }
 
-        public Filter WhereNotMask(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNotMask(string column, object bitmask, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NotMask, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NotMask, bitmask);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NotMask, value);
+                InnerFilter.AddCondition(column, ConditionOperator.NotMask, bitmask);
             }
 
             return this;
         }
 
-        public Filter WhereNotNull(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not null</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNotNull(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NotNull);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NotNull);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NotNull);
+                InnerFilter.AddCondition(column, ConditionOperator.NotNull);
             }
 
             return this;
         }
 
-        public Filter WhereNotOn(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNotOn(string column, DateTime datetime, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NotOn, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NotOn, datetime);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NotOn, value);
+                InnerFilter.AddCondition(column, ConditionOperator.NotOn, datetime);
             }
 
             return this;
         }
 
-        public Filter WhereNotUnder(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is above <paramref name="value"/> in the hierarchy </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNotUnder(string column, Guid value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.NotUnder, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.NotUnder, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.NotUnder, value);
+                InnerFilter.AddCondition(column, ConditionOperator.NotUnder, value);
             }
 
             return this;
         }
 
-        public Filter WhereNull(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain data</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereNull(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.Null);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.Null);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.Null);
+                InnerFilter.AddCondition(column, ConditionOperator.Null);
             }
 
             return this;
         }
 
-        public Filter WhereOlderThanXDays(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereOlderThanXDays(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXDays, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.OlderThanXDays, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.OlderThanXDays, value);
+                InnerFilter.AddCondition(column, ConditionOperator.OlderThanXDays, x);
             }
 
             return this;
         }
 
-        public Filter WhereOlderThanXHours(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> hours</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereOlderThanXHours(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXHours, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.OlderThanXHours, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.OlderThanXHours, value);
+                InnerFilter.AddCondition(column, ConditionOperator.OlderThanXHours, x);
             }
 
             return this;
         }
 
-        public Filter WhereOlderThanXMinutes(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> minutes</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of minutes to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereOlderThanXMinutes(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXMinutes, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.OlderThanXMinutes, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.OlderThanXMinutes, value);
+                InnerFilter.AddCondition(column, ConditionOperator.OlderThanXMinutes, x);
             }
 
             return this;
         }
 
-        public Filter WhereOlderThanXMonths(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> months</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereOlderThanXMonths(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXMonths, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.OlderThanXMonths, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.OlderThanXMonths, value);
+                InnerFilter.AddCondition(column, ConditionOperator.OlderThanXMonths, x);
             }
 
             return this;
         }
 
-        public Filter WhereOlderThanXWeeks(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> weeks</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereOlderThanXWeeks(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXWeeks, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.OlderThanXWeeks, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.OlderThanXWeeks, value);
+                InnerFilter.AddCondition(column, ConditionOperator.OlderThanXWeeks, x);
             }
 
             return this;
         }
 
-        public Filter WhereOlderThanXYears(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereOlderThanXYears(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXYears, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.OlderThanXYears, x);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.OlderThanXYears, value);
+                InnerFilter.AddCondition(column, ConditionOperator.OlderThanXYears, x);
             }
 
             return this;
         }
 
-        public Filter WhereOn(string attributeName, DateTime value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereOn(string column, DateTime datetime, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.On, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.On, datetime);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.On, value);
+                InnerFilter.AddCondition(column, ConditionOperator.On, datetime);
             }
 
             return this;
         }
 
-        public Filter WhereOnOrAfter(string attributeName, DateTime value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or after the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereOnOrAfter(string column, DateTime datetime, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.OnOrAfter, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.OnOrAfter, datetime);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.OnOrAfter, value);
+                InnerFilter.AddCondition(column, ConditionOperator.OnOrAfter, datetime);
             }
 
             return this;
         }
 
-        public Filter WhereOnOrBefore(string attributeName, DateTime value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or before the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereOnOrBefore(string column, DateTime datetime, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.OnOrBefore, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.OnOrBefore, datetime);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.OnOrBefore, value);
+                InnerFilter.AddCondition(column, ConditionOperator.OnOrBefore, datetime);
             }
 
             return this;
         }
 
-        public Filter WhereThisFiscalPeriod(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereThisFiscalPeriod(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.ThisFiscalPeriod);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.ThisFiscalPeriod);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.ThisFiscalPeriod);
+                InnerFilter.AddCondition(column, ConditionOperator.ThisFiscalPeriod);
             }
 
             return this;
         }
 
-        public Filter WhereThisFiscalYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereThisFiscalYear(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.ThisFiscalYear);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.ThisFiscalYear);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.ThisFiscalYear);
+                InnerFilter.AddCondition(column, ConditionOperator.ThisFiscalYear);
             }
 
             return this;
         }
 
-        public Filter WhereThisMonth(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current month</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereThisMonth(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.ThisMonth);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.ThisMonth);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.ThisMonth);
+                InnerFilter.AddCondition(column, ConditionOperator.ThisMonth);
             }
 
             return this;
         }
 
-        public Filter WhereThisWeek(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current week</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereThisWeek(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.ThisWeek);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.ThisWeek);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.ThisWeek);
+                InnerFilter.AddCondition(column, ConditionOperator.ThisWeek);
             }
 
             return this;
         }
 
-        public Filter WhereThisYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereThisYear(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.ThisYear);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.ThisYear);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.ThisYear);
+                InnerFilter.AddCondition(column, ConditionOperator.ThisYear);
             }
 
             return this;
         }
 
-        public Filter WhereToday(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current day</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereToday(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.Today);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.Today);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.Today);
+                InnerFilter.AddCondition(column, ConditionOperator.Today);
             }
 
             return this;
         }
 
-        public Filter WhereTomorrow(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is tomorrow</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereTomorrow(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.Tomorrow);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.Tomorrow);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.Tomorrow);
+                InnerFilter.AddCondition(column, ConditionOperator.Tomorrow);
             }
 
             return this;
         }
 
-        public Filter WhereUnder(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is under <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereUnder(string column, Guid value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.Under, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.Under, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.Under, value);
+                InnerFilter.AddCondition(column, ConditionOperator.Under, value);
             }
 
             return this;
         }
 
-        public Filter WhereUnderOrEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is under or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereUnderOrEqual(string column, Guid value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.UnderOrEqual, value);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.UnderOrEqual, value);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.UnderOrEqual, value);
+                InnerFilter.AddCondition(column, ConditionOperator.UnderOrEqual, value);
             }
 
             return this;
         }
 
-        public Filter WhereYesterday(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is yesterday</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter WhereYesterday(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                InnerFilter.AddCondition(entityname, attributeName, ConditionOperator.Yesterday);
+                InnerFilter.AddCondition(tableAlias, column, ConditionOperator.Yesterday);
             }
             else
             {
-                InnerFilter.AddCondition(attributeName, ConditionOperator.Yesterday);
+                InnerFilter.AddCondition(column, ConditionOperator.Yesterday);
             }
 
             return this;
@@ -1353,4 +1798,2164 @@ public Filter WhereYesterday(string attributeName, string entityname = null)
 
         #endregion Conditions
     }
+
+    /// <summary>
+    /// A strongly typed filter in the query
+    /// </summary>
+    public class Filter<T> where T : Entity
+    {
+        #region Constructors
+
+        /// <summary>Initializes a new instance of the <see cref="Filter{T}" /> class.</summary>
+        /// <param name="logicalOperator">The logical operator.</param>
+        public Filter(LogicalOperator logicalOperator = LogicalOperator.And)
+        {
+            InnerFilter = new FilterExpression(logicalOperator);
+        }
+
+        #endregion Constructors
+
+        #region Properties
+
+        /// <summary>
+        /// Get the <see cref="FilterExpression"/> representation of this <see cref="Filter{T}"/>
+        /// </summary>
+        internal FilterExpression InnerFilter { get; }
+
+        #endregion Properties
+
+        #region Filters
+
+        /// <summary>Adds filter(s).</summary>
+        /// <param name="filters">The filters.</param>
+        /// <returns>This <see cref="Filter{T}"></see></returns>
+        public Filter<T> AddFilters(params Filter<T>[] filters)
+        {
+            InnerFilter.Filters.AddRange(filters.Select(f => f.InnerFilter));
+
+            return this;
+        }
+
+        /// <summary>Adds filter(s).</summary>
+        /// <param name="logicalOperator">The logicala operator.</param>
+        /// <param name="filters">The filters.</param>
+        /// <returns>This <see cref="Filter{T}"></see></returns>
+        public Filter<T> AddFilters(LogicalOperator logicalOperator, params Filter<T>[] filters)
+        {
+            InnerFilter.FilterOperator = logicalOperator;
+            InnerFilter.Filters.AddRange(filters.Select(f => f.InnerFilter));
+
+            return this;
+        }
+
+        /// <summary>Sets the logical operator for the this filter</summary>
+        /// <param name="logicalOperator">The logical operator.</param>
+        /// <returns>This <see cref="Filter{T}"></see></returns>
+        public Filter<T> SetLogicalOperator(LogicalOperator logicalOperator)
+        {
+            InnerFilter.FilterOperator = logicalOperator;
+
+            return this;
+        }
+
+        /// <summary>Adds a filter.</summary>
+        /// <param name="filter">The filter.</param>
+        /// <returns>This <see cref="Filter{T}"></see></returns>
+        public Filter<T> AddFilter(Func<Filter<T>, Filter<T>> filter)
+        {
+            var fe = new Filter<T>();
+            filter(fe);
+
+            InnerFilter.Filters.AddRange(fe.InnerFilter);
+
+            return this;
+        }
+
+        /// <summary>Adds a filter.</summary>
+        /// <param name="logicalOperator">The logical operator for the new filter.</param>
+        /// <param name="filter">The filter.</param>
+        /// <returns>This <see cref="Filter{T}"></see></returns>
+        public Filter<T> AddFilter(LogicalOperator logicalOperator, Func<Filter<T>, Filter<T>> filter)
+        {
+            var fe = new Filter<T>(logicalOperator);
+            filter(fe);
+
+            InnerFilter.Filters.AddRange(fe.InnerFilter);
+
+            return this;
+        }
+
+        #endregion Filters
+
+        #region Columns Comparer
+
+#if CRMV9
+
+        /// <summary>
+        /// Starts a column comparison
+        /// </summary>
+        /// <param name="column">First column to compare</param>
+        /// <returns>The Comparer</returns>
+        public Shared.AppCode.Comparer<Filter<T>, T> Compare(Expression<Func<T, object>> column)
+        {
+            return new Shared.AppCode.Comparer<Filter<T>, T>(this, AnonymousTypeHelper.GetAttributeName<T>(column));
+        }
+
+        /// <summary>
+        /// Starts a column comparison
+        /// </summary>
+        /// <param name="alias">Alias of the related table in relationship</param>
+        /// <param name="column">First column to compare</param>
+        /// <returns>The Comparer</returns>
+        public Shared.AppCode.Comparer<Filter<T>, T> Compare(string alias, Expression<Func<T, object>> column)
+        {
+            return new Shared.AppCode.Comparer<Filter<T>, T>(this, alias, AnonymousTypeHelper.GetAttributeName<T>(column));
+        }
+#endif
+
+        #endregion Columns Comparer
+
+        #region Conditions
+
+        /// <summary>Adds a condition where <paramref name="column"/> respects the <paramref name="conditionOperator"/> and the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="conditionOperator">The condition operator.</param>
+        /// <param name="values">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> Where(Expression<Func<T, object>> column, ConditionOperator conditionOperator, params object[] values)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName<T>(column), conditionOperator, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> respects the <paramref name="conditionOperator"/> and the <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="conditionOperator">The condition operator.</param>
+        /// <param name="values">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> Where<U>(string tableAlias, Expression<Func<U, object>> column, ConditionOperator conditionOperator, params object[] values) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), conditionOperator, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> is above <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereAbove(Expression<Func<T, object>> column, object value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Above, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> is above <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereAbove<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Above, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> is above or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereAboveOrEqual(Expression<Func<T, object>> column, object value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.AboveOrEqual, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> is above or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereAboveOrEqual<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.AboveOrEqual, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value begins with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereBeginsWith(Expression<Func<T, object>> column, string value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.BeginsWith, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value begins with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereBeginsWith<U>(string tableAlias, Expression<Func<U, object>> column, string value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.BeginsWith, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereBetween(Expression<Func<T, object>> column, object value1, object value2)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Between, value1, value2);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereBetween<U>(string tableAlias, Expression<Func<U, object>> column, object value1, object value2) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Between, value1, value2);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value contains <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereContains(Expression<Func<T, object>> column, object value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Contains, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value contains <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereContains<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Contains, value);
+
+            return this;
+        }
+
+#if CRMV9
+
+        /// <summary>Adds a condition where <paramref name="column"/> contains <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereContainValues(Expression<Func<T, object>> column, params object[] values)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ContainValues, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> contains <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereContainValues<U>(string tableAlias, Expression<Func<U, object>> column, params object[] values) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ContainValues, values);
+
+            return this;
+        }
+
+#endif
+
+        /// <summary>Adds a condition where <paramref name="column"/> value does not begin with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereDoesNotBeginWith(Expression<Func<T, object>> column, object value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotBeginWith, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value does not begin with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereDoesNotBeginWith<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotBeginWith, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value does not contain <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereDoesNotContain(Expression<Func<T, object>> column, object value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotContain, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value does not contain <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereDoesNotContain<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotContain, value);
+
+            return this;
+        }
+
+#if CRMV9
+
+        /// <summary>Adds a condition where <paramref name="column"/> contdoes not containains <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereDoesNotContainValues(Expression<Func<T, object>> column, params object[] values)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotContainValues, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereDoesNotContainValues<U>(string tableAlias, Expression<Func<U, object>> column, params object[] values) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotContainValues, values);
+
+            return this;
+        }
+#endif
+
+        /// <summary>Adds a condition where <paramref name="column"/> value does not end with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereDoesNotEndWith(Expression<Func<T, object>> column, object value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotEndWith, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value does not end with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereDoesNotEndWith<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotEndWith, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value ends with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEndsWith(Expression<Func<T, object>> column, object value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EndsWith, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value ends with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEndsWith<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EndsWith, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value equals <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqual(Expression<Func<T, object>> column, object value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Equal, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value equals <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqual<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Equal, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user business unit</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqualBusinessId(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualBusinessId);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user business unit</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqualBusinessId<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualBusinessId);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user unique identifier</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqualUserId(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserId);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user unique identifier</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqualUserId<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserId);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user language</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqualUserLanguage(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserLanguage);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user language</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqualUserLanguage<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserLanguage);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or their reporting hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqualUserOrUserHierarchy(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserOrUserHierarchy);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or their reporting hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqualUserOrUserHierarchy<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserOrUserHierarchy);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user and his teams or their reporting hierarchy and their teams</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqualUserOrUserHierarchyAndTeams(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserOrUserHierarchyAndTeams);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user and his teams or their reporting hierarchy and their teams</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqualUserOrUserHierarchyAndTeams<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserOrUserHierarchyAndTeams);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or a team the current user is member of</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqualUserOrUserTeams(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserOrUserTeams);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or a team the current user is member of</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqualUserOrUserTeams<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserOrUserTeams);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals a team the current user is member of</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqualUserTeams(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserTeams);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals a team the current user is member of</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereEqualUserTeams<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserTeams);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> is greater or equal to <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereGreaterEqual(Expression<Func<T, object>> column, object value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.GreaterEqual, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> is greater or equal to <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereGreaterEqual<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.GreaterEqual, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> is greater than <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereGreaterThan(Expression<Func<T, object>> column, object value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.GreaterThan, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> is greater than <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereGreaterThan<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.GreaterThan, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereIn(Expression<Func<T, object>> column, IList values)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.In, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereIn<U>(string tableAlias, Expression<Func<U, object>> column, IList values) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.In, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereIn(Expression<Func<T, object>> column, params object[] values)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.In, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereIn(string tableAlias, Expression<Func<T, object>> column, params object[] values)
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.In, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereInFiscalPeriod(Expression<Func<T, object>> column, object value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InFiscalPeriod, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereInFiscalPeriod<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InFiscalPeriod, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereInFiscalPeriodAndYear(Expression<Func<T, object>> column, int period, int year)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InFiscalPeriodAndYear, period, year);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereInFiscalPeriodAndYear<U>(string tableAlias, Expression<Func<U, object>> column, int period, int year) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InFiscalPeriodAndYear, period, year);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereInFiscalYear(Expression<Func<T, object>> column, int year)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InFiscalYear, year);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereInFiscalYear<U>(string tableAlias, Expression<Func<U, object>> column, int year) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InFiscalYear, year);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or after the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereInOrAfterFiscalPeriodAndYear(Expression<Func<T, object>> column, int period, int year)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InOrAfterFiscalPeriodAndYear, period, year);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or after the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereInOrAfterFiscalPeriodAndYear<U>(string tableAlias, Expression<Func<U, object>> column, int period, int year) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InOrAfterFiscalPeriodAndYear, period, year);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or before the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereInOrBeforeFiscalPeriodAndYear(Expression<Func<T, object>> column, int period, int year)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InOrBeforeFiscalPeriodAndYear, period, year);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or before the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereInOrBeforeFiscalPeriodAndYear<U>(string tableAlias, Expression<Func<U, object>> column, int period, int year) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InOrBeforeFiscalPeriodAndYear, period, year);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on last 7 days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLast7Days(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Last7Days);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on last 7 days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLast7Days<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Last7Days);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastFiscalPeriod(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastFiscalPeriod);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastFiscalPeriod<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastFiscalPeriod);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastFiscalYear(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastFiscalYear);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastFiscalYear<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastFiscalYear);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last month</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastMonth(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastMonth);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last month</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastMonth<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastMonth);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last week</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastWeek(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastWeek);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last week</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastWeek<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastWeek);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastXDays(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXDays, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastXDays<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXDays, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal periods</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal periods to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastXFiscalPeriods(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXFiscalPeriods, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal periods</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal periods to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastXFiscalPeriods<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXFiscalPeriods, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastXFiscalYears(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXFiscalYears, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastXFiscalYears<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXFiscalYears, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> hours</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastXHours(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXHours, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> hours</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastXHours<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXHours, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> months</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastXMonths(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXMonths, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> months</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastXMonths<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXMonths, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> weeks</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastXWeeks(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXWeeks, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> weeks</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastXWeeks<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXWeeks, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastXYears(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXYears, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastXYears<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXYears, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastYear(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastYear);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLastYear<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastYear);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is less or equal to <paramref name="value"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLessEqual(Expression<Func<T, object>> column, int value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LessEqual, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is less or equal to <paramref name="value"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLessEqual<U>(string tableAlias, Expression<Func<U, object>> column, int value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LessEqual, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is less than <paramref name="value"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLessThan(Expression<Func<T, object>> column, int value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LessThan, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is less than <paramref name="value"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLessThan<U>(string tableAlias, Expression<Func<U, object>> column, int value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LessThan, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value matches the specifed <paramref name="pattern"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLike(Expression<Func<T, object>> column, string pattern)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Like, pattern);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value matches the specifed <paramref name="pattern"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereLike<U>(string tableAlias, Expression<Func<U, object>> column, string pattern) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Like, pattern);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereMask(Expression<Func<T, object>> column, object bitmask)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Mask, bitmask);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereMask<U>(string tableAlias, Expression<Func<U, object>> column, object bitmask) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Mask, bitmask);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next 7 days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNext7Days(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Next7Days);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next 7 days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNext7Days<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Next7Days);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextFiscalPeriod(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextFiscalPeriod);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextFiscalPeriod<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextFiscalPeriod);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextFiscalYear(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextFiscalYear);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextFiscalYear<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextFiscalYear);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next month</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextMonth(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextMonth);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next month</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextMonth<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextMonth);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next week</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextWeek(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextWeek);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next week</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextWeek<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextWeek);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextXDays(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXDays, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextXDays<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXDays, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal periods</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal perdiods to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextXFiscalPeriods(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXFiscalPeriods, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal periods</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal perdiods to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextXFiscalPeriods<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXFiscalPeriods, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextXFiscalYears(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXFiscalYears, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextXFiscalYears<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXFiscalYears, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> hours</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextXHours(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXHours, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> hours</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextXHours<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXHours, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> months</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextXMonths(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXMonths, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> months</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextXMonths<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXMonths, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> weeks</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextXWeeks(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXWeeks, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> weeks</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextXWeeks<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXWeeks, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextXYears(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXYears, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextXYears<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXYears, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextYear(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextYear);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNextYear<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextYear);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotBetween(Expression<Func<T, object>> column, object value1, object value2)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotBetween, value1, value2);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotBetween<U>(string tableAlias, Expression<Func<U, object>> column, object value1, object value2) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotBetween, value1, value2);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value does not equal <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotEqual(Expression<Func<T, object>> column, object value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotEqual, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value does not equal <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotEqual<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotEqual, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user business unit</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotEqualBusinessId(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotEqualBusinessId);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user business unit</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotEqualBusinessId<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotEqualBusinessId);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user unique identifier</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotEqualUserId(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotEqualUserId);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user unique identifier</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotEqualUserId<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotEqualUserId);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotIn(Expression<Func<T, object>> column, IList values)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotIn, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotIn(string tableAlias, Expression<Func<T, object>> column, IList values)
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotIn, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotIn(Expression<Func<T, object>> column, params object[] values)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotIn, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotIn(string tableAlias, Expression<Func<T, object>> column, params object[] values)
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotIn, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value does not match the specifed <paramref name="pattern"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotLike(Expression<Func<T, object>> column, string pattern)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotLike, pattern);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value does not match the specifed <paramref name="pattern"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotLike<U>(string tableAlias, Expression<Func<U, object>> column, string pattern) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotLike, pattern);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotMask(Expression<Func<T, object>> column, object bitmask)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotMask, bitmask);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotMask<U>(string tableAlias, Expression<Func<U, object>> column, object bitmask) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotMask, bitmask);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not null</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotNull(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotNull);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not null</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotNull<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotNull);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotOn(Expression<Func<T, object>> column, DateTime datetime)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotOn, datetime);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotOn<U>(string tableAlias, Expression<Func<U, object>> column, DateTime datetime) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotOn, datetime);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is above <paramref name="value"/> in the hierarchy </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotUnder(Expression<Func<T, object>> column, object value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotUnder, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is above <paramref name="value"/> in the hierarchy </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNotUnder<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotUnder, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain data</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNull(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Null);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain data</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereNull<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Null);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOlderThanXDays(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXDays, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOlderThanXDays<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXDays, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> hours</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOlderThanXHours(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXHours, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> hours</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOlderThanXHours<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXHours, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> minutes</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of minutes to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOlderThanXMinutes(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXMinutes, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> minutes</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of minutes to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOlderThanXMinutes<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXMinutes, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> months</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOlderThanXMonths(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXMonths, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> months</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOlderThanXMonths<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXMonths, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> weeks</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOlderThanXWeeks(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXWeeks, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> weeks</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOlderThanXWeeks<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXWeeks, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOlderThanXYears(Expression<Func<T, object>> column, int x)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXYears, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOlderThanXYears<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXYears, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOn(Expression<Func<T, object>> column, DateTime datetime)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.On, datetime);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOn<U>(string tableAlias, Expression<Func<U, object>> column, DateTime datetime) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.On, datetime);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or after the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOnOrAfter(Expression<Func<T, object>> column, DateTime datetime)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OnOrAfter, datetime);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or after the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOnOrAfter<U>(string tableAlias, Expression<Func<U, object>> column, DateTime datetime) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OnOrAfter, datetime);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or before the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOnOrBefore(Expression<Func<T, object>> column, DateTime datetime)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OnOrBefore, datetime);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or before the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereOnOrBefore<U>(string tableAlias, Expression<Func<U, object>> column, DateTime datetime) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OnOrBefore, datetime);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereThisFiscalPeriod(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisFiscalPeriod);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereThisFiscalPeriod<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisFiscalPeriod);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereThisFiscalYear(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisFiscalYear);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereThisFiscalYear<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisFiscalYear);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current month</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereThisMonth(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisMonth);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current month</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereThisMonth<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisMonth);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current week</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereThisWeek(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisWeek);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current week</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereThisWeek<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisWeek);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereThisYear(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisYear);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereThisYear<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisYear);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current day</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereToday(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Today);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current day</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereToday<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Today);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is tomorrow</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereTomorrow(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Tomorrow);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is tomorrow</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereTomorrow<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Tomorrow);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> is under <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereUnder(Expression<Func<T, object>> column, Guid value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Under, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> is under <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereUnder<U>(string tableAlias, Expression<Func<U, object>> column, Guid value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Under, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> is under or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereUnderOrEqual(Expression<Func<T, object>> column, Guid value)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.UnderOrEqual, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> is under or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereUnderOrEqual<U>(string tableAlias, Expression<Func<U, object>> column, Guid value) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.UnderOrEqual, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is yesterday</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereYesterday(Expression<Func<T, object>> column)
+        {
+            InnerFilter.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Yesterday);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is yesterday</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Filter<T> WhereYesterday<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            InnerFilter.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Yesterday);
+
+            return this;
+        }
+
+        #endregion Conditions
+    }
 }
\ No newline at end of file
diff --git a/MscrmTools.Shared/Helpers/AnonymousTypeHelper.cs b/MscrmTools.Shared/Helpers/AnonymousTypeHelper.cs
index 3de7696..fd97a52 100644
--- a/MscrmTools.Shared/Helpers/AnonymousTypeHelper.cs
+++ b/MscrmTools.Shared/Helpers/AnonymousTypeHelper.cs
@@ -18,19 +18,29 @@ internal class AnonymousTypeHelper
         /// <returns></returns>
         /// <exception cref="System.ArgumentException">lambda must return an object initializer</exception>
         public static string[] GetAttributeNamesArray<T>(Expression<Func<T, object>> anonymousTypeInitializer) where T : Entity
-
         {
-            var initializer = anonymousTypeInitializer.Body as NewExpression;
+            var newInitializer = anonymousTypeInitializer.Body as NewExpression;
+            var memberInitializer = anonymousTypeInitializer.Body as MemberExpression;
+            var unaryInitialiazer = anonymousTypeInitializer.Body as UnaryExpression;
 
-            if (initializer?.Members == null)
+            if (newInitializer?.Members == null && memberInitializer?.Member == null && unaryInitialiazer?.Operand == null)
 
             {
                 throw new ArgumentException("lambda must return an object initializer");
             }
 
-            // Search for and replace any occurence of Id with the actual Entity's Id
-
-            return initializer.Members.Select(GetLogicalAttributeName<T>).ToArray();
+            if (newInitializer?.Members != null)
+            {
+                return newInitializer.Members.Select(GetLogicalAttributeName<T>).ToArray();
+            }
+            else if (memberInitializer?.Member != null)
+            {
+                return new string[] { memberInitializer?.Member.Name.ToLower() };
+            }
+            else
+            {
+                return new string[] { ((MemberExpression)unaryInitialiazer?.Operand).Member.Name.ToLower() };
+            }
         }
 
         public static string GetAttributeName<T>(Expression<Func<T, object>> anonymousTypeInitializer) where T : Entity
diff --git a/MscrmTools.Shared/Link.cs b/MscrmTools.Shared/Link.cs
index 4383bf7..d1ec7ad 100644
--- a/MscrmTools.Shared/Link.cs
+++ b/MscrmTools.Shared/Link.cs
@@ -1,1407 +1,2386 @@
 using Microsoft.Xrm.Sdk;
 using Microsoft.Xrm.Sdk.Query;
+using MscrmTools.FluentQueryExpressions.Helpers;
 using System;
 using System.Collections;
 using System.Linq;
+using System.Linq.Expressions;
 
 namespace MscrmTools.FluentQueryExpressions
 {
-    public class Link : Link<Entity>
+    /// <summary>
+    /// A link between two Dataverse table for a query
+    /// </summary>
+    public class Link : Link<Entity, Entity>
     {
+        /// <summary>
+        /// Initialize a new instance of the <see cref="Link"/> class
+        /// </summary>
+        /// <param name="toEntity">Target table logical name</param>
+        /// <param name="toAttribute">Target table column logical name</param>
+        /// <param name="fromAttribute">Source table column logical name</param>
+        /// <param name="joinOperator">Relationship join operator</param>
         public Link(string toEntity, string toAttribute, string fromAttribute, JoinOperator joinOperator = JoinOperator.Inner) :
             base(toEntity, toAttribute, fromAttribute, joinOperator)
         {
             ToEntity = toEntity;
         }
-    }
 
-    public class Link<T> where T : Entity
-    {
-        protected string ToEntity;
+        #region Attributes
+
+        /// <summary>Selects the specified columns from the target table.</summary>
+        /// <param name="columns">The colums.</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link Select(params string[] columns)
+        {
+            InnerLinkEntity.Columns.AddColumns(columns);
+
+            return this;
+        }
+
+        #endregion Attributes
+
+        #region Filters
+
+        /// <summary>
+        /// Adds a filter for the target table
+        /// </summary>
+        /// <param name="filter">Filter</param>
+        /// <returns>The link</returns>
+        public Link AddFilter(Filter filter)
+        {
+            InnerLinkEntity.LinkCriteria.Filters.Add(filter.InnerFilter);
+
+            return this;
+        }
+
+        /// <summary>
+        /// Adds filters for the target table
+        /// </summary>
+        /// <param name="filters">Filters</param>
+        /// <returns>The link</returns>
+        public Link AddFilters(params Filter[] filters)
+        {
+            InnerLinkEntity.LinkCriteria.Filters.AddRange(filters.Select(f => f.InnerFilter));
+
+            return this;
+        }
+
+        #endregion Filters
+
+        #region Link Entities
+
+        /// <summary>Adds a related table as a link.</summary>
+        /// <param name="link">The link.</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link AddLink(Link link)
+        {
+            InnerLinkEntity.LinkEntities.Add(link.InnerLinkEntity);
+            link.InnerLinkEntity.LinkFromEntityName = InnerLinkEntity.LinkToEntityName;
+            return this;
+        }
+        /// <summary>Adds a related table as a link.</summary>
+        /// <param name="sourceColumn">Logical name of the source column in the relationship</param>
+        /// <param name="targetTable">Logical name of the target table</param>
+        /// <param name="targetColumn">Logical name of the target column in the relationship</param>
+        /// <param name="jo">The join operator.</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link AddLink(string sourceColumn, string targetTable, string targetColumn, JoinOperator jo = JoinOperator.Inner)
+        {
+            string fromEntity = InnerLinkEntity.LinkToEntityName;
+
+            var link = new LinkEntity
+            {
+                LinkFromEntityName = fromEntity,
+                LinkFromAttributeName = sourceColumn,
+                LinkToAttributeName = targetColumn,
+                LinkToEntityName = targetTable,
+                JoinOperator = jo,
+                EntityAlias = targetTable
+            };
+
+            InnerLinkEntity.LinkEntities.Add(link);
+            return this;
+        }
+
+        #endregion Link Entities
+
+        #region Order
+
+        /// <summary>
+        /// Order the result of the query by the <paramref name="column"/>
+        /// </summary>
+        /// <param name="column">Column to use to sort results of the query</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link OrderBy(string column)
+        {
+            InnerLinkEntity.Orders.Add(new OrderExpression(column, OrderType.Ascending));
+
+            return this;
+        }
+
+        /// <summary>
+        /// Order the result of the query by the <paramref name="column"/> descending
+        /// </summary>
+        /// <param name="column">Column to use to sort results of the query</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link OrderByDescending(string column)
+        {
+            InnerLinkEntity.Orders.Add(new OrderExpression(column, OrderType.Descending));
+
+            return this;
+        }
+
+        #endregion Order
+
+        #region Columns Comparer
+
+#if CRMV9
+
+        /// <summary>
+        /// Starts a column comparison
+        /// </summary>
+        /// <param name="column">First column to compare</param>
+        /// <returns>The Comparer</returns>
+        public Shared.AppCode.Comparer<Link> Compare(string column)
+        {
+            return new Shared.AppCode.Comparer<Link>(this, column);
+        }
+
+#endif
+
+        #endregion Columns Comparer
+
+        #region Conditions
+
+        /// <summary>Adds a condition where <paramref name="column"/> respects the <paramref name="conditionOperator"/> and the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="conditionOperator">The condition operator.</param>
+        /// <param name="values">The values.</param>
+        /// <returns>The <see cref="Link{T, U}"/></returns>
+        public Link Where(string column, ConditionOperator conditionOperator, params object[] values)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, conditionOperator, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> is above <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereAbove(string column, object value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.Above, value);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> is above or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereAboveOrEqual(string column, object value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.AboveOrEqual, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value begins with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereBeginsWith(string column, string value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.BeginsWith, value);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereBetween(string column, object value1, object value2)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.Between, value1, value2);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value contains <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereContains(string column, object value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.Contains, value);
+
+            return this;
+        }
+#if CRMV9
+
+        /// <summary>Adds a condition where <paramref name="column"/> contains <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereContainValues(string column, params object[] values)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.ContainValues, values);
+
+            return this;
+        }
+
+#endif
+
+        /// <summary>Adds a condition where <paramref name="column"/> value does not begin with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereDoesNotBeginWith(string column, object value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.DoesNotBeginWith, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value does not contain <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereDoesNotContain(string column, object value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.DoesNotContain, value);
+
+            return this;
+        }
+
+#if CRMV9
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereDoesNotContainValues(string column, params object[] values)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.DoesNotContainValues, values);
+
+            return this;
+        }
+
+#endif
+        /// <summary>Adds a condition where <paramref name="column"/> value does not end with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereDoesNotEndWith(string column, string value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.DoesNotEndWith, value);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value ends with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereEndsWith(string column, string value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.EndsWith, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value equals <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereEqual(string column, object value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.Equal, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user business unit</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereEqualBusinessId(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.EqualBusinessId);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user unique identifier</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereEqualUserId(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.EqualUserId);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user language</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereEqualUserLanguage(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.EqualUserLanguage);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or their reporting hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereEqualUserOrUserHierarchy(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.EqualUserOrUserHierarchy);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user and his teams or their reporting hierarchy and their teams</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereEqualUserOrUserHierarchyAndTeams(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.EqualUserOrUserHierarchyAndTeams);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or a team the current user is member of</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereEqualUserOrUserTeams(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.EqualUserOrUserTeams);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> equals a team the current user is member of</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereEqualUserTeams(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.EqualUserTeams);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> is greater or equal to <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereGreaterEqual(string column, object value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.GreaterEqual, value);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> is greater than <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereGreaterThan(string column, object value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.GreaterThan, value);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereIn(string column, IList values)
+        {
+            InnerLinkEntity.LinkCriteria.Conditions.Add(new ConditionExpression(column, ConditionOperator.In, values));
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereIn(string column, params object[] values)
+        {
+            InnerLinkEntity.LinkCriteria.Conditions.Add(new ConditionExpression(column, ConditionOperator.In, values));
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereInFiscalPeriod(string column, object value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.InFiscalPeriod, value);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereInFiscalPeriodAndYear(string column, int period, int year)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.InFiscalPeriodAndYear, period, year);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereInFiscalYear(string column, int year)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.InFiscalYear, year);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or after the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereInOrAfterFiscalPeriodAndYear(string column, int period, int year)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.InOrAfterFiscalPeriodAndYear,
+                period, year);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or before the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereInOrBeforeFiscalPeriodAndYear(string column, int period, int year)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.InOrBeforeFiscalPeriodAndYear,
+                period, year);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on last 7 days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereLast7Days(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.Last7Days);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereLastFiscalPeriod(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.LastFiscalPeriod);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereLastFiscalYear(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.LastFiscalYear);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last month</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereLastMonth(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.LastMonth);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last week</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereLastWeek(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.LastWeek);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereLastXDays(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.LastXDays, x);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal periods</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal periods to evaluate</param>
+        public Link WhereLastXFiscalPeriods(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.LastXFiscalPeriods, x);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereLastXFiscalYears(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.LastXFiscalYears, x);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> hours</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereLastXHours(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.LastXHours, x);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> months</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereLastXMonths(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.LastXMonths, x);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> weeks</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereLastXWeeks(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.LastXWeeks, x);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereLastXYears(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.LastXYears, x);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereLastYear(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.LastYear);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is less or equal to <paramref name="value"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereLessEqual(string column, object value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.LessEqual, value);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is less than <paramref name="value"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereLessThan(string column, object value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.LessThan, value);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value matches the specifed <paramref name="pattern"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereLike(string column, string pattern)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.Like, pattern);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereMask(string column, object bitmask)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.Mask, bitmask);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next 7 days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNext7Days(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.Next7Days);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNextFiscalPeriod(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NextFiscalPeriod);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNextFiscalYear(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NextFiscalYear);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next month</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNextMonth(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NextMonth);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next week</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNextWeek(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NextWeek);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal periods</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNextXDays(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NextXDays, x);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal periods</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal perdiods to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNextXFiscalPeriods(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NextXFiscalPeriods, x);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal years to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNextXFiscalYears(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NextXFiscalYears, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> hours</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNextXHours(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NextXHours, x);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> months</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNextXMonths(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NextXMonths, x);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> weeks</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNextXWeeks(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NextXWeeks, x);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNextXYears(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NextXYears, x);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNextYear(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NextYear);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is not between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNotBetween(string column, object value1, object value2)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NotBetween, value1, value2);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value does not equal <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNotEqual(string column, object value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NotEqual, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user business unit</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNotEqualBusinessId(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NotEqualBusinessId);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user unique identifier</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNotEqualUserId(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NotEqualUserId);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNotIn(string column, IList values)
+        {
+            InnerLinkEntity.LinkCriteria.Conditions.Add(new ConditionExpression(column, ConditionOperator.NotIn, values));
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNotIn(string column, params object[] values)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NotIn, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNotMask(string column, object bitmask)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NotMask, bitmask);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not null</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNotNull(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NotNull);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNotOn(string column, DateTime datetime)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NotOn, datetime);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is above <paramref name="value"/> in the hierarchy </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The date</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereNotUnder(string column, object value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NotUnder, value);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain data</summary>
+        /// <param name="column">Logical name of the column</param>
+        public Link WhereNull(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.Null);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereOlderThanXDays(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.OlderThanXDays, x);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> hours</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereOlderThanXHours(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.OlderThanXHours, x);
+
+            return this;
+        }
 
-        public Link(string toAttribute, string fromAttribute, JoinOperator joinOperator = JoinOperator.Inner)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> minutes</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of minutes to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereOlderThanXMinutes(string column, int x)
         {
-            string toEntity = typeof(T).GetField("EntityLogicalName").GetRawConstantValue().ToString();
-            ToEntity = toEntity;
-            InnerLinkEntity = new LinkEntity(null, toEntity, fromAttribute, toAttribute, joinOperator)
-            { EntityAlias = toEntity };
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.OlderThanXMinutes, x);
+
+            return this;
         }
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> months</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereOlderThanXMonths(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.OlderThanXMonths, x);
 
-        protected Link(string toEntity, string toAttribute, string fromAttribute, JoinOperator joinOperator = JoinOperator.Inner)
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> weeks</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereOlderThanXWeeks(string column, int x)
         {
-            InnerLinkEntity = new LinkEntity(null, toEntity, fromAttribute, toAttribute, joinOperator)
-            { EntityAlias = toEntity };
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.OlderThanXWeeks, x);
+
+            return this;
         }
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereOlderThanXYears(string column, int x)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.OlderThanXYears, x);
 
-        public LinkEntity InnerLinkEntity { get; }
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereOn(string column, DateTime datetime)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.On, datetime);
 
-        public Link<T> AddFilters(params Filter[] filters)
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or after the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereOnOrAfter(string column, DateTime datetime)
         {
-            InnerLinkEntity.LinkCriteria.Filters.AddRange(filters.Select(f => f.InnerFilter));
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.OnOrAfter, datetime);
 
             return this;
         }
 
-        public Link<T> AddFilters(LogicalOperator logicalOperator, params Filter[] filters)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or before the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereOnOrBefore(string column, DateTime datetime)
         {
-            InnerLinkEntity.LinkCriteria.FilterOperator = logicalOperator;
-            InnerLinkEntity.LinkCriteria.Filters.AddRange(filters.Select(f => f.InnerFilter));
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.OnOrBefore, datetime);
 
             return this;
         }
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereThisFiscalPeriod(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.ThisFiscalPeriod);
 
-        public Link<T> AddLink<TU>(Link<TU> link) where TU : Entity
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereThisFiscalYear(string column)
         {
-            string fromEntity = typeof(TU) == typeof(Entity) ? ToEntity : typeof(TU).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.ThisFiscalYear);
 
-            InnerLinkEntity.LinkEntities.Add(link.InnerLinkEntity);
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current month</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereThisMonth(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.ThisMonth);
 
-            link.InnerLinkEntity.LinkFromEntityName = fromEntity;
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current week</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereThisWeek(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.ThisWeek);
 
             return this;
         }
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereThisYear(string column)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.ThisYear);
 
-        public Link<T> Select(bool allColumns)
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current day</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereToday(string column)
         {
-            InnerLinkEntity.Columns = new ColumnSet(allColumns);
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.Today);
 
             return this;
         }
 
-        public Link<T> Select(params string[] attributes)
+        /// <summary>Adds a condition where <paramref name="column"/> value is tomorrow</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereTomorrow(string column)
         {
-            InnerLinkEntity.Columns.AddColumns(attributes);
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.Tomorrow);
 
             return this;
         }
 
-        public Link<T> SetAlias(string alias)
+        /// <summary>Adds a condition where <paramref name="column"/> is under <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereUnder(string column, Guid value)
         {
-            InnerLinkEntity.EntityAlias = alias;
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.Under, value);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> is under or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereUnderOrEqual(string column, Guid value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.UnderOrEqual, value);
 
             return this;
         }
 
-        public Link<T> SetDefaultFilterOperator(LogicalOperator logicalOperator)
+        /// <summary>Adds a condition where <paramref name="column"/> value is yesterday</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link WhereYesterday(string column)
         {
-            InnerLinkEntity.LinkCriteria.FilterOperator = logicalOperator;
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.Yesterday);
 
             return this;
         }
 
-        public Link<T> Order(string attribute, OrderType order)
+        #endregion Conditions
+    }
+
+    /// <summary>
+    /// A link between two Dataverse table for a query
+    /// </summary>
+    /// <typeparam name="T">Strongly typed source table in the relationship</typeparam>
+    /// <typeparam name="U">Strongly typed target table in the relationship</typeparam>
+    public class Link<T, U>
+        where T : Entity
+        where U : Entity
+    {
+        /// <summary>
+        /// Target table
+        /// </summary>
+        protected string ToEntity;
+
+        #region Constructors
+
+        /// <summary>Initializes a new instance of the <see cref="Link{T, U}" /> class.</summary>
+        /// <param name="toAttribute">Logical name of the target table column in the relationship</param>
+        /// <param name="fromAttribute">Logical name of the source table column in the relationship</param>
+        /// <param name="joinOperator">The join operator.</param>
+        public Link(string toAttribute, string fromAttribute, JoinOperator joinOperator = JoinOperator.Inner)
+        {
+            string toEntity = typeof(U).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+            ToEntity = toEntity;
+            InnerLinkEntity = new LinkEntity(null, toEntity, fromAttribute, toAttribute, joinOperator)
+            { EntityAlias = toEntity };
+        }
+
+        /// <summary>Initializes a new instance of the <see cref="Link{T, U}" /> class.</summary>
+        /// <param name="toAttribute">Logical name of the target table column in the relationship</param>
+        /// <param name="fromAttribute">Logical name of the source table column in the relationship</param>
+        /// <param name="joinOperator">The join operator.</param>
+        public Link(Expression<Func<T, object>> fromAttribute, Expression<Func<U, object>> toAttribute, JoinOperator joinOperator = JoinOperator.Inner)
+        {
+            string fromEntity = typeof(T).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+            string toEntity = typeof(U).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+            ToEntity = toEntity;
+            InnerLinkEntity = new LinkEntity(fromEntity, toEntity, AnonymousTypeHelper.GetAttributeName(fromAttribute), AnonymousTypeHelper.GetAttributeName(toAttribute), joinOperator)
+            { EntityAlias = toEntity };
+        }
+
+        /// <summary>Initializes a new instance of the <see cref="Link{T, U}" /> class.</summary>
+        /// <param name="toEntity">Logical name of the target table</param>
+        /// <param name="toAttribute">Logical name of the target table column in the relationship</param>
+        /// <param name="fromAttribute">Logical name of the source table column in the relationship</param>
+        /// <param name="joinOperator">The join operator.</param>
+        protected Link(string toEntity, string toAttribute, string fromAttribute, JoinOperator joinOperator = JoinOperator.Inner)
+        {
+            InnerLinkEntity = new LinkEntity(null, toEntity, fromAttribute, toAttribute, joinOperator)
+            { EntityAlias = toEntity };
+        }
+
+        /// <summary>Initializes a new instance of the <see cref="Link{T, U}" /> class.</summary>
+        /// <param name="fromEntity">Logical name of the source table</param>
+        /// <param name="toEntity">Logical name of the target table</param>
+        /// <param name="toAttribute">Logical name of the target table column in the relationship</param>
+        /// <param name="fromAttribute">Logical name of the source table column in the relationship</param>
+        /// <param name="joinOperator">The join operator.</param>
+        public Link(string fromEntity, string toEntity, string fromAttribute, string toAttribute, JoinOperator joinOperator = JoinOperator.Inner)
+        {
+            InnerLinkEntity = new LinkEntity(fromEntity, toEntity, fromAttribute, toAttribute, joinOperator)
+            { EntityAlias = toEntity };
+        }
+
+        #endregion Constructors
+
+        #region Properties
+
+        /// <summary>
+        /// Get the inner <see cref="LinkEntity"/> of this link
+        /// </summary>
+        public LinkEntity InnerLinkEntity { get; }
+
+        #endregion Properties
+
+        #region Link
+
+        /// <summary>Set the column for the relationship from the source table</summary>
+        /// <param name="column">The column</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> From(Expression<Func<T, object>> column)
         {
-            InnerLinkEntity.Orders.Add(new OrderExpression(attribute, order));
+            InnerLinkEntity.LinkFromAttributeName = AnonymousTypeHelper.GetAttributeName(column);
 
             return this;
         }
 
-        #region Columns Comparer
+        /// <summary>Set the column for the relationship from the target table</summary>
+        /// <param name="column">The column</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> To(Expression<Func<U, object>> column)
+        {
+            InnerLinkEntity.LinkToAttributeName = AnonymousTypeHelper.GetAttributeName(column);
 
-#if CRMV9
-        public Shared.AppCode.Comparer<Link<T>> Compare(string attributeName)
+            return this;
+        }
+
+        /// <summary>Set the join operator for the relationship</summary>
+        /// <param name="joinOperator">The join operator</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> SetJoin(JoinOperator joinOperator)
         {
-            return new Shared.AppCode.Comparer<Link<T>>(this, attributeName);
+            InnerLinkEntity.JoinOperator = joinOperator;
+
+            return this;
         }
 
-        public Shared.AppCode.Comparer<Link<T>> Compare(string entityName, string attributeName)
+        /// <summary>Set the alias for the relationship</summary>
+        /// <param name="alias">The alias</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> SetAlias(string alias)
         {
-            return new Shared.AppCode.Comparer<Link<T>>(this, entityName, attributeName);
+            InnerLinkEntity.EntityAlias = alias;
+
+            return this;
         }
-#endif
 
-        #endregion Columns Comparer
+        #endregion Link
 
-        #region Conditions
+        #region Attributes
 
-        public Link<T> Where(string attributeName, ConditionOperator conditionOperator, params object[] values)
+        /// <summary>Selects all columns of the target table</summary>
+        /// <param name="allColumns">if set to <c>true</c>, retrieves all columns, else retrieves no column.</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> Select(bool allColumns = false)
         {
-            InnerLinkEntity.LinkCriteria.AddCondition(attributeName, conditionOperator, values);
+            InnerLinkEntity.Columns = new ColumnSet(allColumns);
+
+            return this;
+        }
 
+        /// <summary>Selects the specified columns from the target table.
+        /// <example>
+        /// For one column:
+        /// <code>
+        /// link.Select(a => a.AccountId);
+        /// </code>
+        /// For multiple columns:
+        /// <code>
+        /// link.Select(a => new { a.AccountId, a.Name});
+        /// </code>
+        /// </example>
+        /// </summary>
+        /// <param name="column">The column(s).</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> Select(Expression<Func<U, object>> column)
+        {
+            InnerLinkEntity.Columns.AddColumns(AnonymousTypeHelper.GetAttributeNamesArray(column));
             return this;
         }
 
-        public Link<T> Where(string entityName, string attributeName, ConditionOperator conditionOperator, params object[] values)
+        #endregion Attributes
+
+        #region Filters
+
+        /// <summary>Adds a filter.</summary>
+        /// <param name="filter">The filter.</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> AddFilter(Filter<U> filter)
         {
-            InnerLinkEntity.LinkCriteria.AddCondition(entityName, attributeName, conditionOperator, values);
+            InnerLinkEntity.LinkCriteria.Filters.Add(filter.InnerFilter);
 
             return this;
         }
 
-        public Link<T> WhereAbove(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a filter.</summary>
+        /// <param name="filter">The filter as a lambda expression</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> AddFilter(Func<Filter<U>, Filter<U>> filter)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.Above, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.Above, value);
-            }
+            var fe = new Filter<U>();
+            filter(fe);
+
+            InnerLinkEntity.LinkCriteria.Filters.Add(fe.InnerFilter);
 
             return this;
         }
 
-        public Link<T> WhereAboveOrEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds multiple filters.</summary>
+        /// <param name="filters">The filters.</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> AddFilters(params Filter<U>[] filters)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.AboveOrEqual, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.AboveOrEqual, value);
-            }
+            InnerLinkEntity.LinkCriteria.Filters.AddRange(filters.Select(f => f.InnerFilter));
 
             return this;
         }
 
-        public Link<T> WhereBeginsWith(string attributeName, object value, string entityname = null)
+        /// <summary>Adds multiple filters.</summary>
+        /// <param name="filters">The filters.</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> AddFilters(params Func<Filter<U>, Filter<U>>[] filters)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.BeginsWith, value);
-            }
-            else
+            foreach (var filter in filters)
             {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.BeginsWith, value);
+                var fe = new Filter<U>();
+                filter(fe);
+
+                InnerLinkEntity.LinkCriteria.Filters.Add(fe.InnerFilter);
             }
 
             return this;
         }
 
-        public Link<T> WhereBetween(string attributeName, object value1, object value2, string entityname = null)
+        /// <summary>Sets the logical operator for the link root filter</summary>
+        /// <param name="logicalOperator">The logical operator.</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> SetLogicalOperator(LogicalOperator logicalOperator)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.Between, value1, value2);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.Between, value1, value2);
-            }
+            InnerLinkEntity.LinkCriteria.FilterOperator = logicalOperator;
 
             return this;
         }
 
-        public Link<T> WhereChildOf(string attributeName, object value, string entityname = null)
+        #endregion Filters
+
+        #region Link Entities
+
+        /// <summary>Adds a related table as a link.</summary>
+        /// <param name="link">The link.</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> AddLink<V>(Link<U, V> link) where V : Entity
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.ChildOf, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.ChildOf, value);
-            }
+            string fromEntity = typeof(U).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+
+            InnerLinkEntity.LinkEntities.Add(link.InnerLinkEntity);
+
+            link.InnerLinkEntity.LinkFromEntityName = fromEntity;
 
             return this;
         }
 
-        public Link<T> WhereContains(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a related table as a link.</summary>
+        /// <param name="sourceColumn">Logical name of the source column in the relationship</param>
+        /// <param name="targetColumn">Logical name of the target column in the relationship</param>
+        /// <param name="link">The link as lambda expression</param>
+        /// <param name="jo">The join operator.</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> AddLink<V>(Expression<Func<U, object>> sourceColumn, Expression<Func<V, object>> targetColumn, Func<Link<U, V>, Link<U, V>> link, JoinOperator jo = JoinOperator.Inner) where V : Entity
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.Contains, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.Contains, value);
-            }
+            string fromEntity = typeof(U).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+            string fromAttr = AnonymousTypeHelper.GetAttributeName(sourceColumn);
+            string toAttr = AnonymousTypeHelper.GetAttributeName(targetColumn);
+            string toEntity = typeof(V).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+
+            var le = new Link<U, V>(fromEntity, toEntity, fromAttr, toAttr, jo);
+
+            link(le);
+
+            InnerLinkEntity.LinkEntities.Add(le.InnerLinkEntity);
 
             return this;
         }
-#if CRMV9
-        public Link<T> WhereContainValues(string attributeName, params object[] values)
+
+        /// <summary>Adds a related table as a link.</summary>
+        /// <param name="link">The link as lambda expression</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> AddLink<V>(Func<Link<U, V>, Link<U, V>> link) where V : Entity
         {
-            InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.ContainValues, values);
+            string fromEntity = typeof(U).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+            string toEntity = typeof(V).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+
+            var le = new Link<U, V>(fromEntity, toEntity, null, null, JoinOperator.Inner);
+
+            link(le);
+
+            InnerLinkEntity.LinkEntities.Add(le.InnerLinkEntity);
 
             return this;
         }
 
-        public Link<T> WhereContainValues(string entityname, string attributeName, params object[] values)
+        /// <summary>Adds a related table as a link.</summary>
+        /// <param name="sourceColumn">Logical name of the source column in the relationship</param>
+        /// <param name="targetColumn">Logical name of the target column in the relationship</param>
+        /// <param name="jo">The join operator.</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> AddLink<V>(Expression<Func<U, object>> sourceColumn, Expression<Func<V, object>> targetColumn, JoinOperator jo = JoinOperator.Inner) where V : Entity
         {
-            InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.ContainValues, values);
+            string fromEntity = typeof(U).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+            string fromAttr = AnonymousTypeHelper.GetAttributeName(sourceColumn);
+            string toAttr = AnonymousTypeHelper.GetAttributeName(targetColumn);
+            string toEntity = typeof(V).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+
+            var le = new Link<U, V>(fromEntity, toEntity, fromAttr, toAttr, jo);
+
+            InnerLinkEntity.LinkEntities.Add(le.InnerLinkEntity);
 
             return this;
         }
-#endif
-        public Link<T> WhereDoesNotBeginWith(string attributeName, object value, string entityname = null)
+
+        #endregion Link Entities
+
+        #region Order
+
+        /// <summary>
+        /// Order the result of the query by the <paramref name="column"/>
+        /// </summary>
+        /// <param name="column">Column to use to sort results of the query</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> OrderBy(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.DoesNotBeginWith, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.DoesNotBeginWith, value);
-            }
+            InnerLinkEntity.Orders.Add(new OrderExpression(AnonymousTypeHelper.GetAttributeName(column), OrderType.Ascending));
 
             return this;
         }
 
-        public Link<T> WhereDoesNotContain(string attributeName, object value, string entityname = null)
+        /// <summary>
+        /// Order the result of the query by the <paramref name="column"/> descending
+        /// </summary>
+        /// <param name="column">Column to use to sort results of the query</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Link<T, U> OrderByDescending(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.DoesNotContain, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.DoesNotContain, value);
-            }
+            InnerLinkEntity.Orders.Add(new OrderExpression(AnonymousTypeHelper.GetAttributeName(column), OrderType.Descending));
 
             return this;
         }
+
+        #endregion Order
+
+        #region Columns Comparer
+
 #if CRMV9
-        public Link<T> WhereDoesNotContainValues(string attributeName, params object[] values)
+
+        /// <summary>
+        /// Starts a column comparison
+        /// </summary>
+        /// <param name="column">First column to compare</param>
+        /// <returns>The Comparer</returns>
+        public Shared.AppCode.Comparer<Link<T, U>, U> Compare(Expression<Func<U, object>> column)
+        {
+            return new Shared.AppCode.Comparer<Link<T, U>, U>(this, AnonymousTypeHelper.GetAttributeName(column));
+        }
+
+#endif
+
+        #endregion Columns Comparer
+
+        #region Conditions
+
+        /// <summary>Adds a condition where <paramref name="column"/> respects the <paramref name="conditionOperator"/> and the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="conditionOperator">The condition operator.</param>
+        /// <param name="values">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> Where(Expression<Func<U, object>> column, ConditionOperator conditionOperator, params object[] values)
         {
-            InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.DoesNotContainValues, values);
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), conditionOperator, values);
 
             return this;
         }
 
-        public Link<T> WhereDoesNotContainValues(string entityname, string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> is above <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereAbove(Expression<Func<U, object>> column, object value)
         {
-            InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.DoesNotContainValues, values);
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Above, value);
 
             return this;
         }
-#endif
 
-        public Link<T> WhereDoesNotEndWith(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is above or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereAboveOrEqual(Expression<Func<U, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.DoesNotEndWith, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.DoesNotEndWith, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.AboveOrEqual, value);
 
             return this;
         }
 
-        public Link<T> WhereEndsWith(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value begins with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereBeginsWith(Expression<Func<U, object>> column, string value)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.EndsWith, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.EndsWith, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.BeginsWith, value);
 
             return this;
         }
 
-        public Link<T> WhereEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereBetween(Expression<Func<U, object>> column, object value1, object value2)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.Equal, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.Equal, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Between, value1, value2);
+
+            return this;
+        }
+        /// <summary>Adds a condition where <paramref name="column"/> value contains <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereContains(Expression<Func<U, object>> column, object value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Contains, value);
 
             return this;
         }
 
-        public Link<T> WhereEqualBusinessId(string attributeName, string entityname = null)
+#if CRMV9
+
+        /// <summary>Adds a condition where <paramref name="column"/> contains <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereContainValues(Expression<Func<U, object>> column, params object[] values)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.EqualBusinessId);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.EqualBusinessId);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ContainValues, values);
 
             return this;
         }
 
-        public Link<T> WhereEqualUserId(string attributeName, string entityname = null)
+#endif
+        /// <summary>Adds a condition where <paramref name="column"/> value does not begin with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereDoesNotBeginWith(Expression<Func<U, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.EqualUserId);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.EqualUserId);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotBeginWith, value);
 
             return this;
         }
 
-        public Link<T> WhereEqualUserLanguage(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not contain <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereDoesNotContain(Expression<Func<U, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.EqualUserLanguage);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.EqualUserLanguage);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotContain, value);
 
             return this;
         }
 
-        public Link<T> WhereEqualUserOrUserHierarchy(string attributeName, string entityname = null)
+#if CRMV9
+
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereDoesNotContainValues(Expression<Func<U, object>> column, params object[] values)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.EqualUserOrUserHierarchy);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.EqualUserOrUserHierarchy);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotContainValues, values);
 
             return this;
         }
 
-        public Link<T> WhereEqualUserOrUserHierarchyAndTeams(string attributeName, string entityname = null)
+#endif
+
+        /// <summary>Adds a condition where <paramref name="column"/> value does not end with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereDoesNotEndWith(Expression<Func<U, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.EqualUserOrUserHierarchyAndTeams);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName,
-                    ConditionOperator.EqualUserOrUserHierarchyAndTeams);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotEndWith, value);
 
             return this;
         }
 
-        public Link<T> WhereEqualUserOrUserTeams(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value ends with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereEndsWith(Expression<Func<U, object>> column, string value)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.EqualUserOrUserTeams);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.EqualUserOrUserTeams);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EndsWith, value);
 
             return this;
         }
 
-        public Link<T> WhereEqualUserTeams(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value equals <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereEqual(Expression<Func<U, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.EqualUserTeams);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.EqualUserTeams);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Equal, value);
 
             return this;
         }
 
-        public Link<T> WhereGreaterEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user business unit</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereEqualBusinessId(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.GreaterEqual, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.GreaterEqual, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualBusinessId);
 
             return this;
         }
 
-        public Link<T> WhereGreaterThan(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user unique identifier</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereEqualUserId(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.GreaterThan, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.GreaterThan, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserId);
 
             return this;
         }
 
-        public Link<T> WhereIn(string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user language</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereEqualUserLanguage(Expression<Func<U, object>> column)
         {
-            InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.In, values);
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserLanguage);
 
             return this;
         }
 
-        public Link<T> WhereIn(string entityname, string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or their reporting hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereEqualUserOrUserHierarchy(Expression<Func<U, object>> column)
         {
-            InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.In, values);
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserOrUserHierarchy);
 
             return this;
         }
 
-        public Link<T> WhereIn(string attributeName, IList value)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user and his teams or their reporting hierarchy and their teams</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereEqualUserOrUserHierarchyAndTeams(Expression<Func<U, object>> column)
         {
-            InnerLinkEntity.LinkCriteria.Conditions.Add(new ConditionExpression(attributeName, ConditionOperator.In, value));
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserOrUserHierarchyAndTeams);
 
             return this;
         }
 
-        public Link<T> WhereIn(string entityname, string attributeName, IList value)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or a team the current user is member of</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereEqualUserOrUserTeams(Expression<Func<U, object>> column)
         {
-            InnerLinkEntity.LinkCriteria.Conditions.Add(new ConditionExpression(entityname, attributeName, ConditionOperator.In, value));
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserOrUserTeams);
 
             return this;
         }
 
-        public Link<T> WhereInFiscalPeriod(string attributeName, int period, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> equals a team the current user is member of</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereEqualUserTeams(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.InFiscalPeriod, period);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.InFiscalPeriod, period);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserTeams);
 
             return this;
         }
 
-        public Link<T> WhereInFiscalPeriodAndYear(string attributeName, int period, int year, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is greater or equal to <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereGreaterEqual(Expression<Func<U, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.InFiscalPeriodAndYear, period, year);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.InFiscalPeriodAndYear, period, year);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.GreaterEqual, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> is greater than <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereGreaterThan(Expression<Func<U, object>> column, object value)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.GreaterThan, value);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereIn(Expression<Func<U, object>> column, IList values)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.In, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereIn(Expression<Func<U, object>> column, params object[] values)
+        {
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.In, values);
 
             return this;
         }
 
-        public Link<T> WhereInFiscalYear(string attributeName, int year, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereInFiscalPeriod(Expression<Func<U, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.InFiscalYear, year);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.InFiscalYear, year);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InFiscalPeriod, value);
 
             return this;
         }
 
-        public Link<T> WhereInOrAfterFiscalPeriodAndYear(string attributeName, int period, int year, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereInFiscalPeriodAndYear(Expression<Func<U, object>> column, int period, int year)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.InOrAfterFiscalPeriodAndYear, period, year);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.InOrAfterFiscalPeriodAndYear,
-                    period, year);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InFiscalPeriodAndYear, period, year);
 
             return this;
         }
 
-        public Link<T> WhereInOrBeforeFiscalPeriodAndYear(string attributeName, int period, int year, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereInFiscalYear(Expression<Func<U, object>> column, int year)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.InOrBeforeFiscalPeriodAndYear, period, year);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.InOrBeforeFiscalPeriodAndYear,
-                    period, year);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InFiscalYear, year);
 
             return this;
         }
 
-        public Link<T> WhereLast7Days(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or after the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereInOrAfterFiscalPeriodAndYear(Expression<Func<U, object>> column, int period, int year)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.Last7Days);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.Last7Days);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InOrAfterFiscalPeriodAndYear, period, year);
 
             return this;
         }
 
-        public Link<T> WhereLastFiscalPeriod(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or before the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereInOrBeforeFiscalPeriodAndYear(Expression<Func<U, object>> column, int period, int year)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.LastFiscalPeriod);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.LastFiscalPeriod);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InOrBeforeFiscalPeriodAndYear, period, year);
 
             return this;
         }
 
-        public Link<T> WhereLastFiscalYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on last 7 days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereLast7Days(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.LastFiscalYear);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.LastFiscalYear);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Last7Days);
 
             return this;
         }
 
-        public Link<T> WhereLastMonth(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereLastFiscalPeriod(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.LastMonth);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.LastMonth);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastFiscalPeriod);
 
             return this;
         }
 
-        public Link<T> WhereLastWeek(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereLastFiscalYear(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.LastWeek);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.LastWeek);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastFiscalYear);
 
             return this;
         }
 
-        public Link<T> WhereLastXDays(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last month</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereLastMonth(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.LastXDays, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.LastXDays, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastMonth);
 
             return this;
         }
 
-        public Link<T> WhereLastXFiscalPeriods(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last week</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereLastWeek(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.LastXFiscalPeriods, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.LastXFiscalPeriods, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastWeek);
 
             return this;
         }
 
-        public Link<T> WhereLastXFiscalYears(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereLastXDays(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.LastXFiscalYears, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.LastXFiscalYears, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXDays, x);
 
             return this;
         }
 
-        public Link<T> WhereLastXHours(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal periods</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal periods to evaluate</param>
+        public Link<T, U> WhereLastXFiscalPeriods(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.LastXHours, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.LastXHours, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXFiscalPeriods, x);
 
             return this;
         }
 
-        public Link<T> WhereLastXMonths(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereLastXFiscalYears(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.LastXMonths, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.LastXMonths, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXFiscalYears, x);
 
             return this;
         }
 
-        public Link<T> WhereLastXWeeks(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> hours</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereLastXHours(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.LastXWeeks, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.LastXWeeks, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXHours, x);
 
             return this;
         }
 
-        public Link<T> WhereLastXYears(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> months</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereLastXMonths(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.LastXYears, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.LastXYears, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXMonths, x);
 
             return this;
         }
 
-        public Link<T> WhereLastYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> weeks</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereLastXWeeks(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.LastYear);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.LastYear);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXWeeks, x);
 
             return this;
         }
 
-        public Link<T> WhereLessEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereLastXYears(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.LessEqual, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.LessEqual, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXYears, x);
 
             return this;
         }
 
-        public Link<T> WhereLessThan(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereLastYear(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.LessThan, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.LessThan, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastYear);
 
             return this;
         }
 
-        public Link<T> WhereLike(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is less or equal to <paramref name="value"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereLessEqual(Expression<Func<U, object>> column, int value)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.Like, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.Like, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LessEqual, value);
 
             return this;
         }
 
-        public Link<T> WhereMask(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is less than <paramref name="value"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereLessThan(Expression<Func<U, object>> column, int value)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.Mask, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.Mask, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LessThan, value);
 
             return this;
         }
 
-        public Link<T> WhereMasksSelect(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value matches the specifed <paramref name="pattern"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereLike(Expression<Func<U, object>> column, string pattern)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.MasksSelect, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.MasksSelect, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Like, pattern);
 
             return this;
         }
 
-        public Link<T> WhereNext7Days(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereMask(Expression<Func<U, object>> column, object bitmask)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.Next7Days);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.Next7Days);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Mask, bitmask);
 
             return this;
         }
 
-        public Link<T> WhereNextFiscalPeriod(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next 7 days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNext7Days(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NextFiscalPeriod);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NextFiscalPeriod);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Next7Days);
 
             return this;
         }
 
-        public Link<T> WhereNextFiscalYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNextFiscalPeriod(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NextFiscalYear);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NextFiscalYear);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextFiscalPeriod);
 
             return this;
         }
 
-        public Link<T> WhereNextMonth(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNextFiscalYear(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NextMonth);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NextMonth);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextFiscalYear);
 
             return this;
         }
 
-        public Link<T> WhereNextWeek(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next month</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNextMonth(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NextWeek);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NextWeek);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextMonth);
 
             return this;
         }
 
-        public Link<T> WhereNextXDays(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next week</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNextWeek(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NextXDays, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NextXDays, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextWeek);
 
             return this;
         }
 
-        public Link<T> WhereNextXFiscalPeriods(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal periods</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNextXDays(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NextXFiscalPeriods, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NextXFiscalPeriods, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXDays, x);
 
             return this;
         }
 
-        public Link<T> WhereNextXFiscalYears(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal periods</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal perdiods to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNextXFiscalPeriods(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NextXFiscalYears, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NextXFiscalYears, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXFiscalPeriods, x);
 
             return this;
         }
 
-        public Link<T> WhereNextXHours(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal years to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNextXFiscalYears(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NextXHours, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NextXHours, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXFiscalYears, x);
 
             return this;
         }
 
-        public Link<T> WhereNextXMonths(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> hours</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNextXHours(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NextXMonths, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NextXMonths, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXHours, x);
 
             return this;
         }
 
-        public Link<T> WhereNextXWeeks(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> months</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNextXMonths(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NextXWeeks, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NextXWeeks, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXMonths, x);
 
             return this;
         }
 
-        public Link<T> WhereNextXYears(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> weeks</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNextXWeeks(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NextXYears, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NextXYears, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXWeeks, x);
 
             return this;
         }
 
-        public Link<T> WhereNextYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNextXYears(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NextYear);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NextYear);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXYears, x);
 
             return this;
         }
 
-        public Link<T> WhereNotBetween(string attributeName, object value1, object value2, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNextYear(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NotBetween, value1, value2);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NotBetween, value1, value2);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextYear);
 
             return this;
         }
 
-        public Link<T> WhereNotEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNotBetween(Expression<Func<U, object>> column, object value1, object value2)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NotEqual, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NotEqual, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotBetween, value1, value2);
 
             return this;
         }
 
-        public Link<T> WhereNotEqualBusinessId(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not equal <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNotEqual(Expression<Func<U, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NotEqualBusinessId);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NotEqualBusinessId);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotEqual, value);
 
             return this;
         }
-
-        public Link<T> WhereNotEqualUserId(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user business unit</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNotEqualBusinessId(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NotEqualUserId);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NotEqualUserId);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotEqualBusinessId);
 
             return this;
         }
 
-        public Link<T> WhereNotIn(string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user unique identifier</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNotEqualUserId(Expression<Func<U, object>> column)
         {
-            InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NotIn, values);
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotEqualUserId);
 
             return this;
         }
 
-        public Link<T> WhereNotIn(string entityname, string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNotIn(Expression<Func<U, object>> column, IList values)
         {
-            InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NotIn, values);
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotIn, values);
 
             return this;
         }
 
-        public Link<T> WhereNotIn(string attributeName, IList value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNotIn(Expression<Func<U, object>> column, params object[] values)
         {
-            InnerLinkEntity.LinkCriteria.Conditions.Add(new ConditionExpression(attributeName, ConditionOperator.NotIn, value));
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotIn, values);
 
             return this;
         }
 
-        public Link<T> WhereNotIn(string entityname, string attributeName, IList value)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not match the specifed <paramref name="pattern"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        public Link<T, U> WhereNotLike(string column, string pattern)
         {
-            InnerLinkEntity.LinkCriteria.Conditions.Add(new ConditionExpression(entityname, attributeName, ConditionOperator.NotIn, value));
+            InnerLinkEntity.LinkCriteria.AddCondition(column, ConditionOperator.NotLike, pattern);
 
             return this;
         }
 
-        public Link<T> WhereNotLike(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not match the specifed <paramref name="pattern"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        public Link<T, U> WhereNotLike(Expression<Func<U, object>> column, string pattern)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NotLike, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NotLike, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotLike, pattern);
 
             return this;
         }
 
-        public Link<T> WhereNotMask(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNotMask(Expression<Func<U, object>> column, object bitmask)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NotMask, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NotMask, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotMask, bitmask);
 
             return this;
         }
 
-        public Link<T> WhereNotNull(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not null</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNotNull(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NotNull);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NotNull);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotNull);
 
             return this;
         }
 
-        public Link<T> WhereNotOn(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNotOn(Expression<Func<U, object>> column, DateTime datetime)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NotOn, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NotOn, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotOn, datetime);
 
             return this;
         }
 
-        public Link<T> WhereNotUnder(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is above <paramref name="value"/> in the hierarchy </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The date</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereNotUnder(Expression<Func<U, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.NotUnder, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.NotUnder, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotUnder, value);
 
             return this;
         }
 
-        public Link<T> WhereNull(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain data</summary>
+        /// <param name="column">Logical name of the column</param>
+        public Link<T, U> WhereNull(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.Null);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.Null);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Null);
 
             return this;
         }
-
-        public Link<T> WhereOlderThanXDays(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereOlderThanXDays(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXDays, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.OlderThanXDays, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXDays, x);
 
             return this;
         }
 
-        public Link<T> WhereOlderThanXHours(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> hours</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereOlderThanXHours(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXHours, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.OlderThanXHours, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXHours, x);
 
             return this;
         }
 
-        public Link<T> WhereOlderThanXMinutes(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> minutes</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of minutes to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereOlderThanXMinutes(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXMinutes, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.OlderThanXMinutes, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXMinutes, x);
 
             return this;
         }
 
-        public Link<T> WhereOlderThanXMonths(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> months</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereOlderThanXMonths(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXMonths, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.OlderThanXMonths, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXMonths, x);
 
             return this;
         }
 
-        public Link<T> WhereOlderThanXWeeks(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> weeks</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereOlderThanXWeeks(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXWeeks, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.OlderThanXWeeks, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXWeeks, x);
 
             return this;
         }
 
-        public Link<T> WhereOlderThanXYears(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereOlderThanXYears(Expression<Func<U, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXYears, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.OlderThanXYears, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXYears, x);
 
             return this;
         }
 
-        public Link<T> WhereOn(string attributeName, DateTime value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereOn(Expression<Func<U, object>> column, DateTime datetime)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.On, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.On, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.On, datetime);
 
             return this;
         }
 
-        public Link<T> WhereOnOrAfter(string attributeName, DateTime value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or after the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereOnOrAfter(Expression<Func<U, object>> column, DateTime datetime)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.OnOrAfter, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.OnOrAfter, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OnOrAfter, datetime);
 
             return this;
         }
 
-        public Link<T> WhereOnOrBefore(string attributeName, DateTime value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or before the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereOnOrBefore(Expression<Func<U, object>> column, DateTime datetime)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.OnOrBefore, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.OnOrBefore, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OnOrBefore, datetime);
 
             return this;
         }
 
-        public Link<T> WhereThisFiscalPeriod(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereThisFiscalPeriod(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.ThisFiscalPeriod);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.ThisFiscalPeriod);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisFiscalPeriod);
 
             return this;
         }
 
-        public Link<T> WhereThisFiscalYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereThisFiscalYear(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.ThisFiscalYear);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.ThisFiscalYear);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisFiscalYear);
 
             return this;
         }
 
-        public Link<T> WhereThisMonth(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current month</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereThisMonth(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.ThisMonth);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.ThisMonth);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisMonth);
 
             return this;
         }
 
-        public Link<T> WhereThisWeek(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current week</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereThisWeek(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.ThisWeek);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.ThisWeek);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisWeek);
 
             return this;
         }
 
-        public Link<T> WhereThisYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereThisYear(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.ThisYear);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.ThisYear);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisYear);
 
             return this;
         }
 
-        public Link<T> WhereToday(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current day</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereToday(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.Today);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.Today);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Today);
 
             return this;
         }
 
-        public Link<T> WhereTomorrow(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is tomorrow</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereTomorrow(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.Tomorrow);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.Tomorrow);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Tomorrow);
 
             return this;
         }
 
-        public Link<T> WhereUnder(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is under <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereUnder(Expression<Func<U, object>> column, Guid value)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.Under, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.Under, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Under, value);
 
             return this;
         }
 
-        public Link<T> WhereUnderOrEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is under or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereUnderOrEqual(Expression<Func<U, object>> column, Guid value)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.UnderOrEqual, value);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.UnderOrEqual, value);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.UnderOrEqual, value);
 
             return this;
         }
 
-        public Link<T> WhereYesterday(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is yesterday</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Link{T,U}"/></returns>
+        public Link<T, U> WhereYesterday(Expression<Func<U, object>> column)
         {
-            if (entityname != null)
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(entityname, attributeName, ConditionOperator.Yesterday);
-            }
-            else
-            {
-                InnerLinkEntity.LinkCriteria.AddCondition(attributeName, ConditionOperator.Yesterday);
-            }
+            InnerLinkEntity.LinkCriteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Yesterday);
 
             return this;
         }
diff --git a/MscrmTools.Shared/Query.cs b/MscrmTools.Shared/Query.cs
index 71350bb..c9b255c 100644
--- a/MscrmTools.Shared/Query.cs
+++ b/MscrmTools.Shared/Query.cs
@@ -9,2750 +9,4316 @@
 
 namespace MscrmTools.FluentQueryExpressions
 {
+    /// <summary>
+    /// A query to request Dataverse data
+    /// </summary>
     public class Query : Query<Entity>
     {
-        public Query(string entityLogicalName) : base(entityLogicalName)
+        #region Constructors
+
+        /// <summary>
+        /// Initialize a new instance of class <see cref="Query"/>
+        /// </summary>
+        /// <param name="table">Logical name of the table to query</param>
+        public Query(string table) : base(table)
         {
         }
-    }
 
-    public class Query<T> where T : Entity
-    {
-        public Query()
+        #endregion Constructors
+
+        #region Attributes
+
+        /// <summary>
+        /// Specifies the list of columns the query should return
+        /// </summary>
+        /// <param name="columns">Columns to return</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query Select(params string[] columns)
         {
-            string entityLogicalName = typeof(T).GetField("EntityLogicalName").GetRawConstantValue().ToString();
-            QueryExpression = new QueryExpression(entityLogicalName);
+            if (columns.Length == 0)
+            {
+                QueryExpression.ColumnSet = new ColumnSet();
+            }
+
+            QueryExpression.ColumnSet.AddColumns(columns);
+
+            return this;
         }
 
-        protected Query(string entityLogicalName)
+        #endregion Attributes
+
+        #region Filters
+
+        /// <summary>
+        /// Add a filter under the default filter for this query
+        /// </summary>
+        /// <param name="filter">Filter to add</param>
+        /// <returns>The <see cref="Query"/></returns>
+        public Query AddFilter(Filter filter)
         {
-            QueryExpression = new QueryExpression(entityLogicalName);
+            QueryExpression.Criteria.Filters.Add(filter.InnerFilter);
+
+            return this;
         }
 
-        public QueryExpression QueryExpression { get; protected set; }
+        /// <summary>
+        /// Add filters under the default filter for this query
+        /// </summary>
+        /// <param name="filters">List of filters</param>
+        /// <returns>The <see cref="Query"/></returns>
+        public Query AddFilters(params Filter[] filters)
+        {
+            QueryExpression.Criteria.Filters.AddRange(filters.Select(f => f.InnerFilter));
 
-        #region QueryExpression
+            return this;
+        }
 
-        public Query<T> Distinct()
+        /// <summary>
+        /// Add multiple filters under the default filter for this query
+        /// </summary>
+        /// <param name="logicalOperator">Logical operator for the default filter of this query</param>
+        /// <param name="filters">Filters to add</param>
+        /// <returns>The <see cref="Query"/></returns>
+        [Obsolete("Use method AddFilters without LogicalOperator argument and use SetFilterOperator method to change the QueryExpression default filter logical operator")]
+        public Query AddFilters(LogicalOperator logicalOperator, params Filter[] filters)
         {
-            QueryExpression.Distinct = true;
+            QueryExpression.Criteria.FilterOperator = logicalOperator;
+            QueryExpression.Criteria.Filters.AddRange(filters.Select(f => f.InnerFilter));
 
             return this;
         }
 
-        public Query<T> NoLock()
+        #endregion Filters
+
+        #region Links
+
+        /// <summary>
+        /// Add a related table in the query
+        /// </summary>
+        /// <param name="link">Link to the related table</param>
+        /// <returns>The <see cref="Query"/></returns>
+        public Query AddLink(Link link)
         {
-            QueryExpression.NoLock = true;
+            QueryExpression.LinkEntities.Add(link.InnerLinkEntity);
+            link.InnerLinkEntity.LinkFromEntityName = QueryExpression.EntityName;
+            return this;
+        }
+
+        /// <summary>
+        /// Add a related table in the query
+        /// </summary>
+        /// <param name="fromAttributeName">Column from the source table</param>
+        /// <param name="toEntityName">Related table to query</param>
+        /// <param name="toAttributeName">Column from the related table</param>
+        /// <param name="jo">Join operator for the link</param>
+        /// <returns>The <see cref="Query"/></returns>
+        public Query AddLink(string fromAttributeName, string toEntityName, string toAttributeName, JoinOperator jo = JoinOperator.Inner)
+        {
+            var link = new LinkEntity
+            {
+                LinkFromEntityName = QueryExpression.EntityName,
+                LinkFromAttributeName = fromAttributeName,
+                LinkToAttributeName = toAttributeName,
+                LinkToEntityName = toEntityName,
+                JoinOperator = jo,
+                EntityAlias = toEntityName
+            };
 
+            QueryExpression.LinkEntities.Add(link);
             return this;
         }
 
-        public Query<T> Top(int top)
+        #endregion Links
+
+        #region Columns Comparer
+
+#if CRMV9
+
+        /// <summary>
+        /// Starts a column comparison
+        /// </summary>
+        /// <param name="column">First column to compare</param>
+        /// <returns>The Comparer</returns>
+        public Shared.AppCode.Comparer<Query> Compare(string column)
         {
-            QueryExpression.TopCount = top;
+            return new Shared.AppCode.Comparer<Query>(this, column);
+        }
+
+        /// <summary>
+        /// Starts a column comparison for a related table
+        /// </summary>
+        /// <param name="tableAlias">Alias of the linked table where to compare columns</param>
+        /// <param name="column">First column to compare</param>
+        /// <returns>The Comparer</returns>
+        public Shared.AppCode.Comparer<Query> Compare(string tableAlias, string column)
+        {
+            return new Shared.AppCode.Comparer<Query>(this, tableAlias, column);
+        }
+
+#endif
+
+        #endregion Columns Comparer
+
+        #region Order
 
+        /// <summary>
+        /// Order the result of the query by the <paramref name="column"/>
+        /// </summary>
+        /// <param name="column">Column to use to sort results of the query</param>
+        /// <returns>The <see cref="Query"/></returns>
+        public Query OrderBy(string column)
+        {
+            QueryExpression.AddOrder(column, OrderType.Ascending);
             return this;
         }
 
-        #endregion QueryExpression
+        /// <summary>
+        /// Order the result of the query by the <paramref name="column"/> descending
+        /// </summary>
+        /// <param name="column">Column to use to sort results of the query</param>
+        /// <returns>The <see cref="Query"/></returns>
+        public Query OrderByDescending(string column)
+        {
+            QueryExpression.AddOrder(column, OrderType.Descending);
+            return this;
+        }
 
-        #region Attributes
+        #endregion Order
 
-        public Query<T> Select(bool allColumns)
+        #region Conditions
+
+        /// <summary>Adds a condition where <paramref name="column"/> respects the <paramref name="conditionOperator"/> and the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="conditionOperator">The condition operator.</param>
+        /// <param name="values">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query Where(string column, ConditionOperator conditionOperator, params object[] values)
         {
-            QueryExpression.ColumnSet = new ColumnSet(allColumns);
+            QueryExpression.Criteria.AddCondition(column, conditionOperator, values);
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> respects the <paramref name="conditionOperator"/> and the <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="conditionOperator">The condition operator.</param>
+        /// <param name="values">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query Where(string tableAlias, string column, ConditionOperator conditionOperator, params object[] values)
+        {
+            QueryExpression.Criteria.AddCondition(tableAlias, column, conditionOperator, values);
 
             return this;
         }
 
-        public Query<T> Select(params string[] attributes)
+        /// <summary>Adds a condition where <paramref name="column"/> is above <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereAbove(string column, Guid value, string tableAlias = null)
         {
-            if (attributes.Length == 0)
+            if (tableAlias != null)
             {
-                QueryExpression.ColumnSet = new ColumnSet();
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.Above, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.Above, value);
             }
 
-            QueryExpression.ColumnSet.AddColumns(attributes);
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> is above or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereAboveOrEqual(string column, object value, string tableAlias = null)
+        {
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.AboveOrEqual, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.AboveOrEqual, value);
+            }
 
             return this;
         }
 
-        public Query<T> Select(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value begins with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereBeginsWith(string column, string value, string tableAlias = null)
         {
-            QueryExpression.ColumnSet.AddColumns(AnonymousTypeHelper.GetAttributeNamesArray(anonymousTypeInitializer));
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.BeginsWith, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.BeginsWith, value);
+            }
+
             return this;
         }
 
-        #endregion Attributes
+        /// <summary>Adds a condition where <paramref name="column"/> value is between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereBetween(string column, object value1, object value2, string tableAlias = null)
+        {
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.Between, value1, value2);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.Between, value1, value2);
+            }
 
-        #region Filters
+            return this;
+        }
 
-        public Query<T> AddFilters(params Filter[] filters)
+        /// <summary>Adds a condition where <paramref name="column"/> value contains <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereContains(string column, string value, string tableAlias = null)
         {
-            QueryExpression.Criteria.Filters.AddRange(filters.Select(f => f.InnerFilter));
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.Contains, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.Contains, value);
+            }
 
             return this;
         }
 
-        public Query<T> AddFilters(LogicalOperator logicalOperator, params Filter[] filters)
+#if CRMV9
+
+        /// <summary>Adds a condition where <paramref name="column"/> contains <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereContainValues(string column, params object[] values)
         {
-            QueryExpression.Criteria.FilterOperator = logicalOperator;
-            QueryExpression.Criteria.Filters.AddRange(filters.Select(f => f.InnerFilter));
+            QueryExpression.Criteria.AddCondition(column, ConditionOperator.ContainValues, values);
 
             return this;
         }
 
-        public Query<T> SetDefaultFilterOperator(LogicalOperator logicalOperator)
+        /// <summary>Adds a condition where <paramref name="column"/> contains <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereContainValues(string tableAlias, string column, params object[] values)
         {
-            QueryExpression.Criteria.FilterOperator = logicalOperator;
+            QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.ContainValues, values);
 
             return this;
         }
 
-        #endregion Filters
+#endif
 
-        #region Columns Comparer
+        /// <summary>Adds a condition where <paramref name="column"/> value does not begin with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereDoesNotBeginWith(string column, object value, string tableAlias = null)
+        {
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.DoesNotBeginWith, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.DoesNotBeginWith, value);
+            }
 
-#if CRMV9
-        public Shared.AppCode.Comparer<Query<T>> Compare(string attributeName)
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value does not contain <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereDoesNotContain(string column, object value, string tableAlias = null)
         {
-            return new Shared.AppCode.Comparer<Query<T>>(this, attributeName);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.DoesNotContain, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.DoesNotContain, value);
+            }
+
+            return this;
         }
 
-        public Shared.AppCode.Comparer<Query<T>> Compare(string entityName, string attributeName)
+#if CRMV9
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereDoesNotContainValues(string column, params object[] values)
         {
-            return new Shared.AppCode.Comparer<Query<T>>(this, entityName, attributeName);
+            QueryExpression.Criteria.AddCondition(column, ConditionOperator.DoesNotContainValues, values);
+
+            return this;
         }
-#endif
 
-        #endregion Columns Comparer
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereDoesNotContainValues(string tableAlias, string column, params object[] values)
+        {
+            QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.DoesNotContainValues, values);
 
-        #region Link Entities
+            return this;
+        }
 
-        public Query<T> AddLink<TU>(Link<TU> link) where TU : Entity
+#endif
+        /// <summary>Adds a condition where <paramref name="column"/> value does not end with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereDoesNotEndWith(string column, string value, string tableAlias = null)
         {
-            QueryExpression.LinkEntities.Add(link.InnerLinkEntity);
-            link.InnerLinkEntity.LinkFromEntityName = QueryExpression.EntityName;
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.DoesNotEndWith, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.DoesNotEndWith, value);
+            }
+
             return this;
         }
 
-        #endregion Link Entities
+        /// <summary>Adds a condition where <paramref name="column"/> value ends with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereEndsWith(string column, object value, string tableAlias = null)
+        {
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.EndsWith, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.EndsWith, value);
+            }
 
-        #region Order
+            return this;
+        }
 
-        public Query<T> Order(string attribute, OrderType order)
+        /// <summary>Adds a condition where <paramref name="column"/> value equals <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereEqual(string column, object value, string tableAlias = null)
         {
-            QueryExpression.AddOrder(attribute, order);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.Equal, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.Equal, value);
+            }
+
             return this;
         }
 
-        #endregion Order
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user business unit</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereEqualBusinessId(string column, string tableAlias = null)
+        {
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.EqualBusinessId);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.EqualBusinessId);
+            }
 
-        #region PagingInfo
+            return this;
+        }
 
-        public Query<T> NextPage(string pagingCookie)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user unique identifier</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereEqualUserId(string column, string tableAlias = null)
         {
-            QueryExpression.PageInfo.PageNumber++;
-            QueryExpression.PageInfo.PagingCookie = pagingCookie;
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.EqualUserId);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.EqualUserId);
+            }
 
             return this;
         }
 
-        public Query<T> SetPagingInfo(int pageNumber, int count, bool returnTotalCount = false)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user language</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereEqualUserLanguage(string column, string tableAlias = null)
         {
-            QueryExpression.PageInfo = new PagingInfo
+            if (tableAlias != null)
             {
-                Count = count,
-                PageNumber = pageNumber,
-                ReturnTotalRecordCount = returnTotalCount
-            };
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.EqualUserLanguage);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.EqualUserLanguage);
+            }
 
             return this;
         }
 
-        #endregion PagingInfo
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or their reporting hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereEqualUserOrUserHierarchy(string column, string tableAlias = null)
+        {
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.EqualUserOrUserHierarchy);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.EqualUserOrUserHierarchy);
+            }
 
-        #region Conditions
+            return this;
+        }
 
-        public Query<T> Where(string attributeName, ConditionOperator conditionOperator, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user and his teams or their reporting hierarchy and their teams</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereEqualUserOrUserHierarchyAndTeams(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(attributeName, conditionOperator, values);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.EqualUserOrUserHierarchyAndTeams);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column,
+                    ConditionOperator.EqualUserOrUserHierarchyAndTeams);
+            }
 
             return this;
         }
 
-        public Query<T> Where(Expression<Func<T, object>> anonymousTypeInitializer, ConditionOperator conditionOperator, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or a team the current user is member of</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereEqualUserOrUserTeams(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName<T>(anonymousTypeInitializer), conditionOperator, values);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.EqualUserOrUserTeams);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.EqualUserOrUserTeams);
+            }
 
             return this;
         }
 
-        public Query<T> Where(string entityName, string attributeName, ConditionOperator conditionOperator, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> equals a team the current user is member of</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereEqualUserTeams(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityName, attributeName, conditionOperator, values);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.EqualUserTeams);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.EqualUserTeams);
+            }
 
             return this;
         }
 
-        public Query<T> Where<U>(string entityName, Expression<Func<U, object>> anonymousTypeInitializer, ConditionOperator conditionOperator, params object[] values) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> is greater or equal to <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereGreaterEqual(string column, object value, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityName, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), conditionOperator, values);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.GreaterEqual, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.GreaterEqual, value);
+            }
 
             return this;
         }
 
-        public Query<T> WhereAbove(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is greater than <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereGreaterThan(string column, object value, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.Above, value);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.GreaterThan, value);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.Above, value);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.GreaterThan, value);
             }
 
             return this;
         }
 
-        public Query<T> WhereAbove(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereIn(string column, IList values)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Above, value);
+            QueryExpression.Criteria.Conditions.Add(new ConditionExpression(column, ConditionOperator.In, values));
 
             return this;
         }
 
-        public Query<T> WhereAbove<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereIn(string tableAlias, string column, IList values)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Above, value);
+            QueryExpression.Criteria.Conditions.Add(new ConditionExpression(tableAlias, column, ConditionOperator.In, values));
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereIn(string column, params object[] values)
+        {
+            QueryExpression.Criteria.Conditions.Add(new ConditionExpression(column, ConditionOperator.In, values));
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereIn(string tableAlias, string column, params object[] values)
+        {
+            QueryExpression.Criteria.Conditions.Add(new ConditionExpression(tableAlias, column, ConditionOperator.In, values));
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereInFiscalPeriod(string column, object value, string tableAlias = null)
+        {
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.InFiscalPeriod, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.InFiscalPeriod, value);
+            }
 
             return this;
         }
 
-        public Query<T> WhereAboveOrEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereInFiscalPeriodAndYear(string column, int period, int year, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.AboveOrEqual, value);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.InFiscalPeriodAndYear, period, year);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.AboveOrEqual, value);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.InFiscalPeriodAndYear, period, year);
             }
 
             return this;
         }
 
-        public Query<T> WhereAboveOrEqual(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereInFiscalYear(string column, int year, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.AboveOrEqual, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.InFiscalYear, year);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.InFiscalYear, year);
+            }
 
             return this;
         }
 
-        public Query<T> WhereAboveOrEqual<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or after the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereInOrAfterFiscalPeriodAndYear(string column, int period, int year, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.AboveOrEqual, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.InOrAfterFiscalPeriodAndYear, period, year);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.InOrAfterFiscalPeriodAndYear,
+                    period, year);
+            }
 
             return this;
         }
 
-        public Query<T> WhereBeginsWith(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or before the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereInOrBeforeFiscalPeriodAndYear(string column, int period, int year, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.BeginsWith, value);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.InOrBeforeFiscalPeriodAndYear, period, year);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.BeginsWith, value);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.InOrBeforeFiscalPeriodAndYear,
+                    period, year);
             }
 
             return this;
         }
 
-        public Query<T> WhereBeginsWith(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on last 7 days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLast7Days(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.BeginsWith, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.Last7Days);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.Last7Days);
+            }
 
             return this;
         }
 
-        public Query<T> WhereBeginsWith<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLastFiscalPeriod(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.BeginsWith, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.LastFiscalPeriod);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.LastFiscalPeriod);
+            }
 
             return this;
         }
 
-        public Query<T> WhereBetween(string attributeName, object value1, object value2, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLastFiscalYear(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.Between, value1, value2);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.LastFiscalYear);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.Between, value1, value2);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.LastFiscalYear);
             }
 
             return this;
         }
 
-        public Query<T> WhereBetween(Expression<Func<T, object>> anonymousTypeInitializer, object value1, object value2)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last month</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLastMonth(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Between, value1, value2);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.LastMonth);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.LastMonth);
+            }
 
             return this;
         }
 
-        public Query<T> WhereBetween<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value1, object value2) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last week</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLastWeek(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Between, value1, value2);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.LastWeek);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.LastWeek);
+            }
 
             return this;
         }
 
-        public Query<T> WhereChildOf(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLastXDays(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.ChildOf, value);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.LastXDays, x);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.ChildOf, value);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.LastXDays, x);
             }
 
             return this;
         }
 
-        public Query<T> WhereChildOf(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal periods</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal periods to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLastXFiscalPeriods(string column, int x, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.ChildOf, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.LastXFiscalPeriods, x);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.LastXFiscalPeriods, x);
+            }
 
             return this;
         }
 
-        public Query<T> WhereChildOf<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLastXFiscalYears(string column, int x, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.ChildOf, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.LastXFiscalYears, x);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.LastXFiscalYears, x);
+            }
 
             return this;
         }
 
-        public Query<T> WhereContains(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> hours</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLastXHours(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.Contains, value);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.LastXHours, x);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.Contains, value);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.LastXHours, x);
             }
 
             return this;
         }
 
-        public Query<T> WhereContains(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> months</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLastXMonths(string column, int x, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Contains, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.LastXMonths, x);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.LastXMonths, x);
+            }
 
             return this;
         }
 
-        public Query<T> WhereContains<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> months</summary>
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> weeks</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLastXWeeks(string column, int x, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Contains, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.LastXWeeks, x);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.LastXWeeks, x);
+            }
 
             return this;
         }
 
-#if CRMV9
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLastXYears(string column, int x, string tableAlias = null)
+        {
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.LastXYears, x);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.LastXYears, x);
+            }
+
+            return this;
+        }
 
-        public Query<T> WhereContainValues(string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLastYear(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.ContainValues, values);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.LastYear);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.LastYear);
+            }
 
             return this;
         }
 
-        public Query<T> WhereContainValues(string entityname, string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> value is less or equal to <paramref name="value"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLessEqual(string column, object value, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.ContainValues, values);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.LessEqual, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.LessEqual, value);
+            }
 
             return this;
         }
 
-        public Query<T> WhereContainValues(Expression<Func<T, object>> anonymousTypeInitializer, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> value is less than <paramref name="value"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLessThan(string column, object value, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.ContainValues, values);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.LessThan, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.LessThan, value);
+            }
 
             return this;
         }
 
-        public Query<T> WhereContainValues<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, params object[] values) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value matches the specifed <paramref name="pattern"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereLike(string column, string pattern, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.ContainValues, values);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.Like, pattern);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.Like, pattern);
+            }
 
             return this;
         }
 
-#endif
+        /// <summary>Adds a condition where <paramref name="column"/> value is found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereMask(string column, object bitmask, string tableAlias = null)
+        {
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.Mask, bitmask);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.Mask, bitmask);
+            }
 
-        public Query<T> WhereDoesNotBeginWith(string attributeName, object value, string entityname = null)
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next 7 days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNext7Days(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.DoesNotBeginWith, value);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.Next7Days);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.DoesNotBeginWith, value);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.Next7Days);
             }
 
             return this;
         }
 
-        public Query<T> WhereDoesNotBeginWith(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNextFiscalPeriod(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.DoesNotBeginWith, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NextFiscalPeriod);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NextFiscalPeriod);
+            }
 
             return this;
         }
 
-        public Query<T> WhereDoesNotBeginWith<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNextFiscalYear(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.DoesNotBeginWith, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NextFiscalYear);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NextFiscalYear);
+            }
 
             return this;
         }
 
-        public Query<T> WhereDoesNotContain(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next month</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNextMonth(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.DoesNotContain, value);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NextMonth);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.DoesNotContain, value);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NextMonth);
             }
 
             return this;
         }
 
-        public Query<T> WhereDoesNotContain(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next week</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNextWeek(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.DoesNotContain, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NextWeek);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NextWeek);
+            }
 
             return this;
         }
 
-        public Query<T> WhereDoesNotContain<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNextXDays(string column, int x, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.DoesNotContain, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NextXDays, x);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NextXDays, x);
+            }
 
             return this;
         }
 
-#if CRMV9
-        public Query<T> WhereDoesNotContainValues(string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal periods</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal perdiods to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNextXFiscalPeriods(string column, int x, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.DoesNotContainValues, values);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NextXFiscalPeriods, x);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NextXFiscalPeriods, x);
+            }
 
             return this;
         }
 
-        public Query<T> WhereDoesNotContainValues(string entityname, string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNextXFiscalYears(string column, int x, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.DoesNotContainValues, values);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NextXFiscalYears, x);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NextXFiscalYears, x);
+            }
 
             return this;
         }
 
-        public Query<T> WhereDoesNotContainValues(Expression<Func<T, object>> anonymousTypeInitializer, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> hours</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNextXHours(string column, int x, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.DoesNotContainValues, values);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NextXHours, x);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NextXHours, x);
+            }
 
             return this;
         }
 
-        public Query<T> WhereDoesNotContainValues<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, params object[] values) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> months</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNextXMonths(string column, int x, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.DoesNotContainValues, values);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NextXMonths, x);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NextXMonths, x);
+            }
 
             return this;
         }
-#endif
-        public Query<T> WhereDoesNotEndWith(string attributeName, object value, string entityname = null)
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> weeks</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNextXWeeks(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.DoesNotEndWith, value);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NextXWeeks, x);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.DoesNotEndWith, value);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NextXWeeks, x);
             }
 
             return this;
         }
 
-        public Query<T> WhereDoesNotEndWith(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNextXYears(string column, int x, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.DoesNotEndWith, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NextXYears, x);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NextXYears, x);
+            }
 
             return this;
         }
 
-        public Query<T> WhereDoesNotEndWith<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNextYear(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.DoesNotEndWith, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NextYear);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NextYear);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEndsWith(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNotBetween(string column, object value1, object value2, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.EndsWith, value);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NotBetween, value1, value2);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.EndsWith, value);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NotBetween, value1, value2);
             }
 
             return this;
         }
 
-        public Query<T> WhereEndsWith(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not equal <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNotEqual(string column, object value, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EndsWith, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NotEqual, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NotEqual, value);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEndsWith<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user business unit</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNotEqualBusinessId(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EndsWith, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NotEqualBusinessId);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NotEqualBusinessId);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user unique identifier</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNotEqualUserId(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.Equal, value);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NotEqualUserId);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.Equal, value);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NotEqualUserId);
             }
 
             return this;
         }
 
-        public Query<T> WhereEqual(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNotIn(string tableAlias, string column, IList values)
+        {
+            QueryExpression.Criteria.Conditions.Add(new ConditionExpression(tableAlias, column, ConditionOperator.NotIn, values));
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNotIn(string column, IList values)
+        {
+            QueryExpression.Criteria.Conditions.Add(new ConditionExpression(column, ConditionOperator.NotIn, values));
+
+            return this;
+        }
+
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNotIn(string column, params object[] values)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Equal, value);
+            QueryExpression.Criteria.AddCondition(column, ConditionOperator.NotIn, values);
 
             return this;
         }
 
-        public Query<T> WhereEqual<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNotIn(string tableAlias, string column, params object[] values)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Equal, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NotIn, values);
 
             return this;
         }
 
-        public Query<T> WhereEqualBusinessId(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not match the specifed <paramref name="pattern"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNotLike(string column, string pattern, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.EqualBusinessId);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NotLike, pattern);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.EqualBusinessId);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NotLike, pattern);
             }
 
             return this;
         }
 
-        public Query<T> WhereEqualBusinessId(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNotMask(string column, object bitmask, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EqualBusinessId);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NotMask, bitmask);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NotMask, bitmask);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEqualBusinessId<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is not null</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNotNull(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EqualBusinessId);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NotNull);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NotNull);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserId(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNotOn(string column, DateTime datetime, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.EqualUserId);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NotOn, datetime);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.EqualUserId);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NotOn, datetime);
             }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserId(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is above <paramref name="value"/> in the hierarchy </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNotUnder(string column, Guid value, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EqualUserId);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.NotUnder, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.NotUnder, value);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserId<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain data</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereNull(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EqualUserId);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.Null);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.Null);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserLanguage(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereOlderThanXDays(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.EqualUserLanguage);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.OlderThanXDays, x);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.EqualUserLanguage);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.OlderThanXDays, x);
             }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserLanguage(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> hours</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereOlderThanXHours(string column, int x, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EqualUserLanguage);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.OlderThanXHours, x);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.OlderThanXHours, x);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserLanguage<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> minutes</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of minutes to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereOlderThanXMinutes(string column, int x, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EqualUserLanguage);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.OlderThanXMinutes, x);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.OlderThanXMinutes, x);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserOrUserHierarchy(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> months</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereOlderThanXMonths(string column, int x, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.EqualUserOrUserHierarchy);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.OlderThanXMonths, x);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.EqualUserOrUserHierarchy);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.OlderThanXMonths, x);
             }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserOrUserHierarchy(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> weeks</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereOlderThanXWeeks(string column, int x, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EqualUserOrUserHierarchy);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.OlderThanXWeeks, x);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.OlderThanXWeeks, x);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserOrUserHierarchy<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereOlderThanXYears(string column, int x, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EqualUserOrUserHierarchy);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.OlderThanXYears, x);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.OlderThanXYears, x);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserOrUserHierarchyAndTeams(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereOn(string column, DateTime datetime, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.EqualUserOrUserHierarchyAndTeams);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.On, datetime);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName,
-                    ConditionOperator.EqualUserOrUserHierarchyAndTeams);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.On, datetime);
             }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserOrUserHierarchyAndTeams(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or after the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereOnOrAfter(string column, DateTime datetime, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EqualUserOrUserHierarchyAndTeams);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.OnOrAfter, datetime);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.OnOrAfter, datetime);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserOrUserHierarchyAndTeams<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or before the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereOnOrBefore(string column, DateTime datetime, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EqualUserOrUserHierarchyAndTeams);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.OnOrBefore, datetime);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.OnOrBefore, datetime);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserOrUserTeams(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereThisFiscalPeriod(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.EqualUserOrUserTeams);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.ThisFiscalPeriod);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.EqualUserOrUserTeams);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.ThisFiscalPeriod);
             }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserOrUserTeams(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereThisFiscalYear(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EqualUserOrUserTeams);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.ThisFiscalYear);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.ThisFiscalYear);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserOrUserTeams<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current month</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereThisMonth(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EqualUserOrUserTeams);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.ThisMonth);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.ThisMonth);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserTeams(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current week</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereThisWeek(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.EqualUserTeams);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.ThisWeek);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.EqualUserTeams);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.ThisWeek);
             }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserTeams(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereThisYear(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EqualUserTeams);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.ThisYear);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.ThisYear);
+            }
 
             return this;
         }
 
-        public Query<T> WhereEqualUserTeams<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current day</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereToday(string column, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.EqualUserTeams);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.Today);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.Today);
+            }
 
             return this;
         }
 
-        public Query<T> WhereGreaterEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is tomorrow</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereTomorrow(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.GreaterEqual, value);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.Tomorrow);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.GreaterEqual, value);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.Tomorrow);
             }
 
             return this;
         }
 
-        public Query<T> WhereGreaterEqual(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> is under <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereUnder(string column, Guid value, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.GreaterEqual, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.Under, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.Under, value);
+            }
 
             return this;
         }
 
-        public Query<T> WhereGreaterEqual<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> is under or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereUnderOrEqual(string column, Guid value, string tableAlias = null)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.GreaterEqual, value);
+            if (tableAlias != null)
+            {
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.UnderOrEqual, value);
+            }
+            else
+            {
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.UnderOrEqual, value);
+            }
 
             return this;
         }
 
-        public Query<T> WhereGreaterThan(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is yesterday</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query WhereYesterday(string column, string tableAlias = null)
         {
-            if (entityname != null)
+            if (tableAlias != null)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.GreaterThan, value);
+                QueryExpression.Criteria.AddCondition(tableAlias, column, ConditionOperator.Yesterday);
             }
             else
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.GreaterThan, value);
+                QueryExpression.Criteria.AddCondition(column, ConditionOperator.Yesterday);
             }
 
             return this;
         }
 
-        public Query<T> WhereGreaterThan(Expression<Func<T, object>> anonymousTypeInitializer, object value)
-        {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.GreaterThan, value);
+        #endregion Conditions
+    }
 
-            return this;
-        }
+    /// <summary>
+    /// A typed query to request Dataverse data
+    /// </summary>
+    /// <typeparam name="T">Table to query</typeparam>
+    public class Query<T> where T : Entity
+    {
+        #region Constructors
 
-        public Query<T> WhereGreaterThan<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>
+        /// Initialize a new instance of class <see cref="Query{T}"/>
+        /// </summary>
+        public Query()
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.GreaterThan, value);
-
-            return this;
+            string entityLogicalName = typeof(T).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+            QueryExpression = new QueryExpression(entityLogicalName);
         }
 
-        public Query<T> WhereIn(string attributeName, IList value)
+        /// <summary>
+        /// Initialize a new instance of class <see cref="Query"/>
+        /// <paramref name="table">Logical name of the table to query</paramref>
+        /// </summary>
+        protected Query(string table)
         {
-            QueryExpression.Criteria.Conditions.Add(new ConditionExpression(attributeName, ConditionOperator.In, value));
-
-            return this;
+            QueryExpression = new QueryExpression(table.ToLower());
         }
 
-        public Query<T> WhereIn(string entityname, string attributeName, IList value)
-        {
-            QueryExpression.Criteria.Conditions.Add(new ConditionExpression(entityname, attributeName, ConditionOperator.In, value));
+        #endregion Constructors
 
-            return this;
-        }
+        #region Properties
 
-        public Query<T> WhereIn(Expression<Func<T, object>> anonymousTypeInitializer, IList value)
-        {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.In, value);
+        /// <summary>
+        /// Get the <c>QueryExpression</c> representation of this <see cref="Query{T}"/>
+        /// </summary>
+        public QueryExpression QueryExpression { get; protected set; }
 
-            return this;
-        }
+        #endregion Properties
+
+        #region QueryExpression
 
-        public Query<T> WhereIn<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, IList value) where U : Entity
+        /// <summary>
+        /// Specifies that the <c>QueryExpression</c> should retrieve distinct data
+        /// </summary>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> Distinct()
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.In, value);
+            QueryExpression.Distinct = true;
 
             return this;
         }
 
-        public Query<T> WhereIn(string attributeName, params object[] values)
+        /// <summary>
+        /// Specifies that the <c>QueryExpression</c> should not lock the table when retrieving data
+        /// </summary>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> NoLock()
         {
-            QueryExpression.Criteria.Conditions.Add(new ConditionExpression(attributeName, ConditionOperator.In, values));
+            QueryExpression.NoLock = true;
 
             return this;
         }
 
-        public Query<T> WhereIn(string entityname, string attributeName, params object[] values)
+        /// <summary>
+        /// Specifies the number of records the <c>QueryExpression</c> should retrieve
+        /// </summary>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> Top(int top)
         {
-            QueryExpression.Criteria.Conditions.Add(new ConditionExpression(entityname, attributeName, ConditionOperator.In, values));
+            QueryExpression.TopCount = top;
 
             return this;
         }
 
-        public Query<T> WhereIn(Expression<Func<T, object>> anonymousTypeInitializer, params object[] values)
+        #endregion QueryExpression
+
+        #region Attributes
+
+        /// <summary>
+        /// Specifies that the query should return all columns of the queried table
+        /// </summary>
+        /// <param name="allColumns">Boolean that indicates if all columns should be returned</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> Select(bool allColumns = false)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.In, values);
+            QueryExpression.ColumnSet = new ColumnSet(allColumns);
 
             return this;
         }
 
-        public Query<T> WhereIn<U>(string entityname, Expression<Func<T, object>> anonymousTypeInitializer, params object[] values) where U : Entity
+        /// <summary>
+        /// Specifies the list of columns the query should return
+        /// <example>
+        /// For one column:
+        /// <code>
+        /// query.Select(a => a.AccountId);
+        /// </code>
+        /// For multiple columns:
+        /// <code>
+        /// query.Select(a => new { a.AccountId, a.Name});
+        /// </code>
+        /// </example>
+        /// </summary>
+        /// <param name="columns">Columns to return</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> Select(Expression<Func<T, object>> columns)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.In, values);
-
+            QueryExpression.ColumnSet.AddColumns(AnonymousTypeHelper.GetAttributeNamesArray(columns));
             return this;
         }
 
-        public Query<T> WhereInFiscalPeriod(string attributeName, object value, string entityname = null)
+        #endregion Attributes
+
+        #region Filters
+
+        /// <summary>
+        /// Add a filter under the default filter for this query
+        /// </summary>
+        /// <param name="filter">Filter to add</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> AddFilter(Filter<T> filter)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.InFiscalPeriod, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.InFiscalPeriod, value);
-            }
+            QueryExpression.Criteria.Filters.Add(filter.InnerFilter);
 
             return this;
         }
 
-        public Query<T> WhereInFiscalPeriod(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>
+        /// Add a filter under the default filter for this query
+        /// </summary>
+        /// <param name="filter">Filter to add</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> AddFilter(Func<Filter<T>, Filter<T>> filter)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.InFiscalPeriod, value);
+            var fe = new Filter<T>();
+            filter(fe);
+
+            QueryExpression.Criteria.Filters.Add(fe.InnerFilter);
 
             return this;
         }
 
-        public Query<T> WhereInFiscalPeriod<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>
+        /// Add multiple filters under the default filter for this query
+        /// </summary>
+        /// <param name="filters">Filters to add</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> AddFilters(params Filter<T>[] filters)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.InFiscalPeriod, value);
+            QueryExpression.Criteria.Filters.AddRange(filters.Select(f => f.InnerFilter));
 
             return this;
         }
 
-        public Query<T> WhereInFiscalPeriodAndYear(string attributeName, int period, int year, string entityname = null)
+        /// <summary>
+        /// Add multiple filters under the default filter for this query
+        /// </summary>
+        /// <param name="filters">Filters to add</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> AddFilters(params Func<Filter<T>, Filter<T>>[] filters)
         {
-            if (entityname != null)
+            foreach (var filter in filters)
             {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.InFiscalPeriodAndYear, period, year);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.InFiscalPeriodAndYear, period, year);
+                var fe = new Filter<T>();
+                filter(fe);
+
+                QueryExpression.Criteria.Filters.Add(fe.InnerFilter);
             }
 
             return this;
         }
 
-        public Query<T> WhereInFiscalPeriodAndYear(Expression<Func<T, object>> anonymousTypeInitializer, int period, int year)
+        /// <summary>
+        /// Define the filter operator for the default filter of this query
+        /// </summary>
+        /// <param name="logicalOperator">Logical operator</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> SetLogicalOperator(LogicalOperator logicalOperator)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.InFiscalPeriodAndYear, period, year);
+            QueryExpression.Criteria.FilterOperator = logicalOperator;
 
             return this;
         }
 
-        public Query<T> WhereInFiscalPeriodAndYear<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int period, int year) where U : Entity
-        {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.InFiscalPeriodAndYear, period, year);
+        #endregion Filters
 
-            return this;
-        }
+        #region Columns Comparer
 
-        public Query<T> WhereInFiscalYear(string attributeName, int year, string entityname = null)
-        {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.InFiscalYear, year);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.InFiscalYear, year);
-            }
+#if CRMV9
 
-            return this;
+        /// <summary>
+        /// Starts a column comparison
+        /// </summary>
+        /// <param name="column">First column to compare</param>
+        /// <returns>The Comparer</returns>
+        public Shared.AppCode.Comparer<Query<T>, T> Compare(Expression<Func<T, object>> column)
+        {
+            return new Shared.AppCode.Comparer<Query<T>, T>(this, AnonymousTypeHelper.GetAttributeName<T>(column));
         }
 
-        public Query<T> WhereInFiscalYear(Expression<Func<T, object>> anonymousTypeInitializer, int year)
+        /// <summary>
+        /// Starts a column comparison for a related table
+        /// </summary>
+        /// <param name="tableAlias">Alias of the linked table where to compare columns</param>
+        /// <param name="column">First column to compare</param>
+        /// <returns>The Comparer</returns>
+        public Shared.AppCode.Comparer<Query<T>, T> Compare(string tableAlias, Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.InFiscalYear, year);
-
-            return this;
+            return new Shared.AppCode.Comparer<Query<T>, T>(this, tableAlias, AnonymousTypeHelper.GetAttributeName<T>(column));
         }
+#endif
 
-        public Query<T> WhereInFiscalYear<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int year) where U : Entity
-        {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.InFiscalYear, year);
+        #endregion Columns Comparer
 
-            return this;
-        }
+        #region Link Entities
 
-        public Query<T> WhereInOrAfterFiscalPeriodAndYear(string attributeName, int period, int year, string entityname = null)
+        /// <summary>
+        /// Add a related table in the query
+        /// </summary>
+        /// <param name="link">Link to the related table</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> AddLink<U>(Link<T, U> link) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.InOrAfterFiscalPeriodAndYear, period, year);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.InOrAfterFiscalPeriodAndYear,
-                    period, year);
-            }
-
+            QueryExpression.LinkEntities.Add(link.InnerLinkEntity);
+            link.InnerLinkEntity.LinkFromEntityName = QueryExpression.EntityName;
             return this;
         }
 
-        public Query<T> WhereInOrAfterFiscalPeriodAndYear(Expression<Func<T, object>> anonymousTypeInitializer, int period, int year)
+        /// <summary>
+        /// Add a related table in the query
+        /// </summary>
+        /// <typeparam name="U">Type of the related table</typeparam>
+        /// <param name="fromAttribute">Column from the source table</param>
+        /// <param name="toAttribute">Column from the related table</param>
+        /// <param name="link">Link to the related table</param>
+        /// <param name="jo">Join operator for the link</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> AddLink<U>(Expression<Func<T, object>> fromAttribute, Expression<Func<U, object>> toAttribute, Func<Link<T, U>, Link<T, U>> link, JoinOperator jo = JoinOperator.Inner)
+            where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.InOrAfterFiscalPeriodAndYear, period, year);
+            string fromEntity = typeof(T).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+            string fromAttr = AnonymousTypeHelper.GetAttributeName(fromAttribute);
+            string toAttr = AnonymousTypeHelper.GetAttributeName(toAttribute);
+            string toEntity = typeof(U).GetField("EntityLogicalName").GetRawConstantValue().ToString();
 
-            return this;
-        }
+            var le = new Link<T, U>(fromEntity, toEntity, fromAttr, toAttr, jo);
 
-        public Query<T> WhereInOrAfterFiscalPeriodAndYear<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int period, int year) where U : Entity
-        {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.InOrAfterFiscalPeriodAndYear, period, year);
+            link(le);
+
+            QueryExpression.LinkEntities.Add(le.InnerLinkEntity);
 
             return this;
         }
 
-        public Query<T> WhereInOrBeforeFiscalPeriodAndYear(string attributeName, int period, int year, string entityname = null)
+        /// <summary>
+        /// Add a related table in the query
+        /// </summary>
+        /// <typeparam name="U">Type of the related table</typeparam>
+        /// <param name="link">Link to the related table</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> AddLink<U>(Func<Link<T, U>, Link<T, U>> link)
+           where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.InOrBeforeFiscalPeriodAndYear, period, year);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.InOrBeforeFiscalPeriodAndYear,
-                    period, year);
-            }
+            string fromEntity = typeof(T).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+            string toEntity = typeof(U).GetField("EntityLogicalName").GetRawConstantValue().ToString();
 
-            return this;
-        }
+            var le = new Link<T, U>(fromEntity, toEntity, null, null, JoinOperator.Inner);
 
-        public Query<T> WhereInOrBeforeFiscalPeriodAndYear(Expression<Func<T, object>> anonymousTypeInitializer, int period, int year)
-        {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.InOrBeforeFiscalPeriodAndYear, period, year);
+            link(le);
+
+            QueryExpression.LinkEntities.Add(le.InnerLinkEntity);
 
             return this;
         }
 
-        public Query<T> WhereInOrBeforeFiscalPeriodAndYear<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int period, int year) where U : Entity
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="U"></typeparam>
+        /// <param name="fromAttribute">Column from the source table></param>
+        /// <param name="toAttribute">Column from the related table</param>
+        /// <param name="jo">Join operator for the link</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> AddLink<U>(Expression<Func<T, object>> fromAttribute, Expression<Func<U, object>> toAttribute, JoinOperator jo = JoinOperator.Inner)
+            where U : Entity
+
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.InOrBeforeFiscalPeriodAndYear, period, year);
+            string fromEntity = typeof(T).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+            string fromAttr = AnonymousTypeHelper.GetAttributeName(fromAttribute);
+            string toAttr = AnonymousTypeHelper.GetAttributeName(toAttribute);
+            string toEntity = typeof(U).GetField("EntityLogicalName").GetRawConstantValue().ToString();
 
-            return this;
-        }
+            var le = new Link<T, U>(fromEntity, toEntity, fromAttr, toAttr, jo);
 
-        public Query<T> WhereLast7Days(string attributeName, string entityname = null)
-        {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.Last7Days);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.Last7Days);
-            }
+            QueryExpression.LinkEntities.Add(le.InnerLinkEntity);
 
             return this;
         }
 
-        public Query<T> WhereLast7Days(Expression<Func<T, object>> anonymousTypeInitializer)
-        {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Last7Days);
+        #endregion Link Entities
 
-            return this;
-        }
+        #region Order
 
-        public Query<T> WhereLast7Days<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>
+        /// Order the result of the query by the <paramref name="column"/>
+        /// </summary>
+        /// <param name="column">Column to use to sort results of the query</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Query<T> OrderBy(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Last7Days);
-
+            QueryExpression.AddOrder(AnonymousTypeHelper.GetAttributeName(column), OrderType.Ascending);
             return this;
         }
 
-        public Query<T> WhereLastFiscalPeriod(string attributeName, string entityname = null)
+        /// <summary>
+        /// Order the result of the query by the <paramref name="column"/> descending
+        /// </summary>
+        /// <param name="column">Column to use to sort results of the query</param>
+        /// <returns>This <see cref="Link{T, U}"></see></returns>
+        public Query<T> OrderByDescending(Expression<Func<T, object>> column)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.LastFiscalPeriod);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.LastFiscalPeriod);
-            }
-
+            QueryExpression.AddOrder(AnonymousTypeHelper.GetAttributeName(column), OrderType.Descending);
             return this;
         }
 
-        public Query<T> WhereLastFiscalPeriod(Expression<Func<T, object>> anonymousTypeInitializer)
-        {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastFiscalPeriod);
+        #endregion Order
 
-            return this;
-        }
+        #region PagingInfo
 
-        public Query<T> WhereLastFiscalPeriod<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>
+        /// Set next page number in paging info
+        /// </summary>
+        /// <param name="pagingCookie">Paging cookie to find the next page</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> NextPage(string pagingCookie)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastFiscalPeriod);
+            QueryExpression.PageInfo.PageNumber++;
+            QueryExpression.PageInfo.PagingCookie = pagingCookie;
 
             return this;
         }
 
-        public Query<T> WhereLastFiscalYear(string attributeName, string entityname = null)
+        /// <summary>
+        /// Set configuration for query paging
+        /// </summary>
+        /// <param name="pageNumber">Number of the page to return</param>
+        /// <param name="count">Number of items to return per page</param>
+        /// <param name="returnTotalCount">Indicates if total count should be returned</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> SetPagingInfo(int pageNumber, int count, bool returnTotalCount = false)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.LastFiscalYear);
-            }
-            else
+            QueryExpression.PageInfo = new PagingInfo
             {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.LastFiscalYear);
-            }
+                Count = count,
+                PageNumber = pageNumber,
+                ReturnTotalRecordCount = returnTotalCount
+            };
 
             return this;
         }
 
-        public Query<T> WhereLastFiscalYear(Expression<Func<T, object>> anonymousTypeInitializer)
-        {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastFiscalYear);
+        #endregion PagingInfo
 
-            return this;
-        }
+        #region Conditions
 
-        public Query<T> WhereLastFiscalYear<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> respects the <paramref name="conditionOperator"/> and the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="conditionOperator">The condition operator.</param>
+        /// <param name="values">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> Where(Expression<Func<T, object>> column, ConditionOperator conditionOperator, params object[] values)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastFiscalYear);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName<T>(column), conditionOperator, values);
 
             return this;
         }
 
-        public Query<T> WhereLastMonth(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> respects the <paramref name="conditionOperator"/> and the <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="conditionOperator">The condition operator.</param>
+        /// <param name="values">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> Where<U>(string tableAlias, Expression<Func<U, object>> column, ConditionOperator conditionOperator, params object[] values) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.LastMonth);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.LastMonth);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), conditionOperator, values);
 
             return this;
         }
 
-        public Query<T> WhereLastMonth(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> is above <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereAbove(Expression<Func<T, object>> column, object value)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastMonth);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Above, value);
 
             return this;
         }
 
-        public Query<T> WhereLastMonth<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> is above <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereAbove<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastMonth);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Above, value);
 
             return this;
         }
 
-        public Query<T> WhereLastWeek(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is above or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereAboveOrEqual(Expression<Func<T, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.LastWeek);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.LastWeek);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.AboveOrEqual, value);
 
             return this;
         }
 
-        public Query<T> WhereLastWeek(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> is above or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereAboveOrEqual<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastWeek);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.AboveOrEqual, value);
 
             return this;
         }
 
-        public Query<T> WhereLastWeek<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value begins with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereBeginsWith(Expression<Func<T, object>> column, string value)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastWeek);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.BeginsWith, value);
 
             return this;
         }
 
-        public Query<T> WhereLastXDays(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value begins with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereBeginsWith<U>(string tableAlias, Expression<Func<U, object>> column, string value) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.LastXDays, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.LastXDays, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.BeginsWith, value);
 
             return this;
         }
 
-        public Query<T> WhereLastXDays(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereBetween(Expression<Func<T, object>> column, object value1, object value2)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastXDays, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Between, value1, value2);
 
             return this;
         }
 
-        public Query<T> WhereLastXDays<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereBetween<U>(string tableAlias, Expression<Func<U, object>> column, object value1, object value2) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastXDays, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Between, value1, value2);
 
             return this;
         }
 
-        public Query<T> WhereLastXFiscalPeriods(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value contains <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereContains(Expression<Func<T, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.LastXFiscalPeriods, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.LastXFiscalPeriods, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Contains, value);
 
             return this;
         }
-        public Query<T> WhereLastXFiscalPeriods(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+
+        /// <summary>Adds a condition where <paramref name="column"/> value contains <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereContains<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastXFiscalPeriods, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Contains, value);
 
             return this;
         }
 
-        public Query<T> WhereLastXFiscalPeriods<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+#if CRMV9
+
+        /// <summary>Adds a condition where <paramref name="column"/> contains <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereContainValues(Expression<Func<T, object>> column, params object[] values)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastXFiscalPeriods, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ContainValues, values);
 
             return this;
         }
 
-        public Query<T> WhereLastXFiscalYears(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> contains <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereContainValues<U>(string tableAlias, Expression<Func<U, object>> column, params object[] values) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.LastXFiscalYears, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.LastXFiscalYears, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ContainValues, values);
 
             return this;
         }
 
-        public Query<T> WhereLastXFiscalYears(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+#endif
+
+        /// <summary>Adds a condition where <paramref name="column"/> value does not begin with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereDoesNotBeginWith(Expression<Func<T, object>> column, object value)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastXFiscalYears, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotBeginWith, value);
 
             return this;
         }
 
-        public Query<T> WhereLastXFiscalYears<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value does not begin with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereDoesNotBeginWith<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastXFiscalYears, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotBeginWith, value);
 
             return this;
         }
 
-        public Query<T> WhereLastXHours(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not contain <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereDoesNotContain(Expression<Func<T, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.LastXHours, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.LastXHours, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotContain, value);
 
             return this;
         }
 
-        public Query<T> WhereLastXHours(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not contain <paramref name="value"/></summary>
+        /// <remarks>You must use the Contains operator for only those attributes that are enabled for full-text indexing.
+        /// Otherwise, you will receive a generic SQL error message while retrieving data. In a Microsoft Dynamics 365 default
+        /// installation, only the attributes of the KBArticle (article) entity are enabled for full-text indexing.</remarks>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">Value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereDoesNotContain<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastXHours, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotContain, value);
 
             return this;
         }
 
-        public Query<T> WhereLastXHours<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+#if CRMV9
+
+        /// <summary>Adds a condition where <paramref name="column"/> contdoes not containains <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereDoesNotContainValues(Expression<Func<T, object>> column, params object[] values)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastXHours, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotContainValues, values);
 
             return this;
         }
 
-        public Query<T> WhereLastXMonths(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">Values to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereDoesNotContainValues<U>(string tableAlias, Expression<Func<U, object>> column, params object[] values) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.LastXMonths, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.LastXMonths, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotContainValues, values);
 
             return this;
         }
+#endif
 
-        public Query<T> WhereLastXMonths(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not end with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereDoesNotEndWith(Expression<Func<T, object>> column, object value)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastXMonths, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotEndWith, value);
 
             return this;
         }
 
-        public Query<T> WhereLastXMonths<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value does not end with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereDoesNotEndWith<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastXMonths, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.DoesNotEndWith, value);
 
             return this;
         }
 
-        public Query<T> WhereLastXWeeks(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value ends with <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEndsWith(Expression<Func<T, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.LastXWeeks, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.LastXWeeks, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EndsWith, value);
 
             return this;
         }
 
-        public Query<T> WhereLastXWeeks(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value ends with <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEndsWith<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastXWeeks, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EndsWith, value);
 
             return this;
         }
 
-        public Query<T> WhereLastXWeeks<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value equals <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqual(Expression<Func<T, object>> column, object value)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastXWeeks, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Equal, value);
 
             return this;
         }
 
-        public Query<T> WhereLastXYears(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value equals <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqual<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.LastXYears, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.LastXYears, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Equal, value);
 
             return this;
         }
 
-        public Query<T> WhereLastXYears(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user business unit</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqualBusinessId(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastXYears, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualBusinessId);
 
             return this;
         }
 
-        public Query<T> WhereLastXYears<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user business unit</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqualBusinessId<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastXYears, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualBusinessId);
 
             return this;
         }
 
-        public Query<T> WhereLastYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user unique identifier</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqualUserId(Expression<Func<T, object>> column)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.LastYear);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.LastYear);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserId);
 
             return this;
         }
 
-        public Query<T> WhereLastYear(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user unique identifier</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqualUserId<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastYear);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserId);
 
             return this;
         }
 
-        public Query<T> WhereLastYear<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user language</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqualUserLanguage(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LastYear);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserLanguage);
 
             return this;
         }
 
-        public Query<T> WhereLessEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user language</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqualUserLanguage<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.LessEqual, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.LessEqual, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserLanguage);
 
             return this;
         }
 
-        public Query<T> WhereLessEqual(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or their reporting hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqualUserOrUserHierarchy(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LessEqual, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserOrUserHierarchy);
 
             return this;
         }
 
-        public Query<T> WhereLessEqual<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or their reporting hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqualUserOrUserHierarchy<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LessEqual, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserOrUserHierarchy);
 
             return this;
         }
 
-        public Query<T> WhereLessThan(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user and his teams or their reporting hierarchy and their teams</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqualUserOrUserHierarchyAndTeams(Expression<Func<T, object>> column)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.LessThan, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.LessThan, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserOrUserHierarchyAndTeams);
 
             return this;
         }
 
-        public Query<T> WhereLessThan(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user and his teams or their reporting hierarchy and their teams</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqualUserOrUserHierarchyAndTeams<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LessThan, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserOrUserHierarchyAndTeams);
 
             return this;
         }
 
-        public Query<T> WhereLessThan<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or a team the current user is member of</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqualUserOrUserTeams(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.LessThan, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserOrUserTeams);
 
             return this;
         }
 
-        public Query<T> WhereLike(string attributeName, string value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> equals current user or a team the current user is member of</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqualUserOrUserTeams<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.Like, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.Like, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserOrUserTeams);
 
             return this;
         }
 
-        public Query<T> WhereLike(Expression<Func<T, object>> anonymousTypeInitializer, string value)
+        /// <summary>Adds a condition where <paramref name="column"/> equals a team the current user is member of</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqualUserTeams(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Like, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserTeams);
 
             return this;
         }
 
-        public Query<T> WhereLike<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, string value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> equals a team the current user is member of</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereEqualUserTeams<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Like, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.EqualUserTeams);
 
             return this;
         }
 
-        public Query<T> WhereMask(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is greater or equal to <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereGreaterEqual(Expression<Func<T, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.Mask, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.Mask, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.GreaterEqual, value);
 
             return this;
         }
 
-        public Query<T> WhereMask(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> is greater or equal to <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereGreaterEqual<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Mask, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.GreaterEqual, value);
 
             return this;
         }
 
-        public Query<T> WhereMask<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> is greater than <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereGreaterThan(Expression<Func<T, object>> column, object value)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Mask, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.GreaterThan, value);
 
             return this;
         }
 
-        public Query<T> WhereMasksSelect(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is greater than <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereGreaterThan<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.MasksSelect, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.MasksSelect, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.GreaterThan, value);
 
             return this;
         }
 
-        public Query<T> WhereMasksSelect(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereIn(Expression<Func<T, object>> column, IList values)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.MasksSelect, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.In, values);
 
             return this;
         }
 
-        public Query<T> WhereMasksSelect<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereIn<U>(string tableAlias, Expression<Func<U, object>> column, IList values) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.MasksSelect, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.In, values);
 
             return this;
         }
 
-        public Query<T> WhereNext7Days(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereIn(Expression<Func<T, object>> column, params object[] values)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.Next7Days);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.Next7Days);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.In, values);
 
             return this;
         }
 
-        public Query<T> WhereNext7Days(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereIn(string tableAlias, Expression<Func<T, object>> column, params object[] values)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Next7Days);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.In, values);
 
             return this;
         }
 
-        public Query<T> WhereNext7Days<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereInFiscalPeriod(Expression<Func<T, object>> column, object value)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Next7Days);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InFiscalPeriod, value);
 
             return this;
         }
 
-        public Query<T> WhereNextFiscalPeriod(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereInFiscalPeriod<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NextFiscalPeriod);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NextFiscalPeriod);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InFiscalPeriod, value);
 
             return this;
         }
 
-        public Query<T> WhereNextFiscalPeriod(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereInFiscalPeriodAndYear(Expression<Func<T, object>> column, int period, int year)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextFiscalPeriod);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InFiscalPeriodAndYear, period, year);
 
             return this;
         }
 
-        public Query<T> WhereNextFiscalPeriod<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereInFiscalPeriodAndYear<U>(string tableAlias, Expression<Func<U, object>> column, int period, int year) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextFiscalPeriod);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InFiscalPeriodAndYear, period, year);
 
             return this;
         }
 
-        public Query<T> WhereNextFiscalYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereInFiscalYear(Expression<Func<T, object>> column, int year)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NextFiscalYear);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NextFiscalYear);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InFiscalYear, year);
 
             return this;
         }
 
-        public Query<T> WhereNextFiscalYear(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereInFiscalYear<U>(string tableAlias, Expression<Func<U, object>> column, int year) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextFiscalYear);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InFiscalYear, year);
 
             return this;
         }
 
-        public Query<T> WhereNextFiscalYear<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or after the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereInOrAfterFiscalPeriodAndYear(Expression<Func<T, object>> column, int period, int year)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextFiscalYear);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InOrAfterFiscalPeriodAndYear, period, year);
 
             return this;
         }
 
-        public Query<T> WhereNextMonth(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or after the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereInOrAfterFiscalPeriodAndYear<U>(string tableAlias, Expression<Func<U, object>> column, int period, int year) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NextMonth);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NextMonth);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InOrAfterFiscalPeriodAndYear, period, year);
 
             return this;
         }
 
-        public Query<T> WhereNextMonth(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or before the curent fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereInOrBeforeFiscalPeriodAndYear(Expression<Func<T, object>> column, int period, int year)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextMonth);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InOrBeforeFiscalPeriodAndYear, period, year);
 
             return this;
         }
 
-        public Query<T> WhereNextMonth<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is in or before the curent fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="period">The period</param>
+        /// <param name="year">The year</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereInOrBeforeFiscalPeriodAndYear<U>(string tableAlias, Expression<Func<U, object>> column, int period, int year) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextMonth);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.InOrBeforeFiscalPeriodAndYear, period, year);
 
             return this;
         }
 
-        public Query<T> WhereNextWeek(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on last 7 days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLast7Days(Expression<Func<T, object>> column)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NextWeek);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NextWeek);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Last7Days);
 
             return this;
         }
 
-        public Query<T> WhereNextWeek(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on last 7 days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLast7Days<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextWeek);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Last7Days);
 
             return this;
         }
 
-        public Query<T> WhereNextWeek<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastFiscalPeriod(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextWeek);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastFiscalPeriod);
 
             return this;
         }
 
-        public Query<T> WhereNextXDays(string attributeName, int value, string entityname = null)
-        {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NextXDays, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NextXDays, value);
-            }
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastFiscalPeriod<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
+        {
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastFiscalPeriod);
 
             return this;
         }
 
-        public Query<T> WhereNextXDays(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastFiscalYear(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextXDays, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastFiscalYear);
 
             return this;
         }
 
-        public Query<T> WhereNextXDays<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last fiscal year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastFiscalYear<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextXDays, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastFiscalYear);
 
             return this;
         }
 
-        public Query<T> WhereNextXFiscalPeriods(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last month</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastMonth(Expression<Func<T, object>> column)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NextXFiscalPeriods, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NextXFiscalPeriods, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastMonth);
 
             return this;
         }
 
-        public Query<T> WhereNextXFiscalPeriods(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last month</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastMonth<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextXFiscalPeriods, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastMonth);
 
             return this;
         }
 
-        public Query<T> WhereNextXFiscalPeriods<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last week</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastWeek(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextXFiscalPeriods, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastWeek);
 
             return this;
         }
 
-        public Query<T> WhereNextXFiscalYears(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last week</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastWeek<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NextXFiscalYears, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NextXFiscalYears, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastWeek);
 
             return this;
         }
 
-        public Query<T> WhereNextXFiscalYears(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastXDays(Expression<Func<T, object>> column, int x)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextXFiscalYears, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXDays, x);
 
             return this;
         }
 
-        public Query<T> WhereNextXFiscalYears<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastXDays<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextXFiscalYears, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXDays, x);
 
             return this;
         }
 
-        public Query<T> WhereNextXHours(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal periods</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal periods to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastXFiscalPeriods(Expression<Func<T, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NextXHours, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NextXHours, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXFiscalPeriods, x);
 
             return this;
         }
 
-        public Query<T> WhereNextXHours(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal periods</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal periods to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastXFiscalPeriods<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextXHours, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXFiscalPeriods, x);
 
             return this;
         }
 
-        public Query<T> WhereNextXHours<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastXFiscalYears(Expression<Func<T, object>> column, int x)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextXHours, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXFiscalYears, x);
 
             return this;
         }
 
-        public Query<T> WhereNextXMonths(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> fiscal years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastXFiscalYears<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NextXMonths, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NextXMonths, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXFiscalYears, x);
 
             return this;
         }
 
-        public Query<T> WhereNextXMonths(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> hours</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastXHours(Expression<Func<T, object>> column, int x)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextXMonths, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXHours, x);
 
             return this;
         }
 
-        public Query<T> WhereNextXMonths<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> hours</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastXHours<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextXMonths, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXHours, x);
 
             return this;
         }
 
-        public Query<T> WhereNextXWeeks(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> months</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastXMonths(Expression<Func<T, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NextXWeeks, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NextXWeeks, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXMonths, x);
 
             return this;
         }
 
-        public Query<T> WhereNextXWeeks(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> months</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastXMonths<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextXWeeks, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXMonths, x);
 
             return this;
         }
 
-        public Query<T> WhereNextXWeeks<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> weeks</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastXWeeks(Expression<Func<T, object>> column, int x)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextXWeeks, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXWeeks, x);
 
             return this;
         }
 
-        public Query<T> WhereNextXYears(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> weeks</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastXWeeks<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NextXYears, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NextXYears, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXWeeks, x);
 
             return this;
         }
 
-        public Query<T> WhereNextXYears(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastXYears(Expression<Func<T, object>> column, int x)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextXYears, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXYears, x);
 
             return this;
         }
 
-        public Query<T> WhereNextXYears<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last <paramref name="x"/> years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastXYears<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextXYears, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastXYears, x);
 
             return this;
         }
 
-        public Query<T> WhereNextYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastYear(Expression<Func<T, object>> column)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NextYear);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NextYear);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastYear);
 
             return this;
         }
 
-        public Query<T> WhereNextYear(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the last year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLastYear<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextYear);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LastYear);
 
             return this;
         }
 
-        public Query<T> WhereNextYear<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is less or equal to <paramref name="value"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLessEqual(Expression<Func<T, object>> column, int value)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NextYear);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LessEqual, value);
 
             return this;
         }
 
-        public Query<T> WhereNotBetween(string attributeName, object value1, object value2, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is less or equal to <paramref name="value"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLessEqual<U>(string tableAlias, Expression<Func<U, object>> column, int value) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NotBetween, value1, value2);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NotBetween, value1, value2);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LessEqual, value);
 
             return this;
         }
 
-        public Query<T> WhereNotBetween(Expression<Func<T, object>> anonymousTypeInitializer, object value1, object value2)
+        /// <summary>Adds a condition where <paramref name="column"/> value is less than <paramref name="value"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLessThan(Expression<Func<T, object>> column, int value)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotBetween, value1, value2);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LessThan, value);
 
             return this;
         }
 
-        public Query<T> WhereNotBetween<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value1, object value2) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is less than <paramref name="value"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The value</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLessThan<U>(string tableAlias, Expression<Func<U, object>> column, int value) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotBetween, value1, value2);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.LessThan, value);
 
             return this;
         }
 
-        public Query<T> WhereNotEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value matches the specifed <paramref name="pattern"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLike(Expression<Func<T, object>> column, string pattern)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NotEqual, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NotEqual, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Like, pattern);
 
             return this;
         }
 
-        public Query<T> WhereNotEqual(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> value matches the specifed <paramref name="pattern"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereLike<U>(string tableAlias, Expression<Func<U, object>> column, string pattern) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotEqual, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Like, pattern);
 
             return this;
         }
 
-        public Query<T> WhereNotEqual<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereMask(Expression<Func<T, object>> column, object bitmask)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotEqual, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Mask, bitmask);
 
             return this;
         }
 
-        public Query<T> WhereNotEqualBusinessId(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereMask<U>(string tableAlias, Expression<Func<U, object>> column, object bitmask) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NotEqualBusinessId);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NotEqualBusinessId);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Mask, bitmask);
 
             return this;
         }
 
-        public Query<T> WhereNotEqualBusinessId(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next 7 days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNext7Days(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotEqualBusinessId);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Next7Days);
 
             return this;
         }
 
-        public Query<T> WhereNotEqualBusinessId<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next 7 days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNext7Days<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotEqualBusinessId);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Next7Days);
 
             return this;
         }
 
-        public Query<T> WhereNotEqualUserId(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextFiscalPeriod(Expression<Func<T, object>> column)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NotEqualUserId);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NotEqualUserId);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextFiscalPeriod);
 
             return this;
         }
 
-        public Query<T> WhereNotEqualUserId(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextFiscalPeriod<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotEqualUserId);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextFiscalPeriod);
 
             return this;
         }
 
-        public Query<T> WhereNotEqualUserId<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextFiscalYear(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotEqualUserId);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextFiscalYear);
 
             return this;
         }
 
-        public Query<T> WhereNotIn(string entityname, string attributeName, IList value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next fiscal year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextFiscalYear<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.Conditions.Add(new ConditionExpression(entityname, attributeName, ConditionOperator.NotIn, value));
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextFiscalYear);
 
             return this;
         }
 
-        public Query<T> WhereNotIn(string attributeName, IList value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next month</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextMonth(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.Conditions.Add(new ConditionExpression(attributeName, ConditionOperator.NotIn, value));
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextMonth);
 
             return this;
         }
 
-        public Query<T> WhereNotIn(Expression<Func<T, object>> anonymousTypeInitializer, IList value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next month</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextMonth<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotIn, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextMonth);
 
             return this;
         }
 
-        public Query<T> WhereNotIn<U>(string entityname, Expression<Func<T, object>> anonymousTypeInitializer, IList value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next week</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextWeek(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotIn, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextWeek);
 
             return this;
         }
 
-        public Query<T> WhereNotIn(string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on next week</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextWeek<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NotIn, values);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextWeek);
 
             return this;
         }
 
-        public Query<T> WhereNotIn(string entityname, string attributeName, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextXDays(Expression<Func<T, object>> column, int x)
         {
-            QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NotIn, values);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXDays, x);
 
             return this;
         }
 
-        public Query<T> WhereNotIn(Expression<Func<T, object>> anonymousTypeInitializer, params object[] values)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextXDays<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotIn, values);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXDays, x);
 
             return this;
         }
 
-        public Query<T> WhereNotIn<U>(string entityname, Expression<Func<T, object>> anonymousTypeInitializer, params object[] values) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal periods</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal perdiods to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextXFiscalPeriods(Expression<Func<T, object>> column, int x)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotIn, values);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXFiscalPeriods, x);
 
             return this;
         }
 
-        public Query<T> WhereNotLike(string attributeName, string value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal periods</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal perdiods to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextXFiscalPeriods<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NotLike, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NotLike, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXFiscalPeriods, x);
 
             return this;
         }
 
-        public Query<T> WhereNotLike(Expression<Func<T, object>> anonymousTypeInitializer, string value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextXFiscalYears(Expression<Func<T, object>> column, int x)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotLike, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXFiscalYears, x);
 
             return this;
         }
 
-        public Query<T> WhereNotLike<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, string value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> fiscal years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of fiscal years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextXFiscalYears<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotLike, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXFiscalYears, x);
 
             return this;
         }
 
-        public Query<T> WhereNotMask(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> hours</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextXHours(Expression<Func<T, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NotMask, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NotMask, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXHours, x);
 
             return this;
         }
 
-        public Query<T> WhereNotMask(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> hours</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextXHours<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotMask, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXHours, x);
 
             return this;
         }
 
-        public Query<T> WhereNotMask<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> months</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextXMonths(Expression<Func<T, object>> column, int x)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotMask, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXMonths, x);
 
             return this;
         }
 
-        public Query<T> WhereNotNull(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> months</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextXMonths<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NotNull);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NotNull);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXMonths, x);
 
             return this;
         }
 
-        public Query<T> WhereNotNull(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> weeks</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextXWeeks(Expression<Func<T, object>> column, int x)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotNull);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXWeeks, x);
 
             return this;
         }
 
-        public Query<T> WhereNotNull<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> weeks</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextXWeeks<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotNull);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXWeeks, x);
 
             return this;
         }
 
-        public Query<T> WhereNotOn(string attributeName, DateTime value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextXYears(Expression<Func<T, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NotOn, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NotOn, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXYears, x);
 
             return this;
         }
 
-        public Query<T> WhereNotOn(Expression<Func<T, object>> anonymousTypeInitializer, DateTime value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next <paramref name="x"/> years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextXYears<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotOn, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextXYears, x);
 
             return this;
         }
 
-        public Query<T> WhereNotOn<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, DateTime value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextYear(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotOn, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextYear);
 
             return this;
         }
 
-        public Query<T> WhereNotUnder(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the next year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNextYear<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.NotUnder, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.NotUnder, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NextYear);
 
             return this;
         }
 
-        public Query<T> WhereNotUnder(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotBetween(Expression<Func<T, object>> column, object value1, object value2)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotUnder, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotBetween, value1, value2);
 
             return this;
         }
 
-        public Query<T> WhereNotUnder<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is not between <paramref name="value1"/> and <paramref name="value2"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value1">Value 1</param>
+        /// <param name="value2">Value 2</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotBetween<U>(string tableAlias, Expression<Func<U, object>> column, object value1, object value2) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.NotUnder, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotBetween, value1, value2);
 
             return this;
         }
 
-        public Query<T> WhereNull(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not equal <paramref name="value"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotEqual(Expression<Func<T, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.Null);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.Null);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotEqual, value);
 
             return this;
         }
 
-        public Query<T> WhereNull(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not equal <paramref name="value"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotEqual<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Null);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotEqual, value);
 
             return this;
         }
 
-        public Query<T> WhereNull<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user business unit</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotEqualBusinessId(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Null);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotEqualBusinessId);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXDays(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user business unit</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotEqualBusinessId<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXDays, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.OlderThanXDays, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotEqualBusinessId);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXDays(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user unique identifier</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotEqualUserId(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OlderThanXDays, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotEqualUserId);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXDays<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> does not equal current user unique identifier</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotEqualUserId<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OlderThanXDays, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotEqualUserId);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXHours(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotIn(Expression<Func<T, object>> column, IList values)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXHours, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.OlderThanXHours, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotIn, values);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXHours(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotIn(string tableAlias, Expression<Func<T, object>> column, IList values)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OlderThanXHours, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotIn, values);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXHours<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotIn(Expression<Func<T, object>> column, params object[] values)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OlderThanXHours, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotIn, values);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXMinutes(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not in the specified <paramref name="values"/></summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="values">The values</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotIn(string tableAlias, Expression<Func<T, object>> column, params object[] values)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXMinutes, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.OlderThanXMinutes, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotIn, values);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXMinutes(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value does not match the specifed <paramref name="pattern"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotLike(Expression<Func<T, object>> column, string pattern)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OlderThanXMinutes, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotLike, pattern);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXMinutes<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value does not match the specifed <paramref name="pattern"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="pattern">The pattern</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotLike<U>(string tableAlias, Expression<Func<U, object>> column, string pattern) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OlderThanXMinutes, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotLike, pattern);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXMonths(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotMask(Expression<Func<T, object>> column, object bitmask)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXMonths, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.OlderThanXMonths, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotMask, bitmask);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXMonths(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not found in the specifed <paramref name="bitmask"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="bitmask">The bitmask</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotMask<U>(string tableAlias, Expression<Func<U, object>> column, object bitmask) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OlderThanXMonths, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotMask, bitmask);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXMonths<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is not null</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotNull(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OlderThanXMonths, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotNull);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXWeeks(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not null</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotNull<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXWeeks, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.OlderThanXWeeks, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotNull);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXWeeks(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is not on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotOn(Expression<Func<T, object>> column, DateTime datetime)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OlderThanXWeeks, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotOn, datetime);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXWeeks<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is not on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotOn<U>(string tableAlias, Expression<Func<U, object>> column, DateTime datetime) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OlderThanXWeeks, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotOn, datetime);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXYears(string attributeName, int value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is above <paramref name="value"/> in the hierarchy </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotUnder(Expression<Func<T, object>> column, object value)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.OlderThanXYears, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.OlderThanXYears, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotUnder, value);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXYears(Expression<Func<T, object>> anonymousTypeInitializer, int value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is above <paramref name="value"/> in the hierarchy </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNotUnder<U>(string tableAlias, Expression<Func<U, object>> column, object value) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OlderThanXYears, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.NotUnder, value);
 
             return this;
         }
 
-        public Query<T> WhereOlderThanXYears<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, int value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain data</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNull(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OlderThanXYears, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Null);
 
             return this;
         }
 
-        public Query<T> WhereOn(string attributeName, DateTime value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> does not contain data</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereNull<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.On, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.On, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Null);
 
             return this;
         }
 
-        public Query<T> WhereOn(Expression<Func<T, object>> anonymousTypeInitializer, DateTime value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> days</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOlderThanXDays(Expression<Func<T, object>> column, int x)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.On, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXDays, x);
 
             return this;
         }
 
-        public Query<T> WhereOn<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, DateTime value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> days</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of days to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOlderThanXDays<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.On, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXDays, x);
 
             return this;
         }
 
-        public Query<T> WhereOnOrAfter(string attributeName, DateTime value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> hours</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOlderThanXHours(Expression<Func<T, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.OnOrAfter, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.OnOrAfter, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXHours, x);
 
             return this;
         }
 
-        public Query<T> WhereOnOrAfter(Expression<Func<T, object>> anonymousTypeInitializer, DateTime value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> hours</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of hours to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOlderThanXHours<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OnOrAfter, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXHours, x);
 
             return this;
         }
 
-        public Query<T> WhereOnOrAfter<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, DateTime value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> minutes</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of minutes to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOlderThanXMinutes(Expression<Func<T, object>> column, int x)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OnOrAfter, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXMinutes, x);
 
             return this;
         }
 
-        public Query<T> WhereOnOrBefore(string attributeName, DateTime value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> minutes</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of minutes to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOlderThanXMinutes<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.OnOrBefore, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.OnOrBefore, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXMinutes, x);
 
             return this;
         }
 
-        public Query<T> WhereOnOrBefore(Expression<Func<T, object>> anonymousTypeInitializer, DateTime value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> months</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOlderThanXMonths(Expression<Func<T, object>> column, int x)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OnOrBefore, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXMonths, x);
 
             return this;
         }
 
-        public Query<T> WhereOnOrBefore<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, DateTime value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> months</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of months to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOlderThanXMonths<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.OnOrBefore, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXMonths, x);
 
             return this;
         }
 
-        public Query<T> WhereThisFiscalPeriod(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> weeks</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOlderThanXWeeks(Expression<Func<T, object>> column, int x)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.ThisFiscalPeriod);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.ThisFiscalPeriod);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXWeeks, x);
 
             return this;
         }
 
-        public Query<T> WhereThisFiscalPeriod(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> weeks</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of weeks to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOlderThanXWeeks<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.ThisFiscalPeriod);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXWeeks, x);
 
             return this;
         }
 
-        public Query<T> WhereThisFiscalPeriod<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> years</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOlderThanXYears(Expression<Func<T, object>> column, int x)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.ThisFiscalPeriod);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXYears, x);
 
             return this;
         }
 
-        public Query<T> WhereThisFiscalYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is older than <paramref name="x"/> years</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="x">Number of years to evaluate</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOlderThanXYears<U>(string tableAlias, Expression<Func<U, object>> column, int x) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.ThisFiscalYear);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.ThisFiscalYear);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OlderThanXYears, x);
 
             return this;
         }
 
-        public Query<T> WhereThisFiscalYear(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOn(Expression<Func<T, object>> column, DateTime datetime)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.ThisFiscalYear);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.On, datetime);
 
             return this;
         }
 
-        public Query<T> WhereThisFiscalYear<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOn<U>(string tableAlias, Expression<Func<U, object>> column, DateTime datetime) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.ThisFiscalYear);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.On, datetime);
 
             return this;
         }
 
-        public Query<T> WhereThisMonth(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or after the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOnOrAfter(Expression<Func<T, object>> column, DateTime datetime)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.ThisMonth);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.ThisMonth);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OnOrAfter, datetime);
 
             return this;
         }
 
-        public Query<T> WhereThisMonth(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or after the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOnOrAfter<U>(string tableAlias, Expression<Func<U, object>> column, DateTime datetime) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.ThisMonth);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OnOrAfter, datetime);
 
             return this;
         }
 
-        public Query<T> WhereThisMonth<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or before the specifed <paramref name="datetime"/> </summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOnOrBefore(Expression<Func<T, object>> column, DateTime datetime)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.ThisMonth);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OnOrBefore, datetime);
 
             return this;
         }
 
-        public Query<T> WhereThisWeek(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is on or before the specifed <paramref name="datetime"/> </summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="datetime">The date</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereOnOrBefore<U>(string tableAlias, Expression<Func<U, object>> column, DateTime datetime) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.ThisWeek);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.ThisWeek);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.OnOrBefore, datetime);
 
             return this;
         }
 
-        public Query<T> WhereThisWeek(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal period</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereThisFiscalPeriod(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.ThisWeek);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisFiscalPeriod);
 
             return this;
         }
 
-        public Query<T> WhereThisWeek<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal period</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereThisFiscalPeriod<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.ThisWeek);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisFiscalPeriod);
 
             return this;
         }
 
-        public Query<T> WhereThisYear(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereThisFiscalYear(Expression<Func<T, object>> column)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.ThisYear);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.ThisYear);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisFiscalYear);
 
             return this;
         }
 
-        public Query<T> WhereThisYear(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current fiscal year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereThisFiscalYear<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.ThisYear);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisFiscalYear);
 
             return this;
         }
 
-        public Query<T> WhereThisYear<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current month</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereThisMonth(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.ThisYear);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisMonth);
 
             return this;
         }
 
-        public Query<T> WhereToday(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current month</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereThisMonth<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.Today);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.Today);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisMonth);
 
             return this;
         }
 
-        public Query<T> WhereToday(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current week</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereThisWeek(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Today);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisWeek);
 
             return this;
         }
 
-        public Query<T> WhereToday<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current week</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereThisWeek<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Today);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisWeek);
 
             return this;
         }
 
-        public Query<T> WhereTomorrow(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current year</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereThisYear(Expression<Func<T, object>> column)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.Tomorrow);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.Tomorrow);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisYear);
 
             return this;
         }
 
-        public Query<T> WhereTomorrow(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current year</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereThisYear<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Tomorrow);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.ThisYear);
 
             return this;
         }
 
-        public Query<T> WhereTomorrow<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current day</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereToday(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Tomorrow);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Today);
 
             return this;
         }
 
-        public Query<T> WhereUnder(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> value is in the current day</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereToday<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.Under, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.Under, value);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Today);
 
             return this;
         }
 
-        public Query<T> WhereUnder(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> value is tomorrow</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereTomorrow(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Under, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Tomorrow);
 
             return this;
         }
 
-        public Query<T> WhereUnder<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is tomorrow</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereTomorrow<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Under, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Tomorrow);
 
             return this;
         }
 
-        public Query<T> WhereUnderOrEqual(string attributeName, object value, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is under <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereUnder(Expression<Func<T, object>> column, Guid value)
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.UnderOrEqual, value);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.UnderOrEqual, value);
-            }
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Under, value);
 
             return this;
         }
 
-        public Query<T> WhereUnderOrEqual(Expression<Func<T, object>> anonymousTypeInitializer, object value)
+        /// <summary>Adds a condition where <paramref name="column"/> is under <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereUnder<U>(string tableAlias, Expression<Func<U, object>> column, Guid value) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.UnderOrEqual, value);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Under, value);
 
             return this;
         }
 
-        public Query<T> WhereUnderOrEqual<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer, object value) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> is under or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereUnderOrEqual(Expression<Func<T, object>> column, Guid value)
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.UnderOrEqual, value);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.UnderOrEqual, value);
 
             return this;
         }
 
-        public Query<T> WhereYesterday(string attributeName, string entityname = null)
+        /// <summary>Adds a condition where <paramref name="column"/> is under or equals <paramref name="value"/> in the hierarchy</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <param name="value">The values.</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereUnderOrEqual<U>(string tableAlias, Expression<Func<U, object>> column, Guid value) where U : Entity
         {
-            if (entityname != null)
-            {
-                QueryExpression.Criteria.AddCondition(entityname, attributeName, ConditionOperator.Yesterday);
-            }
-            else
-            {
-                QueryExpression.Criteria.AddCondition(attributeName, ConditionOperator.Yesterday);
-            }
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.UnderOrEqual, value);
 
             return this;
         }
 
-        public Query<T> WhereYesterday(Expression<Func<T, object>> anonymousTypeInitializer)
+        /// <summary>Adds a condition where <paramref name="column"/> value is yesterday</summary>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereYesterday(Expression<Func<T, object>> column)
         {
-            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Yesterday);
+            QueryExpression.Criteria.AddCondition(AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Yesterday);
 
             return this;
         }
 
-        public Query<T> WhereYesterday<U>(string entityname, Expression<Func<U, object>> anonymousTypeInitializer) where U : Entity
+        /// <summary>Adds a condition where <paramref name="column"/> value is yesterday</summary>
+        /// <param name="tableAlias">Logical name of the related table where to apply the condition</param>
+        /// <param name="column">Logical name of the column</param>
+        /// <returns>The <see cref="Query{T}"/></returns>
+        public Query<T> WhereYesterday<U>(string tableAlias, Expression<Func<U, object>> column) where U : Entity
         {
-            QueryExpression.Criteria.AddCondition(entityname, AnonymousTypeHelper.GetAttributeName(anonymousTypeInitializer), ConditionOperator.Yesterday);
+            QueryExpression.Criteria.AddCondition(tableAlias, AnonymousTypeHelper.GetAttributeName(column), ConditionOperator.Yesterday);
 
             return this;
         }
@@ -2761,6 +4327,11 @@ public Query<T> WhereYesterday<U>(string entityname, Expression<Func<U, object>>
 
         #region Service calls
 
+        /// <summary>
+        /// Retrieve all records for the entity
+        /// </summary>
+        /// <param name="service">Dataverse service</param>
+        /// <returns>List of <typeparamref name="T"/> records</returns>
         public List<T> GetAll(IOrganizationService service)
         {
             if (QueryExpression.TopCount.HasValue)
@@ -2785,48 +4356,214 @@ public List<T> GetAll(IOrganizationService service)
             return list;
         }
 
+        /// <summary>
+        /// Retrieve the first item from the query
+        /// </summary>
+        /// <param name="service">Dataverse service</param>
+        /// <returns>First <typeparamref name="T"/> record</returns>
         public T GetFirst(IOrganizationService service)
         {
-            return service.RetrieveMultiple(QueryExpression).Entities.First().ToEntity<T>();
+            var topCount = 0;
+            if (!QueryExpression.TopCount.HasValue)
+            {
+                QueryExpression.TopCount = 1;
+            }
+            else
+            {
+                topCount = QueryExpression.TopCount.Value;
+            }
+
+            var record = service.RetrieveMultiple(QueryExpression).Entities.First().ToEntity<T>();
+
+            if (topCount == 0)
+            {
+                QueryExpression.TopCount = null;
+            }
+            else
+            {
+                QueryExpression.TopCount = topCount;
+            }
+
+            return record;
         }
 
+        /// <summary>
+        /// Retrieve the first item from the query or null if no records match the query
+        /// </summary>
+        /// <param name="service">Dataverse service</param>
+        /// <returns>First <typeparamref name="T"/> record</returns>
         public T GetFirstOrDefault(IOrganizationService service)
         {
-            return service.RetrieveMultiple(QueryExpression).Entities.FirstOrDefault()?.ToEntity<T>();
+            var topCount = 0;
+            if (!QueryExpression.TopCount.HasValue)
+            {
+                QueryExpression.TopCount = 1;
+            }
+            else
+            {
+                topCount = QueryExpression.TopCount.Value;
+            }
+
+            var record = service.RetrieveMultiple(QueryExpression).Entities.FirstOrDefault()?.ToEntity<T>();
+
+            if (topCount == 0)
+            {
+                QueryExpression.TopCount = null;
+            }
+            else
+            {
+                QueryExpression.TopCount = topCount;
+            }
+
+            return record;
         }
 
+        /// <summary>
+        /// Retrieve the last item from the query
+        /// </summary>
+        /// <param name="service">Dataverse service</param>
+        /// <returns>First <typeparamref name="T"/> record</returns>
         public T GetLast(IOrganizationService service)
         {
-            return service.RetrieveMultiple(QueryExpression).Entities.Last().ToEntity<T>();
+            if (QueryExpression.Orders.Count == 0)
+            {
+                throw new InvalidOperationException("Please provide a sorting criteria before using GetLast method");
+            }
+
+            foreach (var order in QueryExpression.Orders)
+            {
+                order.OrderType = (order.OrderType == OrderType.Ascending) ? OrderType.Descending : OrderType.Ascending;
+            }
+
+            var results = GetFirst(service);
+
+            foreach (var order in QueryExpression.Orders)
+            {
+                order.OrderType = (order.OrderType == OrderType.Ascending) ? OrderType.Descending : OrderType.Ascending;
+            }
+
+            return results;
         }
 
+        /// <summary>
+        /// Retrieve the last item from the query or null if no records match the query
+        /// </summary>
+        /// <param name="service">Dataverse service</param>
+        /// <returns>First <typeparamref name="T"/> record</returns>
         public T GetLastOrDefault(IOrganizationService service)
         {
-            return service.RetrieveMultiple(QueryExpression).Entities.LastOrDefault()?.ToEntity<T>();
+            if (QueryExpression.Orders.Count == 0)
+            {
+                throw new InvalidOperationException("Please provide a sorting criteria before using GetLast method");
+            }
+
+            foreach (var order in QueryExpression.Orders)
+            {
+                order.OrderType = (order.OrderType == OrderType.Ascending) ? OrderType.Descending : OrderType.Ascending;
+            }
+
+            var results = GetFirstOrDefault(service);
+
+            foreach (var order in QueryExpression.Orders)
+            {
+                order.OrderType = (order.OrderType == OrderType.Ascending) ? OrderType.Descending : OrderType.Ascending;
+            }
+
+            return results;
         }
 
+        /// <summary>
+        /// Retrieves current page of records for the query
+        /// </summary>
+        /// <param name="service">Dataverse service</param>
+        /// <returns>List of records as <see cref="EntityCollection"/></returns>
         public EntityCollection GetResults(IOrganizationService service)
         {
             return service.RetrieveMultiple(QueryExpression);
         }
 
+        /// <summary>
+        /// Returns the only record of the query result and throw an exception if there is not exactly one record in the result
+        /// </summary>
+        /// <param name="service">Dataverse service</param>
+        /// <returns>The single <typeparamref name="T"/> record</returns>
         public T GetSingle(IOrganizationService service)
         {
-            return service.RetrieveMultiple(QueryExpression).Entities.Single().ToEntity<T>();
+            var topCount = 0;
+            if (!QueryExpression.TopCount.HasValue)
+            {
+                QueryExpression.TopCount = 2;
+            }
+            else
+            {
+                topCount = QueryExpression.TopCount.Value;
+            }
+
+            var record = service.RetrieveMultiple(QueryExpression).Entities.Single().ToEntity<T>();
+
+            if (topCount == 0)
+            {
+                QueryExpression.TopCount = null;
+            }
+            else
+            {
+                QueryExpression.TopCount = topCount;
+            }
+
+            return record;
         }
 
+        /// <summary>
+        /// Returns the only record of the query result or null if no record and throw an exception if there is more than one record in the result
+        /// </summary>
+        /// <param name="service">Dataverse service</param>
+        /// <returns>The single <typeparamref name="T"/> record</returns>
         public T GetSingleOrDefault(IOrganizationService service)
         {
-            return service.RetrieveMultiple(QueryExpression).Entities.SingleOrDefault()?.ToEntity<T>();
+            var topCount = 0;
+            if (!QueryExpression.TopCount.HasValue)
+            {
+                QueryExpression.TopCount = 2;
+            }
+            else
+            {
+                topCount = QueryExpression.TopCount.Value;
+            }
+
+            var record = service.RetrieveMultiple(QueryExpression).Entities.SingleOrDefault()?.ToEntity<T>();
+
+            if (topCount == 0)
+            {
+                QueryExpression.TopCount = null;
+            }
+            else
+            {
+                QueryExpression.TopCount = topCount;
+            }
+
+            return record;
         }
 
+        /// <summary>
+        /// Returns a record from its unique identifier or null if the record does not exist
+        /// </summary>
+        /// <param name="id">Unique identifier of the record</param>
+        /// <param name="service">Dataverse service</param>
+        /// <param name="isActivityEntity">Indicates if the table queried is an activity table (optional if <typeparamref name="T"/> is not <c>Entity</c>)</param>
+        /// <returns></returns>
         public T GetById(Guid id, IOrganizationService service, bool isActivityEntity = false)
         {
+            string primaryKey = typeof(T) != typeof(Entity) ? typeof(T).GetField("PrimaryIdAttribute").GetRawConstantValue().ToString() : null;
+            if (string.IsNullOrEmpty(primaryKey))
+            {
+                primaryKey = isActivityEntity ? "activityid" : $"{QueryExpression.EntityName}id";
+            }
+
             QueryExpression.Criteria = new FilterExpression
             {
                 Conditions =
                 {
-                    new ConditionExpression(isActivityEntity ? "activityid" : QueryExpression.EntityName + "id", ConditionOperator.Equal, id)
+                    new ConditionExpression(primaryKey, ConditionOperator.Equal, id)
                 }
             };
 

From d8785d610fb3e7ce0217bb902bc121e1168dabac Mon Sep 17 00:00:00 2001
From: MscrmTools <tanguy92@hotmail.com>
Date: Thu, 1 Dec 2022 17:30:55 +0100
Subject: [PATCH 2/5] Update README.md

---
 README.md | 69 ++++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 48 insertions(+), 21 deletions(-)

diff --git a/README.md b/README.md
index 3704f21..e9bdff2 100644
--- a/README.md
+++ b/README.md
@@ -7,14 +7,30 @@ You can rely on :
 - [EarlyBoundGenerator](https://github.com/daryllabar/DLaB.Xrm.XrmToolBoxTools) from Daryl LaBar to create the Early Bound Entities to be used with this project (optional)
 - [LateBoundConstantsGenerator](https://github.com/rappen/LateboundConstantsGenerator) from Jonas Rapp to create Late Bound constants to be used with this projet (optional)
 
+## What's new on version 2
+
+Lambda expressions everywhere for Early Bound queries
+
+No more mix between Late Bound and Early Bound queries
+
+Code is fully documented
+
+Performance optimizations for `GetFirst`, `GetFirstOrDefault`, `GetSingle`, `GetSingleOrDefault`, `GetLast` and `GetLastOrDefault` methods
+
 ## Query properties
 
 ```
-var query = new Query<Account>()
+var earlyBoundQuery = new Query<Account>()
+                .Top(10)
+                .Distinct()
+                .NoLock()
+                .SetPaging(1, 100, true);      
+                
+var lateBoundQuery = new Query("account")
                 .Top(10)
                 .Distinct()
                 .NoLock()
-                .SetPaging(1, 100, true);                
+                .SetPaging(1, 100, true);     
                 
 ```
 
@@ -22,7 +38,7 @@ var query = new Query<Account>()
 
 ```
 var earlyBoundQuery = new Query<Account>()
-                .Select(Account.Fields.Name, Account.Fields.AccountNumber);
+                .Select(a => a.AccountNumber);
                 
 var earlyBoundQuery2 = new Query<Account>()
                 .Select(a => new { a.Name, a.AccountNumber});
@@ -36,8 +52,8 @@ var lateBoundQuery = new Query("account")
 
 ```
 var earlyBoundQuery = new Query<Account>()
-                .Select(Account.Fields.Name, Account.Fields.AccountNumber)
-                .WhereEqual(Account.Address1_City, "Paris");
+                .Select(a => new { a.Name, a.AccountNumber})
+                .WhereEqual(a => a.Address1_City, "Paris");
                 
 var lateBoundQuery = new Query("account")
                 .Select("name", "accountnumber")
@@ -49,16 +65,17 @@ var lateBoundQuery = new Query("account")
 
 ```
 var earlyBoundQuery = new Query<Account>()
-                .Select(Account.Fields.Name, Account.Fields.AccountNumber)
-                .AddFilters(new Filter(LogicalOperator.Or)
-                    .WhereEqual(Account.Address1_City, "Paris")
-                    .WhereEqual(Account.Address1_City, "Nantes")
+                .Select(a => new { a.Name, a.AccountNumber})
+                .AddFilter(f => f
+                    .SetLogicalOperator(LogicalOperator.Or)
+                    .WhereEqual(a => a.Address1_City, "Paris")
+                    .WhereEqual(a => a.Address1_City, "Nantes")
                 );
                 
                 
 var lateBoundQuery = new Query("account")
                 .Select("name", "accountnumber")
-                .AddFilters(new Filter(LogicalOperator.Or)
+                .AddFilter(new Filter(LogicalOperator.Or)
                     .WhereEqual("address1_city", "Paris")
                     .WhereEqual("address1_city", "Nantes")
                 );
@@ -68,8 +85,8 @@ var lateBoundQuery = new Query("account")
 ## Comparing Columns (online only, from 2020 July 1st)
 ```
 var earlyBoundQuery = new Query<Account>()
-    .Select(Account.Fields.Name, Account.Fields.AccountNumber)
-    .Compare(Account.Fields.CreatedOn).LessThan(Account.Fields.ModifiedOn);
+    .Select(a => new { a.Name, a.AccountNumber})
+    .Compare(a => a.CreatedOn).LessThan(a => a.ModifiedOn);
 
 var lateBoundQuery = new Query("account")
     .Select("name", "accountnumber")
@@ -80,17 +97,19 @@ var lateBoundQuery = new Query("account")
 
 ```
 var earlyBoundQuery = new Query<Account>()
-                .Select(Account.Fields.Name, Account.Fields.AccountNumber)
-                .AddLink<Contact>(new Link(Contact.Fields.ParentCustomerId, Account.Fields.AccountId, JoinOperator.LeftOuter)
+                .Select(a => new { a.Name, a.AccountNumber})
+                .AddLink<Contact>(a => a.AccountId, c => c.ParentCustomerId, l => l
                     .SetAlias("cont")
-                    .Select(Contact.Fields.Fullname)
-                    .WhereEqual(Contact.Address1_City, "Paris")
-                    .WhereEqual(Contact.Address1_City, "Nantes")
+                    .Select(c => c.Fullname)
+                    .SetLogicalOperator(LogicalOperator.Or)
+                    .WhereEqual(c => c.Address1_City, "Paris")
+                    .WhereEqual(c => c.Address1_City, "Nantes")
+                    , JoinOperator.LeftOuter)
                 );
                 
                 
 var lateBoundQuery = new Query("account")
-                .Select("name", "accountnumber")
+                 .Select("name", "accountnumber")
                  .AddLink(new Link(Contact.EntityLogicalName, Contact.Fields.ParentCustomerId, Account.Fields.AccountId, JoinOperator.LeftOuter)
                     .SetAlias("cont")
                     .Select("fullname")
@@ -104,13 +123,21 @@ var lateBoundQuery = new Query("account")
 
 ```
 var earlyBoundQuery = new Query<Account>()
-                .Select(Account.Fields.Name, Account.Fields.AccountNumber)
-                .Order(Account.Fields.Name, OrderType.Ascending);
+                .Select(a => new { a.Name, a.AccountNumber})
+                .OrderBy(a => a.Name);
+                
+var earlyBoundQuery2 = new Query<Account>()
+                .Select(a => new { a.Name, a.AccountNumber})
+                .OrderByDescending(a => a.Name);
                 
                 
 var lateBoundQuery = new Query("account")
                 .Select("name", "accountnumber")
-                .Order("name", OrderType.Ascending);
+                .OrderBy("name");
+                
+var lateBoundQuery2 = new Query("account")
+                .Select("name", "accountnumber")
+                .OrderByDescending("name");
                 
 ```
 

From 5c8ed606d86c8d067f014a8b7ee171aa8863e59b Mon Sep 17 00:00:00 2001
From: MscrmTools <tanguy92@hotmail.com>
Date: Thu, 1 Dec 2022 17:39:37 +0100
Subject: [PATCH 3/5] Added Nuget badge

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index e9bdff2..bceb77a 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 # MscrmTools.FluentQueryExpressions
 A library to create QueryExpression the fluent way
 
-[![Build status](https://ci.appveyor.com/api/projects/status/lyre23w2ccnnyayr?svg=true)](https://ci.appveyor.com/project/MscrmTools/mscrmtools-fluentqueryexpressions)
+[![Build status](https://ci.appveyor.com/api/projects/status/lyre23w2ccnnyayr?svg=true)](https://ci.appveyor.com/project/MscrmTools/mscrmtools-fluentqueryexpressions) [![NuGet Badge](https://buildstats.info/nuget/MscrmTools.FluentQueryExpressions)](https://www.nuget.org/packages/MscrmTools.FluentQueryExpressions)
 
 You can rely on :
 - [EarlyBoundGenerator](https://github.com/daryllabar/DLaB.Xrm.XrmToolBoxTools) from Daryl LaBar to create the Early Bound Entities to be used with this project (optional)

From b4fe1474c340bc1cfe6421c5fd105bfb9e9e3836 Mon Sep 17 00:00:00 2001
From: MscrmTools <tanguy92@hotmail.com>
Date: Fri, 2 Dec 2022 15:07:40 +0100
Subject: [PATCH 4/5] Fixed Constructor error for Late bound entities

---
 .../QueryExpressionTest.cs                    | 14 ++++++++++
 MscrmTools.Shared/Query.cs                    | 26 +++++++++++--------
 2 files changed, 29 insertions(+), 11 deletions(-)

diff --git a/MscrmTools.FluentQueryExpressions.Test/QueryExpressionTest.cs b/MscrmTools.FluentQueryExpressions.Test/QueryExpressionTest.cs
index c1b8452..bb059dc 100644
--- a/MscrmTools.FluentQueryExpressions.Test/QueryExpressionTest.cs
+++ b/MscrmTools.FluentQueryExpressions.Test/QueryExpressionTest.cs
@@ -4070,6 +4070,13 @@ public void ShouldGetLast()
 
                 Assert.IsNotNull(record);
                 Assert.AreEqual(item2Id, record.Id);
+
+                record = new Query<Account>()
+                    .OrderByDescending(a => a.CreatedOn)
+                    .GetLast(service);
+
+                Assert.IsNotNull(record);
+                Assert.AreEqual(item2Id, record.Id);
             }
         }
 
@@ -4139,6 +4146,13 @@ public void ShouldGetLastOrDefault()
 
                 Assert.IsNotNull(record);
                 Assert.AreEqual(item2Id, record.Id);
+
+                record = new Query<Account>()
+                   .OrderByDescending(a => a.CreatedOn)
+                   .GetLastOrDefault(service);
+
+                Assert.IsNotNull(record);
+                Assert.AreEqual(item2Id, record.Id);
             }
         }
 
diff --git a/MscrmTools.Shared/Query.cs b/MscrmTools.Shared/Query.cs
index c9b255c..4ec57f7 100644
--- a/MscrmTools.Shared/Query.cs
+++ b/MscrmTools.Shared/Query.cs
@@ -20,8 +20,9 @@ public class Query : Query<Entity>
         /// Initialize a new instance of class <see cref="Query"/>
         /// </summary>
         /// <param name="table">Logical name of the table to query</param>
-        public Query(string table) : base(table)
+        public Query(string table) : base()
         {
+            QueryExpression = new QueryExpression(table);
         }
 
         #endregion Constructors
@@ -88,6 +89,18 @@ public Query AddFilters(LogicalOperator logicalOperator, params Filter[] filters
             return this;
         }
 
+        /// <summary>
+        /// Define the filter operator for the default filter of this query
+        /// </summary>
+        /// <param name="logicalOperator">Logical operator</param>
+        /// <returns>The <see cref="Query"/></returns>
+        public new Query SetLogicalOperator(LogicalOperator logicalOperator)
+        {
+            QueryExpression.Criteria.FilterOperator = logicalOperator;
+
+            return this;
+        }
+
         #endregion Filters
 
         #region Links
@@ -1934,19 +1947,10 @@ public class Query<T> where T : Entity
         /// </summary>
         public Query()
         {
-            string entityLogicalName = typeof(T).GetField("EntityLogicalName").GetRawConstantValue().ToString();
+            string entityLogicalName = typeof(T).GetField("EntityLogicalName")?.GetRawConstantValue().ToString();
             QueryExpression = new QueryExpression(entityLogicalName);
         }
 
-        /// <summary>
-        /// Initialize a new instance of class <see cref="Query"/>
-        /// <paramref name="table">Logical name of the table to query</paramref>
-        /// </summary>
-        protected Query(string table)
-        {
-            QueryExpression = new QueryExpression(table.ToLower());
-        }
-
         #endregion Constructors
 
         #region Properties

From 66058c6b85bc0e65c6269cc141508e723175ef89 Mon Sep 17 00:00:00 2001
From: Jonas Rapp <jonas@jonasr.app>
Date: Sat, 3 Dec 2022 13:16:06 +0100
Subject: [PATCH 5/5] Fixing #1 GetAll + GetFirst

---
 MscrmTools.Shared/Query.cs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/MscrmTools.Shared/Query.cs b/MscrmTools.Shared/Query.cs
index 4ec57f7..877c158 100644
--- a/MscrmTools.Shared/Query.cs
+++ b/MscrmTools.Shared/Query.cs
@@ -1,4 +1,4 @@
-using Microsoft.Xrm.Sdk;
+using Microsoft.Xrm.Sdk;
 using Microsoft.Xrm.Sdk.Query;
 using MscrmTools.FluentQueryExpressions.Helpers;
 using System;
@@ -4346,6 +4346,8 @@ public List<T> GetAll(IOrganizationService service)
                     .ToList();
             }
 
+            var tmpPagingNumber = QueryExpression.PageInfo.PageNumber;
+            var tmpPagingCookie = QueryExpression.PageInfo.PagingCookie;
             EntityCollection ec;
             var list = new List<T>();
             do
@@ -4357,6 +4359,8 @@ public List<T> GetAll(IOrganizationService service)
                 NextPage(ec.PagingCookie);
             } while (ec.MoreRecords);
 
+            QueryExpression.PageInfo.PageNumber = tmpPagingNumber;
+            QueryExpression.PageInfo.PagingCookie = tmpPagingCookie;
             return list;
         }
 
@@ -4576,4 +4580,4 @@ public T GetById(Guid id, IOrganizationService service, bool isActivityEntity =
 
         #endregion Service calls
     }
-}
\ No newline at end of file
+}