read and read async made part of idbhandler interface

nhlpa · Apr 12, 2024 · 8a5803b · 8a5803b
1 parent d2de1ab
commit 8a5803b
Show file tree

Hide file tree

Showing 9 changed files with 544 additions and 391 deletions.
diff --git a/src/Spiffy/Batch/DbBatch.cs b/src/Spiffy/Batch/DbBatch.cs
@@ -139,9 +139,19 @@ public T QuerySingle<T>(string sql, Func<IDataReader, T> map) =>
     /// </summary>
     /// <param name="sql"></param>
     /// <param name="param"></param>
+    /// <param name="read"></param>
     /// <returns></returns>
-    public IDataReader Read(string sql, DbParams param = null) =>
-        Do(sql, param, cmd => cmd.Read());
+    public T Read<T>(string sql, DbParams param, Func<IDataReader, T> read) =>
+        Do(sql, param, cmd => cmd.Read(read));
+
+    /// <summary>
+    /// Execute paramterized query and manually cursor IDataReader.
+    /// </summary>
+    /// <param name="sql"></param>
+    /// <param name="read"></param>
+    /// <returns></returns>
+    public T Read<T>(string sql, Func<IDataReader, T> read) =>
+        Do(sql, null, cmd => cmd.Read(read));
 
     /// <summary>
     /// Asynchronously execute parameterized query.
@@ -218,9 +228,19 @@ public Task<T> QuerySingleAsync<T>(string sql, Func<IDataReader, T> map) =>
     /// </summary>
     /// <param name="sql"></param>
     /// <param name="param"></param>
+    /// <param name="read"></param>
+    /// <returns></returns>
+    public Task<T> ReadAsync<T>(string sql, DbParams param, Func<IDataReader, T> read) =>
+        DoAsync(sql, param, cmd => cmd.ReadAsync(read));
+
+    /// <summary>
+    /// Execute paramterized query and manually cursor IDataReader.
+    /// </summary>
+    /// <param name="sql"></param>
+    /// <param name="read"></param>
     /// <returns></returns>
-    public Task<IDataReader> ReadAsync(string sql, DbParams param = null) =>
-        DoAsync(sql, param, cmd => cmd.ReadAsync());
+    public Task<T> ReadAsync<T>(string sql, Func<IDataReader, T> read) =>
+        DoAsync(sql, null, cmd => cmd.ReadAsync(read));
 
     /// <summary>
     /// Ensure the DbConnection and DbTransaction resources are properly disposed
@@ -235,12 +255,12 @@ private void Do(string sql, DbParams param, Action<IDbCommand> action)
     {
       try
       {
-        var cmd = new DbCommandBuilder(_transaction, sql, param).Build();
+        var cmd = new DbCommandBuilder(_transaction, sql, param ?? new DbParams()).Build();
         action(cmd);
       }
       catch (FailedExecutionException)
       {
-        // Rollback();
+        Rollback();
         throw;
       }
     }
@@ -249,12 +269,12 @@ private T Do<T>(string sql, DbParams param, Func<IDbCommand, T> func)
     {
       try
       {
-        var cmd = new DbCommandBuilder(_transaction, sql, param).Build();
+        var cmd = new DbCommandBuilder(_transaction, sql, param ?? new DbParams()).Build();
         return func(cmd);
       }
       catch (FailedExecutionException)
       {
-        // Rollback();
+        Rollback();
         throw;
       }
     }

diff --git a/src/Spiffy/Batch/DbFixture.cs b/src/Spiffy/Batch/DbFixture.cs
@@ -7,7 +7,7 @@
 namespace Spiffy
 {
   /// <summary>
-  /// Represents the ability to obtain new unit instances to perform 
+  /// Represents the ability to obtain new unit instances to perform
   /// database-bound tasks transactionally, as well as query
   /// the database directly.
   /// </summary>
@@ -27,14 +27,14 @@ public DbFixture(TConn connectionFactory)
 
       _connectionFactory = connectionFactory;
     }
-  
+
     /// <summary>
     /// Create a new IDbConnection, which represents a interface to a database.
     /// </summary>
     /// <returns></returns>
     public IDbConnection NewConnection() =>
       _connectionFactory.NewConnection();
-      
+
     /// <summary>
     /// Create a new IDbBatch, which represents a database unit of work.
     /// </summary>
@@ -63,7 +63,7 @@ public T Batch<T>(Func<IDbBatch, T> fn)
 
     /// <summary>
     /// Do work in an auto-batch that returns no results
-    /// </summary>        
+    /// </summary>
     /// <param name="fn"></param>
     /// <returns></returns>
     public void Batch(Action<IDbBatch> fn)
@@ -89,7 +89,7 @@ public async Task<T> BatchAsync<T>(Func<IDbBatch, Task<T>> fn)
 
     /// <summary>
     /// Do asynchronous work in an auto-batch that returns no results
-    /// </summary>        
+    /// </summary>
     /// <param name="fn"></param>
     /// <returns></returns>
     public async Task BatchAsync(Func<IDbBatch, Task> fn)
@@ -106,7 +106,7 @@ public async Task BatchAsync(Func<IDbBatch, Task> fn)
     /// <param name="param"></param>
     /// <returns></returns>
     public void Exec(string sql, DbParams param = null) =>
-        Batch(b => b.Exec(sql, param));
+      Batch(b => b.Exec(sql, param));
 
     /// <summary>
     /// Execute parameterized query multiple times
@@ -115,16 +115,16 @@ public void Exec(string sql, DbParams param = null) =>
     /// <param name="param"></param>
     /// <returns></returns>
     public void ExecMany(string sql, IEnumerable<DbParams> param) =>
-        Batch(b => b.ExecMany(sql, param));
+      Batch(b => b.ExecMany(sql, param));
 
     /// <summary>
     /// Execute parameterized query and return single-value.
-    /// </summary>        
+    /// </summary>
     /// <param name="sql"></param>
     /// <param name="param"></param>
     /// <returns></returns>
     public object Scalar(string sql, DbParams param = null) =>
-        Batch(b => b.Scalar(sql, param));
+      Batch(b => b.Scalar(sql, param));
 
     /// <summary>
     /// Execute parameterized query, enumerate all records and apply mapping.
@@ -135,7 +135,7 @@ public object Scalar(string sql, DbParams param = null) =>
     /// <param name="param"></param>
     /// <returns></returns>
     public IEnumerable<T> Query<T>(string sql, DbParams param, Func<IDataReader, T> map) =>
-        Batch(b => b.Query(sql, param, map));
+      Batch(b => b.Query(sql, param, map));
 
     /// <summary>
     /// Execute query, enumerate all records and apply mapping.
@@ -145,7 +145,7 @@ public IEnumerable<T> Query<T>(string sql, DbParams param, Func<IDataReader, T>
     /// <param name="map"></param>
     /// <returns></returns>
     public IEnumerable<T> Query<T>(string sql, Func<IDataReader, T> map) =>
-        Batch(b => b.Query(sql, map));
+      Batch(b => b.Query(sql, map));
 
     /// <summary>
     /// Execute paramterized query, read only first record and apply mapping.
@@ -156,17 +156,36 @@ public IEnumerable<T> Query<T>(string sql, Func<IDataReader, T> map) =>
     /// <param name="param"></param>
     /// <returns></returns>
     public T QuerySingle<T>(string sql, DbParams param, Func<IDataReader, T> map) =>
-        Batch(b => b.QuerySingle(sql, param, map));
+      Batch(b => b.QuerySingle(sql, param, map));
 
     /// <summary>
     /// Execute query, read only first record and apply mapping.
     /// </summary>
     /// <typeparam name="T"></typeparam>
     /// <param name="sql"></param>
-    /// <param name="map"></param>        
+    /// <param name="map"></param>
     /// <returns></returns>
     public T QuerySingle<T>(string sql, Func<IDataReader, T> map) =>
-        Batch(b => b.QuerySingle(sql, map));
+      Batch(b => b.QuerySingle(sql, map));
+
+    /// <summary>
+    /// Execute paramterized query and manually cursor IDataReader.
+    /// </summary>
+    /// <param name="sql"></param>
+    /// <param name="param"></param>
+    /// <param name="read"></param>
+    /// <returns></returns>
+    public T Read<T>(string sql, DbParams param, Func<IDataReader, T> read) =>
+      Batch(b => b.Read(sql, param, read));
+
+    /// <summary>
+    /// Execute paramterized query and manually cursor IDataReader.
+    /// </summary>
+    /// <param name="sql"></param>
+    /// <param name="read"></param>
+    /// <returns></returns>
+    public T Read<T>(string sql, Func<IDataReader, T> read) =>
+      Batch(b => b.Read(sql, read));
 
     /// <summary>
     /// Asynchronously execute parameterized query.
@@ -175,7 +194,7 @@ public T QuerySingle<T>(string sql, Func<IDataReader, T> map) =>
     /// <param name="param"></param>
     /// <returns></returns>
     public Task ExecAsync(string sql, DbParams param = null) =>
-        BatchAsync(b => b.ExecAsync(sql, param));
+      BatchAsync(b => b.ExecAsync(sql, param));
 
     /// <summary>
     /// Asynchronously execute parameterized query.
@@ -184,16 +203,16 @@ public Task ExecAsync(string sql, DbParams param = null) =>
     /// <param name="paramList"></param>
     /// <returns></returns>
     public Task ExecManyAsync(string sql, IEnumerable<DbParams> paramList) =>
-        BatchAsync(b => b.ExecManyAsync(sql, paramList));
+      BatchAsync(b => b.ExecManyAsync(sql, paramList));
 
     /// <summary>
     /// Asynchronously execute parameterized query and return single-value.
-    /// </summary>        
+    /// </summary>
     /// <param name="sql"></param>
     /// <param name="param"></param>
     /// <returns></returns>
     public Task<object> ScalarAsync(string sql, DbParams param = null) =>
-        BatchAsync(b => b.ScalarAsync(sql, param));
+      BatchAsync(b => b.ScalarAsync(sql, param));
 
     /// <summary>
     /// Asynchronously execute parameterized query, enumerate all records and apply mapping.
@@ -204,17 +223,17 @@ public Task<object> ScalarAsync(string sql, DbParams param = null) =>
     /// <param name="param"></param>
     /// <returns></returns>
     public Task<IEnumerable<T>> QueryAsync<T>(string sql, DbParams param, Func<IDataReader, T> map) =>
-        BatchAsync(b => b.QueryAsync(sql, param, map));
+      BatchAsync(b => b.QueryAsync(sql, param, map));
 
     /// <summary>
     /// Asynchronously execute query, enumerate all records and apply mapping.
     /// </summary>
     /// <typeparam name="T"></typeparam>
     /// <param name="sql"></param>
-    /// <param name="map"></param>        
+    /// <param name="map"></param>
     /// <returns></returns>
     public Task<IEnumerable<T>> QueryAsync<T>(string sql, Func<IDataReader, T> map) =>
-        BatchAsync(b => b.QueryAsync(sql, map));
+      BatchAsync(b => b.QueryAsync(sql, map));
 
     /// <summary>
     /// Asynchronously execute paramterized query, read only first record and apply mapping.
@@ -225,16 +244,35 @@ public Task<IEnumerable<T>> QueryAsync<T>(string sql, Func<IDataReader, T> map)
     /// <param name="param"></param>
     /// <returns></returns>
     public Task<T> QuerySingleAsync<T>(string sql, DbParams param, Func<IDataReader, T> map) =>
-        BatchAsync(b => b.QuerySingleAsync(sql, param, map));
+      BatchAsync(b => b.QuerySingleAsync(sql, param, map));
 
     /// <summary>
     /// Asynchronously execute query, read only first record and apply mapping.
     /// </summary>
     /// <typeparam name="T"></typeparam>
     /// <param name="sql"></param>
-    /// <param name="map"></param>        
+    /// <param name="map"></param>
     /// <returns></returns>
     public Task<T> QuerySingleAsync<T>(string sql, Func<IDataReader, T> map) =>
-        BatchAsync(b => b.QuerySingleAsync(sql, map));
+      BatchAsync(b => b.QuerySingleAsync(sql, map));
+
+    /// <summary>
+    /// Execute paramterized query and manually cursor IDataReader.
+    /// </summary>
+    /// <param name="sql"></param>
+    /// <param name="param"></param>
+    /// <param name="read"></param>
+    /// <returns></returns>
+    public Task<T> ReadAsync<T>(string sql, DbParams param, Func<IDataReader, T> read) =>
+      BatchAsync(b => b.ReadAsync(sql, param, read));
+
+    /// <summary>
+    /// Execute paramterized query and manually cursor IDataReader.
+    /// </summary>
+    /// <param name="sql"></param>
+    /// <param name="read"></param>
+    /// <returns></returns>
+    public Task<T> ReadAsync<T>(string sql, Func<IDataReader, T> read) =>
+      BatchAsync(b => b.ReadAsync(sql, read));
   }
 }
diff --git a/src/Spiffy/Batch/IDbBatch.cs b/src/Spiffy/Batch/IDbBatch.cs
@@ -20,20 +20,20 @@ public interface IDbBatch : IDbHandler, IDbHandlerAsync, IDisposable
     /// </summary>
     void Rollback();
 
-    /// <summary>
-    /// Execute paramterized query and manually cursor IDataReader.
-    /// </summary>
-    /// <param name="sql"></param>
-    /// <param name="param"></param>
-    /// <returns></returns>
-    IDataReader Read(string sql, DbParams param = null);
+    // /// <summary>
+    // /// Execute paramterized query and manually cursor IDataReader.
+    // /// </summary>
+    // /// <param name="sql"></param>
+    // /// <param name="param"></param>
+    // /// <returns></returns>
+    // IDataReader Read(string sql, DbParams param = null);
 
-    /// <summary>
-    /// Asynchronously execute paramterized query and manually cursor IDataReader.
-    /// </summary>
-    /// <param name="sql"></param>
-    /// <param name="param"></param>
-    /// <returns></returns>
-    Task<IDataReader> ReadAsync(string sql, DbParams param = null);
+    // /// <summary>
+    // /// Asynchronously execute paramterized query and manually cursor IDataReader.
+    // /// </summary>
+    // /// <param name="sql"></param>
+    // /// <param name="param"></param>
+    // /// <returns></returns>
+    // Task<IDataReader> ReadAsync(string sql, DbParams param = null);
   }
 }
diff --git a/src/Spiffy/Batch/IDbBatchFactory.cs b/src/Spiffy/Batch/IDbBatchFactory.cs
@@ -13,5 +13,36 @@ public interface IDbBatchFactory
     /// </summary>
     /// <returns></returns>
     IDbBatch NewBatch();
+
+    /// <summary>
+    /// Do work in an auto-batch that returns results
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <param name="fn"></param>
+    /// <returns></returns>
+    T Batch<T>(Func<IDbBatch, T> fn);
+
+    /// <summary>
+    /// Do work in an auto-batch that returns no results
+    /// </summary>
+    /// <param name="fn"></param>
+    /// <returns></returns>
+    void Batch(Action<IDbBatch> fn);
+
+    /// <summary>
+    /// Do asynchronous work in an auto-batch that returns results
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <param name="fn"></param>
+    /// <returns></returns>
+    Task<T> BatchAsync<T>(Func<IDbBatch, Task<T>> fn);
+
+    /// <summary>
+    /// Do asynchronous work in an auto-batch that returns no results
+    /// </summary>
+    /// <param name="fn"></param>
+    /// <returns></returns>
+    Task BatchAsync(Func<IDbBatch, Task> fn);
+
   }
 }
diff --git a/src/Spiffy/Batch/IDbHandler.cs b/src/Spiffy/Batch/IDbHandler.cs
@@ -71,5 +71,22 @@ public interface IDbHandler
     /// <param name="map"></param>
     /// <returns></returns>
     T QuerySingle<T>(string sql, Func<IDataReader, T> map);
+
+    /// <summary>
+    /// Execute paramterized query and manually cursor IDataReader.
+    /// </summary>
+    /// <param name="sql"></param>
+    /// <param name="param"></param>
+    /// <param name="read"></param>
+    /// <returns></returns>
+    T Read<T>(string sql, DbParams param, Func<IDataReader, T> read);
+
+    /// <summary>
+    /// Execute paramterized query and manually cursor IDataReader.
+    /// </summary>
+    /// <param name="sql"></param>
+    /// <param name="read"></param>
+    /// <returns></returns>
+    T Read<T>(string sql, Func<IDataReader, T> read);
   }
 }