Add more join overloads and more tests

Author: mythz

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

@@ -10,11 +10,32 @@ public abstract partial class SqlExpression<T> : ISqlExpression
         List<ModelDefinition> tableDefs = new List<ModelDefinition>();
 
         public SqlExpression<T> Join<Source, Target>(Expression<Func<Source, Target, bool>> joinExpr = null)
+        {
+            return InternalJoin("INNER JOIN", joinExpr);
+        }
+
+        public SqlExpression<T> LeftJoin<Source, Target>(Expression<Func<Source, Target, bool>> joinExpr = null)
+        {
+            return InternalJoin("LEFT JOIN", joinExpr);
+        }
+
+        public SqlExpression<T> RightJoin<Source, Target>(Expression<Func<Source, Target, bool>> joinExpr = null)
+        {
+            return InternalJoin("RIGHT JOIN", joinExpr);
+        }
+
+        public SqlExpression<T> FullJoin<Source, Target>(Expression<Func<Source, Target, bool>> joinExpr = null)
+        {
+            return InternalJoin("FULL JOIN", joinExpr);
+        }
+
+        private SqlExpression<T> InternalJoin<Source, Target>(string joinType,
+            Expression<Func<Source, Target, bool>> joinExpr)
         {
             PrefixFieldWithTableName = true;
 
-            var sourceDef = typeof(Source).GetModelDefinition();
-            var targetDef = typeof(Target).GetModelDefinition();
+            var sourceDef = typeof (Source).GetModelDefinition();
+            var targetDef = typeof (Target).GetModelDefinition();
 
             if (tableDefs.Count == 0)
                 tableDefs.Add(modelDef);
@@ -34,19 +55,31 @@ public SqlExpression<T> Join<Source, Target>(Expression<Func<Source, Target, boo
             }
             else
             {
-                var refField = OrmLiteReadExtensions.GetRefFieldDef(sourceDef, targetDef, typeof(Source));
+                var parentDef = sourceDef;
+                var childDef = targetDef;
+
+                var refField = OrmLiteReadExtensions.GetRefFieldDefIfExists(parentDef, childDef);
                 if (refField == null)
+                {
+                    parentDef = targetDef;
+                    childDef = sourceDef;
+                    refField = OrmLiteReadExtensions.GetRefFieldDefIfExists(parentDef, childDef);
+                }
+
+                if (refField == null)
+                {
                     throw new ArgumentException("Could not infer relationship between {0} and {1}"
-                        .Fmt(sourceDef.ModelName, targetDef.ModelName));
+                                                    .Fmt(sourceDef.ModelName, targetDef.ModelName));
+                }
 
                 sqlExpr = "\n({0}.{1} = {2}.{3})".Fmt(
-                    sourceDef.ModelName.SqlTable(),
-                    sourceDef.PrimaryKey.FieldName.SqlColumn(),
-                    targetDef.ModelName.SqlTable(),
+                    parentDef.ModelName.SqlTable(),
+                    parentDef.PrimaryKey.FieldName.SqlColumn(),
+                    childDef.ModelName.SqlTable(),
                     refField.FieldName.SqlColumn());
             }
 
-            sbJoin.Append(" INNER JOIN {0} ".Fmt(targetDef.ModelName.SqlTable()));
+            sbJoin.Append(" {0} {1} ".Fmt(joinType, targetDef.ModelName.SqlTable()));
             sbJoin.Append(" ON ");
             sbJoin.Append(sqlExpr);
 

src/ServiceStack.OrmLite/OrmLiteReadExtensions.cs

@@ -843,12 +843,18 @@ public static void LoadReferences<T>(this IDbCommand dbCmd, T instance)
         }
 
         public static FieldDefinition GetRefFieldDef(ModelDefinition modelDef, ModelDefinition refModelDef, Type refType)
+        {
+            var refField = GetRefFieldDefIfExists(modelDef, refModelDef);
+            if (refField == null)
+                throw new ArgumentException("Cant find '{0}' Property on Type '{1}'".Fmt(modelDef.ModelName + "Id", refType.Name));
+            return refField;
+        }
+
+        public static FieldDefinition GetRefFieldDefIfExists(ModelDefinition modelDef, ModelDefinition refModelDef)
         {
             var refNameConvention = modelDef.ModelName + "Id";
             var refField = refModelDef.FieldDefinitions.FirstOrDefault(x => x.FieldName == refNameConvention)
-                ?? refModelDef.FieldDefinitions.FirstOrDefault(x => x.Name == modelDef.Name + "Id");
-            if (refField == null)
-                throw new ArgumentException("Cant find '{0}' Property on Type '{1}'".Fmt(refNameConvention, refType.Name));
+                           ?? refModelDef.FieldDefinitions.FirstOrDefault(x => x.Name == modelDef.Name + "Id");
             return refField;
         }
     }

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

@@ -125,6 +125,7 @@ public void When_chaining_expressions_using_Where_it_behaves_like_And()
             visitor.Where(x => x.FirstName.StartsWith("M"));
             //WHERE (((upper("FirstName") like 'JIM%'  AND upper("LastName") like 'HEN%' ) OR upper("FirstName") like 'M%' ) AND upper("FirstName") like 'M%' )
             results = db.Select(visitor);
+            db.GetLastSql().Print();
             Assert.AreEqual(1, results.Count);
         }
 

tests/ServiceStack.OrmLite.Tests/LoadReferencesTests.cs

@@ -402,6 +402,15 @@ public void Can_do_joins_with_wheres_using_SqlExpression()
             var costs = results.ConvertAll(x => x.Cost);
             Assert.That(costs, Is.EquivalentTo(new[] { 1.99m }));
 
+            var orders = db.Select<Order>(q => q
+                .Join<Order, Customer>()
+                .Join<Customer, CustomerAddress>()
+                .Where(o => o.Cost < 2)
+                .And<Customer>(c => c.Name == "Customer 1"));
+
+            costs = orders.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>()