Add new Join behavior to SqlExpression with tests

Author: mythz

src/ServiceStack.OrmLite/Expressions/SqlExpression.Join.cs

@@ -5,7 +5,7 @@
 
 namespace ServiceStack.OrmLite
 {
-    public abstract partial class SqlExpression<T> : ISqlExpression, ISelectableSqlExpression
+    public abstract partial class SqlExpression<T> : ISqlExpression
     {
         List<ModelDefinition> tableDefs = new List<ModelDefinition>();
 
@@ -66,7 +66,8 @@ public string SelectInto<TModel>()
                 this.tableDefs.Add(modelDef);
 
             var sbSelect = new StringBuilder();
-            foreach (var fieldDef in modelDef.FieldDefinitions)
+            var selectDef = typeof(TModel).GetModelDefinition();
+            foreach (var fieldDef in selectDef.FieldDefinitions)
             {
                 var found = false;
 
@@ -110,5 +111,71 @@ public string SelectInto<TModel>()
 
             return ToSelectStatement();
         }
+
+        public virtual SqlExpression<T> Where<Target>(Expression<Func<Target, bool>> predicate)
+        {
+            if (predicate == null)
+                throw new ArgumentNullException("predicate");
+
+            var newExpr = Visit(predicate).ToString();
+            whereExpression = " WHERE " + newExpr;
+
+            return this;
+        }
+
+        public virtual SqlExpression<T> Where<Source, Target>(Expression<Func<Source, Target, bool>> predicate)
+        {
+            if (predicate == null)
+                throw new ArgumentNullException("predicate");
+
+            var newExpr = Visit(predicate).ToString();
+            whereExpression = " WHERE " + newExpr;
+
+            return this;
+        }
+
+        public virtual SqlExpression<T> And<Target>(Expression<Func<Target, bool>> predicate)
+        {
+            if (predicate == null)
+                throw new ArgumentNullException("predicate");
+
+            var newExpr = Visit(predicate).ToString();
+            whereExpression += " AND " + newExpr;
+
+            return this;
+        }
+
+        public virtual SqlExpression<T> And<Source, Target>(Expression<Func<Source, Target, bool>> predicate)
+        {
+            if (predicate == null)
+                throw new ArgumentNullException("predicate");
+
+            var newExpr = Visit(predicate).ToString();
+            whereExpression += " AND " + newExpr;
+
+            return this;
+        }
+
+        public virtual SqlExpression<T> Or<Target>(Expression<Func<Target, bool>> predicate)
+        {
+            if (predicate == null)
+                throw new ArgumentNullException("predicate");
+
+            var newExpr = Visit(predicate).ToString();
+            whereExpression += " OR " + newExpr;
+
+            return this;
+        }
+
+        public virtual SqlExpression<T> Or<Source, Target>(Expression<Func<Source, Target, bool>> predicate)
+        {
+            if (predicate == null)
+                throw new ArgumentNullException("predicate");
+
+            var newExpr = Visit(predicate).ToString();
+            whereExpression += " OR " + newExpr;
+
+            return this;
+        }
     }
 }

src/ServiceStack.OrmLite/JoinSqlBuilder.cs

@@ -494,17 +494,12 @@ public virtual JoinSqlBuilder<TNewPoco, TBasePoco> Limit()
             return this;
         }
 
-        public string ToSelectStatement()
+        public string SelectInto<T>()
         {
-            return ToSql();
-        }
+            var modelDef = typeof(T).GetModelDefinition();
 
-        public string ToSql()
-        {
             CheckAggregateUsage(false);
 
-            var modelDef = typeof(TNewPoco).GetModelDefinition();
-
             var sbSelect = new StringBuilder();
             sbSelect.Append("SELECT ");
 
@@ -577,7 +572,7 @@ public string ToSql()
                 var sbWhere = new StringBuilder();
                 foreach (var where in whereList)
                 {
-                    sbWhere.AppendFormat("{0}{1}", sbWhere.Length > 0 
+                    sbWhere.AppendFormat("{0}{1}", sbWhere.Length > 0
                         ? (where.Value == WhereType.OR ? " OR " : " AND ") : "", where.Key);
                 }
                 sbBody.Append("WHERE " + sbWhere + " \n");
@@ -597,7 +592,17 @@ public string ToSql()
             var sql = OrmLiteConfig.DialectProvider.ToSelectStatement(
                 modelDef, sbSelect.ToString(), sbBody.ToString(), sbOrderBy.ToString(), Offset, Rows);
 
-            return sql;
+            return sql; 
+        }
+
+        public string ToSql()
+        {
+            return SelectInto<TNewPoco>();
+        }
+
+        public string ToSelectStatement()
+        {
+            return SelectInto<TNewPoco>();
         }
     }
 

tests/ServiceStack.OrmLite.Tests/Expression/SqlExpressionTests.cs

@@ -168,7 +168,7 @@ public void Can_select_limit_with_JoinSqlBuilder()
         }
 
         [Test]
-        public void Can_join_with_SqlExpression()
+        public void Can_add_basic_joins_with_SqlExpression()
         {
             using (var db = OpenDbConnection())
             {

tests/ServiceStack.OrmLite.Tests/LoadReferencesTests.cs

@@ -130,7 +130,7 @@ public class MismatchAliasAddress
         public string Country { get; set; }
     }
 
-    public class LoadReferencesTests 
+    public class LoadReferencesTests
         : OrmLiteTestBase
     {
         private IDbConnection db;
@@ -161,7 +161,7 @@ public void TestFixtureTearDown()
         public void Does_not_include_complex_reference_type_in_sql()
         {
             db.Select<Customer>();
-            Assert.That(db.GetLastSql().NormalizeSql(), 
+            Assert.That(db.GetLastSql().NormalizeSql(),
                 Is.EqualTo("select id, name from customer"));
         }
 
@@ -293,8 +293,7 @@ public void Can_Save_and_Load_MismatchedAlias_References_using_code_conventions(
             Assert.That(dbCustomer.PrimaryAddress, Is.Not.Null);
         }
 
-        [Test] 
-        public void Can_SaveAllReferences_then_Load_them()
+        private Customer AddCustomerWithOrders()
         {
             var customer = new Customer
             {
@@ -306,13 +305,22 @@ public void Can_SaveAllReferences_then_Load_them()
                     State = "Northern Territory",
                     Country = "Australia"
                 },
-                Orders = new[] { 
-                    new Order { LineItem = "Line 1", Qty = 1, Cost = 1.99m },
-                    new Order { LineItem = "Line 2", Qty = 2, Cost = 2.99m },
+                Orders = new[]
+                {
+                    new Order {LineItem = "Line 1", Qty = 1, Cost = 1.99m},
+                    new Order {LineItem = "Line 2", Qty = 2, Cost = 2.99m},
                 }.ToList(),
             };
 
-            db.Save(customer, references:true);
+            db.Save(customer, references: true);
+
+            return customer;
+        }
+
+        [Test]
+        public void Can_SaveAllReferences_then_Load_them()
+        {
+            var customer = AddCustomerWithOrders();
 
             Assert.That(customer.Id, Is.GreaterThan(0));
             Assert.That(customer.PrimaryAddress.CustomerId, Is.EqualTo(customer.Id));
@@ -337,8 +345,146 @@ public void Can_save_with_null_references()
             };
 
             db.Save(customer, references: true);
-            
+
             Assert.That(customer.Id, Is.GreaterThan(0));
         }
+
+
+        public class CustomerJoin
+        {
+            public int Id { get; set; }
+            public string Name { get; set; }
+            public string AddressLine1 { get; set; }
+            public string City { get; set; }
+            public string LineItem { get; set; }
+            public decimal Cost { get; set; }
+        }
+
+        [Test]
+        public void Can_do_multiple_joins_with_SqlExpression()
+        {
+            AddCustomerWithOrders();
+
+            var results = db.Select<CustomerJoin, Customer>(q => q
+                .Join<Customer, CustomerAddress>()
+                .Join<Customer, Order>());
+
+            var costs = results.ConvertAll(x => x.Cost);
+            Assert.That(costs, Is.EquivalentTo(new[] { 1.99m, 2.99m }));
+
+            var expr = db.From<Customer>()
+                .Join<Customer, CustomerAddress>()
+                .Join<Customer, Order>();
+
+            results = db.Select<CustomerJoin>(expr);
+
+            costs = results.ConvertAll(x => x.Cost);
+            Assert.That(costs, Is.EquivalentTo(new[] { 1.99m, 2.99m }));
+        }
+
+        [Test]
+        public void Can_do_joins_with_wheres_using_SqlExpression()
+        {
+            AddCustomerWithOrders();
+
+            var results = db.Select<CustomerJoin, Customer>(q => q
+                .Join<Customer, CustomerAddress>()
+                .Join<Customer, Order>((c, o) => c.Id == o.CustomerId && o.Cost < 2));
+
+            var costs = results.ConvertAll(x => x.Cost);
+            Assert.That(costs, Is.EquivalentTo(new[] { 1.99m }));
+
+            results = db.Select<CustomerJoin, Customer>(q => q
+                .Join<Customer, CustomerAddress>()
+                .Join<Customer, Order>()
+                .Where<Order>(o => o.Cost < 2));
+
+            costs = results.ConvertAll(x => x.Cost);
+            Assert.That(costs, Is.EquivalentTo(new[] { 1.99m }));
+
+            results = db.Select<CustomerJoin, Customer>(q => q
+                .Join<Customer, CustomerAddress>()
+                .Join<Customer, Order>()
+                .Where<Order>(o => o.Cost < 2 || o.LineItem == "Line 2"));
+
+            costs = results.ConvertAll(x => x.Cost);
+            Assert.That(costs, Is.EquivalentTo(new[] { 1.99m, 2.99m }));
+
+            var expr = db.From<Customer>()
+                .Join<Customer, CustomerAddress>()
+                .Join<Customer, Order>()
+                .Where<Order>(o => o.Cost < 2 || o.LineItem == "Line 2");
+            results = db.Select<CustomerJoin>(expr);
+
+            costs = results.ConvertAll(x => x.Cost);
+            Assert.That(costs, Is.EquivalentTo(new[] { 1.99m, 2.99m }));
+        }
+
+        [Test]
+        public void Can_do_joins_with_complex_wheres_using_SqlExpression()
+        {
+            var customer1 = new Customer
+            {
+                Name = "Customer 1",
+                PrimaryAddress = new CustomerAddress
+                {
+                    AddressLine1 = "1 Humpty Street",
+                    City = "Humpty Doo",
+                    State = "Northern Territory",
+                    Country = "Australia"
+                },
+                Orders = new[]
+                {
+                    new Order {LineItem = "Line 1", Qty = 1, Cost = 1.99m},
+                    new Order {LineItem = "Line 1", Qty = 2, Cost = 3.98m},
+                    new Order {LineItem = "Line 2", Qty = 1, Cost = 1.49m},
+                    new Order {LineItem = "Line 2", Qty = 2, Cost = 2.98m},
+                    new Order {LineItem = "Australia Flag", Qty = 1, Cost = 9.99m},
+                }.ToList(),
+            };
+
+            db.Save(customer1, references: true);
+            
+            var customer2 = new Customer
+            {
+                Name = "Customer 2",
+                PrimaryAddress = new CustomerAddress
+                {
+                    AddressLine1 = "2 Prospect Park",
+                    City = "Brooklyn",
+                    State = "New York",
+                    Country = "USA"
+                },
+                Orders = new[]
+                {
+                    new Order {LineItem = "USA", Qty = 1, Cost = 20m},
+                }.ToList(),
+            };
+
+            db.Save(customer2, references: true);
+
+            var results = db.Select<CustomerJoin, Customer>(q => q
+                .Join<Customer, CustomerAddress>()
+                .Join<Customer, Order>()
+                .Where(c => c.Name == "Customer 1")
+                .And<Order>(o => o.Cost < 2)
+                .Or<Order>(o => o.LineItem == "Australia Flag"));
+
+            var costs = results.ConvertAll(x => x.Cost);
+            Assert.That(costs, Is.EquivalentTo(new[] { 1.99m, 1.49m, 9.99m }));
+
+            results = db.Select<CustomerJoin, Customer>(q => q
+                .Join<Customer, CustomerAddress>()
+                .Join<Customer, Order>()
+                .Where(c => c.Name == "Customer 2")
+                .And<CustomerAddress, Order>((a, o) => a.Country == o.LineItem));
+
+            db.GetLastSql().Print();
+
+            costs = results.ConvertAll(x => x.Cost);
+            Assert.That(costs, Is.EquivalentTo(new[] { 20m }));
+        }
+    
     }
+
 }