Merge pull request #232 from sqlkata/includes

Support includes for *dynamic* queries

Author: ahmad-moussawi

Program/Program.cs

@@ -39,17 +39,25 @@ static void Main(string[] args)
 
             // SQLiteConnection.CreateFile("Demo.db");
 
-            connection = new SQLiteConnection("Data Source=Demo.db");
+            // connection = new SQLiteConnection("Data Source=Demo.db");
 
-            var db = new QueryFactory(connection, new SqliteCompiler());
+            var db = new QueryFactory(connection, new SqlServerCompiler());
 
-            // db.Statement("create table accounts(id integer primary key,name text,currency_id text);");
+            db.Logger = result =>
+            {
+                Console.WriteLine(result.ToString());
+            };
 
-            db.Logger = q => Console.WriteLine(q.ToString());
+            var accounts = db.Query("Accounts")
+                .WhereNotNull("BankId")
+                .Include("bank",
+                    db.Query("Banks").Include("Country", db.Query("Countries"))
+                        .Select("Id", "Name", "CountryId")
+                )
+                .Select("Id", "Name", "BankId")
+                .OrderByDesc("Id").Limit(10).Get();
 
-            var accounts = db.Query("Accounts").OrderByDesc("Id").Offset(10).Get();
-
-            Console.WriteLine(JsonConvert.SerializeObject(accounts));
+            Console.WriteLine(JsonConvert.SerializeObject(accounts, Formatting.Indented));
 
         }
 

QueryBuilder/Include.cs

@@ -0,0 +1,10 @@
+namespace SqlKata
+{
+    public class Include
+    {
+        public string Name { get; set; }
+        public Query Query { get; set; }
+        public string ForeignKey { get; set; }
+        public string LocalKey { get; set; }
+    }
+}

QueryBuilder/Query.cs

@@ -10,6 +10,7 @@ public partial class Query : BaseQuery<Query>
         public string QueryAlias { get; set; }
         public string Method { get; set; } = "select";
         public string QueryComment { get; set; }
+        public List<Include> Includes = new List<Include>();
 
         public Query() : base()
         {
@@ -56,6 +57,7 @@ public override Query Clone()
             clone.QueryAlias = QueryAlias;
             clone.IsDistinct = IsDistinct;
             clone.Method = Method;
+            clone.Includes = Includes;
             return clone;
         }
 
@@ -308,5 +310,23 @@ public override Query NewQuery()
             return new Query();
         }
 
+        public Query Include(string relationName, Query query, string foreignKey = null, string localKey = "Id")
+        {
+            if (foreignKey == null)
+            {
+                foreignKey = relationName + "Id";
+            }
+
+            Includes.Add(new Include
+            {
+                Name = relationName,
+                LocalKey = localKey,
+                ForeignKey = foreignKey,
+                Query = query,
+            });
+
+            return this;
+        }
+
     }
 }

SqlKata.Execution/QueryFactory.Extensions.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Data;
+using System.Dynamic;
 using System.Linq;
 using Dapper;
 
@@ -14,11 +15,52 @@ public static IEnumerable<T> Get<T>(this QueryFactory db, Query query)
         {
             var compiled = db.Compile(query);
 
-            return db.Connection.Query<T>(
+            var result = db.Connection.Query<T>(
                 compiled.Sql,
                 compiled.NamedBindings,
                 commandTimeout: db.QueryTimeout
-            );
+            ).ToList();
+
+            if (!result.Any())
+            {
+                return result;
+            }
+
+            if (result[0] is IDynamicMetaObjectProvider)
+            {
+                var dynamicResult = result
+                    .Cast<IDictionary<string, object>>()
+                    .Select(x => new Dictionary<string, object>(x, StringComparer.OrdinalIgnoreCase))
+                    .ToList();
+
+                foreach (var include in query.Includes)
+                {
+                    var ids = dynamicResult.Where(x => x[include.ForeignKey] != null)
+                        .Select(x => x[include.ForeignKey].ToString())
+                        .ToList();
+
+                    if (!ids.Any())
+                    {
+                        continue;
+                    }
+
+                    var related = include.Query.WhereIn(include.LocalKey, ids).Get()
+                        .Cast<IDictionary<string, object>>()
+                        .Select(x => new Dictionary<string, object>(x, StringComparer.OrdinalIgnoreCase))
+                        .ToDictionary(x => x[include.LocalKey].ToString());
+
+                    foreach (var item in dynamicResult)
+                    {
+                        var foreignValue = item[include.ForeignKey].ToString();
+                        item[include.Name] = related.ContainsKey(foreignValue) ? related[foreignValue] : null;
+                    }
+                }
+
+                return dynamicResult.Cast<T>();
+
+            }
+
+            return result;
         }
 
         public static IEnumerable<IDictionary<string, object>> GetDictionary(this QueryFactory db, Query query)
@@ -30,7 +72,7 @@ public static IEnumerable<IDictionary<string, object>> GetDictionary(this QueryF
 
         public static IEnumerable<dynamic> Get(this QueryFactory db, Query query)
         {
-            return Get<dynamic>(db, query);
+            return Get<dynamic>(db, query).Cast<IDictionary<string, object>>().ToList();
         }
 
         public static T First<T>(this QueryFactory db, Query query)
@@ -42,7 +84,14 @@ public static T First<T>(this QueryFactory db, Query query)
 
         public static dynamic First(this QueryFactory db, Query query)
         {
-            return First<dynamic>(db, query);
+            var list = Get<dynamic>(db, query);
+
+            if (!list.Any())
+            {
+                throw new InvalidOperationException("The sequence contains no elements");
+            }
+
+            return list.ElementAt(0);
         }
 
         public static T FirstOrDefault<T>(this QueryFactory db, Query query)
@@ -54,7 +103,9 @@ public static T FirstOrDefault<T>(this QueryFactory db, Query query)
 
         public static dynamic FirstOrDefault(this QueryFactory db, Query query)
         {
-            return FirstOrDefault<dynamic>(db, query);
+            var list = Get<dynamic>(db, query);
+
+            return list.Any() ? list.ElementAt(0) : null;
         }
 
         public static int Execute(

SqlKata.Execution/QueryFactory.cs

@@ -52,6 +52,7 @@ public Query FromQuery(Query query)
             xQuery.QueryAlias = query.QueryAlias;
             xQuery.IsDistinct = query.IsDistinct;
             xQuery.Method = query.Method;
+            xQuery.Includes = query.Includes;
 
             xQuery.SetEngineScope(query.EngineScope);