Rename helper methods to Execute and Query

api design for multi-mapping

Dapper/SqlMapper.cs

@@ -134,95 +134,107 @@ public bool Equals(Identity other)
         /// Execute parameterized SQL  
         /// </summary>
         /// <returns>Number of rows affected</returns>
-        public static int ExecuteMapperCommand(this IDbConnection cnn, string sql, object param = null, IDbTransaction transaction = null)
+        public static int Execute(this IDbConnection cnn, string sql, object param = null, IDbTransaction transaction = null)
         {
             return ExecuteCommand(cnn, transaction, sql, GetParamInfo(param));
         }
 
-        static class DynamicStub
-        {
-            public static Type Type = typeof(DynamicStub);
-        }
-
         /// <summary>
-        /// Enumerates the query, keeping the reader open after it is called. Use when iterating through huge result sets . You should usually use ExecuteMapperQuery instead. 
+        /// Return a list of dynamic objects, reader is closed after the call
         /// </summary>
-        public static IEnumerable<T> EnumerateMapperQuery<T>(this IDbConnection cnn, string sql, object param = null, IDbTransaction transaction = null)
+        public static IEnumerable<dynamic> Query(this IDbConnection cnn, string sql, object param = null, IDbTransaction transaction = null, bool buffered = true)
         {
-            var identity = new Identity(sql, cnn, typeof(T));
+            if (!buffered)
+            {
+                return EnumerateMapperQuery(cnn, sql, param, transaction);
+            }
+
+            var identity = new Identity(sql, cnn, DynamicStub.Type);
+            var list = new List<dynamic>();
 
             using (var reader = GetReader(cnn, transaction, sql, GetParamInfo(param)))
             {
-                Func<IDataReader, T> deserializer = GetDeserializer<T>(identity, reader);
+                Func<IDataReader, ExpandoObject> deserializer = GetDeserializer<ExpandoObject>(identity, reader);
                 while (reader.Read())
                 {
-                    yield return deserializer(reader);
+                    list.Add(deserializer(reader));
                 }
             }
+            return list;
         }
 
         /// <summary>
-        /// Enumerates the query, keeping the reader open after it is called. Use when iterating through huge result sets. You should usually use ExecuteMapperQuery instead 
+        /// Return a typed list of objects, reader is closed after the call
         /// </summary>
-        public static IEnumerable<dynamic> EnumerateMapperQuery(this IDbConnection cnn, string sql, object param = null, IDbTransaction transaction = null)
+        public static IEnumerable<T> Query<T>(this IDbConnection cnn, string sql, object param = null, IDbTransaction transaction = null, bool buffered = true)
         {
-            var identity = new Identity(sql, cnn, DynamicStub.Type);
+
+            if (!buffered)
+            {
+                return EnumerateMapperQuery<T>(cnn, sql, param, transaction);
+            }
+
+            var identity = new Identity(sql, cnn, typeof(T));
+            var rval = new List<T>();
+
 
             using (var reader = GetReader(cnn, transaction, sql, GetParamInfo(param)))
             {
-                Func<IDataReader, ExpandoObject> deserializer = GetDeserializer<ExpandoObject>(identity, reader);
+                Func<IDataReader, T> deserializer = GetDeserializer<T>(identity, reader);
                 while (reader.Read())
                 {
-                    yield return deserializer(reader);
+                    rval.Add(deserializer(reader));
                 }
             }
+            return rval;
+        }
+
+        public static List<T> Query<T,U>(this IDbConnection cnn, string sql, Action<T,U> map, object param = null, IDbTransaction transaction = null)
+        {
+            return null;
+        }
+
+
+        static class DynamicStub
+        {
+            public static Type Type = typeof(DynamicStub);
         }
 
         /// <summary>
-        /// Return a list of dynamic objects, reader is closed after the call
+        /// Enumerates the query, keeping the reader open after it is called. Use when iterating through huge result sets . You should usually use ExecuteMapperQuery instead. 
         /// </summary>
-        public static List<dynamic> ExecuteMapperQuery(this IDbConnection cnn, string sql, object param = null, IDbTransaction transaction = null)
+        static IEnumerable<T> EnumerateMapperQuery<T>(this IDbConnection cnn, string sql, object param = null, IDbTransaction transaction = null)
         {
-            var identity = new Identity(sql, cnn, DynamicStub.Type);
-            var list = new List<dynamic>();
+            var identity = new Identity(sql, cnn, typeof(T));
 
             using (var reader = GetReader(cnn, transaction, sql, GetParamInfo(param)))
             {
-                Func<IDataReader, ExpandoObject> deserializer = GetDeserializer<ExpandoObject>(identity, reader);
+                Func<IDataReader, T> deserializer = GetDeserializer<T>(identity, reader);
                 while (reader.Read())
                 {
-                    list.Add(deserializer(reader));
+                    yield return deserializer(reader);
                 }
             }
-            return list;
         }
 
         /// <summary>
-        /// Return a typed list of objects, reader is closed after the call
+        /// Enumerates the query, keeping the reader open after it is called. Use when iterating through huge result sets. You should usually use ExecuteMapperQuery instead 
         /// </summary>
-        public static List<T> ExecuteMapperQuery<T>(this IDbConnection cnn, string sql, object param = null, IDbTransaction transaction = null)
+        static IEnumerable<dynamic> EnumerateMapperQuery(this IDbConnection cnn, string sql, object param = null, IDbTransaction transaction = null)
         {
-            var identity = new Identity(sql, cnn, typeof(T));
-            var rval = new List<T>();
-
+            var identity = new Identity(sql, cnn, DynamicStub.Type);
 
             using (var reader = GetReader(cnn, transaction, sql, GetParamInfo(param)))
             {
-                Func<IDataReader, T> deserializer = GetDeserializer<T>(identity, reader);
+                Func<IDataReader, ExpandoObject> deserializer = GetDeserializer<ExpandoObject>(identity, reader);
                 while (reader.Read())
                 {
-                    rval.Add(deserializer(reader));
+                    yield return deserializer(reader);
                 }
             }
-            return rval;
-        }
-
-        public static List<T> ExecuteMapperQuery<T,U>(this IDbConnection cnn, string sql, Action<T,U> map, object param = null, IDbTransaction transaction = null)
-        {
-            return null;
         }
 
-        private static Func<IDataReader, T> GetDeserializer<T>(Identity identity, IDataReader reader)
+        static Func<IDataReader, T> GetDeserializer<T>(Identity identity, IDataReader reader)
         {
             object oDeserializer;
             if (!cachedSerializers.TryGetValue(identity, out oDeserializer))

Tests/PerformanceTests.cs

@@ -104,10 +104,10 @@ public void Run(int iterations)
 			tests.Add(id => entityContext.Posts.First(p => p.Id == id), "Entity framework No Tracking");
 
             var mapperConnection = Program.GetOpenConnection();
-            tests.Add(id => mapperConnection.ExecuteMapperQuery<Post>("select * from Posts where Id = @Id", new { Id = id }).ToList(), "Mapper Query");
+            tests.Add(id => mapperConnection.Query<Post>("select * from Posts where Id = @Id", new { Id = id }).ToList(), "Mapper Query");
 
             var mapperConnection2 = Program.GetOpenConnection();
-            tests.Add(id => mapperConnection2.ExecuteMapperQuery("select * from Posts where Id = @Id", new { Id = id }).ToList(), "Dynamic Mapper Query");
+            tests.Add(id => mapperConnection2.Query("select * from Posts where Id = @Id", new { Id = id }).ToList(), "Dynamic Mapper Query");
 
             var massiveModel = new DynamicModel(Program.connectionString);
             var massiveConnection = Program.GetOpenConnection();

Tests/Tests.cs

@@ -58,32 +58,32 @@ class Tests
 
         public void SelectListInt()
         {
-            connection.ExecuteMapperQuery<int>("select 1 union all select 2 union all select 3")
+            connection.Query<int>("select 1 union all select 2 union all select 3")
               .IsSequenceEqualTo(new[] { 1, 2, 3 });
         }
 
         public void PassInIntArray()
         {
-            connection.ExecuteMapperQuery<int>("select * from (select 1 as Id union all select 2 union all select 3) as X where Id in @Ids", new { Ids = new int[] { 1, 2, 3 }.AsEnumerable() })
+            connection.Query<int>("select * from (select 1 as Id union all select 2 union all select 3) as X where Id in @Ids", new { Ids = new int[] { 1, 2, 3 }.AsEnumerable() })
              .IsSequenceEqualTo(new[] { 1, 2, 3 });
         }
 
 
         public void TestDoubleParam()
         {
-            connection.ExecuteMapperQuery<double>("select @d", new { d = 0.1d }).First()
+            connection.Query<double>("select @d", new { d = 0.1d }).First()
                 .IsEqualTo(0.1d);
         }
 
         public void TestBoolParam()
         {
-            connection.ExecuteMapperQuery<bool>("select @b", new { b = false }).First()
+            connection.Query<bool>("select @b", new { b = false }).First()
                 .IsFalse();
         }
 
         public void TestStrings()
         {
-            connection.ExecuteMapperQuery<string>(@"select 'a' a union select 'b'")
+            connection.Query<string>(@"select 'a' a union select 'b'")
                 .IsSequenceEqualTo(new[] { "a", "b" });
         }
 
@@ -100,7 +100,7 @@ public class Dog
         public void TestExtraFields()
         {
             var guid = Guid.NewGuid();
-            var dog = connection.ExecuteMapperQuery<Dog>("select '' as Extra, 1 as Age, 0.1 as Name1 , Id = @id", new { Id = guid});
+            var dog = connection.Query<Dog>("select '' as Extra, 1 as Age, 0.1 as Name1 , Id = @id", new { Id = guid});
 
             dog.Count()
                .IsEqualTo(1);
@@ -116,7 +116,7 @@ public void TestExtraFields()
         public void TestStrongType()
         {
             var guid = Guid.NewGuid();
-            var dog = connection.ExecuteMapperQuery<Dog>("select Age = @Age, Id = @Id", new { Age = (int?)null, Id = guid });
+            var dog = connection.Query<Dog>("select Age = @Age, Id = @Id", new { Age = (int?)null, Id = guid });
             
             dog.Count()
                 .IsEqualTo(1);
@@ -130,13 +130,13 @@ public void TestStrongType()
 
         public void TestSimpleNull()
         {
-            connection.ExecuteMapperQuery<DateTime?>("select null").First().IsNull();
+            connection.Query<DateTime?>("select null").First().IsNull();
         }
 
         public void TestExpando()
         {
-            var rows = connection.ExecuteMapperQuery("select 1 A, 2 B union all select 3, 4");
-
+            var rows = connection.Query("select 1 A, 2 B union all select 3, 4").ToList();
+            
             ((int)rows[0].A)
                 .IsEqualTo(1);
 
@@ -152,13 +152,13 @@ public void TestExpando()
 
         public void TestStringList()
         {
-            connection.ExecuteMapperQuery<string>("select * from (select 'a' as x union all select 'b' union all select 'c') as T where x in @strings", new {strings = new[] {"a","b","c"}})
+            connection.Query<string>("select * from (select 'a' as x union all select 'b' union all select 'c') as T where x in @strings", new {strings = new[] {"a","b","c"}})
                 .IsSequenceEqualTo(new[] {"a","b","c"});
         }
 
         public void TestExecuteCommand()
         {
-            connection.ExecuteMapperCommand(@"
+            connection.Execute(@"
     set nocount on 
     create table #t(i int) 
     set nocount off 
@@ -171,7 +171,7 @@ public void TestExecuteCommand()
         public void TestMassiveStrings()
         { 
             var str = new string('X', 20000);
-            connection.ExecuteMapperQuery<string>("select @a", new { a = str }).First()
+            connection.Query<string>("select @a", new { a = str }).First()
                 .IsEqualTo(str);
         }
 
@@ -186,21 +186,21 @@ class TestObj
 
         public void TestSetInternal()
         {
-            connection.ExecuteMapperQuery<TestObj>("select 10 as [Internal]").First()._internal.IsEqualTo(10);
+            connection.Query<TestObj>("select 10 as [Internal]").First()._internal.IsEqualTo(10);
         }
 
         public void TestSetPrivate()
         {
-            connection.ExecuteMapperQuery<TestObj>("select 10 as [Priv]").First()._priv.IsEqualTo(10);
+            connection.Query<TestObj>("select 10 as [Priv]").First()._priv.IsEqualTo(10);
         }
 
         public void TestEnumeration()
         {
-            var en = connection.EnumerateMapperQuery<int>("select 1 as one");
+            var en = connection.Query<int>("select 1 as one", buffered: false);
             bool gotException = false;
             try
             {
-                connection.EnumerateMapperQuery<int>("select 1 as one");
+                connection.Query<int>("select 1 as one", buffered: false);
             }
             catch (Exception)
             {
@@ -210,18 +210,18 @@ public void TestEnumeration()
             var realItems = en.ToList();
 
             // should not exception, since enumertated
-            en = connection.EnumerateMapperQuery<int>("select 1 as one");
+            en = connection.Query<int>("select 1 as one", buffered: false);
 
             gotException.IsTrue();
         }
 
         public void TestEnumerationDynamic()
         {
-            var en = connection.EnumerateMapperQuery("select 1 as one");
+            var en = connection.Query("select 1 as one", buffered: false);
             bool gotException = false;
             try
             {
-                connection.EnumerateMapperQuery("select 1 as one");
+                connection.Query("select 1 as one", buffered: false);
             }
             catch (Exception)
             {
@@ -232,7 +232,7 @@ public void TestEnumerationDynamic()
             i.IsEqualTo(1);
 
             // should not exception, since enumertated
-            en = connection.EnumerateMapperQuery("select 1 as one");
+            en = connection.Query("select 1 as one",buffered:false);
 
             gotException.IsTrue();
         }
@@ -252,7 +252,7 @@ class Post
         public void TestMultiMap()
         {
 
-            var test = connection.ExecuteMapperQuery<Post, User>("select * from Posts p left join Users u on u.Id = p.OwnerId");
+            var test = connection.Query<Post, User>("select * from Posts p left join Users u on u.Id = p.OwnerId", (post, user) => { post.Owner = user; });
         }
     }
 }