Support basic join operations with SqlExpression

Author: mythz

src/ServiceStack.OrmLite/Expressions/ReadConnectionExtensions.cs

@@ -43,6 +43,13 @@ public static SqlExpression<T> From<T>(this IDbConnection dbConn)
             return OrmLiteConfig.ExecFilter.SqlExpression<T>(dbConn);
         }
 
+        public static SqlExpression<T> From<T, JoinWith>(this IDbConnection dbConn, Expression<Func<T, JoinWith, bool>> joinExpr=null)
+        {
+            var sql = OrmLiteConfig.ExecFilter.SqlExpression<T>(dbConn);
+            sql.Join(joinExpr);
+            return sql;
+        }
+
         /// <summary>
         /// Creates a new SqlExpression builder for the specified type using a user-defined FROM sql expression.
         /// </summary>

src/ServiceStack.OrmLite/Expressions/ReadExtensions.cs

@@ -16,14 +16,14 @@ public static SqlExpression<T> SqlExpression<T>()
         internal static List<T> Select<T>(this IDbCommand dbCmd, Func<SqlExpression<T>, SqlExpression<T>> expression)
         {
             var expr = OrmLiteConfig.DialectProvider.SqlExpression<T>();
-            string sql = expression(expr).ToSelectStatement();
+            string sql = expression(expr).SelectInto<T>();
 
             return dbCmd.ExprConvertToList<T>(sql);
         }
 
         internal static List<T> Select<T>(this IDbCommand dbCmd, SqlExpression<T> expression)
         {
-            string sql = expression.ToSelectStatement();
+            string sql = expression.SelectInto<T>();
 
             return dbCmd.ExprConvertToList<T>(sql);
         }

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

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Text;
+
+namespace ServiceStack.OrmLite
+{
+    public abstract partial class SqlExpression<T> : ISqlExpression, ISelectableSqlExpression
+    {
+        List<ModelDefinition> tableDefs = new List<ModelDefinition>();
+
+        public SqlExpression<T> Join<Source, Target>(Expression<Func<Source, Target, bool>> joinExpr = null)
+        {
+            PrefixFieldWithTableName = true;
+
+            var sourceDef = typeof(Source).GetModelDefinition();
+            var targetDef = typeof(Target).GetModelDefinition();
+
+            if (tableDefs.Count == 0)
+                tableDefs.Add(modelDef);
+            if (!tableDefs.Contains(sourceDef))
+                tableDefs.Add(sourceDef);
+            if (!tableDefs.Contains(targetDef))
+                tableDefs.Add(targetDef);
+
+            var fromExpr = FromExpression;
+            var sbJoin = new StringBuilder();
+
+            string sqlExpr;
+
+            if (joinExpr != null)
+            {
+                sqlExpr = Visit(joinExpr).ToString();
+            }
+            else
+            {
+                var refField = OrmLiteReadExtensions.GetRefFieldDef(sourceDef, targetDef, typeof(Source));
+                if (refField == null)
+                    throw new ArgumentException("Could not infer relationship between {0} and {1}"
+                        .Fmt(sourceDef.ModelName, targetDef.ModelName));
+
+                sqlExpr = "\n({0}.{1} = {2}.{3})".Fmt(
+                    sourceDef.ModelName.SqlTable(),
+                    sourceDef.PrimaryKey.FieldName.SqlColumn(),
+                    targetDef.ModelName.SqlTable(),
+                    refField.FieldName.SqlColumn());
+            }
+
+            sbJoin.Append(" INNER JOIN {0} ".Fmt(targetDef.ModelName.SqlTable()));
+            sbJoin.Append(" ON ");
+            sbJoin.Append(sqlExpr);
+
+            FromExpression = fromExpr + sbJoin;
+
+            return this;
+        }
+
+        public string SelectInto<TModel>()
+        {
+            if (typeof(TModel) == typeof(T) && !PrefixFieldWithTableName)
+            {
+                return ToSelectStatement();
+            }
+
+            if (this.tableDefs.Count == 0)
+                this.tableDefs.Add(modelDef);
+
+            var sbSelect = new StringBuilder();
+            foreach (var fieldDef in modelDef.FieldDefinitions)
+            {
+                var found = false;
+
+                foreach (var tableDef in tableDefs)
+                {
+                    foreach (var tableFieldDef in tableDef.FieldDefinitions)
+                    {
+                        if (tableFieldDef.Name == fieldDef.Name)
+                        {
+                            found = true;
+                            if (sbSelect.Length > 0)
+                                sbSelect.Append(", ");
+
+                            sbSelect.AppendFormat("{0}.{1}", 
+                                tableDef.ModelName.SqlTable(),
+                                tableFieldDef.IsRowVersion 
+                                    ? OrmLiteConfig.DialectProvider.GetRowVersionColumnName(tableFieldDef)
+                                    : tableFieldDef.FieldName.SqlColumn());
+                            break;
+                        }
+                    }
+
+                    if (found)
+                        break;
+                }
+
+                if (!found)
+                {
+                    if (sbSelect.Length > 0)
+                        sbSelect.Append(", ");
+
+                    sbSelect.AppendFormat("{0}.{1}",
+                        modelDef.ModelName.SqlTable(),
+                        fieldDef.IsRowVersion
+                            ? OrmLiteConfig.DialectProvider.GetRowVersionColumnName(fieldDef)
+                            : fieldDef.FieldName.SqlColumn());
+                }
+            }
+
+            SelectExpression = "SELECT " + sbSelect;
+
+            return ToSelectStatement();
+        }
+    }
+}

src/ServiceStack.OrmLite/Expressions/SqlExpression.cs

@@ -9,7 +9,7 @@
 
 namespace ServiceStack.OrmLite
 {
-    public abstract class SqlExpression<T> : ISqlExpression
+    public abstract partial class SqlExpression<T> : ISqlExpression
     {
         private Expression<Func<T, bool>> underlyingExpression;
         private List<string> orderByProperties = new List<string>();
@@ -846,9 +846,16 @@ protected virtual object VisitMemberAccess(MemberExpression m)
                 var propertyInfo = m.Member as PropertyInfo;
 
                 if (propertyInfo.PropertyType.IsEnum)
-                    return new EnumMemberAccess((PrefixFieldWithTableName ? OrmLiteConfig.DialectProvider.GetQuotedTableName(modelDef.ModelName) + "." : "") + GetQuotedColumnName(m.Member.Name), propertyInfo.PropertyType);
-
-                return new PartialSqlString((PrefixFieldWithTableName ? OrmLiteConfig.DialectProvider.GetQuotedTableName(modelDef.ModelName) + "." : "") + GetQuotedColumnName(m.Member.Name));
+                    return new EnumMemberAccess(
+                        (PrefixFieldWithTableName
+                            ? OrmLiteConfig.DialectProvider.GetQuotedTableName(propertyInfo.DeclaringType.GetModelDefinition().ModelName) + "." 
+                            : "") 
+                            + GetQuotedColumnName(m.Member.Name), propertyInfo.PropertyType);
+
+                return new PartialSqlString((PrefixFieldWithTableName 
+                    ? OrmLiteConfig.DialectProvider.GetQuotedTableName(propertyInfo.DeclaringType.GetModelDefinition().ModelName) + "." 
+                    : "") 
+                    + GetQuotedColumnName(m.Member.Name));
             }
 
             var member = Expression.Convert(m, typeof(object));
@@ -1348,6 +1355,11 @@ public interface ISqlExpression
         string ToSelectStatement();
     }
 
+    public interface ISelectableSqlExpression
+    {
+        string SelectInto<TModel>();
+    }
+
     public class PartialSqlString
     {
         public PartialSqlString(string text)

src/ServiceStack.OrmLite/OrmLiteReadExtensions.cs

@@ -842,7 +842,7 @@ public static void LoadReferences<T>(this IDbCommand dbCmd, T instance)
             }
         }
 
-        private static FieldDefinition GetRefFieldDef(ModelDefinition modelDef, ModelDefinition refModelDef, Type refType)
+        public static FieldDefinition GetRefFieldDef(ModelDefinition modelDef, ModelDefinition refModelDef, Type refType)
         {
             var refNameConvention = modelDef.ModelName + "Id";
             var refField = refModelDef.FieldDefinitions.FirstOrDefault(x => x.FieldName == refNameConvention)

src/ServiceStack.OrmLite/ServiceStack.OrmLite.csproj

@@ -105,6 +105,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AliasNamingStrategy.cs" />
+    <Compile Include="Expressions\SqlExpression.Join.cs" />
     <Compile Include="Expressions\SqlExpressionVisitor.cs" />
     <Compile Include="Expressions\ParameterRebinder.cs" />
     <Compile Include="Expressions\PredicateBuilder.cs" />

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

@@ -21,6 +21,15 @@ public class LetterWeighting
         public int Weighting { get; set; }
     }
 
+    public class LetterStat
+    {
+        [AutoIncrement]
+        public int Id { get; set; }
+        public long LetterFrequencyId { get; set; }
+        public string Letter { get; set; }
+        public int Weighting { get; set; }
+    }
+
     public class SqlExpressionTests : ExpressionsTestBase
     {
         private static void InitLetters(IDbConnection db)
@@ -130,7 +139,7 @@ public void Can_select_limit_with_JoinSqlBuilder()
                     db.Insert(new LetterWeighting { LetterFrequencyId = id, Weighting = ++i * 10 });
                 });
 
-                var joinFn = new Func<JoinSqlBuilder<LetterFrequency, LetterWeighting>>(() => 
+                var joinFn = new Func<JoinSqlBuilder<LetterFrequency, LetterWeighting>>(() =>
                     new JoinSqlBuilder<LetterFrequency, LetterWeighting>()
                         .Join<LetterFrequency, LetterWeighting>(x => x.Id, x => x.LetterFrequencyId)
                     );
@@ -157,5 +166,50 @@ public void Can_select_limit_with_JoinSqlBuilder()
                 Assert.That(results.ConvertAll(x => x.Letter), Is.EquivalentTo(new[] { "D", "C" }));
             }
         }
+
+        [Test]
+        public void Can_join_with_SqlExpression()
+        {
+            using (var db = OpenDbConnection())
+            {
+                db.DropAndCreateTable<LetterFrequency>();
+                db.DropAndCreateTable<LetterStat>();
+
+                var letters = "A,B,C,D,E".Split(',');
+                var i = 0;
+                letters.Each(letter =>
+                {
+                    var id = db.Insert(new LetterFrequency { Letter = letter }, selectIdentity: true);
+                    db.Insert(new LetterStat
+                    {
+                        LetterFrequencyId = id,
+                        Letter = letter,
+                        Weighting = ++i * 10
+                    });
+                });
+
+                db.Insert(new LetterFrequency { Letter = "F" });
+
+                Assert.That(db.Count<LetterFrequency>(), Is.EqualTo(6));
+
+                var results = db.Select(db.From<LetterFrequency, LetterStat>());
+                db.GetLastSql().Print();
+                Assert.That(results.Count, Is.EqualTo(5));
+
+                results = db.Select(db.From<LetterFrequency, LetterStat>((x, y) => x.Id == y.LetterFrequencyId));
+                db.GetLastSql().Print();
+                Assert.That(results.Count, Is.EqualTo(5));
+
+                results = db.Select(db.From<LetterFrequency>()
+                    .Join<LetterFrequency, LetterStat>((x, y) => x.Id == y.LetterFrequencyId));
+                db.GetLastSql().Print();
+                Assert.That(results.Count, Is.EqualTo(5));
+
+                results = db.Select<LetterFrequency>(q =>
+                    q.Join<LetterFrequency, LetterStat>((x, y) => x.Id == y.LetterFrequencyId));
+                db.GetLastSql().Print();
+                Assert.That(results.Count, Is.EqualTo(5));
+            }
+        }
     }
 }