Merge pull request #469 from jklemmack/Feature/LoadSingle

Add include support to LoadSingleById

Author: mythz

src/ServiceStack.OrmLite/OrmLiteReadApi.cs

@@ -669,9 +669,9 @@ public static long LongScalar(this IDbConnection dbConn)
         /// Returns the first result with all its references loaded, using a primary key id. E.g:
         /// <para>db.LoadSingleById&lt;Person&gt;(1)</para>
         /// </summary>
-        public static T LoadSingleById<T>(this IDbConnection dbConn, object idValue)
+        public static T LoadSingleById<T>(this IDbConnection dbConn, object idValue, string[] include = null)
         {
-            return dbConn.Exec(dbCmd => dbCmd.LoadSingleById<T>(idValue));
+            return dbConn.Exec(dbCmd => dbCmd.LoadSingleById<T>(idValue, include));
         }
 
         /// <summary>

src/ServiceStack.OrmLite/OrmLiteReadCommandExtensions.cs

@@ -878,22 +878,34 @@ internal static long ToLong(object result)
             return (long)result;
         }
 
-        internal static T LoadSingleById<T>(this IDbCommand dbCmd, object value)
+        internal static T LoadSingleById<T>(this IDbCommand dbCmd, object value, string[] include = null)
         {
             var row = dbCmd.SingleById<T>(value);
             if (row == null)
                 return default(T);
 
-            dbCmd.LoadReferences(row);
+            dbCmd.LoadReferences(row, include);
 
             return row;
         }
 
-        public static void LoadReferences<T>(this IDbCommand dbCmd, T instance)
+        public static void LoadReferences<T>(this IDbCommand dbCmd, T instance, string[] include = null)
         {
             var loadRef = new LoadReferencesSync<T>(dbCmd, instance);
+            var fieldDefs = loadRef.FieldDefs;
 
-            foreach (var fieldDef in loadRef.FieldDefs)
+            if (!include.IsEmpty())
+            {
+                // Check that any include values aren't reference fields of the specified type
+                var fields = fieldDefs.Select(q => q.FieldName);
+                var invalid = include.Except<string>(fields).ToList();
+                if (invalid.Count > 0)
+                    throw new ArgumentException("Fields '{0}' are not Reference Properties of Type '{1}'".Fmt(invalid.Join("', '"), typeof(T).Name));
+
+                fieldDefs = fieldDefs.Where(fd => include.Contains(fd.FieldName)).ToList();
+            }
+
+            foreach (var fieldDef in fieldDefs)
             {
                 dbCmd.Parameters.Clear();
                 var listInterface = fieldDef.FieldType.GetTypeWithGenericInterfaceOf(typeof(IList<>));

tests/ServiceStack.OrmLite.Tests/LoadReferencesTests.cs

@@ -656,6 +656,13 @@ public void Can_load_only_included_references()
             Assert.That(dbCustomers[0].Orders, Is.Null);
             Assert.That(dbCustomers[0].PrimaryAddress, Is.Not.Null);
 
+            // Test LoadSingleById
+            var dbCustomer = db.LoadSingleById<Customer>(customer.Id, include: new[] { "PrimaryAddress" });
+            Assert.That(dbCustomer.Name, Is.EqualTo("Customer 1"));
+
+            Assert.That(dbCustomer.Orders, Is.Null);
+            Assert.That(dbCustomer.PrimaryAddress, Is.Not.Null);
+
 
             // Invalid field name
             try
@@ -670,6 +677,20 @@ public void Can_load_only_included_references()
             {
                 Assert.Fail();
             }
+
+
+            try
+            {
+                dbCustomer = db.LoadSingleById<Customer>(customer.Id, include: new[] { "InvalidOption1", "InvalidOption2" });
+                Assert.Fail();
+            }
+            catch (System.ArgumentException ex)
+            {
+            }
+            catch (System.Exception ex)
+            {
+                Assert.Fail();
+            }
         }
 
         [Test]