Add support for new Merge API to merge parent collections with their child references

Author: mythz

src/ServiceStack.OrmLite/Expressions/SqlExpression.cs

@@ -132,6 +132,12 @@ public virtual SqlExpression<T> SelectDistinct<TKey>(Expression<Func<T, TKey>> f
             return this;
         }
 
+        public virtual SqlExpression<T> SelectDistinct()
+        {
+            selectDistinct = true;
+            return this;
+        }
+
         public virtual SqlExpression<T> From(string tables)
         {
             if (tables != null)

src/ServiceStack.OrmLite/OrmLiteUtils.cs

@@ -13,6 +13,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Data;
+using System.Linq;
 using System.Text;
 using ServiceStack.Text;
 
@@ -348,5 +349,123 @@ public static ulong ConvertToULong(byte[] bytes)
             var ulongValue = BitConverter.ToUInt64(bytes, 0);
             return ulongValue;
         }
+
+        public static List<Parent> Merge<Parent, Child>(this Parent parent, List<Child> children)
+        {
+            return new List<Parent>{ parent}.Merge(children);
+        }
+    
+        public static List<Parent> Merge<Parent, Child>(this List<Parent> parents, List<Child> children)
+        {
+            var modelDef = ModelDefinition<Parent>.Definition;
+            var fieldDef = modelDef.AllFieldDefinitionsArray.FirstOrDefault(
+                x => (x.FieldType == typeof(Child) || x.FieldType == typeof(List<Child>)) && x.IsReference);
+
+            if (fieldDef == null)
+                throw new Exception("Could not find Child Reference for '{0}' on Parent '{1}'".Fmt(typeof(Child).Name, typeof(Parent).Name));
+
+            var listInterface = fieldDef.FieldType.GetTypeWithGenericInterfaceOf(typeof(IList<>));
+            if (listInterface != null)
+            {
+                var refType = listInterface.GenericTypeArguments()[0];
+                var refModelDef = refType.GetModelDefinition();
+                var refField = modelDef.GetRefFieldDef(refModelDef, refType);
+
+                SetListChildResults(parents, modelDef, fieldDef, refType, children, refField);
+            }
+            else
+            {
+                var refType = fieldDef.FieldType;
+
+                var refModelDef = refType.GetModelDefinition();
+
+                var refSelf = modelDef.GetSelfRefFieldDefIfExists(refModelDef, fieldDef);
+                var refField = refSelf == null
+                    ? modelDef.GetRefFieldDef(refModelDef, refType)
+                    : modelDef.GetRefFieldDefIfExists(refModelDef);
+
+                if (refSelf != null)
+                {
+                    SetRefSelfChildResults(parents, fieldDef, refModelDef, refSelf, children);
+                }
+                else if (refField != null)
+                {
+                    SetRefFieldChildResults(parents, modelDef, fieldDef, refField, children);
+                }
+            }
+
+            return parents;
+        }
+
+        internal static void SetListChildResults<Parent>(List<Parent> parents, ModelDefinition modelDef, 
+            FieldDefinition fieldDef, Type refType, IList childResults, FieldDefinition refField)
+        {
+            var map = new Dictionary<object, List<object>>();
+            List<object> refValues;
+
+            foreach (var result in childResults)
+            {
+                var refValue = refField.GetValue(result);
+                if (!map.TryGetValue(refValue, out refValues))
+                {
+                    map[refValue] = refValues = new List<object>();
+                }
+                refValues.Add(result);
+            }
+
+            var untypedApi = refType.CreateTypedApi();
+            foreach (var result in parents)
+            {
+                var pkValue = modelDef.PrimaryKey.GetValue(result);
+                if (map.TryGetValue(pkValue, out refValues))
+                {
+                    var castResults = untypedApi.Cast(refValues);
+                    fieldDef.SetValueFn(result, castResults);
+                }
+            }
+        }
+
+        internal static void SetRefSelfChildResults<Parent>(List<Parent> parents, FieldDefinition fieldDef, ModelDefinition refModelDef, FieldDefinition refSelf, IList childResults)
+        {
+            var map = new Dictionary<object, object>();
+            foreach (var result in childResults)
+            {
+                var pkValue = refModelDef.PrimaryKey.GetValue(result);
+                map[pkValue] = result;
+            }
+
+            foreach (var result in parents)
+            {
+                object childResult;
+                var fkValue = refSelf.GetValue(result);
+                if (fkValue != null && map.TryGetValue(fkValue, out childResult))
+                {
+                    fieldDef.SetValueFn(result, childResult);
+                }
+            }
+        }
+
+        internal static void SetRefFieldChildResults<Parent>(List<Parent> parents, ModelDefinition modelDef,
+            FieldDefinition fieldDef, FieldDefinition refField, IList childResults)
+        {
+            var map = new Dictionary<object, object>();
+
+            foreach (var result in childResults)
+            {
+                var refValue = refField.GetValue(result);
+                map[refValue] = result;
+            }
+
+            foreach (var result in parents)
+            {
+                object childResult;
+                var pkValue = modelDef.PrimaryKey.GetValue(result);
+                if (map.TryGetValue(pkValue, out childResult))
+                {
+                    fieldDef.SetValueFn(result, childResult);
+                }
+            }
+        }
+        
     }
 }

src/ServiceStack.OrmLite/UntypedApi.cs

@@ -29,6 +29,13 @@ public static IUntypedApi CreateTypedApi(this IDbCommand dbCmd, Type forType)
             unTypedApi.DbCmd = dbCmd;
             return unTypedApi;
         }
+
+        public static IUntypedApi CreateTypedApi(this Type forType)
+        {
+            var genericType = untypedApiMap.GetOrAdd(forType, key => typeof(UntypedApi<>).MakeGenericType(key));
+            var unTypedApi = genericType.CreateInstance<IUntypedApi>();
+            return unTypedApi;
+        }
     }
 
     public class UntypedApi<T> : IUntypedApi

tests/ServiceStack.OrmLite.Tests/LoadReferencesJoinTests.cs

@@ -551,6 +551,29 @@ public void Can_load_list_of_references()
                 Is.EquivalentTo(new[] { 1.99m, 3.98m, 1.49m, 2.98m, 9.99m }));
         }
 
+        [Test]
+        public void Can_load_list_of_references_using_subselect()
+        {
+            AddCustomersWithOrders();
+
+            var customers = db.Select<Customer>(q =>
+                q.Join<Order>()
+                 .Where<Order>(o => o.Qty == 1)
+                 .SelectDistinct());
+
+            var orders = db.Select<Order>(o => o.Qty == 1);
+
+            customers.Merge(orders);
+
+            customers.PrintDump();
+
+            Assert.That(customers.Count, Is.EqualTo(2));
+            Assert.That(customers[0].Orders.Count, Is.EqualTo(3));
+            Assert.That(customers[0].Orders.All(x => x.Qty == 1));
+            Assert.That(customers[1].Orders.Count, Is.EqualTo(1));
+            Assert.That(customers[1].Orders.All(x => x.Qty == 1));
+        }
+
         [Test]
         public void Can_join_on_references_attribute()
         {