Added async methods, and Fixed nuget package

Author: ernestoherrera

FluentSql/DapperHelpers.cs

@@ -105,5 +105,33 @@ internal static object ExecuteScalar(IDbConnection connection, string sql, objec
             finally
             { }
         }
+
+        internal static async Task<object> ExecuteScalarAsync(IDbConnection connection, string sql, object parameters = null, IDbTransaction transaction = null,
+                                        int? commandTimeout = null, CommandType? commandType = null)
+        {
+            try
+            {
+                var result = await connection.ExecuteScalarAsync(sql, parameters, transaction, commandTimeout, commandType);
+
+                return result;
+
+            }
+            finally
+            { }
+        }
+
+        internal static async Task<T> ExecuteScalarAsync<T>(IDbConnection connection, string sql, object parameters = null, IDbTransaction transaction = null,
+                                        int? commandTimeout = null, CommandType? commandType = null)
+        {
+            try
+            {
+                var result = await connection.ExecuteScalarAsync<T>(sql, parameters, transaction, commandTimeout, commandType);
+
+                return result;
+
+            }
+            finally
+            { }
+        }
     }
 }

FluentSql/Mappers/EntityMapper.cs FluentSql/EntityMapper.csFluentSql/Mappers/EntityMapper.cs renamed to FluentSql/EntityMapper.cs

@@ -41,8 +41,8 @@ public class EntityMapper
         public EntityMapper(IDbConnection dbConnection, IEnumerable<Database> targetDatabases, Assembly[] assembliesOfModelTypes = null, 
                             IDatabaseMapper defaultDatabaseMapper = null, Action onPostEntityMapping = null, ISqlGenerator sqlGenerator = null)
         {
-            if (dbConnection == null || targetDatabases == null)
-                throw new ArgumentNullException("Database connection, or Database names can not be null.");
+            if (dbConnection == null )
+                throw new ArgumentNullException("Database connection can not be null.");
 
             if (sqlGenerator != null)
                 SqlGenerator = sqlGenerator;
@@ -64,6 +64,10 @@ public EntityMapper(IDbConnection dbConnection, IEnumerable<Database> allDatabas
             this(dbConnection, allDatabases, null, null, onPostEntityMapping)
         { }
 
+        public EntityMapper(IDbConnection dbConnection) :
+           this(dbConnection, new List<Database> { new Database { Name = dbConnection.Database, TableNamesInPlural = true } }, null, null, null)
+        { }
+
         public EntityMapper(IDbConnection dbConnection, bool tableNamesInPlural = true) :
            this(dbConnection, new List<Database> { new Database { Name = dbConnection.Database, TableNamesInPlural = tableNamesInPlural } }, null, null, null)
         { }

FluentSql/EntityStore.cs

@@ -290,6 +290,20 @@ public async Task<IEnumerable<T>> GetAllAsync<T>()
             var insertQuery = SqlGenerator.Insert<T>(entity);
             IEnumerable<T> entityIn = DapperHelper.Query<T>(DbConnection, insertQuery.ToSql(), insertQuery.Parameters);
 
+            if (entityIn == null) return default(T);
+
+            T result = entityIn.FirstOrDefault();
+
+            return result;
+        }
+
+        public async Task<T> InsertAsync<T>(T entity) where T : new()
+        {
+            var insertQuery = SqlGenerator.Insert<T>(entity);
+            IEnumerable<T> entityIn = await DapperHelper.QueryAsync<T>(DbConnection, insertQuery.ToSql(), insertQuery.Parameters);
+
+            if (entityIn == null) return default(T);
+
             T result = entityIn.FirstOrDefault();
 
             return result;
@@ -342,6 +356,18 @@ public int UpdateByKey<T>(T entity)
             return recordsAffected;
         }
 
+        public async Task<int> UpdateByKeyAsync<T>(T entity)
+        {
+            if (entity == null) return 0 ;
+
+            var updateQuery = SqlGenerator.Update<T>(entity);
+            var query = GetQueryByKey<T>(entity, updateQuery);
+
+            var recordsAffected = await DapperHelper.ExecuteScalarAsync(DbConnection, updateQuery.ToSql(), updateQuery.Parameters);
+
+            return (int)recordsAffected;
+        }
+
         #endregion
 
         #region Delete
@@ -363,6 +389,18 @@ public int DeleteByKey<T>(dynamic entity)
 
             return recordsAffected;
         }
+
+        public async Task<int> DeleteByKeyAsync<T>(dynamic entity)
+        {
+            if (entity == null) return 0;
+
+            var deleteQuery = SqlGenerator.Delete<T>();
+            var query = GetQueryByKey<T>(entity, deleteQuery);
+
+            var recordsAffected = await DapperHelper.ExecuteScalarAsync(DbConnection, deleteQuery.ToSql(), deleteQuery.Parameters);
+
+            return (int)recordsAffected;
+        }
         #endregion
 
         #region Get query objects
@@ -491,7 +529,7 @@ public IEnumerable<TResult> ExecuteQuery<T, R, TResult>(IQuery<T> query)
             return entities;
         }
 
-        public async Task<IEnumerable<TResult>> ExecuteQueryAsyc<T, R, TResult>(IQuery<T> query, IDbTransaction dbTransaction, int? commandTimeout = null)
+        public async Task<IEnumerable<TResult>> ExecuteQueryAsyc<T, R, TResult>(IQuery<T> query, IDbTransaction dbTransaction = null, int? commandTimeout = null)
         {
             var entities = await DapperHelper.QueryAsync<TResult>(DbConnection, query.ToSql(), query.Parameters, dbTransaction, commandTimeout, CommandType.Text);
 
@@ -510,6 +548,21 @@ public object ExecuteScalar<T>(IQuery<T> query)
             return DapperHelper.ExecuteScalar(DbConnection, query.ToSql(), query.Parameters, null, null, CommandType.Text);
         }
 
+        public object ExecuteScalar<T>(IQuery<T> query, IDbTransaction dbTransaction, int? commandTimeout = null)
+        {
+            return DapperHelper.ExecuteScalar(DbConnection, query.ToSql(), query.Parameters, dbTransaction, commandTimeout, CommandType.Text);
+        }
+
+        public async Task<T> ExecuteScalarAsync<T>(IQuery<T> query, IDbTransaction dbTransaction, int? commandTimeout = null)
+        {
+            return await DapperHelper.ExecuteScalarAsync<T>(DbConnection, query.ToSql(), query.Parameters, dbTransaction, commandTimeout, CommandType.Text);
+        }
+
+        public async Task<T> ExecuteScalarAsync<T>(IQuery<T> query)
+        {
+            return await DapperHelper.ExecuteScalarAsync<T>(DbConnection, query.ToSql(), query.Parameters, null, null, CommandType.Text);
+        }
+
         #endregion
 
         #region Stored Procedures - SQL script Execution

FluentSql/FluentSql.csproj

@@ -30,8 +30,8 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Dapper, Version=1.50.2.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>packages\Dapper.1.50.2\lib\net451\Dapper.dll</HintPath>
+    <Reference Include="Dapper, Version=1.40.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>packages\Dapper.1.42\lib\net45\Dapper.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="System" />
@@ -55,7 +55,7 @@
     <Compile Include="Mappers\IEntityMap.cs" />
     <Compile Include="Mappers\IPropertyMap.cs" />
     <Compile Include="Mappers\EntityMap.cs" />
-    <Compile Include="Mappers\EntityMapper.cs" />
+    <Compile Include="EntityMapper.cs" />
     <Compile Include="Mappers\PropertyMap.cs" />
     <Compile Include="EntityReaders\IEntityReader.cs" />
     <Compile Include="EntityReaders\DefaultEntityReader.cs" />

FluentSql/FluentSql.nuspec

@@ -2,7 +2,7 @@
 <package >
   <metadata>
     <id>FluentSql</id>
-    <version>1.0.7.1</version>
+    <version>1.0.7.3</version>
     <authors>Ernesto.Herrera</authors>
     <owners>Ernesto.Herrera</owners>
     <licenseUrl>http://www.apache.org/licenses/LICENSE-2.0</licenseUrl>

FluentSql/IEntityStore.cs

@@ -156,6 +156,8 @@ Task<IEnumerable<TResult>> GetWithJoinAsync<T, R, TResult>(Expression<Func<T, R,
         /// <returns>The new entity which autoincremented field represents the new number</returns>
         T Insert<T>(T entity) where T : new();
 
+        Task<T> InsertAsync<T>(T entity) where T : new();
+
         /// <summary>
         /// Inserts multiple entities into the database. One entity at a time.
         /// </summary>
@@ -175,6 +177,8 @@ Task<IEnumerable<TResult>> GetWithJoinAsync<T, R, TResult>(Expression<Func<T, R,
         /// <returns></returns>
         int UpdateByKey<T>(T entity);
 
+        Task<int> UpdateByKeyAsync<T>(T entity);
+
         #endregion
 
         #region Delete
@@ -186,6 +190,8 @@ Task<IEnumerable<TResult>> GetWithJoinAsync<T, R, TResult>(Expression<Func<T, R,
         /// <param name="entity"></param>
         /// <returns></returns>
         int DeleteByKey<T>(dynamic entity);
+
+        Task<int> DeleteByKeyAsync<T>(dynamic entity);
         #endregion
 
         #region Get query objects
@@ -271,6 +277,12 @@ Task<IEnumerable<TResult>> GetWithJoinAsync<T, R, TResult>(Expression<Func<T, R,
         IEnumerable<Tuple<T, R>> ExecuteQuery<T, R>(IQuery<T> query);
 
         object ExecuteScalar<T>(IQuery<T> query);
+
+        object ExecuteScalar<T>(IQuery<T> query, IDbTransaction dbTransaction, int? commandTimeout = null);
+
+        Task<T> ExecuteScalarAsync<T>(IQuery<T> query);
+
+        Task<T> ExecuteScalarAsync<T>(IQuery<T> query, IDbTransaction dbTransaction, int? commandTimeout = null);
         #endregion
     }
 }

FluentSql/Properties/AssemblyInfo.cs

@@ -31,4 +31,4 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.7.2")]
+[assembly: AssemblyVersion("1.0.7.3")]

FluentSql/packages.config

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Dapper" version="1.50.2" targetFramework="net452" />
+  <package id="Dapper" version="1.42" targetFramework="net452" />
 </packages>