Add support for dynamic result sets in singleAsync

Author: mythz

src/ServiceStack.OrmLite/Async/OrmLiteUtilExtensionsAsync.cs

@@ -23,9 +23,19 @@ public static T CreateInstance<T>()
         public static Task<T> ConvertToAsync<T>(this IDataReader reader, IOrmLiteDialectProvider dialectProvider, CancellationToken token)
         {
             var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider);
-            var values = new object[reader.FieldCount];
             return dialectProvider.ReaderRead(reader, () =>
             {
+                if (typeof(T) == typeof(List<object>))
+                    return (T)(object)reader.ConvertToListObjects();
+
+                if (typeof(T) == typeof(Dictionary<string, object>))
+                    return (T)(object)reader.ConvertToDictionaryObjects();
+
+                var values = new object[reader.FieldCount];
+
+                if (typeof(T).Name.StartsWith("ValueTuple`"))
+                    return reader.ConvertToValueTuple<T>(values, dialectProvider);
+
                 var row = CreateInstance<T>();
                 row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);
                 return row;

src/ServiceStack.OrmLite/OrmLiteUtils.cs

@@ -83,7 +83,8 @@ public static T CreateInstance<T>()
 
         public static bool IsScalar<T>()
         {
-            return typeof(T).IsValueType() && !typeof(T).Name.StartsWith("ValueTuple`", StringComparison.Ordinal) || typeof(T) == typeof(string);
+            var isScalar = typeof(T).IsValueType() && !typeof(T).Name.StartsWith("ValueTuple`", StringComparison.Ordinal) || typeof(T) == typeof(string);
+            return isScalar;
         }
 
         public static T ConvertTo<T>(this IDataReader reader, IOrmLiteDialectProvider dialectProvider, HashSet<string> onlyFields=null)

src/ServiceStack.OrmLite/TemplateDbFilters.cs

@@ -31,13 +31,13 @@ T exec<T>(Func<IDbConnection, T> fn, TemplateScopeContext scope, object options)
         }
 
         public object dbSelect(TemplateScopeContext scope, string sql) => 
-            exec(db => db.Select<Dictionary<string, object>>(sql), scope, null);
+            exec(db => db.SqlList<Dictionary<string, object>>(sql), scope, null);
 
         public object dbSelect(TemplateScopeContext scope, string sql, Dictionary<string, object> args) => 
-            exec(db => db.Select<Dictionary<string, object>>(sql, args), scope, null);
+            exec(db => db.SqlList<Dictionary<string, object>>(sql, args), scope, null);
 
         public object dbSelect(TemplateScopeContext scope, string sql, Dictionary<string, object> args, object options) => 
-            exec(db => db.Select<Dictionary<string, object>>(sql, args), scope, options);
+            exec(db => db.SqlList<Dictionary<string, object>>(sql, args), scope, options);
 
 
         public object dbSingle(TemplateScopeContext scope, string sql) => 

src/ServiceStack.OrmLite/TemplateDbFiltersAsync.cs

@@ -16,13 +16,14 @@ public IDbConnectionFactory DbFactory
             set => dbFactory = value;
         }
 
-        Task<object> exec<T>(Func<IDbConnection, Task<T>> fn, TemplateScopeContext scope, object options)
+        async Task<object> exec<T>(Func<IDbConnection, Task<T>> fn, TemplateScopeContext scope, object options)
         {
             try
             {
                 using (var db = DbFactory.Open())
                 {
-                    return fn(db).Then(x => (object)x);
+                    var result = await fn(db);
+                    return result;
                 }
             }
             catch (Exception ex)
@@ -32,13 +33,13 @@ Task<object> exec<T>(Func<IDbConnection, Task<T>> fn, TemplateScopeContext scope
         }
 
         public Task<object> dbSelect(TemplateScopeContext scope, string sql) => 
-            exec(db => db.SelectAsync<Dictionary<string, object>>(sql), scope, null);
+            exec(db => db.SqlListAsync<Dictionary<string, object>>(sql), scope, null);
 
         public Task<object> dbSelect(TemplateScopeContext scope, string sql, Dictionary<string, object> args) => 
-            exec(db => db.SelectAsync<Dictionary<string, object>>(sql, args), scope, null);
+            exec(db => db.SqlListAsync<Dictionary<string, object>>(sql, args), scope, null);
 
         public Task<object> dbSelect(TemplateScopeContext scope, string sql, Dictionary<string, object> args, object options) => 
-            exec(db => db.SelectAsync<Dictionary<string, object>>(sql, args), scope, options);
+            exec(db => db.SqlListAsync<Dictionary<string, object>>(sql, args), scope, options);
 
 
         public Task<object> dbSingle(TemplateScopeContext scope, string sql) => 

tests/ServiceStack.OrmLite.Tests/TemplateDbTests.cs

@@ -0,0 +1,56 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using ServiceStack.Templates;
+
+namespace ServiceStack.OrmLite.Tests
+{
+    public class TemplateDbTests : OrmLiteTestBase
+    {
+        public TemplateDbTests() : base(Dialect.SqlServer) {}
+
+        [Test]
+        public async Task Can_retrieve_single_record_with_param()
+        {
+            using (var db = OpenDbConnection())
+            {
+                db.DropAndCreateTable<Rockstar>();
+                db.InsertAll(AutoQueryTests.SeedRockstars);
+
+                var args = new Dictionary<string, object> {{"id", 3}};
+                var result = db.Single<Rockstar>("SELECT * FROM Rockstar WHERE Id = @id", args);
+                Assert.That(result.FirstName, Is.EqualTo("Kurt"));
+
+                result = await db.SingleAsync<Rockstar>("SELECT * FROM Rockstar WHERE Id = @id", args);
+                Assert.That(result.FirstName, Is.EqualTo("Kurt"));
+
+                result = await db.SingleAsync<Rockstar>("SELECT * FROM Rockstar WHERE Id = @id", new { id = 3 });
+                Assert.That(result.FirstName, Is.EqualTo("Kurt"));
+            }
+        }
+
+        [Test]
+        public async Task Can_call_dbSingle_with_param()
+        {
+            using (var db = OpenDbConnection())
+            {
+                db.DropAndCreateTable<Rockstar>();
+                db.InsertAll(AutoQueryTests.SeedRockstars);
+
+                var args = new Dictionary<string, object> { { "id", 3 } };
+
+                var filter = new TemplateDbFilters { DbFactory = base.DbFactory };
+                var result = filter.dbSingle(default(TemplateScopeContext), "SELECT * FROM Rockstar WHERE Id = @id", args);
+                var objDictionary = (Dictionary<string, object>)result;
+                Assert.That(objDictionary["FirstName"], Is.EqualTo("Kurt"));
+
+                var asyncFilter = new TemplateDbFiltersAsync { DbFactory = base.DbFactory };
+                result = await asyncFilter.dbSingle(default(TemplateScopeContext), "SELECT * FROM Rockstar WHERE Id = @id", args);
+
+                objDictionary = (Dictionary<string, object>)result;
+                Assert.That(objDictionary["FirstName"], Is.EqualTo("Kurt"));
+            }
+        }
+
+    }
+}