Include with async support

Author: ahmad-moussawi

SqlKata.Execution/QueryFactory.Extensions.Async.cs

@@ -4,6 +4,7 @@
 using System.Linq;
 using Dapper;
 using System.Threading.Tasks;
+using System.Dynamic;
 
 namespace SqlKata.Execution
 {
@@ -15,11 +16,52 @@ public static async Task<IEnumerable<T>> GetAsync<T>(this QueryFactory db, Query
         {
             var compiled = db.Compile(query);
 
-            return await db.Connection.QueryAsync<T>(
+            var result = (await db.Connection.QueryAsync<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 = (await include.Query.WhereIn(include.LocalKey, ids).GetAsync())
+                        .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 async Task<IEnumerable<IDictionary<string, object>>> GetDictionaryAsync(this QueryFactory db, Query query)
@@ -40,36 +82,33 @@ public static async Task<IEnumerable<dynamic>> GetAsync(this QueryFactory db, Qu
             return await GetAsync<dynamic>(db, query);
         }
 
-        public static async Task<T> FirstAsync<T>(this QueryFactory db, Query query)
+        public static async Task<T> FirstOrDefaultAsync<T>(this QueryFactory db, Query query)
         {
-            var compiled = db.Compile(query.Limit(1));
+            var list = await GetAsync(db, query.Limit(1));
 
-            return await db.Connection.QueryFirstAsync<T>(
-                compiled.Sql,
-                compiled.NamedBindings,
-                commandTimeout: db.QueryTimeout
-            );
+            return list.ElementAtOrDefault(0);
         }
 
-        public static async Task<dynamic> FirstAsync(this QueryFactory db, Query query)
+        public static async Task<dynamic> FirstOrDefaultAsync(this QueryFactory db, Query query)
         {
-            return await FirstAsync<dynamic>(db, query);
+            return await FirstOrDefaultAsync<dynamic>(db, query);
         }
 
-        public static async Task<T> FirstOrDefaultAsync<T>(this QueryFactory db, Query query)
+        public static async Task<T> FirstAsync<T>(this QueryFactory db, Query query)
         {
-            var compiled = db.Compile(query.Limit(1));
+            var item = await FirstOrDefaultAsync<T>(db, query);
 
-            return await db.Connection.QueryFirstOrDefaultAsync<T>(
-                compiled.Sql,
-                compiled.NamedBindings,
-                commandTimeout: db.QueryTimeout
-            );
+            if (item == null)
+            {
+                throw new InvalidOperationException("The sequence contains no elements");
+            }
+
+            return item;
         }
 
-        public static async Task<dynamic> FirstOrDefaultAsync(this QueryFactory db, Query query)
+        public static async Task<dynamic> FirstAsync(this QueryFactory db, Query query)
         {
-            return await FirstOrDefaultAsync<dynamic>(db, query);
+            return await FirstAsync<dynamic>(db, query);
         }
 
         public static async Task<int> ExecuteAsync(

SqlKata.Execution/QueryFactory.Extensions.cs

@@ -72,41 +72,38 @@ public static IEnumerable<IDictionary<string, object>> GetDictionary(this QueryF
 
         public static IEnumerable<dynamic> Get(this QueryFactory db, Query query)
         {
-            return Get<dynamic>(db, query).Cast<IDictionary<string, object>>().ToList();
+            return Get<dynamic>(db, query);
         }
 
-        public static T First<T>(this QueryFactory db, Query query)
+        public static T FirstOrDefault<T>(this QueryFactory db, Query query)
         {
-            var compiled = db.Compile(query.Limit(1));
+            var list = Get<T>(db, query.Limit(1));
 
-            return db.Connection.QueryFirst<T>(compiled.Sql, compiled.NamedBindings, commandTimeout: db.QueryTimeout);
+            return list.ElementAtOrDefault(0);
         }
 
-        public static dynamic First(this QueryFactory db, Query query)
+        public static dynamic FirstOrDefault(this QueryFactory db, Query query)
+        {
+            return FirstOrDefault<dynamic>(db, query);
+        }
+
+        public static T First<T>(this QueryFactory db, Query query)
         {
-            var list = Get<dynamic>(db, query);
+            var item = FirstOrDefault(db, query);
 
-            if (!list.Any())
+            if (item == null)
             {
                 throw new InvalidOperationException("The sequence contains no elements");
             }
 
-            return list.ElementAt(0);
+            return item;
         }
 
-        public static T FirstOrDefault<T>(this QueryFactory db, Query query)
+        public static dynamic First(this QueryFactory db, Query query)
         {
-            var compiled = db.Compile(query.Limit(1));
-
-            return db.Connection.QueryFirstOrDefault<T>(compiled.Sql, compiled.NamedBindings, commandTimeout: db.QueryTimeout);
+            return First<dynamic>(db, query);
         }
 
-        public static dynamic FirstOrDefault(this QueryFactory db, Query query)
-        {
-            var list = Get<dynamic>(db, query);
-
-            return list.Any() ? list.ElementAt(0) : null;
-        }
 
         public static int Execute(
             this QueryFactory db,