diff --git a/PetaPoco/Core/ColumnInfo.cs b/PetaPoco/Core/ColumnInfo.cs
index 8168691b..afa7d6f0 100644
--- a/PetaPoco/Core/ColumnInfo.cs
+++ b/PetaPoco/Core/ColumnInfo.cs
@@ -92,6 +92,18 @@ public class ColumnInfo
         /// <seealso cref="ColumnAttribute.UpdateTemplate"/>
         public string UpdateTemplate { get; set; }
 
+        /// <summary>
+        /// Creates and populates a ColumnInfo from the attributes of a POCO property.
+        /// </summary>
+        /// <param name="propertyInfo">The POCO property to use for initializing the ColumnInfo.</param>
+        /// <returns>A ColumnInfo instance.</returns>
+        public static ColumnInfo FromProperty(PropertyInfo propertyInfo)
+        {
+            var ci = new ColumnInfo();
+            PopulateFromProperty(propertyInfo, ref ci, out _);
+            return ci;
+        }
+
         internal static void PopulateFromProperty(PropertyInfo pi, ref ColumnInfo ci, out ColumnAttribute columnAttr)
         {
             // Check if declaring poco has [Explicit] attribute
@@ -123,17 +135,5 @@ internal static void PopulateFromProperty(PropertyInfo pi, ref ColumnInfo ci, ou
                 }
             }
         }
-
-        /// <summary>
-        /// Creates and populates a ColumnInfo from the attributes of a POCO property.
-        /// </summary>
-        /// <param name="propertyInfo">The POCO property to use for initializing the ColumnInfo.</param>
-        /// <returns>A ColumnInfo instance.</returns>
-        public static ColumnInfo FromProperty(PropertyInfo propertyInfo)
-        {
-            var ci = new ColumnInfo();
-            PopulateFromProperty(propertyInfo, ref ci, out _);
-            return ci;
-        }
     }
 }
diff --git a/PetaPoco/Core/IGridReader.cs b/PetaPoco/Core/IGridReader.cs
index a2406075..1681dec3 100644
--- a/PetaPoco/Core/IGridReader.cs
+++ b/PetaPoco/Core/IGridReader.cs
@@ -8,6 +8,8 @@ namespace PetaPoco
     /// </summary>
     public interface IGridReader : IDisposable
     {
+        #region ReadSinglePoco
+
         /// <summary>
         /// Performs a read, returning the results as an <see cref="IEnumerable{T}"/> collection.
         /// </summary>
@@ -15,6 +17,10 @@ public interface IGridReader : IDisposable
         /// <returns>An enumerable collection of <typeparamref name="T"/> POCOs containing the result records.</returns>
         IEnumerable<T> Read<T>();
 
+        #endregion
+
+        #region ReadMultiPoco : auto-mapping
+
         /// <inheritdoc cref="Read{T1,T2,T3,T4}()"/>
         IEnumerable<T1> Read<T1, T2>();
 
@@ -31,6 +37,10 @@ public interface IGridReader : IDisposable
         /// <returns>An enumerable collection of <typeparamref name="T1"/> POCOs containing the result records.</returns>
         IEnumerable<T1> Read<T1, T2, T3, T4>();
 
+        #endregion
+
+        #region ReadMultiPoco : custom-mapping
+
         /// <inheritdoc cref="Read{T1, T2, T3, T4, TRet}(Func{T1,T2,T3,T4,TRet})"/>
         IEnumerable<TRet> Read<T1, T2, TRet>(Func<T1, T2, TRet> func);
 
@@ -48,5 +58,7 @@ public interface IGridReader : IDisposable
         /// <param name="func">A callback function to used to connect the POCO instances, or <see langword="null"/> to let PetaPoco automatically deduce the relationships.</param>
         /// <returns>An enumerable collection of <typeparamref name="TRet"/> POCOs containing the result records.</returns>
         IEnumerable<TRet> Read<T1, T2, T3, T4, TRet>(Func<T1, T2, T3, T4, TRet> func);
+
+        #endregion
     }
 }
diff --git a/PetaPoco/Core/PocoData.cs b/PetaPoco/Core/PocoData.cs
index 255f4ef0..a9e9ac31 100644
--- a/PetaPoco/Core/PocoData.cs
+++ b/PetaPoco/Core/PocoData.cs
@@ -74,6 +74,14 @@ public PocoData(Type type, IMapper defaultMapper)
             QueryColumns = (from c in Columns where !c.Value.ResultColumn || c.Value.AutoSelectedResultColumn select c.Key).ToArray();
         }
 
+        public static PocoData ForType(Type type, IMapper defaultMapper)
+        {
+            if (type == typeof(System.Dynamic.ExpandoObject))
+                throw new InvalidOperationException("Can't use dynamic types with this method");
+
+            return _pocoDatas.GetOrAdd(type, () => new PocoData(type, defaultMapper));
+        }
+
         public static PocoData ForObject(object obj, string primaryKeyName, IMapper defaultMapper)
         {
             var t = obj.GetType();
@@ -97,20 +105,6 @@ public static PocoData ForObject(object obj, string primaryKeyName, IMapper defa
             return ForType(t, defaultMapper);
         }
 
-        public static PocoData ForType(Type type, IMapper defaultMapper)
-        {
-            if (type == typeof(System.Dynamic.ExpandoObject))
-                throw new InvalidOperationException("Can't use dynamic types with this method");
-
-            return _pocoDatas.GetOrAdd(type, () => new PocoData(type, defaultMapper));
-        }
-
-        private static bool IsIntegralType(Type type)
-        {
-            var tc = Type.GetTypeCode(type);
-            return tc >= TypeCode.SByte && tc <= TypeCode.UInt64;
-        }
-
         // Create factory function that can convert a IDataReader record into a POCO
         public Delegate GetFactory(string sql, string connectionString, int firstColumn, int countColumns, IDataReader reader, IMapper defaultMapper)
         {
@@ -393,6 +387,12 @@ private static Func<object, object> GetConverter(IMapper mapper, PocoColumn pc,
             return null;
         }
 
+        private static bool IsIntegralType(Type type)
+        {
+            var tc = Type.GetTypeCode(type);
+            return tc >= TypeCode.SByte && tc <= TypeCode.UInt64;
+        }
+
         private static T RecurseInheritedTypes<T>(Type t, Func<Type, T> cb)
         {
             while (t != null)
diff --git a/PetaPoco/Database.cs b/PetaPoco/Database.cs
index e801890a..2d87c20e 100644
--- a/PetaPoco/Database.cs
+++ b/PetaPoco/Database.cs
@@ -18,46 +18,27 @@
 namespace PetaPoco
 {
     /// <inheritdoc cref="IDatabase"/>
-    public class Database : IDatabase
+    public partial class Database : IDatabase
     {
-#region Internal operations
-
-        internal void DoPreExecute(IDbCommand cmd)
-        {
-            if (CommandTimeout > 0 || OneTimeCommandTimeout > 0)
-            {
-                cmd.CommandTimeout = OneTimeCommandTimeout > 0 ? OneTimeCommandTimeout : CommandTimeout;
-                OneTimeCommandTimeout = 0;
-            }
-
-            _provider.PreExecute(cmd);
-            OnExecutingCommand(cmd);
-
-            _lastSql = cmd.CommandText;
-            _lastArgs = cmd.Parameters.Cast<IDataParameter>().Select(parameter => parameter.Value).ToArray();
-        }
-
-#endregion
-
-#region Member Fields
+        #region Member Fields
 
         private IMapper _defaultMapper;
         private string _connectionString;
         private IProvider _provider;
+        private IsolationLevel? _isolationLevel;
         private IDbConnection _sharedConnection;
         private IDbTransaction _transaction;
+        private DbProviderFactory _factory;
         private int _sharedConnectionDepth;
         private int _transactionDepth;
         private bool _transactionCancelled;
+        private string _paramPrefix;
         private string _lastSql;
         private object[] _lastArgs;
-        private string _paramPrefix;
-        private DbProviderFactory _factory;
-        private IsolationLevel? _isolationLevel;
 
-#endregion
+        #endregion
 
-#region Constructors
+        #region Constructors
 
 #if !NETSTANDARD
         /// <summary>
@@ -121,15 +102,6 @@ public Database(IDbConnection connection, IMapper defaultMapper = null)
             Initialise(DatabaseProvider.Resolve(_sharedConnection.GetType(), false, _connectionString), defaultMapper);
         }
 
-        private void SetupFromConnection(IDbConnection connection)
-        {
-            _sharedConnection = connection;
-            _connectionString = connection.ConnectionString;
-
-            // Prevent closing external connection
-            _sharedConnectionDepth = 2;
-        }
-
         /// <summary>
         /// Constructs an instance using a supplied connection string and provider name.
         /// </summary>
@@ -203,7 +175,7 @@ public Database(IDatabaseBuildConfiguration configuration)
             if (configuration == null)
                 throw new ArgumentNullException(nameof(configuration));
 
-            var settings = (IBuildConfigurationSettings) configuration;
+            var settings = (IBuildConfigurationSettings)configuration;
 
             IMapper defaultMapper = null;
             settings.TryGetSetting<IMapper>(DatabaseConfigurationExtensions.DefaultMapper, v => defaultMapper = v);
@@ -283,6 +255,15 @@ public Database(IDatabaseBuildConfiguration configuration)
             settings.TryGetSetting<EventHandler<ExceptionEventArgs>>(DatabaseConfigurationExtensions.ExceptionThrown, v => ExceptionThrown += v);
         }
 
+        private void SetupFromConnection(IDbConnection connection)
+        {
+            _sharedConnection = connection;
+            _connectionString = connection.ConnectionString;
+
+            // Prevent closing external connection
+            _sharedConnectionDepth = 2;
+        }
+
         /// <summary>
         /// Provides common initialization for the various constructors.
         /// </summary>
@@ -301,15 +282,9 @@ private void Initialise(IProvider provider, IMapper mapper)
             _defaultMapper = mapper ?? new ConventionMapper();
         }
 
-#endregion
-
-#region Connection Management
+        #endregion
 
-        /// <summary>
-        /// When set to <see langword="true"/> the first opened connection is kept alive until <see cref="CloseSharedConnection" /> or <see cref="Dispose" /> is called.
-        /// </summary>
-        /// <seealso cref="OpenSharedConnection" />
-        public bool KeepConnectionAlive { get; set; }
+        #region Connection Management (IConnection Implementation)
 
         /// <summary>
         /// Provides access to the currently open shared connection.
@@ -430,14 +405,14 @@ public void Dispose()
             CloseSharedConnection();
         }
 
-#endregion
+        #endregion
 
-#region Transaction Management
+        #region Transaction Management (ITransactionAccessor, IDatabase implementation)
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         IDbTransaction ITransactionAccessor.Transaction => _transaction;
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public ITransaction GetTransaction()
             => new Transaction(this);
 
@@ -458,7 +433,7 @@ public virtual void OnEndTransaction()
             TransactionEnding?.Invoke(this, new DbTransactionEventArgs(_transaction));
         }
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public void BeginTransaction()
         {
             _transactionDepth++;
@@ -473,11 +448,11 @@ public void BeginTransaction()
         }
 
 #if ASYNC
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public Task BeginTransactionAsync()
             => BeginTransactionAsync(CancellationToken.None);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public async Task BeginTransactionAsync(CancellationToken cancellationToken)
         {
             if (_sharedConnection is DbConnection asyncConn)
@@ -506,6 +481,36 @@ public async Task BeginTransactionAsync(CancellationToken cancellationToken)
         }
 #endif
 
+        /// <inheritdoc/>
+        public void AbortTransaction()
+        {
+            _transactionCancelled = true;
+            CompleteTransaction();
+        }
+
+#if ASYNC
+        public Task AbortTransactionAsync()
+        {
+            this._transactionCancelled = true;
+            return CompleteTransactionAsync();
+        }
+#endif
+
+        /// <inheritdoc/>
+        public void CompleteTransaction()
+        {
+            if ((--_transactionDepth) == 0)
+                CleanupTransaction();
+        }
+
+#if ASYNC
+        public async Task CompleteTransactionAsync()
+        {
+            if ((--_transactionDepth) == 0)
+                await CleanupTransactionAsync().ConfigureAwait(false);
+        }
+#endif
+
         /// <summary>
         /// Internal helper to cleanup transaction.
         /// </summary>
@@ -524,20 +529,6 @@ private void CleanupTransaction()
             CloseSharedConnection();
         }
 
-        /// <inheritdoc />
-        public void AbortTransaction()
-        {
-            _transactionCancelled = true;
-            CompleteTransaction();
-        }
-
-        /// <inheritdoc />
-        public void CompleteTransaction()
-        {
-            if ((--_transactionDepth) == 0)
-                CleanupTransaction();
-        }
-
 #if ASYNC
 #pragma warning disable 1998
         private async Task CleanupTransactionAsync()
@@ -564,633 +555,946 @@ private async Task CleanupTransactionAsync()
             }
         }
 #pragma warning restore 1998
+#endif
 
-        public Task AbortTransactionAsync()
+        #endregion
+
+        #region Exception Reporting and Logging
+
+        /// <summary>
+        /// Called if an exception occurs during processing of a DB operation.  Override to provide custom logging/handling.
+        /// </summary>
+        /// <param name="ex">The exception instance.</param>
+        /// <returns><see langword="true"/> to re-throw the exception, <see langword="false"/> to suppress it.</returns>
+        public virtual bool OnException(Exception ex)
         {
-            this._transactionCancelled = true;
-            return CompleteTransactionAsync();
+            System.Diagnostics.Debug.WriteLine(ex.ToString());
+            System.Diagnostics.Debug.WriteLine(LastCommand);
+
+            var args = new ExceptionEventArgs(ex);
+            ExceptionThrown?.Invoke(this, new ExceptionEventArgs(ex));
+            return args.Raise;
         }
 
-        public async Task CompleteTransactionAsync()
+        /// <summary>
+        /// Called when DB connection opened.
+        /// </summary>
+        /// <remarks>
+        /// Override this method to provide custom logging of opened connections, or to provide a proxy IDbConnection.
+        /// </remarks>
+        /// <param name="conn">The newly-opened IDbConnection.</param>
+        /// <returns>The same or a replacement IDbConnection.</returns>
+        public virtual IDbConnection OnConnectionOpened(IDbConnection conn)
         {
-            if ((--_transactionDepth) == 0)
-                await CleanupTransactionAsync().ConfigureAwait(false);
+            var args = new DbConnectionEventArgs(conn);
+            ConnectionOpened?.Invoke(this, args);
+            return args.Connection;
         }
-#endif
 
-#endregion
+        /// <summary>
+        /// Called before a DB connection is opened.
+        /// </summary>
+        /// <remarks>
+        /// Override this method to provide custom logging of opening connections, or to provide a proxy IDbConnection.
+        /// </remarks>
+        /// <param name="conn">The soon-to-be-opened IDbConnection.</param>
+        /// <returns>The same or a replacement IDbConnection.</returns>
+        public virtual IDbConnection OnConnectionOpening(IDbConnection conn)
+        {
+            var args = new DbConnectionEventArgs(conn);
+            ConnectionOpening?.Invoke(this, args);
+            return args.Connection;
+        }
 
-#region Command Management
+        /// <summary>
+        /// Called when DB connection closed.
+        /// </summary>
+        /// <param name="conn">The soon-to-be-closed IDBConnection.</param>
+        public virtual void OnConnectionClosing(IDbConnection conn)
+        {
+            ConnectionClosing?.Invoke(this, new DbConnectionEventArgs(conn));
+        }
 
         /// <summary>
-        /// Adds a parameter to a DB command.
+        /// Called just before an DB command is executed.
         /// </summary>
-        /// <param name="cmd">A reference to the IDbCommand to which the parameter is to be added.</param>
-        /// <param name="value">The value to assign to the parameter.</param>
-        /// <param name="pc">Optional, a reference to the property info of the POCO property from which the value is coming.</param>
-        private void AddParam(IDbCommand cmd, object value, PocoColumn pc)
+        /// <remarks>
+        /// Override this method to provide custom logging of commands, modification of the IDbCommand before it's executed, or any other custom actions that should be performed before every command
+        /// </remarks>
+        /// <param name="cmd">The command to be executed.</param>
+        public virtual void OnExecutingCommand(IDbCommand cmd)
         {
-            // Convert value to from poco type to db type
-            if (pc?.PropertyInfo != null)
-            {
-                var mapper = Mappers.GetMapper(pc.PropertyInfo.DeclaringType, _defaultMapper);
-                var fn = mapper.GetToDbConverter(pc.PropertyInfo);
-                if (fn != null)
-                    value = fn(value);
-            }
+            CommandExecuting?.Invoke(this, new DbCommandEventArgs(cmd));
+        }
 
-            // Support passed in parameters
-            if (value is IDbDataParameter idbParam)
-            {
-                if (cmd.CommandType == CommandType.Text)
-                    idbParam.ParameterName = cmd.Parameters.Count.EnsureParamPrefix(_paramPrefix);
-                else if (idbParam.ParameterName?.StartsWith(_paramPrefix) != true)
-                    idbParam.ParameterName = idbParam.ParameterName.EnsureParamPrefix(_paramPrefix);
+        /// <summary>
+        /// Called on completion of command execution.
+        /// </summary>
+        /// <remarks>
+        /// Override this method to provide custom logging or other actions after every command has completed.
+        /// </remarks>
+        /// <param name="cmd">The IDbCommand that finished executing.</param>
+        public virtual void OnExecutedCommand(IDbCommand cmd)
+        {
+            CommandExecuted?.Invoke(this, new DbCommandEventArgs(cmd));
+        }
 
-                cmd.Parameters.Add(idbParam);
-            }
-            else
-            {
-                var p = cmd.CreateParameter();
-                p.ParameterName = cmd.Parameters.Count.EnsureParamPrefix(_paramPrefix);
-                SetParameterProperties(p, value, pc);
+        #endregion
 
-                cmd.Parameters.Add(p);
-            }
-        }
+        #region ExecuteNonQuery, ExecuteAsync
 
-        private void SetParameterProperties(IDbDataParameter p, object value, PocoColumn pc)
-        {
-            // Assign the parameter value
-            if (value == null)
-            {
-                p.Value = DBNull.Value;
+        /// <inheritdoc/>
+        public int Execute(Sql sql)
+            => Execute(sql.SQL, sql.Arguments);
 
-                if (pc?.PropertyInfo.PropertyType.Name == "Byte[]")
-                    p.DbType = DbType.Binary;
-            }
-            else
-            {
-                // Give the database type first crack at converting to DB required type
-                value = _provider.MapParameterValue(value);
+        /// <inheritdoc/>
+        public int Execute(string sql, params object[] args)
+            => ExecuteInternal(CommandType.Text, sql, args);
 
-                var t = value.GetType();
+#if ASYNC
+        public Task<int> ExecuteAsync(Sql sql)
+            => ExecuteInternalAsync(CancellationToken.None, CommandType.Text, sql.SQL, sql.Arguments);
 
-                if (t == typeof(string) && pc?.ForceToAnsiString == true)
-                {
-                    t = typeof(AnsiString);
-                    value = value.ToAnsiString();
-                }
-                if (t == typeof(DateTime) && pc?.ForceToDateTime2 == true)
-                {
-                    t = typeof(DateTime2);
-                    value = ((DateTime)value).ToDateTime2();
-                }
+        public Task<int> ExecuteAsync(string sql, params object[] args)
+            => ExecuteInternalAsync(CancellationToken.None, CommandType.Text, sql, args);
 
-                if (t.IsEnum) // PostgreSQL .NET driver wont cast enum to int
+        public Task<int> ExecuteAsync(CancellationToken cancellationToken, Sql sql)
+            => ExecuteInternalAsync(cancellationToken, CommandType.Text, sql.SQL, sql.Arguments);
+
+        public Task<int> ExecuteAsync(CancellationToken cancellationToken, string sql, params object[] args)
+            => ExecuteInternalAsync(cancellationToken, CommandType.Text, sql, args);
+#endif
+
+        protected virtual int ExecuteInternal(CommandType commandType, string sql, params object[] args)
+        {
+            try
+            {
+                OpenSharedConnection();
+                try
                 {
-                    p.Value = Convert.ChangeType(value, ((Enum)value).GetTypeCode());
+                    using (var cmd = CreateCommand(_sharedConnection, commandType, sql, args))
+                    {
+                        return ExecuteNonQueryHelper(cmd);
+                    }
                 }
-                else if (t == typeof(Guid) && !_provider.HasNativeGuidSupport)
+                finally
                 {
-                    p.Value = value.ToString();
-                    p.DbType = DbType.String;
-                    p.Size = 40;
+                    CloseSharedConnection();
                 }
-                else if (t == typeof(string))
-                {
-                    // out of memory exception occurs if trying to save more than 4000 characters to SQL Server CE NText column. Set before attempting to set Size, or Size will always max out at 4000
-                    if ((value as string).Length + 1 > 4000 && p.GetType().Name == "SqlCeParameter")
-                        p.GetType().GetProperty("SqlDbType").SetValue(p, SqlDbType.NText, null);
+            }
+            catch (Exception x)
+            {
+                if (OnException(x))
+                    throw;
+                return -1;
+            }
+        }
 
-                    p.Size = Math.Max((value as string).Length + 1, 4000); // Help query plan caching by using common size
-                    p.Value = value;
-                }
-                else if (t == typeof(AnsiString))
+#if ASYNC
+        protected virtual async Task<int> ExecuteInternalAsync(CancellationToken cancellationToken, CommandType commandType, string sql, params object[] args)
+        {
+            try
+            {
+                await OpenSharedConnectionAsync(cancellationToken).ConfigureAwait(false);
+                try
                 {
-                    var asValue = (value as AnsiString).Value;
-                    if (asValue == null)
-                    {
-                        p.Size = 0;
-                        p.Value = DBNull.Value;
-                    }
-                    else
+                    using (var cmd = CreateCommand(_sharedConnection, commandType, sql, args))
                     {
-                        p.Size = Math.Max(asValue.Length + 1, 4000);
-                        p.Value = asValue;
+                        return await ExecuteNonQueryHelperAsync(cancellationToken, cmd).ConfigureAwait(false);
                     }
-                    // Thanks @DataChomp for pointing out the SQL Server indexing performance hit of using wrong string type on varchar
-                    p.DbType = DbType.AnsiString;
-                }
-                else if (t == typeof(DateTime2))
-                {
-                    var dt2Value = (value as DateTime2)?.Value;
-                    p.Value = dt2Value ?? (object)DBNull.Value;
-                    p.DbType = DbType.DateTime2;
-                }
-                else if (value.GetType().Name == "SqlGeography") //SqlGeography is a CLR Type
-                {
-                    p.GetType().GetProperty("UdtTypeName").SetValue(p, "geography", null); //geography is the equivalent SQL Server Type
-                    p.Value = value;
-                }
-                else if (value.GetType().Name == "SqlGeometry") //SqlGeometry is a CLR Type
-                {
-                    p.GetType().GetProperty("UdtTypeName").SetValue(p, "geometry", null); //geography is the equivalent SQL Server Type
-                    p.Value = value;
-                }
-                else if (t == typeof(byte[]))
-                {
-                    p.Value = value;
-                    p.DbType = DbType.Binary;
                 }
-                else
+                finally
                 {
-                    p.Value = value;
+                    CloseSharedConnection();
                 }
             }
+            catch (Exception x)
+            {
+                if (OnException(x))
+                    throw;
+                return -1;
+            }
         }
+#endif
 
-        public IDbCommand CreateCommand(IDbConnection connection, string sql, params object[] args)
-            => CreateCommand(connection, CommandType.Text, sql, args);
+        #endregion
 
-        public IDbCommand CreateCommand(IDbConnection connection, CommandType commandType, string sql, params object[] args)
-        {
-            var cmd = connection.CreateCommand();
+        #region ExecuteScalar, ExecuteScalarAsync
+
+        /// <inheritdoc/>
+        public T ExecuteScalar<T>(Sql sql)
+            => ExecuteScalar<T>(sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public T ExecuteScalar<T>(string sql, params object[] args)
+            => ExecuteScalarInternal<T>(CommandType.Text, sql, args);
+
+#if ASYNC
+        /// <inheritdoc/>
+        public Task<T> ExecuteScalarAsync<T>(Sql sql)
+            => ExecuteScalarInternalAsync<T>(CancellationToken.None, CommandType.Text, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public Task<T> ExecuteScalarAsync<T>(string sql, params object[] args)
+            => ExecuteScalarInternalAsync<T>(CancellationToken.None, CommandType.Text, sql, args);
+
+        /// <inheritdoc/>
+        public Task<T> ExecuteScalarAsync<T>(CancellationToken cancellationToken, Sql sql)
+            => ExecuteScalarInternalAsync<T>(cancellationToken, CommandType.Text, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public Task<T> ExecuteScalarAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
+            => ExecuteScalarInternalAsync<T>(cancellationToken, CommandType.Text, sql, args);
+#endif
 
+        protected virtual T ExecuteScalarInternal<T>(CommandType commandType, string sql, params object[] args)
+        {
             try
             {
-                cmd.CommandType = commandType;
-                cmd.Transaction = _transaction;
-
-                switch (commandType)
+                OpenSharedConnection();
+                try
                 {
-                    case CommandType.Text:
-                        // Perform named argument replacements
-                        if (EnableNamedParams)
-                        {
-                            var newArgs = new List<object>();
-                            sql = ParametersHelper.ProcessQueryParams(sql, args, newArgs);
-                            args = newArgs.ToArray();
-                        }
+                    using (var cmd = CreateCommand(_sharedConnection, commandType, sql, args))
+                    {
+                        var val = ExecuteScalarHelper(cmd);
 
-                        // Perform parameter prefix replacements
-                        if (_paramPrefix != "@")
-                            sql = sql.ReplaceParamPrefix(_paramPrefix);
-                        sql = sql.Replace("@@", "@"); // <- double @@ escapes a single @
-                        break;
-                    case CommandType.StoredProcedure:
-                        args = ParametersHelper.ProcessStoredProcParams(cmd, args, SetParameterProperties);
-                        break;
-                    case CommandType.TableDirect:
-                        break;
+                        // Handle nullable types
+                        var u = Nullable.GetUnderlyingType(typeof(T));
+                        if (u != null && (val == null || val == DBNull.Value))
+                            return default(T);
+
+                        return (T) Convert.ChangeType(val, u == null ? typeof(T) : u);
+                    }
+                }
+                finally
+                {
+                    CloseSharedConnection();
                 }
+            }
+            catch (Exception x)
+            {
+                if (OnException(x))
+                    throw;
+                return default(T);
+            }
+        }
 
-                cmd.CommandText = sql;
+#if ASYNC
+        protected virtual async Task<T> ExecuteScalarInternalAsync<T>(CancellationToken cancellationToken, CommandType commandType, string sql, params object[] args)
+        {
+            try
+            {
+                await OpenSharedConnectionAsync(cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    using (var cmd = CreateCommand(_sharedConnection, commandType, sql, args))
+                    {
+                        var val = await ExecuteScalarHelperAsync(cancellationToken, cmd).ConfigureAwait(false);
 
-                foreach (var item in args)
-                    AddParam(cmd, item, null);
+                        var u = Nullable.GetUnderlyingType(typeof(T));
+                        if (u != null && (val == null || val == DBNull.Value))
+                            return default(T);
 
-                return cmd;
+                        return (T) Convert.ChangeType(val, u == null ? typeof(T) : u);
+                    }
+                }
+                finally
+                {
+                    CloseSharedConnection();
+                }
             }
-            catch
+            catch (Exception x)
             {
-                cmd.Dispose();
-                throw;
+                if (OnException(x))
+                    throw;
+                return default(T);
             }
         }
+#endif
 
-        /// <summary>
-        /// Creates an IDbDataParameter with default values.
-        /// </summary>
-        /// <returns>The IDbDataParameter.</returns>
-        public IDbDataParameter CreateParameter() => _factory.CreateParameter();
+        #endregion
 
-        /// <summary>
-        /// Creates an IDbDataParameter with the given name and value.
-        /// </summary>
-        /// <param name="name">The parameter name.</param>
-        /// <param name="value">The parameter value.</param>
-        /// <returns>The IDbDataParameter.</returns>
-        public IDbDataParameter CreateParameter(string name, object value)
-            => CreateParameter(name, value, ParameterDirection.Input);
+        #region Query, QueryAsync : Single-Poco
 
-        /// <summary>
-        /// Creates an IDbDataParameter with the given name and direction.
-        /// </summary>
-        /// <param name="name">The parameter name.</param>
-        /// <param name="direction">The parameter direction.</param>
-        /// <returns>The IDbDataParameter.</returns>
-        public IDbDataParameter CreateParameter(string name, ParameterDirection direction)
-            => CreateParameter(name, null, direction);
+        /// <inheritdoc/>
+        public IEnumerable<T> Query<T>()
+            => Query<T>(string.Empty);
 
-        /// <summary>
-        /// Create an IDbParameter with the given ParameterName, Value, and Direction.
-        /// </summary>
-        /// <param name="name">The parameter name.</param>
-        /// <param name="value">The parameter value.</param>
-        /// <param name="direction">The parameter direction.</param>
-        /// <returns>The IDbDataParameter.</returns>
-        public IDbDataParameter CreateParameter(string name, object value, ParameterDirection direction)
+        /// <inheritdoc/>
+        public IEnumerable<T> Query<T>(Sql sql)
+            => Query<T>(sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public IEnumerable<T> Query<T>(string sql, params object[] args)
         {
-            var result = CreateParameter();
-            result.ParameterName = name;
-            result.Value = value;
-            result.Direction = direction;
-            return result;
+            if (EnableAutoSelect)
+                sql = AutoSelectHelper.AddSelectClause<T>(_provider, sql, _defaultMapper);
+
+            return ExecuteReader<T>(CommandType.Text, sql, args);
         }
 
-#endregion
+#if ASYNC
+        /// <inheritdoc/>
+        public Task<IAsyncReader<T>> QueryAsync<T>()
+            => QueryAsync<T>(CancellationToken.None, CommandType.Text, string.Empty);
 
-#region Exception Reporting and Logging
+        /// <inheritdoc/>
+        public Task<IAsyncReader<T>> QueryAsync<T>(Sql sql)
+            => QueryAsync<T>(CancellationToken.None, CommandType.Text, sql.SQL, sql.Arguments);
 
-        /// <summary>
-        /// Called if an exception occurs during processing of a DB operation.  Override to provide custom logging/handling.
-        /// </summary>
-        /// <param name="ex">The exception instance.</param>
-        /// <returns><see langword="true"/> to re-throw the exception, <see langword="false"/> to suppress it.</returns>
-        public virtual bool OnException(Exception ex)
-        {
-            System.Diagnostics.Debug.WriteLine(ex.ToString());
-            System.Diagnostics.Debug.WriteLine(LastCommand);
+        /// <inheritdoc/>
+        public Task<IAsyncReader<T>> QueryAsync<T>(string sql, params object[] args)
+            => QueryAsync<T>(CancellationToken.None, CommandType.Text, sql, args);
 
-            var args = new ExceptionEventArgs(ex);
-            ExceptionThrown?.Invoke(this, new ExceptionEventArgs(ex));
-            return args.Raise;
-        }
+        /// <inheritdoc/>
+        public Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken)
+            => QueryAsync<T>(cancellationToken, CommandType.Text, string.Empty);
 
-        /// <summary>
-        /// Called when DB connection opened.
-        /// </summary>
-        /// <remarks>
-        /// Override this method to provide custom logging of opened connections, or to provide a proxy IDbConnection.
-        /// </remarks>
-        /// <param name="conn">The newly-opened IDbConnection.</param>
-        /// <returns>The same or a replacement IDbConnection.</returns>
-        public virtual IDbConnection OnConnectionOpened(IDbConnection conn)
-        {
-            var args = new DbConnectionEventArgs(conn);
-            ConnectionOpened?.Invoke(this, args);
-            return args.Connection;
-        }
+        /// <inheritdoc/>
+        public Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, Sql sql)
+            => QueryAsync<T>(cancellationToken, CommandType.Text, sql.SQL, sql.Arguments);
 
-        /// <summary>
-        /// Called before a DB connection is opened.
-        /// </summary>
-        /// <remarks>
-        /// Override this method to provide custom logging of opening connections, or to provide a proxy IDbConnection.
-        /// </remarks>
-        /// <param name="conn">The soon-to-be-opened IDbConnection.</param>
-        /// <returns>The same or a replacement IDbConnection.</returns>
-        public virtual IDbConnection OnConnectionOpening(IDbConnection conn)
-        {
-            var args = new DbConnectionEventArgs(conn);
-            ConnectionOpening?.Invoke(this, args);
-            return args.Connection;
-        }
+        /// <inheritdoc/>
+        public Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
+            => QueryAsync<T>(CancellationToken.None, CommandType.Text, sql, args);
 
-        /// <summary>
-        /// Called when DB connection closed.
-        /// </summary>
-        /// <param name="conn">The soon-to-be-closed IDBConnection.</param>
-        public virtual void OnConnectionClosing(IDbConnection conn)
-        {
-            ConnectionClosing?.Invoke(this, new DbConnectionEventArgs(conn));
-        }
+        /// <inheritdoc/>
+        public Task<IAsyncReader<T>> QueryAsync<T>(CommandType commandType)
+            => QueryAsync<T>(CancellationToken.None, commandType, string.Empty);
 
-        /// <summary>
-        /// Called just before an DB command is executed.
-        /// </summary>
-        /// <remarks>
-        /// Override this method to provide custom logging of commands, modification of the IDbCommand before it's executed, or any other custom actions that should be performed before every command
-        /// </remarks>
-        /// <param name="cmd">The command to be executed.</param>
-        public virtual void OnExecutingCommand(IDbCommand cmd)
-        {
-            CommandExecuting?.Invoke(this, new DbCommandEventArgs(cmd));
-        }
+        /// <inheritdoc/>
+        public Task<IAsyncReader<T>> QueryAsync<T>(CommandType commandType, Sql sql)
+            => QueryAsync<T>(CancellationToken.None, commandType, sql.SQL, sql.Arguments);
 
-        /// <summary>
-        /// Called on completion of command execution.
-        /// </summary>
-        /// <remarks>
-        /// Override this method to provide custom logging or other actions after every command has completed.
-        /// </remarks>
-        /// <param name="cmd">The IDbCommand that finished executing.</param>
-        public virtual void OnExecutedCommand(IDbCommand cmd)
+        /// <inheritdoc/>
+        public Task<IAsyncReader<T>> QueryAsync<T>(CommandType commandType, string sql, params object[] args)
+            => QueryAsync<T>(CancellationToken.None, commandType, sql, args);
+
+        /// <inheritdoc/>
+        public Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, CommandType commandType)
+            => QueryAsync<T>(cancellationToken, commandType, string.Empty);
+
+        /// <inheritdoc/>
+        public Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, CommandType commandType, Sql sql)
+            => QueryAsync<T>(cancellationToken, commandType, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, CommandType commandType, string sql, params object[] args)
         {
-            CommandExecuted?.Invoke(this, new DbCommandEventArgs(cmd));
+            if (EnableAutoSelect)
+                sql = AutoSelectHelper.AddSelectClause<T>(_provider, sql, _defaultMapper);
+
+            return ExecuteReaderAsync<T>(cancellationToken, commandType, sql, args);
         }
 
-#endregion
+        /// <inheritdoc/>
+        public Task QueryAsync<T>(Action<T> receivePocoCallback)
+            => QueryAsync(receivePocoCallback, CancellationToken.None, CommandType.Text, string.Empty);
 
-#region operation: Execute
+        /// <inheritdoc/>
+        public Task QueryAsync<T>(Action<T> receivePocoCallback, Sql sql)
+            => QueryAsync(receivePocoCallback, CancellationToken.None, CommandType.Text, sql.SQL, sql.Arguments);
 
-        /// <inheritdoc />
-        public int Execute(string sql, params object[] args)
-            => ExecuteInternal(CommandType.Text, sql, args);
+        /// <inheritdoc/>
+        public Task QueryAsync<T>(Action<T> receivePocoCallback, string sql, params object[] args)
+            => QueryAsync(receivePocoCallback, CancellationToken.None, CommandType.Text, sql, args);
 
-        /// <inheritdoc />
-        public int Execute(Sql sql)
-            => Execute(sql.SQL, sql.Arguments);
+        /// <inheritdoc/>
+        public Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken)
+            => QueryAsync(receivePocoCallback, cancellationToken, CommandType.Text, string.Empty);
 
-        protected virtual int ExecuteInternal(CommandType commandType, string sql, params object[] args)
+        /// <inheritdoc/>
+        public Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, Sql sql)
+            => QueryAsync(receivePocoCallback, cancellationToken, CommandType.Text, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, string sql, params object[] args)
+            => QueryAsync(receivePocoCallback, CancellationToken.None, CommandType.Text, sql, args);
+
+        /// <inheritdoc/>
+        public Task QueryAsync<T>(Action<T> receivePocoCallback, CommandType commandType)
+            => QueryAsync(receivePocoCallback, CancellationToken.None, commandType, string.Empty);
+
+        /// <inheritdoc/>
+        public Task QueryAsync<T>(Action<T> receivePocoCallback, CommandType commandType, Sql sql)
+            => QueryAsync(receivePocoCallback, CancellationToken.None, commandType, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public Task QueryAsync<T>(Action<T> receivePocoCallback, CommandType commandType, string sql, params object[] args)
+            => QueryAsync(receivePocoCallback, CancellationToken.None, commandType, sql, args);
+
+        /// <inheritdoc/>
+        public Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, CommandType commandType)
+            => QueryAsync(receivePocoCallback, cancellationToken, commandType, string.Empty);
+
+        /// <inheritdoc/>
+        public Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, CommandType commandType, Sql sql)
+            => QueryAsync(receivePocoCallback, cancellationToken, commandType, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, CommandType commandType, string sql, params object[] args)
+        {
+            if (EnableAutoSelect)
+                sql = AutoSelectHelper.AddSelectClause<T>(_provider, sql, _defaultMapper);
+            return ExecuteReaderAsync(receivePocoCallback, cancellationToken, commandType, sql, args);
+        }
+
+#endif
+
+        protected virtual IEnumerable<T> ExecuteReader<T>(CommandType commandType, string sql, params object[] args)
         {
+            OpenSharedConnection();
             try
             {
-                OpenSharedConnection();
-                try
+                using (var cmd = CreateCommand(_sharedConnection, commandType, sql, args))
                 {
-                    using (var cmd = CreateCommand(_sharedConnection, commandType, sql, args))
+                    IDataReader r;
+                    var pd = PocoData.ForType(typeof(T), _defaultMapper);
+                    try
                     {
-                        return ExecuteNonQueryHelper(cmd);
+                        r = ExecuteReaderHelper(cmd);
+                    }
+                    catch (Exception x)
+                    {
+                        if (OnException(x))
+                            throw;
+                        yield break;
+                    }
+
+                    var factory = pd.GetFactory(cmd.CommandText, _sharedConnection.ConnectionString, 0, r.FieldCount, r,
+                        _defaultMapper) as Func<IDataReader, T>;
+                    using (r)
+                    {
+                        while (true)
+                        {
+                            T poco;
+                            try
+                            {
+                                if (!r.Read())
+                                    yield break;
+                                poco = factory(r);
+                            }
+                            catch (Exception x)
+                            {
+                                if (OnException(x))
+                                    throw;
+                                yield break;
+                            }
+
+                            yield return poco;
+                        }
                     }
-                }
-                finally
-                {
-                    CloseSharedConnection();
                 }
             }
-            catch (Exception x)
+            finally
             {
-                if (OnException(x))
-                    throw;
-                return -1;
+                CloseSharedConnection();
             }
         }
 
 #if ASYNC
-
-        public Task<int> ExecuteAsync(string sql, params object[] args)
-            => ExecuteInternalAsync(CancellationToken.None, CommandType.Text, sql, args);
-
-        public Task<int> ExecuteAsync(CancellationToken cancellationToken, string sql, params object[] args)
-            => ExecuteInternalAsync(cancellationToken, CommandType.Text, sql, args);
-
-        public Task<int> ExecuteAsync(Sql sql)
-            => ExecuteInternalAsync(CancellationToken.None, CommandType.Text, sql.SQL, sql.Arguments);
-
-        public Task<int> ExecuteAsync(CancellationToken cancellationToken, Sql sql)
-            => ExecuteInternalAsync(cancellationToken, CommandType.Text, sql.SQL, sql.Arguments);
-
-        protected virtual async Task<int> ExecuteInternalAsync(CancellationToken cancellationToken, CommandType commandType, string sql, params object[] args)
+        protected virtual async Task<IAsyncReader<T>> ExecuteReaderAsync<T>(CancellationToken cancellationToken, CommandType commandType, string sql, object[] args)
         {
+            await OpenSharedConnectionAsync(cancellationToken).ConfigureAwait(false);
+            var cmd = CreateCommand(_sharedConnection, commandType, sql, args);
+            IDataReader reader = null;
+            var pd = PocoData.ForType(typeof(T), _defaultMapper);
+
             try
             {
-                await OpenSharedConnectionAsync(cancellationToken).ConfigureAwait(false);
+                reader = await ExecuteReaderHelperAsync(cancellationToken, cmd).ConfigureAwait(false);
+            }
+            catch (Exception e)
+            {
+                if (OnException(e))
+                    throw;
                 try
                 {
-                    using (var cmd = CreateCommand(_sharedConnection, commandType, sql, args))
-                    {
-                        return await ExecuteNonQueryHelperAsync(cancellationToken, cmd).ConfigureAwait(false);
-                    }
+                    cmd?.Dispose();
+                    reader?.Dispose();
                 }
-                finally
+                catch
                 {
-                    CloseSharedConnection();
+                    // ignored
                 }
-            }
-            catch (Exception x)
-            {
-                if (OnException(x))
-                    throw;
-                return -1;
-            }
-        }
-
-#endif
 
-#endregion
-
-#region operation: ExecuteScalar
+                return AsyncReader<T>.Empty();
+            }
 
-        /// <inheritdoc />
-        public T ExecuteScalar<T>(string sql, params object[] args)
-            => ExecuteScalarInternal<T>(CommandType.Text, sql, args);
+            var factory =
+                pd.GetFactory(cmd.CommandText, _sharedConnection.ConnectionString, 0, reader.FieldCount, reader, _defaultMapper) as Func<IDataReader, T>;
 
-        /// <inheritdoc />
-        public T ExecuteScalar<T>(Sql sql)
-            => ExecuteScalar<T>(sql.SQL, sql.Arguments);
+            return new AsyncReader<T>(this, cmd, reader, factory);
+        }
 
-        protected virtual T ExecuteScalarInternal<T>(CommandType commandType, string sql, params object[] args)
+        protected virtual async Task ExecuteReaderAsync<T>(Action<T> processPoco, CancellationToken cancellationToken, CommandType commandType, string sql, object[] args)
         {
+            await OpenSharedConnectionAsync(cancellationToken).ConfigureAwait(false);
             try
             {
-                OpenSharedConnection();
-                try
+                using (var cmd = CreateCommand(_sharedConnection, commandType, sql, args))
                 {
-                    using (var cmd = CreateCommand(_sharedConnection, commandType, sql, args))
-                    {
-                        var val = ExecuteScalarHelper(cmd);
-
-                        // Handle nullable types
-                        var u = Nullable.GetUnderlyingType(typeof(T));
-                        if (u != null && (val == null || val == DBNull.Value))
-                            return default(T);
+                    IDataReader reader;
+                    var pd = PocoData.ForType(typeof(T), _defaultMapper);
 
-                        return (T) Convert.ChangeType(val, u == null ? typeof(T) : u);
+                    try
+                    {
+                        reader = await ExecuteReaderHelperAsync(cancellationToken, cmd).ConfigureAwait(false);
+                    }
+                    catch (Exception e)
+                    {
+                        if (OnException(e))
+                            throw;
+                        return;
+                    }
+
+                    var readerAsync = reader as DbDataReader;
+                    var factory =
+                        pd.GetFactory(cmd.CommandText, _sharedConnection.ConnectionString, 0, reader.FieldCount, reader,
+                            _defaultMapper) as Func<IDataReader, T>;
+
+                    using (reader)
+                    {
+                        while (true)
+                        {
+                            T poco;
+                            try
+                            {
+                                if (readerAsync != null)
+                                {
+                                    if (!await readerAsync.ReadAsync(cancellationToken).ConfigureAwait(false))
+                                        return;
+                                }
+                                else
+                                {
+                                    if (!reader.Read())
+                                        return;
+                                }
+
+                                poco = factory(reader);
+                                processPoco(poco);
+                            }
+                            catch (Exception e)
+                            {
+                                if (OnException(e))
+                                    throw;
+                                return;
+                            }
+                        }
                     }
-                }
-                finally
-                {
-                    CloseSharedConnection();
                 }
             }
-            catch (Exception x)
+            finally
             {
-                if (OnException(x))
-                    throw;
-                return default(T);
+                CloseSharedConnection();
             }
         }
+#endif
 
-#if ASYNC
+        #endregion
 
-        /// <inheritdoc />
-        public Task<T> ExecuteScalarAsync<T>(string sql, params object[] args)
-            => ExecuteScalarInternalAsync<T>(CancellationToken.None, CommandType.Text, sql, args);
+        #region Query : Multi-Poco
 
-        /// <inheritdoc />
-        public Task<T> ExecuteScalarAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
-            => ExecuteScalarInternalAsync<T>(cancellationToken, CommandType.Text, sql, args);
+        /// <inheritdoc/>
+        public IEnumerable<T1> Query<T1, T2>(Sql sql)
+            => Query<T1>(new[] { typeof(T1), typeof(T2) }, null, sql.SQL, sql.Arguments);
 
-        /// <inheritdoc />
-        public Task<T> ExecuteScalarAsync<T>(Sql sql)
-            => ExecuteScalarInternalAsync<T>(CancellationToken.None, CommandType.Text, sql.SQL, sql.Arguments);
+        /// <inheritdoc/>
+        public IEnumerable<T1> Query<T1, T2, T3>(Sql sql)
+            => Query<T1>(new[] { typeof(T1), typeof(T2), typeof(T3) }, null, sql.SQL, sql.Arguments);
 
-        /// <inheritdoc />
-        public Task<T> ExecuteScalarAsync<T>(CancellationToken cancellationToken, Sql sql)
-            => ExecuteScalarInternalAsync<T>(cancellationToken, CommandType.Text, sql.SQL, sql.Arguments);
+        public IEnumerable<T1> Query<T1, T2, T3, T4>(Sql sql)
+            => Query<T1>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4) }, null, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public IEnumerable<T1> Query<T1, T2, T3, T4, T5>(Sql sql)
+            => Query<T1>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4), typeof(T5) }, null, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public IEnumerable<T1> Query<T1, T2>(string sql, params object[] args)
+            => Query<T1>(new[] { typeof(T1), typeof(T2) }, null, sql, args);
+
+        /// <inheritdoc/>
+        public IEnumerable<T1> Query<T1, T2, T3>(string sql, params object[] args)
+            => Query<T1>(new[] { typeof(T1), typeof(T2), typeof(T3) }, null, sql, args);
+
+        /// <inheritdoc/>
+        public IEnumerable<T1> Query<T1, T2, T3, T4>(string sql, params object[] args)
+            => Query<T1>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4) }, null, sql, args);
+
+        /// <inheritdoc/>
+        public IEnumerable<T1> Query<T1, T2, T3, T4, T5>(string sql, params object[] args)
+            => Query<T1>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4), typeof(T5) }, null, sql, args);
+
+        /// <inheritdoc/>
+        public IEnumerable<TRet> Query<T1, T2, TRet>(Func<T1, T2, TRet> cb, Sql sql)
+            => Query<TRet>(new[] { typeof(T1), typeof(T2) }, cb, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public IEnumerable<TRet> Query<T1, T2, T3, TRet>(Func<T1, T2, T3, TRet> cb, Sql sql)
+            => Query<TRet>(new[] { typeof(T1), typeof(T2), typeof(T3) }, cb, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public IEnumerable<TRet> Query<T1, T2, T3, T4, TRet>(Func<T1, T2, T3, T4, TRet> cb, Sql sql)
+            => Query<TRet>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4) }, cb, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public IEnumerable<TRet> Query<T1, T2, T3, T4, T5, TRet>(Func<T1, T2, T3, T4, T5, TRet> cb, Sql sql)
+            => Query<TRet>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4), typeof(T5) }, cb, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public IEnumerable<TRet> Query<T1, T2, TRet>(Func<T1, T2, TRet> cb, string sql, params object[] args)
+            => Query<TRet>(new[] { typeof(T1), typeof(T2) }, cb, sql, args);
+
+        /// <inheritdoc/>
+        public IEnumerable<TRet> Query<T1, T2, T3, TRet>(Func<T1, T2, T3, TRet> cb, string sql, params object[] args)
+            => Query<TRet>(new[] { typeof(T1), typeof(T2), typeof(T3) }, cb, sql, args);
+
+        /// <inheritdoc/>
+        public IEnumerable<TRet> Query<T1, T2, T3, T4, TRet>(Func<T1, T2, T3, T4, TRet> cb, string sql, params object[] args)
+            => Query<TRet>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4) }, cb, sql, args);
+
+        public IEnumerable<TRet> Query<T1, T2, T3, T4, T5, TRet>(Func<T1, T2, T3, T4, T5, TRet> cb, string sql, params object[] args)
+            => Query<TRet>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4), typeof(T5) }, cb, sql, args);
 
-        protected virtual async Task<T> ExecuteScalarInternalAsync<T>(CancellationToken cancellationToken, CommandType commandType, string sql,
-                                                                      params object[] args)
+        /// <inheritdoc/>
+        public IEnumerable<TRet> Query<TRet>(Type[] types, object cb, string sql, params object[] args)
         {
+            OpenSharedConnection();
             try
             {
-                await OpenSharedConnectionAsync(cancellationToken).ConfigureAwait(false);
-                try
+                using (var cmd = CreateCommand(_sharedConnection, sql, args))
                 {
-                    using (var cmd = CreateCommand(_sharedConnection, commandType, sql, args))
+                    IDataReader r;
+                    try
                     {
-                        var val = await ExecuteScalarHelperAsync(cancellationToken, cmd).ConfigureAwait(false);
+                        r = ExecuteReaderHelper(cmd);
+                    }
+                    catch (Exception x)
+                    {
+                        if (OnException(x))
+                            throw;
+                        yield break;
+                    }
 
-                        var u = Nullable.GetUnderlyingType(typeof(T));
-                        if (u != null && (val == null || val == DBNull.Value))
-                            return default(T);
+                    var factory = MultiPocoFactory.GetFactory<TRet>(types, _sharedConnection.ConnectionString, sql, r, _defaultMapper);
+                    if (cb == null)
+                        cb = MultiPocoFactory.GetAutoMapper(types.ToArray());
+                    var bNeedTerminator = false;
+                    using (r)
+                    {
+                        while (true)
+                        {
+                            TRet poco;
+                            try
+                            {
+                                if (!r.Read())
+                                    break;
+                                poco = factory(r, cb);
+                            }
+                            catch (Exception x)
+                            {
+                                if (OnException(x))
+                                    throw;
+                                yield break;
+                            }
 
-                        return (T) Convert.ChangeType(val, u == null ? typeof(T) : u);
+                            if (poco != null)
+                                yield return poco;
+                            else
+                                bNeedTerminator = true;
+                        }
+
+                        if (bNeedTerminator)
+                        {
+                            var poco = (TRet) (cb as Delegate).DynamicInvoke(new object[types.Length]);
+                            if (poco != null)
+                                yield return poco;
+                            else
+                                yield break;
+                        }
                     }
                 }
-                finally
-                {
-                    CloseSharedConnection();
-                }
+            }
+            finally
+            {
+                CloseSharedConnection();
+            }
+        }
+
+        #endregion
+
+        #region QueryMultiple : Multi-POCO Result Set IGridReader
+
+        public IGridReader QueryMultiple(Sql sql)
+            => QueryMultiple(sql.SQL, sql.Arguments);
+
+        public IGridReader QueryMultiple(string sql, params object[] args)
+        {
+            OpenSharedConnection();
+
+            GridReader result = null;
+
+            var cmd = CreateCommand(_sharedConnection, sql, args);
+
+            try
+            {
+                var reader = ExecuteReaderHelper(cmd);
+                result = new GridReader(this, cmd, reader, _defaultMapper);
             }
             catch (Exception x)
             {
                 if (OnException(x))
                     throw;
-                return default(T);
             }
-        }
 
-#endif
+            return result;
+        }
 
-#endregion
+        #endregion
 
-#region operation: Fetch
+        #region Fetch, FetchAsync : Single-Poco
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public List<T> Fetch<T>()
             => Fetch<T>(string.Empty);
 
-        /// <inheritdoc />
-        public List<T> Fetch<T>(string sql, params object[] args)
-            => Query<T>(sql, args).ToList();
-
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public List<T> Fetch<T>(Sql sql)
             => Fetch<T>(sql.SQL, sql.Arguments);
 
-        /// <inheritdoc />
-        public List<T> Fetch<T>(long page, long itemsPerPage)
-            => Fetch<T>(page, itemsPerPage, string.Empty);
-
-        /// <inheritdoc />
-        public List<T> Fetch<T>(long page, long itemsPerPage, string sql, params object[] args)
-            => SkipTake<T>((page - 1) * itemsPerPage, itemsPerPage, sql, args);
-
-        /// <inheritdoc />
-        public List<T> Fetch<T>(long page, long itemsPerPage, Sql sql)
-            => SkipTake<T>((page - 1) * itemsPerPage, itemsPerPage, sql.SQL, sql.Arguments);
+        /// <inheritdoc/>
+        public List<T> Fetch<T>(string sql, params object[] args)
+            => Query<T>(sql, args).ToList();
 
 #if ASYNC
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public Task<List<T>> FetchAsync<T>()
             => FetchAsync<T>(CancellationToken.None, CommandType.Text, string.Empty);
 
-        /// <inheritdoc />
-        public Task<List<T>> FetchAsync<T>(CommandType commandType)
-            => FetchAsync<T>(CancellationToken.None, CommandType.Text, string.Empty);
+        /// <inheritdoc/>
+        public Task<List<T>> FetchAsync<T>(Sql sql)
+            => FetchAsync<T>(CancellationToken.None, CommandType.Text, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public Task<List<T>> FetchAsync<T>(string sql, params object[] args)
+            => FetchAsync<T>(CancellationToken.None, CommandType.Text, sql, args);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken)
             => FetchAsync<T>(cancellationToken, CommandType.Text, string.Empty);
 
-        /// <inheritdoc />
-        public Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, CommandType commandType)
-            => FetchAsync<T>(cancellationToken, commandType, string.Empty);
+        /// <inheritdoc/>
+        public Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, Sql sql)
+            => FetchAsync<T>(cancellationToken, CommandType.Text, sql.SQL, sql.Arguments);
 
-        /// <inheritdoc />
-        public Task<List<T>> FetchAsync<T>(string sql, params object[] args)
+        /// <inheritdoc/>
+        public Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
             => FetchAsync<T>(CancellationToken.None, CommandType.Text, sql, args);
 
-        /// <inheritdoc />
-        public Task<List<T>> FetchAsync<T>(CommandType commandType, string sql, params object[] args)
+        /// <inheritdoc/>
+        public Task<List<T>> FetchAsync<T>(CommandType commandType)
+            => FetchAsync<T>(CancellationToken.None, CommandType.Text, string.Empty);
+
+        /// <inheritdoc/>
+        public Task<List<T>> FetchAsync<T>(CommandType commandType, Sql sql)
+            => FetchAsync<T>(CancellationToken.None, commandType, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public Task<List<T>> FetchAsync<T>(CommandType commandType, string sql, params object[] args)
             => FetchAsync<T>(CancellationToken.None, commandType, sql, args);
 
-        /// <inheritdoc />
-        public Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
-            => FetchAsync<T>(CancellationToken.None, CommandType.Text, sql, args);
+        /// <inheritdoc/>
+        public Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, CommandType commandType)
+            => FetchAsync<T>(cancellationToken, commandType, string.Empty);
+
+        /// <inheritdoc/>
+        public Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, CommandType commandType, Sql sql)
+            => FetchAsync<T>(cancellationToken, commandType, sql.SQL, sql.Arguments);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public async Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, CommandType commandType, string sql, params object[] args)
         {
             var pocos = new List<T>();
             await QueryAsync<T>(p => pocos.Add(p), cancellationToken, commandType, sql, args).ConfigureAwait(false);
             return pocos;
         }
+#endif
 
-        /// <inheritdoc />
-        public Task<List<T>> FetchAsync<T>(Sql sql)
-            => FetchAsync<T>(CancellationToken.None, CommandType.Text, sql.SQL, sql.Arguments);
+        #endregion
 
-        /// <inheritdoc />
-        public Task<List<T>> FetchAsync<T>(CommandType commandType, Sql sql)
-            => FetchAsync<T>(CancellationToken.None, commandType, sql.SQL, sql.Arguments);
+        #region Fetch : Multi-Poco
 
-        /// <inheritdoc />
-        public Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, Sql sql)
-            => FetchAsync<T>(cancellationToken, CommandType.Text, sql.SQL, sql.Arguments);
+        /// <inheritdoc/>
+        public List<T1> Fetch<T1, T2>(Sql sql)
+            => Query<T1, T2>(sql.SQL, sql.Arguments).ToList();
 
-        /// <inheritdoc />
-        public Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, CommandType commandType, Sql sql)
-            => FetchAsync<T>(cancellationToken, commandType, sql.SQL, sql.Arguments);
+        /// <inheritdoc/>
+        public List<T1> Fetch<T1, T2, T3>(Sql sql)
+            => Query<T1, T2, T3>(sql.SQL, sql.Arguments).ToList();
+
+        /// <inheritdoc/>
+        public List<T1> Fetch<T1, T2, T3, T4>(Sql sql)
+            => Query<T1, T2, T3, T4>(sql.SQL, sql.Arguments).ToList();
+
+        /// <inheritdoc/>
+        public List<T1> Fetch<T1, T2, T3, T4, T5>(Sql sql)
+            => Query<T1, T2, T3, T4, T5>(sql.SQL, sql.Arguments).ToList();
+
+        /// <inheritdoc/>
+        public List<T1> Fetch<T1, T2>(string sql, params object[] args)
+            => Query<T1, T2>(sql, args).ToList();
+
+        /// <inheritdoc/>
+        public List<T1> Fetch<T1, T2, T3>(string sql, params object[] args)
+            => Query<T1, T2, T3>(sql, args).ToList();
+
+        /// <inheritdoc/>
+        public List<T1> Fetch<T1, T2, T3, T4>(string sql, params object[] args)
+            => Query<T1, T2, T3, T4>(sql, args).ToList();
+
+        /// <inheritdoc/>
+        public List<T1> Fetch<T1, T2, T3, T4, T5>(string sql, params object[] args)
+            => Query<T1, T2, T3, T4, T5>(sql, args).ToList();
+
+        /// <inheritdoc/>
+        public List<TRet> Fetch<T1, T2, TRet>(Func<T1, T2, TRet> cb, Sql sql)
+            => Query(cb, sql.SQL, sql.Arguments).ToList();
+
+        /// <inheritdoc/>
+        public List<TRet> Fetch<T1, T2, T3, TRet>(Func<T1, T2, T3, TRet> cb, Sql sql)
+            => Query(cb, sql.SQL, sql.Arguments).ToList();
+
+        /// <inheritdoc/>
+        public List<TRet> Fetch<T1, T2, T3, T4, TRet>(Func<T1, T2, T3, T4, TRet> cb, Sql sql)
+            => Query(cb, sql.SQL, sql.Arguments).ToList();
+
+        public List<TRet> Fetch<T1, T2, T3, T4, T5, TRet>(Func<T1, T2, T3, T4, T5, TRet> cb, Sql sql)
+            => Query(cb, sql.SQL, sql.Arguments).ToList();
+
+        /// <inheritdoc/>
+        public List<TRet> Fetch<T1, T2, TRet>(Func<T1, T2, TRet> cb, string sql, params object[] args)
+            => Query(cb, sql, args).ToList();
+
+        /// <inheritdoc/>
+        public List<TRet> Fetch<T1, T2, T3, TRet>(Func<T1, T2, T3, TRet> cb, string sql, params object[] args)
+            => Query(cb, sql, args).ToList();
+
+        /// <inheritdoc/>
+        public List<TRet> Fetch<T1, T2, T3, T4, TRet>(Func<T1, T2, T3, T4, TRet> cb, string sql, params object[] args)
+            => Query(cb, sql, args).ToList();
+
+        /// <inheritdoc/>
+        public List<TRet> Fetch<T1, T2, T3, T4, T5, TRet>(Func<T1, T2, T3, T4, T5, TRet> cb, string sql, params object[] args)
+            => Query(cb, sql, args).ToList();
+
+        #endregion
+
+        #region Fetch, FetchAsync : Paged SkipTake
+
+        /// <inheritdoc/>
+        public List<T> Fetch<T>(long page, long itemsPerPage)
+            => Fetch<T>(page, itemsPerPage, string.Empty);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
+        public List<T> Fetch<T>(long page, long itemsPerPage, Sql sql)
+            => SkipTake<T>((page - 1) * itemsPerPage, itemsPerPage, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public List<T> Fetch<T>(long page, long itemsPerPage, string sql, params object[] args)
+            => SkipTake<T>((page - 1) * itemsPerPage, itemsPerPage, sql, args);
+
+#if ASYNC
+        /// <inheritdoc/>
         public Task<List<T>> FetchAsync<T>(long page, long itemsPerPage)
             => FetchAsync<T>(page, itemsPerPage, string.Empty);
 
-        /// <inheritdoc />
-        public Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage)
-            => FetchAsync<T>(cancellationToken, page, itemsPerPage, string.Empty);
+        /// <inheritdoc/>
+        public Task<List<T>> FetchAsync<T>(long page, long itemsPerPage, Sql sql)
+            => FetchAsync<T>(CancellationToken.None, page, itemsPerPage, sql);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public Task<List<T>> FetchAsync<T>(long page, long itemsPerPage, string sql, params object[] args)
             => FetchAsync<T>(CancellationToken.None, page, itemsPerPage, sql, args);
 
-        /// <inheritdoc />
-        public Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, string sql, params object[] args)
-            => SkipTakeAsync<T>(cancellationToken, (page - 1) * itemsPerPage, itemsPerPage, sql, args);
-
-        /// <inheritdoc />
-        public Task<List<T>> FetchAsync<T>(long page, long itemsPerPage, Sql sql)
-            => FetchAsync<T>(CancellationToken.None, page, itemsPerPage, sql);
+        /// <inheritdoc/>
+        public Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage)
+            => FetchAsync<T>(cancellationToken, page, itemsPerPage, string.Empty);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, Sql sql)
             => SkipTakeAsync<T>(cancellationToken, (page - 1) * itemsPerPage, itemsPerPage, sql.SQL, sql.Arguments);
 
+        /// <inheritdoc/>
+        public Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, string sql, params object[] args)
+            => SkipTakeAsync<T>(cancellationToken, (page - 1) * itemsPerPage, itemsPerPage, sql, args);
 #endif
 
-#endregion
+        #endregion
 
-#region operation: Page
+        #region Page, PageAsync
 
-        /// <summary>
-        /// Starting with a regular SELECT statement, derives the SQL statements required to query a DB for a page of records and the total number of records.
-        /// </summary>
-        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
-        /// <param name="skip">The number of rows to skip before the start of the page.</param>
-        /// <param name="take">The number of rows in the page.</param>
-        /// <param name="sql">The original SQL select statement.</param>
-        /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
-        /// <param name="sqlCount">Outputs the SQL statement to query for the total number of matching rows.</param>
-        /// <param name="sqlPage">Outputs the SQL statement to retrieve a single page of matching rows.</param>
-        /// <exception cref="Exception">Thrown when unable to parse the given <paramref name="sql"/> statement.</exception>
-        protected virtual void BuildPageQueries<T>(long skip, long take, string sql, ref object[] args, out string sqlCount, out string sqlPage)
+        /// <inheritdoc/>
+        public Page<T> Page<T>(long page, long itemsPerPage)
+            => Page<T>(page, itemsPerPage, string.Empty);
+
+        /// <inheritdoc/>
+        public Page<T> Page<T>(long page, long itemsPerPage, Sql sql)
+            => Page<T>(page, itemsPerPage, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public Page<T> Page<T>(long page, long itemsPerPage, string sql, params object[] args)
         {
-            if (EnableAutoSelect)
-                sql = AutoSelectHelper.AddSelectClause<T>(_provider, sql, _defaultMapper);
+            BuildPageQueries<T>((page - 1) * itemsPerPage, itemsPerPage, sql, ref args, out var sqlCount, out var sqlPage);
+            return Page<T>(page, itemsPerPage, sqlCount, args, sqlPage, args);
+        }
 
-            SQLParts parts;
-            if (!Provider.PagingUtility.SplitSQL(sql, out parts))
-                throw new Exception("Unable to parse SQL statement for paged query");
+        /// <inheritdoc/>
+        public Page<T> Page<T>(long page, long itemsPerPage, Sql sqlCount, Sql sqlPage)
+            => Page<T>(page, itemsPerPage, sqlCount.SQL, sqlCount.Arguments, sqlPage.SQL, sqlPage.Arguments);
 
-            sqlPage = _provider.BuildPageQuery(skip, take, parts, ref args);
-            sqlCount = parts.SqlCount;
+#if ASYNC
+        /// <inheritdoc/>
+        public Task<Page<T>> PageAsync<T>(long page, long itemsPerPage)
+            => PageAsync<T>(CancellationToken.None, page, itemsPerPage, string.Empty);
+
+        /// <inheritdoc/>
+        public Task<Page<T>> PageAsync<T>(long page, long itemsPerPage, Sql sql)
+            => PageAsync<T>(CancellationToken.None, page, itemsPerPage, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public Task<Page<T>> PageAsync<T>(long page, long itemsPerPage, string sql, params object[] args)
+            => PageAsync<T>(CancellationToken.None, page, itemsPerPage, sql, args);
+
+        /// <inheritdoc/>
+        public Task<Page<T>> PageAsync<T>(long page, long itemsPerPage, Sql sqlCount, Sql sqlPage)
+            => PageAsync<T>(CancellationToken.None, page, itemsPerPage, sqlCount.SQL, sqlCount.Arguments, sqlPage.SQL, sqlPage.Arguments);
+
+        /// <inheritdoc/>
+        public Task<Page<T>> PageAsync<T>(long page, long itemsPerPage, string sqlCount, object[] countArgs, string sqlPage, object[] pageArgs)
+            => PageAsync<T>(CancellationToken.None, page, itemsPerPage, sqlCount, countArgs, sqlPage, pageArgs);
+
+        /// <inheritdoc/>
+        public Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage)
+            => PageAsync<T>(cancellationToken, page, itemsPerPage, string.Empty);
+
+        /// <inheritdoc/>
+        public Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, Sql sql)
+            => PageAsync<T>(cancellationToken, page, itemsPerPage, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
+        public Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, string sql, params object[] args)
+        {
+            BuildPageQueries<T>((page - 1) * itemsPerPage, itemsPerPage, sql, ref args, out var sqlCount, out var sqlPage);
+            return PageAsync<T>(cancellationToken, page, itemsPerPage, sqlCount, args, sqlPage, args);
         }
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
+        public Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, Sql sqlCount, Sql sqlPage)
+            => PageAsync<T>(cancellationToken, page, itemsPerPage, sqlCount.SQL, sqlCount.Arguments, sqlPage.SQL, sqlPage.Arguments);
+#endif
+
+        /// <inheritdoc/>
         public Page<T> Page<T>(long page, long itemsPerPage, string sqlCount, object[] countArgs, string sqlPage, object[] pageArgs)
         {
             // Save the one-time command time out and use it for both queries
@@ -1215,30 +1519,9 @@ public Page<T> Page<T>(long page, long itemsPerPage, string sqlCount, object[] c
             return result;
         }
 
-        /// <inheritdoc />
-        public Page<T> Page<T>(long page, long itemsPerPage)
-            => Page<T>(page, itemsPerPage, string.Empty);
-
-        /// <inheritdoc />
-        public Page<T> Page<T>(long page, long itemsPerPage, string sql, params object[] args)
-        {
-            BuildPageQueries<T>((page - 1) * itemsPerPage, itemsPerPage, sql, ref args, out var sqlCount, out var sqlPage);
-            return Page<T>(page, itemsPerPage, sqlCount, args, sqlPage, args);
-        }
-
-        /// <inheritdoc />
-        public Page<T> Page<T>(long page, long itemsPerPage, Sql sql)
-            => Page<T>(page, itemsPerPage, sql.SQL, sql.Arguments);
-
-        /// <inheritdoc />
-        public Page<T> Page<T>(long page, long itemsPerPage, Sql sqlCount, Sql sqlPage)
-            => Page<T>(page, itemsPerPage, sqlCount.SQL, sqlCount.Arguments, sqlPage.SQL, sqlPage.Arguments);
-
 #if ASYNC
-
-        /// <inheritdoc />
-        public async Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, string sqlCount, object[] countArgs,
-                                                string sqlPage, object[] pageArgs)
+        /// <inheritdoc/>
+        public async Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, string sqlCount, object[] countArgs, string sqlPage, object[] pageArgs)
         {
             var saveTimeout = OneTimeCommandTimeout;
 
@@ -1259,61 +1542,21 @@ public async Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, lon
 
             return result;
         }
-
-        /// <inheritdoc />
-        public Task<Page<T>> PageAsync<T>(long page, long itemsPerPage, string sqlCount, object[] countArgs, string sqlPage, object[] pageArgs)
-            => PageAsync<T>(CancellationToken.None, page, itemsPerPage, sqlCount, countArgs, sqlPage, pageArgs);
-
-        /// <inheritdoc />
-        public Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage)
-            => PageAsync<T>(cancellationToken, page, itemsPerPage, string.Empty);
-
-        /// <inheritdoc />
-        public Task<Page<T>> PageAsync<T>(long page, long itemsPerPage)
-            => PageAsync<T>(CancellationToken.None, page, itemsPerPage, string.Empty);
-
-        /// <inheritdoc />
-        public Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, string sql, params object[] args)
-        {
-            BuildPageQueries<T>((page - 1) * itemsPerPage, itemsPerPage, sql, ref args, out var sqlCount, out var sqlPage);
-            return PageAsync<T>(cancellationToken, page, itemsPerPage, sqlCount, args, sqlPage, args);
-        }
-
-        /// <inheritdoc />
-        public Task<Page<T>> PageAsync<T>(long page, long itemsPerPage, string sql, params object[] args)
-            => PageAsync<T>(CancellationToken.None, page, itemsPerPage, sql, args);
-
-        /// <inheritdoc />
-        public Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, Sql sql)
-            => PageAsync<T>(cancellationToken, page, itemsPerPage, sql.SQL, sql.Arguments);
-
-        /// <inheritdoc />
-        public Task<Page<T>> PageAsync<T>(long page, long itemsPerPage, Sql sql)
-            => PageAsync<T>(CancellationToken.None, page, itemsPerPage, sql.SQL, sql.Arguments);
-
-        /// <inheritdoc />
-        public Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, Sql sqlCount, Sql sqlPage)
-            => PageAsync<T>(cancellationToken, page, itemsPerPage, sqlCount.SQL, sqlCount.Arguments, sqlPage.SQL, sqlPage.Arguments);
-
-        /// <inheritdoc />
-        public Task<Page<T>> PageAsync<T>(long page, long itemsPerPage, Sql sqlCount, Sql sqlPage)
-            => PageAsync<T>(CancellationToken.None, page, itemsPerPage, sqlCount.SQL, sqlCount.Arguments, sqlPage.SQL, sqlPage.Arguments);
-
 #endif
 
-#endregion
+        #endregion
 
-#region operation: SkipTake
+        #region SkipTake, SkipTakeAsync
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public List<T> SkipTake<T>(long skip, long take)
             => SkipTake<T>(skip, take, string.Empty);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public List<T> SkipTake<T>(long skip, long take, Sql sql)
             => SkipTake<T>(skip, take, sql.SQL, sql.Arguments);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public List<T> SkipTake<T>(long skip, long take, string sql, params object[] args)
         {
             BuildPageQueries<T>(skip, take, sql, ref args, out var sqlCount, out var sqlPage);
@@ -1321,509 +1564,280 @@ public List<T> SkipTake<T>(long skip, long take, string sql, params object[] arg
         }
 
 #if ASYNC
-
-        /// <inheritdoc />
-        public Task<List<T>> SkipTakeAsync<T>(CancellationToken cancellationToken, long skip, long take)
-            => SkipTakeAsync<T>(cancellationToken, skip, take, string.Empty);
-
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public Task<List<T>> SkipTakeAsync<T>(long skip, long take)
             => SkipTakeAsync<T>(CancellationToken.None, skip, take, string.Empty);
 
-        /// <inheritdoc />
-        public Task<List<T>> SkipTakeAsync<T>(CancellationToken cancellationToken, long skip, long take, string sql, params object[] args)
-        {
-            BuildPageQueries<T>(skip, take, sql, ref args, out var sqlCount, out var sqlPage);
-            return FetchAsync<T>(cancellationToken, sqlPage, args);
-        }
+        /// <inheritdoc/>
+        public Task<List<T>> SkipTakeAsync<T>(long skip, long take, Sql sql)
+            => SkipTakeAsync<T>(skip, take, sql.SQL, sql.Arguments);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public Task<List<T>> SkipTakeAsync<T>(long skip, long take, string sql, params object[] args)
             => SkipTakeAsync<T>(CancellationToken.None, skip, take, sql, args);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
+        public Task<List<T>> SkipTakeAsync<T>(CancellationToken cancellationToken, long skip, long take)
+            => SkipTakeAsync<T>(cancellationToken, skip, take, string.Empty);
+
+        /// <inheritdoc/>
         public Task<List<T>> SkipTakeAsync<T>(CancellationToken cancellationToken, long skip, long take, Sql sql)
             => SkipTakeAsync<T>(cancellationToken, skip, take, sql.SQL, sql.Arguments);
 
-        /// <inheritdoc />
-        public Task<List<T>> SkipTakeAsync<T>(long skip, long take, Sql sql)
-            => SkipTakeAsync<T>(skip, take, sql.SQL, sql.Arguments);
-
+        /// <inheritdoc/>
+        public Task<List<T>> SkipTakeAsync<T>(CancellationToken cancellationToken, long skip, long take, string sql, params object[] args)
+        {
+            BuildPageQueries<T>(skip, take, sql, ref args, out var sqlCount, out var sqlPage);
+            return FetchAsync<T>(cancellationToken, sqlPage, args);
+        }
 #endif
 
-#endregion
-
-#region operation: Query
-
-        /// <inheritdoc />
-        public IEnumerable<T> Query<T>()
-            => Query<T>(string.Empty);
+        #endregion
 
-        /// <inheritdoc />
-        public IEnumerable<T> Query<T>(string sql, params object[] args)
+        /// <summary>
+        /// Starting with a regular SELECT statement, derives the SQL statements required to query a DB for a page of records and the total number of records.
+        /// </summary>
+        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
+        /// <param name="skip">The number of rows to skip before the start of the page.</param>
+        /// <param name="take">The number of rows in the page.</param>
+        /// <param name="sql">The original SQL select statement.</param>
+        /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
+        /// <param name="sqlCount">Outputs the SQL statement to query for the total number of matching rows.</param>
+        /// <param name="sqlPage">Outputs the SQL statement to retrieve a single page of matching rows.</param>
+        /// <exception cref="Exception">Thrown when unable to parse the given <paramref name="sql"/> statement.</exception>
+        protected virtual void BuildPageQueries<T>(long skip, long take, string sql, ref object[] args, out string sqlCount, out string sqlPage)
         {
             if (EnableAutoSelect)
                 sql = AutoSelectHelper.AddSelectClause<T>(_provider, sql, _defaultMapper);
 
-            return ExecuteReader<T>(CommandType.Text, sql, args);
+            SQLParts parts;
+            if (!Provider.PagingUtility.SplitSQL(sql, out parts))
+                throw new Exception("Unable to parse SQL statement for paged query");
+
+            sqlPage = _provider.BuildPageQuery(skip, take, parts, ref args);
+            sqlCount = parts.SqlCount;
         }
 
-        /// <inheritdoc />
-        public IEnumerable<T> Query<T>(Sql sql)
-            => Query<T>(sql.SQL, sql.Arguments);
+        #region Exists, ExistsAsync
 
-#if ASYNC
-        /// <inheritdoc />
-        public Task QueryAsync<T>(Action<T> receivePocoCallback)
-            => QueryAsync(receivePocoCallback, CancellationToken.None, CommandType.Text, string.Empty);
+        /// <inheritdoc/>
+        public bool Exists<T>(object primaryKey)
+        {
+            var poco = PocoData.ForType(typeof(T), _defaultMapper);
+            return Exists<T>($"{_provider.EscapeSqlIdentifier(poco.TableInfo.PrimaryKey)}=@0",
+                primaryKey is T ? poco.Columns[poco.TableInfo.PrimaryKey].GetValue(primaryKey) : primaryKey);
+        }
 
-        /// <inheritdoc />
-        public Task QueryAsync<T>(Action<T> receivePocoCallback, CommandType commandType)
-            => QueryAsync(receivePocoCallback, CancellationToken.None, commandType, string.Empty);
+        /// <inheritdoc/>
+        public bool Exists<T>(string sqlCondition, params object[] args)
+        {
+            var poco = PocoData.ForType(typeof(T), _defaultMapper).TableInfo;
 
-        /// <inheritdoc />
-        public Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken)
-            => QueryAsync(receivePocoCallback, cancellationToken, CommandType.Text, string.Empty);
+            if (sqlCondition.TrimStart().StartsWith("where", StringComparison.OrdinalIgnoreCase))
+                sqlCondition = sqlCondition.TrimStart().Substring(5);
 
-        /// <inheritdoc />
-        public Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, CommandType commandType)
-            => QueryAsync(receivePocoCallback, cancellationToken, commandType, string.Empty);
+            return ExecuteScalar<int>(string.Format(_provider.GetExistsSql(), Provider.EscapeTableName(poco.TableName), sqlCondition), args) != 0;
+        }
 
-        /// <inheritdoc />
-        public Task QueryAsync<T>(Action<T> receivePocoCallback, string sql, params object[] args)
-            => QueryAsync(receivePocoCallback, CancellationToken.None, CommandType.Text, sql, args);
+#if ASYNC
+        public Task<bool> ExistsAsync<T>(object primaryKey)
+            => ExistsAsync<T>(CancellationToken.None, primaryKey);
 
-        /// <inheritdoc />
-        public Task QueryAsync<T>(Action<T> receivePocoCallback, CommandType commandType, string sql, params object[] args)
-            => QueryAsync(receivePocoCallback, CancellationToken.None, commandType, sql, args);
+        public Task<bool> ExistsAsync<T>(string sqlCondition, params object[] args)
+            => ExistsAsync<T>(CancellationToken.None, sqlCondition, args);
 
-        /// <inheritdoc />
-        public Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, string sql, params object[] args)
-            => QueryAsync(receivePocoCallback, CancellationToken.None, CommandType.Text, sql, args);
+        public Task<bool> ExistsAsync<T>(CancellationToken cancellationToken, object primaryKey)
+        {
+            var poco = PocoData.ForType(typeof(T), _defaultMapper);
+            return ExistsAsync<T>(cancellationToken, $"{_provider.EscapeSqlIdentifier(poco.TableInfo.PrimaryKey)}=@0",
+                primaryKey is T ? poco.Columns[poco.TableInfo.PrimaryKey].GetValue(primaryKey) : primaryKey);
+        }
 
-        /// <inheritdoc />
-        public Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, CommandType commandType, string sql, params object[] args)
+        public async Task<bool> ExistsAsync<T>(CancellationToken cancellationToken, string sqlCondition, params object[] args)
         {
-            if (EnableAutoSelect)
-                sql = AutoSelectHelper.AddSelectClause<T>(_provider, sql, _defaultMapper);
-            return ExecuteReaderAsync(receivePocoCallback, cancellationToken, commandType, sql, args);
+            var poco = PocoData.ForType(typeof(T), _defaultMapper).TableInfo;
+
+            if (sqlCondition.TrimStart().StartsWith("where", StringComparison.OrdinalIgnoreCase))
+                sqlCondition = sqlCondition.TrimStart().Substring(5);
+
+            return await ExecuteScalarAsync<int>(cancellationToken,
+                       string.Format(_provider.GetExistsSql(), Provider.EscapeTableName(poco.TableName), sqlCondition), args).ConfigureAwait(false) != 0;
         }
+#endif
 
-        /// <inheritdoc />
-        public Task QueryAsync<T>(Action<T> receivePocoCallback, Sql sql)
-            => QueryAsync(receivePocoCallback, CancellationToken.None, CommandType.Text, sql.SQL, sql.Arguments);
+        #endregion
 
-        /// <inheritdoc />
-        public Task QueryAsync<T>(Action<T> receivePocoCallback, CommandType commandType, Sql sql)
-            => QueryAsync(receivePocoCallback, CancellationToken.None, commandType, sql.SQL, sql.Arguments);
+        #region Single, SingleAsync
 
-        /// <inheritdoc />
-        public Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, Sql sql)
-            => QueryAsync(receivePocoCallback, cancellationToken, CommandType.Text, sql.SQL, sql.Arguments);
+        /// <inheritdoc/>
+        public T Single<T>(object primaryKey)
+            => Single<T>(GenerateSingleByKeySql<T>(primaryKey));
 
-        /// <inheritdoc />
-        public Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, CommandType commandType, Sql sql)
-            => QueryAsync(receivePocoCallback, cancellationToken, commandType, sql.SQL, sql.Arguments);
+        /// <inheritdoc/>
+        public T Single<T>(Sql sql)
+            => Query<T>(sql).Single();
 
-        /// <inheritdoc />
-        public Task<IAsyncReader<T>> QueryAsync<T>()
-            => QueryAsync<T>(CancellationToken.None, CommandType.Text, string.Empty);
+        /// <inheritdoc/>
+        public T Single<T>(string sql, params object[] args)
+            => Query<T>(sql, args).Single();
 
-        /// <inheritdoc />
-        public Task<IAsyncReader<T>> QueryAsync<T>(CommandType commandType)
-            => QueryAsync<T>(CancellationToken.None, commandType, string.Empty);
+#if ASYNC
+        /// <inheritdoc/>
+        public Task<T> SingleAsync<T>(object primaryKey)
+            => SingleAsync<T>(CancellationToken.None, primaryKey);
 
-        /// <inheritdoc />
-        public Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken)
-            => QueryAsync<T>(cancellationToken, CommandType.Text, string.Empty);
+        /// <inheritdoc/>
+        public Task<T> SingleAsync<T>(Sql sql)
+            => SingleAsync<T>(CancellationToken.None, sql);
 
-        /// <inheritdoc />
-        public Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, CommandType commandType)
-            => QueryAsync<T>(cancellationToken, commandType, string.Empty);
+        /// <inheritdoc/>
+        public Task<T> SingleAsync<T>(string sql, params object[] args)
+            => SingleAsync<T>(CancellationToken.None, sql, args);
 
-        /// <inheritdoc />
-        public Task<IAsyncReader<T>> QueryAsync<T>(string sql, params object[] args)
-            => QueryAsync<T>(CancellationToken.None, CommandType.Text, sql, args);
+        /// <inheritdoc/>
+        public Task<T> SingleAsync<T>(CancellationToken cancellationToken, object primaryKey)
+            => SingleAsync<T>(cancellationToken, GenerateSingleByKeySql<T>(primaryKey));
 
-        /// <inheritdoc />
-        public Task<IAsyncReader<T>> QueryAsync<T>(CommandType commandType, string sql, params object[] args)
-            => QueryAsync<T>(CancellationToken.None, commandType, sql, args);
+        /// <inheritdoc/>
+        public Task<T> SingleAsync<T>(CancellationToken cancellationToken, Sql sql)
+            => SingleAsync<T>(cancellationToken, sql.SQL, sql.Arguments);
 
-        /// <inheritdoc />
-        public Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
-            => QueryAsync<T>(CancellationToken.None, CommandType.Text, sql, args);
+        /// <inheritdoc/>
+        public async Task<T> SingleAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
+            => (await FetchAsync<T>(cancellationToken, sql, args).ConfigureAwait(false)).Single();
+#endif
 
-        /// <inheritdoc />
-        public Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, CommandType commandType, string sql, params object[] args)
-        {
-            if (EnableAutoSelect)
-                sql = AutoSelectHelper.AddSelectClause<T>(_provider, sql, _defaultMapper);
+        #endregion
 
-            return ExecuteReaderAsync<T>(cancellationToken, commandType, sql, args);
-        }
+        #region SingleOrDefault, SingleOrDefaultAsync
 
-        /// <inheritdoc />
-        public Task<IAsyncReader<T>> QueryAsync<T>(Sql sql)
-            => QueryAsync<T>(CancellationToken.None, CommandType.Text, sql.SQL, sql.Arguments);
+        /// <inheritdoc/>
+        public T SingleOrDefault<T>(object primaryKey)
+            => SingleOrDefault<T>(GenerateSingleByKeySql<T>(primaryKey));
 
-        /// <inheritdoc />
-        public Task<IAsyncReader<T>> QueryAsync<T>(CommandType commandType, Sql sql)
-            => QueryAsync<T>(CancellationToken.None, commandType, sql.SQL, sql.Arguments);
+        /// <inheritdoc/>
+        public T SingleOrDefault<T>(Sql sql)
+            => Query<T>(sql).SingleOrDefault();
 
-        /// <inheritdoc />
-        public Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, Sql sql)
-            => QueryAsync<T>(cancellationToken, CommandType.Text, sql.SQL, sql.Arguments);
+        /// <inheritdoc/>
+        public T SingleOrDefault<T>(string sql, params object[] args)
+            => Query<T>(sql, args).SingleOrDefault();
 
-        /// <inheritdoc />
-        public Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, CommandType commandType, Sql sql)
-            => QueryAsync<T>(cancellationToken, commandType, sql.SQL, sql.Arguments);
+#if ASYNC
+        /// <inheritdoc/>
+        public Task<T> SingleOrDefaultAsync<T>(object primaryKey)
+            => SingleOrDefaultAsync<T>(CancellationToken.None, primaryKey);
 
-        protected virtual async Task ExecuteReaderAsync<T>(Action<T> processPoco, CancellationToken cancellationToken, CommandType commandType, string sql,
-                                                           object[] args)
-        {
-            await OpenSharedConnectionAsync(cancellationToken).ConfigureAwait(false);
-            try
-            {
-                using (var cmd = CreateCommand(_sharedConnection, commandType, sql, args))
-                {
-                    IDataReader reader;
-                    var pd = PocoData.ForType(typeof(T), _defaultMapper);
+        /// <inheritdoc/>
+        public Task<T> SingleOrDefaultAsync<T>(Sql sql)
+            => SingleOrDefaultAsync<T>(CancellationToken.None, sql);
 
-                    try
-                    {
-                        reader = await ExecuteReaderHelperAsync(cancellationToken, cmd).ConfigureAwait(false);
-                    }
-                    catch (Exception e)
-                    {
-                        if (OnException(e))
-                            throw;
-                        return;
-                    }
+        /// <inheritdoc/>
+        public Task<T> SingleOrDefaultAsync<T>(string sql, params object[] args)
+            => SingleOrDefaultAsync<T>(CancellationToken.None, sql, args);
 
-                    var readerAsync = reader as DbDataReader;
-                    var factory =
-                        pd.GetFactory(cmd.CommandText, _sharedConnection.ConnectionString, 0, reader.FieldCount, reader,
-                            _defaultMapper) as Func<IDataReader, T>;
+        /// <inheritdoc/>
+        public Task<T> SingleOrDefaultAsync<T>(CancellationToken cancellationToken, object primaryKey)
+            => SingleOrDefaultAsync<T>(cancellationToken, GenerateSingleByKeySql<T>(primaryKey));
 
-                    using (reader)
-                    {
-                        while (true)
-                        {
-                            T poco;
-                            try
-                            {
-                                if (readerAsync != null)
-                                {
-                                    if (!await readerAsync.ReadAsync(cancellationToken).ConfigureAwait(false))
-                                        return;
-                                }
-                                else
-                                {
-                                    if (!reader.Read())
-                                        return;
-                                }
+        /// <inheritdoc/>
+        public Task<T> SingleOrDefaultAsync<T>(CancellationToken cancellationToken, Sql sql)
+            => SingleOrDefaultAsync<T>(cancellationToken, sql.SQL, sql.Arguments);
 
-                                poco = factory(reader);
-                                processPoco(poco);
-                            }
-                            catch (Exception e)
-                            {
-                                if (OnException(e))
-                                    throw;
-                                return;
-                            }
-                        }
-                    }
-                }
-            }
-            finally
-            {
-                CloseSharedConnection();
-            }
-        }
+        /// <inheritdoc/>
+        public async Task<T> SingleOrDefaultAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
+            => (await FetchAsync<T>(cancellationToken, sql, args).ConfigureAwait(false)).SingleOrDefault();
+#endif
 
-        protected virtual async Task<IAsyncReader<T>> ExecuteReaderAsync<T>(CancellationToken cancellationToken, CommandType commandType, string sql,
-                                                                            object[] args)
+        private Sql GenerateSingleByKeySql<T>(object primaryKey)
         {
-            await OpenSharedConnectionAsync(cancellationToken).ConfigureAwait(false);
-            var cmd = CreateCommand(_sharedConnection, commandType, sql, args);
-            IDataReader reader = null;
-            var pd = PocoData.ForType(typeof(T), _defaultMapper);
-
-            try
-            {
-                reader = await ExecuteReaderHelperAsync(cancellationToken, cmd).ConfigureAwait(false);
-            }
-            catch (Exception e)
-            {
-                if (OnException(e))
-                    throw;
-                try
-                {
-                    cmd?.Dispose();
-                    reader?.Dispose();
-                }
-                catch
-                {
-                    // ignored
-                }
-
-                return AsyncReader<T>.Empty();
-            }
-
-            var factory =
-                pd.GetFactory(cmd.CommandText, _sharedConnection.ConnectionString, 0, reader.FieldCount, reader, _defaultMapper) as Func<IDataReader, T>;
-
-            return new AsyncReader<T>(this, cmd, reader, factory);
-        }
-
-#endif
-
-        protected virtual IEnumerable<T> ExecuteReader<T>(CommandType commandType, string sql, params object[] args)
-        {
-            OpenSharedConnection();
-            try
-            {
-                using (var cmd = CreateCommand(_sharedConnection, commandType, sql, args))
-                {
-                    IDataReader r;
-                    var pd = PocoData.ForType(typeof(T), _defaultMapper);
-                    try
-                    {
-                        r = ExecuteReaderHelper(cmd);
-                    }
-                    catch (Exception x)
-                    {
-                        if (OnException(x))
-                            throw;
-                        yield break;
-                    }
-
-                    var factory = pd.GetFactory(cmd.CommandText, _sharedConnection.ConnectionString, 0, r.FieldCount, r,
-                        _defaultMapper) as Func<IDataReader, T>;
-                    using (r)
-                    {
-                        while (true)
-                        {
-                            T poco;
-                            try
-                            {
-                                if (!r.Read())
-                                    yield break;
-                                poco = factory(r);
-                            }
-                            catch (Exception x)
-                            {
-                                if (OnException(x))
-                                    throw;
-                                yield break;
-                            }
-
-                            yield return poco;
-                        }
-                    }
-                }
-            }
-            finally
-            {
-                CloseSharedConnection();
-            }
-        }
-
-#endregion
-
-#region operation: Exists
-
-        /// <inheritdoc />
-        public bool Exists<T>(string sqlCondition, params object[] args)
-        {
-            var poco = PocoData.ForType(typeof(T), _defaultMapper).TableInfo;
-
-            if (sqlCondition.TrimStart().StartsWith("where", StringComparison.OrdinalIgnoreCase))
-                sqlCondition = sqlCondition.TrimStart().Substring(5);
-
-            return ExecuteScalar<int>(string.Format(_provider.GetExistsSql(), Provider.EscapeTableName(poco.TableName), sqlCondition), args) != 0;
-        }
-
-        /// <inheritdoc />
-        public bool Exists<T>(object primaryKey)
-        {
-            var poco = PocoData.ForType(typeof(T), _defaultMapper);
-            return Exists<T>($"{_provider.EscapeSqlIdentifier(poco.TableInfo.PrimaryKey)}=@0",
-                primaryKey is T ? poco.Columns[poco.TableInfo.PrimaryKey].GetValue(primaryKey) : primaryKey);
-        }
-
-#if ASYNC
-        public Task<bool> ExistsAsync<T>(object primaryKey)
-            => ExistsAsync<T>(CancellationToken.None, primaryKey);
-
-        public Task<bool> ExistsAsync<T>(CancellationToken cancellationToken, object primaryKey)
-        {
-            var poco = PocoData.ForType(typeof(T), _defaultMapper);
-            return ExistsAsync<T>(cancellationToken, $"{_provider.EscapeSqlIdentifier(poco.TableInfo.PrimaryKey)}=@0",
-                primaryKey is T ? poco.Columns[poco.TableInfo.PrimaryKey].GetValue(primaryKey) : primaryKey);
-        }
-
-        public Task<bool> ExistsAsync<T>(string sqlCondition, params object[] args)
-            => ExistsAsync<T>(CancellationToken.None, sqlCondition, args);
-
-        public async Task<bool> ExistsAsync<T>(CancellationToken cancellationToken, string sqlCondition, params object[] args)
-        {
-            var poco = PocoData.ForType(typeof(T), _defaultMapper).TableInfo;
+            string pkName = _provider.EscapeSqlIdentifier(PocoData.ForType(typeof(T), _defaultMapper).TableInfo.PrimaryKey);
+            var sql = $"WHERE {pkName} = @0";
 
-            if (sqlCondition.TrimStart().StartsWith("where", StringComparison.OrdinalIgnoreCase))
-                sqlCondition = sqlCondition.TrimStart().Substring(5);
+            if (!EnableAutoSelect)
+                // We're going to be nice and add the SELECT anyway
+                sql = AutoSelectHelper.AddSelectClause<T>(_provider, sql, _defaultMapper);
 
-            return await ExecuteScalarAsync<int>(cancellationToken,
-                       string.Format(_provider.GetExistsSql(), Provider.EscapeTableName(poco.TableName), sqlCondition), args).ConfigureAwait(false) != 0;
+            return new Sql(sql, primaryKey);
         }
-#endif
-
-#endregion
-
-#region operation: Linq style (Exists, Single, SingleOrDefault, First, FirstOrDefault, etc...)
-
-        /// <inheritdoc />
-        public T Single<T>(object primaryKey)
-            => Single<T>(GenerateSingleByKeySql<T>(primaryKey));
-
-        /// <inheritdoc />
-        public T SingleOrDefault<T>(object primaryKey)
-            => SingleOrDefault<T>(GenerateSingleByKeySql<T>(primaryKey));
-
-        /// <inheritdoc />
-        public T Single<T>(string sql, params object[] args)
-            => Query<T>(sql, args).Single();
-
-        /// <inheritdoc />
-        public T SingleOrDefault<T>(string sql, params object[] args)
-            => Query<T>(sql, args).SingleOrDefault();
 
-        /// <inheritdoc />
-        public T First<T>(string sql, params object[] args)
-            => Query<T>(sql, args).First();
-
-        /// <inheritdoc />
-        public T FirstOrDefault<T>(string sql, params object[] args)
-            => Query<T>(sql, args).FirstOrDefault();
-
-        /// <inheritdoc />
-        public T Single<T>(Sql sql)
-            => Query<T>(sql).Single();
+        #endregion
 
-        /// <inheritdoc />
-        public T SingleOrDefault<T>(Sql sql)
-            => Query<T>(sql).SingleOrDefault();
+        #region First, FirstAsync
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public T First<T>(Sql sql)
             => Query<T>(sql).First();
 
-        /// <inheritdoc />
-        public T FirstOrDefault<T>(Sql sql)
-            => Query<T>(sql).FirstOrDefault();
+        /// <inheritdoc/>
+        public T First<T>(string sql, params object[] args)
+            => Query<T>(sql, args).First();
 
 #if ASYNC
+        /// <inheritdoc/>
+        public Task<T> FirstAsync<T>(Sql sql)
+            => FirstAsync<T>(CancellationToken.None, sql);
 
-        /// <inheritdoc />
-        public Task<T> SingleAsync<T>(object primaryKey)
-            => SingleAsync<T>(CancellationToken.None, primaryKey);
-
-        /// <inheritdoc />
-        public Task<T> SingleAsync<T>(CancellationToken cancellationToken, object primaryKey)
-            => SingleAsync<T>(cancellationToken, GenerateSingleByKeySql<T>(primaryKey));
-
-        /// <inheritdoc />
-        public Task<T> SingleAsync<T>(string sql, params object[] args)
-            => SingleAsync<T>(CancellationToken.None, sql, args);
-
-        /// <inheritdoc />
-        public async Task<T> SingleAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
-            => (await FetchAsync<T>(cancellationToken, sql, args).ConfigureAwait(false)).Single();
-
-        /// <inheritdoc />
-        public Task<T> SingleAsync<T>(Sql sql)
-            => SingleAsync<T>(CancellationToken.None, sql);
-
-        /// <inheritdoc />
-        public Task<T> SingleAsync<T>(CancellationToken cancellationToken, Sql sql)
-            => SingleAsync<T>(cancellationToken, sql.SQL, sql.Arguments);
-
-        /// <inheritdoc />
-        public Task<T> SingleOrDefaultAsync<T>(Sql sql)
-            => SingleOrDefaultAsync<T>(CancellationToken.None, sql);
-
-        /// <inheritdoc />
-        public Task<T> SingleOrDefaultAsync<T>(CancellationToken cancellationToken, Sql sql)
-            => SingleOrDefaultAsync<T>(cancellationToken, sql.SQL, sql.Arguments);
-
-        /// <inheritdoc />
-        public Task<T> SingleOrDefaultAsync<T>(object primaryKey)
-            => SingleOrDefaultAsync<T>(CancellationToken.None, primaryKey);
-
-        /// <inheritdoc />
-        public Task<T> SingleOrDefaultAsync<T>(CancellationToken cancellationToken, object primaryKey)
-            => SingleOrDefaultAsync<T>(cancellationToken, GenerateSingleByKeySql<T>(primaryKey));
-
-        /// <inheritdoc />
-        public Task<T> SingleOrDefaultAsync<T>(string sql, params object[] args)
-            => SingleOrDefaultAsync<T>(CancellationToken.None, sql, args);
-
-        /// <inheritdoc />
-        public async Task<T> SingleOrDefaultAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
-            => (await FetchAsync<T>(cancellationToken, sql, args).ConfigureAwait(false)).SingleOrDefault();
-
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public Task<T> FirstAsync<T>(string sql, params object[] args)
             => FirstAsync<T>(CancellationToken.None, sql, args);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
+        public Task<T> FirstAsync<T>(CancellationToken cancellationToken, Sql sql)
+            => FirstAsync<T>(cancellationToken, sql.SQL, sql.Arguments);
+
+        /// <inheritdoc/>
         public async Task<T> FirstAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
             => (await FetchAsync<T>(cancellationToken, sql, args).ConfigureAwait(false)).First();
+#endif
 
-        /// <inheritdoc />
-        public Task<T> FirstAsync<T>(Sql sql)
-            => FirstAsync<T>(CancellationToken.None, sql);
+        #endregion
 
-        /// <inheritdoc />
-        public Task<T> FirstAsync<T>(CancellationToken cancellationToken, Sql sql)
-            => FirstAsync<T>(cancellationToken, sql.SQL, sql.Arguments);
+        #region FirstOrDefault, FirstOrDefaultAsync
 
-        /// <inheritdoc />
-        public Task<T> FirstOrDefaultAsync<T>(string sql, params object[] args)
-            => FirstOrDefaultAsync<T>(CancellationToken.None, sql, args);
+        /// <inheritdoc/>
+        public T FirstOrDefault<T>(Sql sql)
+            => Query<T>(sql).FirstOrDefault();
 
-        /// <inheritdoc />
-        public async Task<T> FirstOrDefaultAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
-            => (await FetchAsync<T>(cancellationToken, sql, args).ConfigureAwait(false)).FirstOrDefault();
+        /// <inheritdoc/>
+        public T FirstOrDefault<T>(string sql, params object[] args)
+            => Query<T>(sql, args).FirstOrDefault();
 
-        /// <inheritdoc />
+#if ASYNC
+        /// <inheritdoc/>
         public Task<T> FirstOrDefaultAsync<T>(Sql sql)
             => FirstOrDefaultAsync<T>(CancellationToken.None, sql);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
+        public Task<T> FirstOrDefaultAsync<T>(string sql, params object[] args)
+            => FirstOrDefaultAsync<T>(CancellationToken.None, sql, args);
+
+        /// <inheritdoc/>
         public Task<T> FirstOrDefaultAsync<T>(CancellationToken cancellationToken, Sql sql)
             => FirstOrDefaultAsync<T>(cancellationToken, sql.SQL, sql.Arguments);
 
+        /// <inheritdoc/>
+        public async Task<T> FirstOrDefaultAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
+            => (await FetchAsync<T>(cancellationToken, sql, args).ConfigureAwait(false)).FirstOrDefault();
 #endif
 
-        private Sql GenerateSingleByKeySql<T>(object primaryKey)
-        {
-            string pkName = _provider.EscapeSqlIdentifier(PocoData.ForType(typeof(T), _defaultMapper).TableInfo.PrimaryKey);
-            var sql = $"WHERE {pkName} = @0";
-
-            if (!EnableAutoSelect)
-                // We're going to be nice and add the SELECT anyway
-                sql = AutoSelectHelper.AddSelectClause<T>(_provider, sql, _defaultMapper);
+        #endregion
 
-            return new Sql(sql, primaryKey);
-        }
+        #region Insert, InsertAsync
 
-#endregion
+        /// <inheritdoc/>
+        /// <exception cref="ArgumentNullException">Thrown if <paramref name="poco"/> is null.</exception>
+        public object Insert(object poco)
+        {
+            if (poco == null)
+                throw new ArgumentNullException(nameof(poco));
 
-#region operation: Insert
+            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
+            return ExecuteInsert(pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, pd.TableInfo.AutoIncrement, poco);
+        }
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="tableName"/> or <paramref name="poco"/> is null or empty.</exception>
         public object Insert(string tableName, object poco)
         {
             if (string.IsNullOrEmpty(tableName))
@@ -1837,7 +1851,7 @@ public object Insert(string tableName, object poco)
             return ExecuteInsert(tableName, pd == null ? null : pd.TableInfo.PrimaryKey, pd != null && pd.TableInfo.AutoIncrement, poco);
         }
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public object Insert(string tableName, string primaryKeyName, object poco)
         {
             if (string.IsNullOrEmpty(tableName))
@@ -1857,7 +1871,7 @@ public object Insert(string tableName, string primaryKeyName, object poco)
             return ExecuteInsert(tableName, primaryKeyName, autoIncrement, poco);
         }
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public object Insert(string tableName, string primaryKeyName, bool autoIncrement, object poco)
         {
             if (string.IsNullOrEmpty(tableName))
@@ -1872,67 +1886,70 @@ public object Insert(string tableName, string primaryKeyName, bool autoIncrement
             return ExecuteInsert(tableName, primaryKeyName, autoIncrement, poco);
         }
 
-        /// <inheritdoc />
-        /// <exception cref="ArgumentNullException">thrown if <paramref name="poco"/> is <see langword="null"/>.</exception>
-        public object Insert(object poco)
-        {
-            if (poco == null)
-                throw new ArgumentNullException(nameof(poco));
+#if ASYNC
+        public Task<object> InsertAsync(object poco)
+            => InsertAsync(CancellationToken.None, poco);
+
+        public Task<object> InsertAsync(string tableName, object poco)
+            => InsertAsync(CancellationToken.None, tableName, poco);
+
+        public Task<object> InsertAsync(string tableName, string primaryKeyName, object poco)
+            => InsertAsync(CancellationToken.None, tableName, primaryKeyName, poco);
+
+        public Task<object> InsertAsync(string tableName, string primaryKeyName, bool autoIncrement, object poco)
+            => InsertAsync(CancellationToken.None, tableName, primaryKeyName, autoIncrement, poco);
+
+        public Task<object> InsertAsync(CancellationToken cancellationToken, object poco)
+        {
+            if (poco == null)
+                throw new ArgumentNullException(nameof(poco));
 
             var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
-            return ExecuteInsert(pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, pd.TableInfo.AutoIncrement, poco);
+            return ExecuteInsertAsync(cancellationToken, pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, pd.TableInfo.AutoIncrement, poco);
         }
 
-        private object ExecuteInsert(string tableName, string primaryKeyName, bool autoIncrement, object poco)
+        public Task<object> InsertAsync(CancellationToken cancellationToken, string tableName, object poco)
         {
-            try
-            {
-                OpenSharedConnection();
-                try
-                {
-                    using (var cmd = CreateCommand(_sharedConnection, string.Empty))
-                    {
-                        var pd = PocoData.ForObject(poco, primaryKeyName, _defaultMapper);
-                        var names = new List<string>();
-                        var values = new List<string>();
+            if (tableName == null)
+                throw new ArgumentNullException(nameof(tableName));
+            if (poco == null)
+                throw new ArgumentNullException(nameof(poco));
 
-                        PrepareExecuteInsert(tableName, primaryKeyName, autoIncrement, poco, pd, names, values, cmd);
+            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
+            return ExecuteInsertAsync(cancellationToken, tableName, pd?.TableInfo.PrimaryKey, pd != null && pd.TableInfo.AutoIncrement, poco);
+        }
 
-                        if (!autoIncrement)
-                        {
-                            ExecuteNonQueryHelper(cmd);
+        public Task<object> InsertAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco)
+        {
+            if (tableName == null)
+                throw new ArgumentNullException(nameof(tableName));
+            if (primaryKeyName == null)
+                throw new ArgumentNullException(nameof(primaryKeyName));
+            if (poco == null)
+                throw new ArgumentNullException(nameof(poco));
 
-                            if (primaryKeyName != null && pd.Columns.TryGetValue(primaryKeyName, out var pkColumn))
-                                return pkColumn.GetValue(poco);
-                            else
-                                return null;
-                        }
+            var t = poco.GetType();
+            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
+            var autoIncrement = pd == null || pd.TableInfo.AutoIncrement || t.Name.Contains("AnonymousType") &&
+                                !t.GetProperties().Any(p => p.Name.Equals(primaryKeyName, StringComparison.OrdinalIgnoreCase));
 
-                        var id = _provider.ExecuteInsert(this, cmd, primaryKeyName);
+            return ExecuteInsertAsync(cancellationToken, tableName, primaryKeyName, autoIncrement, poco);
+        }
 
-                        // Assign the ID back to the primary key property
-                        if (primaryKeyName != null && !poco.GetType().Name.Contains("AnonymousType"))
-                            if (pd.Columns.TryGetValue(primaryKeyName, out var pc))
-                                pc.SetValue(poco, pc.ChangeType(id));
+        public Task<object> InsertAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, bool autoIncrement, object poco)
+        {
+            if (tableName == null)
+                throw new ArgumentNullException(nameof(tableName));
+            if (primaryKeyName == null)
+                throw new ArgumentNullException(nameof(primaryKeyName));
+            if (poco == null)
+                throw new ArgumentNullException(nameof(poco));
 
-                        return id;
-                    }
-                }
-                finally
-                {
-                    CloseSharedConnection();
-                }
-            }
-            catch (Exception x)
-            {
-                if (OnException(x))
-                    throw;
-                return null;
-            }
+            return ExecuteInsertAsync(cancellationToken, tableName, primaryKeyName, autoIncrement, poco);
         }
+#endif
 
-        private void PrepareExecuteInsert(string tableName, string primaryKeyName, bool autoIncrement, object poco, PocoData pd, List<string> names,
-                                          List<string> values, IDbCommand cmd)
+        private void PrepareExecuteInsert(string tableName, string primaryKeyName, bool autoIncrement, object poco, PocoData pd, List<string> names, List<string> values, IDbCommand cmd)
         {
             var index = 0;
             foreach (var i in pd.Columns)
@@ -1968,71 +1985,56 @@ private void PrepareExecuteInsert(string tableName, string primaryKeyName, bool
                 $"INSERT INTO {_provider.EscapeTableName(tableName)} ({string.Join(",", names.ToArray())}){outputClause} VALUES ({string.Join(",", values.ToArray())})";
         }
 
-#if ASYNC
-
-        public Task<object> InsertAsync(string tableName, object poco)
-            => InsertAsync(CancellationToken.None, tableName, poco);
-
-        public Task<object> InsertAsync(CancellationToken cancellationToken, string tableName, object poco)
-        {
-            if (tableName == null)
-                throw new ArgumentNullException(nameof(tableName));
-            if (poco == null)
-                throw new ArgumentNullException(nameof(poco));
-
-            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
-            return ExecuteInsertAsync(cancellationToken, tableName, pd?.TableInfo.PrimaryKey, pd != null && pd.TableInfo.AutoIncrement, poco);
-        }
-
-        public Task<object> InsertAsync(string tableName, string primaryKeyName, object poco)
-            => InsertAsync(CancellationToken.None, tableName, primaryKeyName, poco);
-
-        public Task<object> InsertAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco)
+        private object ExecuteInsert(string tableName, string primaryKeyName, bool autoIncrement, object poco)
         {
-            if (tableName == null)
-                throw new ArgumentNullException(nameof(tableName));
-            if (primaryKeyName == null)
-                throw new ArgumentNullException(nameof(primaryKeyName));
-            if (poco == null)
-                throw new ArgumentNullException(nameof(poco));
-
-            var t = poco.GetType();
-            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
-            var autoIncrement = pd == null || pd.TableInfo.AutoIncrement || t.Name.Contains("AnonymousType") &&
-                                !t.GetProperties().Any(p => p.Name.Equals(primaryKeyName, StringComparison.OrdinalIgnoreCase));
-
-            return ExecuteInsertAsync(cancellationToken, tableName, primaryKeyName, autoIncrement, poco);
-        }
+            try
+            {
+                OpenSharedConnection();
+                try
+                {
+                    using (var cmd = CreateCommand(_sharedConnection, string.Empty))
+                    {
+                        var pd = PocoData.ForObject(poco, primaryKeyName, _defaultMapper);
+                        var names = new List<string>();
+                        var values = new List<string>();
 
-        public Task<object> InsertAsync(string tableName, string primaryKeyName, bool autoIncrement, object poco)
-            => InsertAsync(CancellationToken.None, tableName, primaryKeyName, autoIncrement, poco);
+                        PrepareExecuteInsert(tableName, primaryKeyName, autoIncrement, poco, pd, names, values, cmd);
 
-        public Task<object> InsertAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, bool autoIncrement, object poco)
-        {
-            if (tableName == null)
-                throw new ArgumentNullException(nameof(tableName));
-            if (primaryKeyName == null)
-                throw new ArgumentNullException(nameof(primaryKeyName));
-            if (poco == null)
-                throw new ArgumentNullException(nameof(poco));
+                        if (!autoIncrement)
+                        {
+                            ExecuteNonQueryHelper(cmd);
 
-            return ExecuteInsertAsync(cancellationToken, tableName, primaryKeyName, autoIncrement, poco);
-        }
+                            if (primaryKeyName != null && pd.Columns.TryGetValue(primaryKeyName, out var pkColumn))
+                                return pkColumn.GetValue(poco);
+                            else
+                                return null;
+                        }
 
-        public Task<object> InsertAsync(object poco)
-            => InsertAsync(CancellationToken.None, poco);
+                        var id = _provider.ExecuteInsert(this, cmd, primaryKeyName);
 
-        public Task<object> InsertAsync(CancellationToken cancellationToken, object poco)
-        {
-            if (poco == null)
-                throw new ArgumentNullException(nameof(poco));
+                        // Assign the ID back to the primary key property
+                        if (primaryKeyName != null && !poco.GetType().Name.Contains("AnonymousType"))
+                            if (pd.Columns.TryGetValue(primaryKeyName, out var pc))
+                                pc.SetValue(poco, pc.ChangeType(id));
 
-            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
-            return ExecuteInsertAsync(cancellationToken, pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, pd.TableInfo.AutoIncrement, poco);
+                        return id;
+                    }
+                }
+                finally
+                {
+                    CloseSharedConnection();
+                }
+            }
+            catch (Exception x)
+            {
+                if (OnException(x))
+                    throw;
+                return null;
+            }
         }
 
-        private async Task<object> ExecuteInsertAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, bool autoIncrement,
-                                                      object poco)
+#if ASYNC
+        private async Task<object> ExecuteInsertAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, bool autoIncrement, object poco)
         {
             try
             {
@@ -2079,113 +2081,204 @@ private async Task<object> ExecuteInsertAsync(CancellationToken cancellationToke
                 return null;
             }
         }
-
 #endif
 
-#endregion
+        #endregion
 
-#region operation: Update
+        #region Update, UpdateAsync
 
-        /// <inheritdoc />
-        public int Update(string tableName, string primaryKeyName, object poco, object primaryKeyValue)
-            => Update(tableName, primaryKeyName, poco, primaryKeyValue, null);
+        /// <inheritdoc/>
+        public int Update(object poco)
+            => Update(poco, null, null);
 
-        /// <inheritdoc />
-        public int Update(string tableName, string primaryKeyName, object poco, object primaryKeyValue, IEnumerable<string> columns)
-        {
-            if (string.IsNullOrEmpty(tableName))
-                throw new ArgumentNullException(nameof(tableName));
+        /// <inheritdoc/>
+        public int Update(object poco, IEnumerable<string> columns)
+            => Update(poco, null, columns);
 
-            if (string.IsNullOrEmpty(primaryKeyName))
-                throw new ArgumentNullException(nameof(primaryKeyName));
+        /// <inheritdoc/>
+        public int Update(object poco, object primaryKeyValue)
+            => Update(poco, primaryKeyValue, null);
 
+        /// <inheritdoc/>
+        public int Update(object poco, object primaryKeyValue, IEnumerable<string> columns)
+        {
             if (poco == null)
                 throw new ArgumentNullException(nameof(poco));
 
             if (columns?.Any() == false)
                 return 0;
 
-            return ExecuteUpdate(tableName, primaryKeyName, poco, primaryKeyValue, columns);
+            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
+            return ExecuteUpdate(pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, poco, primaryKeyValue, columns);
         }
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public int Update(string tableName, string primaryKeyName, object poco)
-            => Update(tableName, primaryKeyName, poco, null, null);
+            => Update(tableName, primaryKeyName, poco, null);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public int Update(string tableName, string primaryKeyName, object poco, IEnumerable<string> columns)
             => Update(tableName, primaryKeyName, poco, null, columns);
 
-        /// <inheritdoc />
-        public int Update(object poco, IEnumerable<string> columns)
-            => Update(poco, null, columns);
+        /// <inheritdoc cref="Update(string, string, object, object, IEnumerable{string})"/>
+        public int Update(string tableName, string primaryKeyName, object poco, object primaryKeyValue)
+            => Update(tableName, primaryKeyName, poco, primaryKeyValue, null);
 
-        /// <inheritdoc />
-        public int Update(object poco)
-            => Update(poco, null, null);
+        /// <inheritdoc/>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="tableName"/>, <paramref name="primaryKeyName"/>, or <paramref name="poco"/> is null or empty.</exception>
+        public int Update(string tableName, string primaryKeyName, object poco, object primaryKeyValue, IEnumerable<string> columns)
+        {
+            if (string.IsNullOrEmpty(tableName))
+                throw new ArgumentNullException(nameof(tableName));
 
-        /// <inheritdoc />
-        public int Update(object poco, object primaryKeyValue)
-            => Update(poco, primaryKeyValue, null);
+            if (string.IsNullOrEmpty(primaryKeyName))
+                throw new ArgumentNullException(nameof(primaryKeyName));
 
-        /// <inheritdoc />
-        public int Update(object poco, object primaryKeyValue, IEnumerable<string> columns)
-        {
             if (poco == null)
                 throw new ArgumentNullException(nameof(poco));
 
             if (columns?.Any() == false)
                 return 0;
 
-            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
-            return ExecuteUpdate(pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, poco, primaryKeyValue, columns);
+            return ExecuteUpdate(tableName, primaryKeyName, poco, primaryKeyValue, columns);
         }
 
-        /// <inheritdoc />
-        public int Update<T>(string sql, params object[] args)
+        /// <inheritdoc/>
+        public int Update<T>(Sql sql)
         {
-            if (string.IsNullOrEmpty(sql))
+            if (sql == null)
                 throw new ArgumentNullException(nameof(sql));
 
             var pd = PocoData.ForType(typeof(T), _defaultMapper);
-            return Execute($"UPDATE {_provider.EscapeTableName(pd.TableInfo.TableName)} {sql}", args);
+            return Execute(new Sql($"UPDATE {_provider.EscapeTableName(pd.TableInfo.TableName)}").Append(sql));
         }
 
-        /// <inheritdoc />
-        public int Update<T>(Sql sql)
+        /// <inheritdoc/>
+        public int Update<T>(string sql, params object[] args)
         {
-            if (sql == null)
+            if (string.IsNullOrEmpty(sql))
                 throw new ArgumentNullException(nameof(sql));
 
             var pd = PocoData.ForType(typeof(T), _defaultMapper);
-            return Execute(new Sql($"UPDATE {_provider.EscapeTableName(pd.TableInfo.TableName)}").Append(sql));
+            return Execute($"UPDATE {_provider.EscapeTableName(pd.TableInfo.TableName)} {sql}", args);
         }
 
-        private int ExecuteUpdate(string tableName, string primaryKeyName, object poco, object primaryKeyValue, IEnumerable<string> columns)
-        {
-            try
-            {
-                OpenSharedConnection();
-                try
-                {
-                    using (var cmd = CreateCommand(_sharedConnection, string.Empty))
-                    {
-                        PreExecuteUpdate(tableName, primaryKeyName, poco, primaryKeyValue, columns, cmd);
-                        return ExecuteNonQueryHelper(cmd);
-                    }
-                }
-                finally
-                {
-                    CloseSharedConnection();
-                }
-            }
-            catch (Exception x)
-            {
-                if (OnException(x))
-                    throw;
-                return -1;
-            }
+#if ASYNC
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(object poco)
+            => UpdateAsync(CancellationToken.None, poco);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(object poco, IEnumerable<string> columns)
+            => UpdateAsync(CancellationToken.None, poco, columns);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(object poco, object primaryKeyValue)
+            => UpdateAsync(CancellationToken.None, poco, primaryKeyValue);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(object poco, object primaryKeyValue, IEnumerable<string> columns)
+            => UpdateAsync(CancellationToken.None, poco, primaryKeyValue, columns);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(string tableName, string primaryKeyName, object poco)
+            => UpdateAsync(CancellationToken.None, tableName, primaryKeyName, poco);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(string tableName, string primaryKeyName, object poco, IEnumerable<string> columns)
+            => UpdateAsync(CancellationToken.None, tableName, primaryKeyName, poco, columns);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(string tableName, string primaryKeyName, object poco, object primaryKeyValue)
+            => UpdateAsync(CancellationToken.None, tableName, primaryKeyName, poco, primaryKeyValue);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(string tableName, string primaryKeyName, object poco, object primaryKeyValue, IEnumerable<string> columns)
+            => UpdateAsync(CancellationToken.None, tableName, primaryKeyName, poco, primaryKeyValue, columns);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync<T>(Sql sql)
+            => UpdateAsync<T>(CancellationToken.None, sql);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync<T>(string sql, params object[] args)
+            => UpdateAsync<T>(CancellationToken.None, sql, args);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(CancellationToken cancellationToken, object poco)
+            => UpdateAsync(cancellationToken, poco, null, null);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(CancellationToken cancellationToken, object poco, IEnumerable<string> columns)
+            => UpdateAsync(cancellationToken, poco, null, columns);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(CancellationToken cancellationToken, object poco, object primaryKeyValue)
+            => UpdateAsync(cancellationToken, poco, primaryKeyValue, null);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(CancellationToken cancellationToken, object poco, object primaryKeyValue, IEnumerable<string> columns)
+        {
+            if (poco == null)
+                throw new ArgumentNullException(nameof(poco));
+
+            if (columns?.Any() == false)
+                return Task.FromResult(0);
+
+            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
+            return ExecuteUpdateAsync(cancellationToken, pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, poco, primaryKeyValue, columns);
+        }
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco)
+            => UpdateAsync(cancellationToken, tableName, primaryKeyName, poco, null);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, IEnumerable<string> columns)
+            => UpdateAsync(cancellationToken, tableName, primaryKeyName, poco, null, columns);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, object primaryKeyValue)
+            => UpdateAsync(cancellationToken, tableName, primaryKeyName, poco, primaryKeyValue, null);
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, object primaryKeyValue, IEnumerable<string> columns)
+        {
+            if (string.IsNullOrEmpty(tableName))
+                throw new ArgumentNullException(nameof(tableName));
+
+            if (string.IsNullOrEmpty(primaryKeyName))
+                throw new ArgumentNullException(nameof(primaryKeyName));
+
+            if (poco == null)
+                throw new ArgumentNullException(nameof(poco));
+
+            if (columns?.Any() == false)
+                return Task.FromResult(0);
+
+            return ExecuteUpdateAsync(cancellationToken, tableName, primaryKeyName, poco, primaryKeyValue, columns);
+        }
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync<T>(CancellationToken cancellationToken, Sql sql)
+        {
+            if (sql == null)
+                throw new ArgumentNullException(nameof(sql));
+
+            var pd = PocoData.ForType(typeof(T), _defaultMapper);
+            return ExecuteAsync(cancellationToken, new Sql($"UPDATE {_provider.EscapeTableName(pd.TableInfo.TableName)}").Append(sql));
+        }
+
+        /// <inheritdoc/>
+        public Task<int> UpdateAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
+        {
+            if (string.IsNullOrEmpty(sql))
+                throw new ArgumentNullException(nameof(sql));
+
+            var pd = PocoData.ForType(typeof(T), _defaultMapper);
+            return ExecuteAsync(cancellationToken, $"UPDATE {_provider.EscapeTableName(pd.TableInfo.TableName)} {sql}", args);
         }
+#endif
 
         private void PreExecuteUpdate(string tableName, string primaryKeyName, object poco, object primaryKeyValue, IEnumerable<string> columns, IDbCommand cmd)
         {
@@ -2256,126 +2349,34 @@ private void PreExecuteUpdate(string tableName, string primaryKeyName, object po
             AddParam(cmd, primaryKeyValue, col);
         }
 
-#if ASYNC
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(string tableName, string primaryKeyName, object poco, object primaryKeyValue)
-            => UpdateAsync(CancellationToken.None, tableName, primaryKeyName, poco, primaryKeyValue);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, object primaryKeyValue)
-            => UpdateAsync(cancellationToken, tableName, primaryKeyName, poco, primaryKeyValue, null);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(string tableName, string primaryKeyName, object poco, object primaryKeyValue, IEnumerable<string> columns)
-            => UpdateAsync(CancellationToken.None, tableName, primaryKeyName, poco, primaryKeyValue, columns);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, object primaryKeyValue,
-                                     IEnumerable<string> columns)
-        {
-            if (string.IsNullOrEmpty(tableName))
-                throw new ArgumentNullException(nameof(tableName));
-
-            if (string.IsNullOrEmpty(primaryKeyName))
-                throw new ArgumentNullException(nameof(primaryKeyName));
-
-            if (poco == null)
-                throw new ArgumentNullException(nameof(poco));
-
-            if (columns?.Any() == false)
-                return Task.FromResult(0);
-
-            return ExecuteUpdateAsync(cancellationToken, tableName, primaryKeyName, poco, primaryKeyValue, columns);
-        }
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(string tableName, string primaryKeyName, object poco)
-            => UpdateAsync(CancellationToken.None, tableName, primaryKeyName, poco);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco)
-            => UpdateAsync(cancellationToken, tableName, primaryKeyName, poco, null);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(string tableName, string primaryKeyName, object poco, IEnumerable<string> columns)
-            => UpdateAsync(CancellationToken.None, tableName, primaryKeyName, poco, columns);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, IEnumerable<string> columns)
-            => UpdateAsync(cancellationToken, tableName, primaryKeyName, poco, null, columns);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(object poco, IEnumerable<string> columns)
-            => UpdateAsync(CancellationToken.None, poco, columns);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(CancellationToken cancellationToken, object poco, IEnumerable<string> columns)
-            => UpdateAsync(cancellationToken, poco, null, columns);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(object poco)
-            => UpdateAsync(CancellationToken.None, poco);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(CancellationToken cancellationToken, object poco)
-            => UpdateAsync(cancellationToken, poco, null, null);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(object poco, object primaryKeyValue)
-            => UpdateAsync(CancellationToken.None, poco, primaryKeyValue);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(CancellationToken cancellationToken, object poco, object primaryKeyValue)
-            => UpdateAsync(cancellationToken, poco, primaryKeyValue, null);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(object poco, object primaryKeyValue, IEnumerable<string> columns)
-            => UpdateAsync(CancellationToken.None, poco, primaryKeyValue, columns);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync(CancellationToken cancellationToken, object poco, object primaryKeyValue, IEnumerable<string> columns)
-        {
-            if (poco == null)
-                throw new ArgumentNullException(nameof(poco));
-
-            if (columns?.Any() == false)
-                return Task.FromResult(0);
-
-            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
-            return ExecuteUpdateAsync(cancellationToken, pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, poco, primaryKeyValue, columns);
-        }
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync<T>(string sql, params object[] args)
-            => UpdateAsync<T>(CancellationToken.None, sql, args);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
-        {
-            if (string.IsNullOrEmpty(sql))
-                throw new ArgumentNullException(nameof(sql));
-
-            var pd = PocoData.ForType(typeof(T), _defaultMapper);
-            return ExecuteAsync(cancellationToken, $"UPDATE {_provider.EscapeTableName(pd.TableInfo.TableName)} {sql}", args);
-        }
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync<T>(Sql sql)
-            => UpdateAsync<T>(CancellationToken.None, sql);
-
-        /// <inheritdoc />
-        public Task<int> UpdateAsync<T>(CancellationToken cancellationToken, Sql sql)
+        private int ExecuteUpdate(string tableName, string primaryKeyName, object poco, object primaryKeyValue, IEnumerable<string> columns)
         {
-            if (sql == null)
-                throw new ArgumentNullException(nameof(sql));
-
-            var pd = PocoData.ForType(typeof(T), _defaultMapper);
-            return ExecuteAsync(cancellationToken, new Sql($"UPDATE {_provider.EscapeTableName(pd.TableInfo.TableName)}").Append(sql));
+            try
+            {
+                OpenSharedConnection();
+                try
+                {
+                    using (var cmd = CreateCommand(_sharedConnection, string.Empty))
+                    {
+                        PreExecuteUpdate(tableName, primaryKeyName, poco, primaryKeyValue, columns, cmd);
+                        return ExecuteNonQueryHelper(cmd);
+                    }
+                }
+                finally
+                {
+                    CloseSharedConnection();
+                }
+            }
+            catch (Exception x)
+            {
+                if (OnException(x))
+                    throw;
+                return -1;
+            }
         }
 
-        private async Task<int> ExecuteUpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco,
-                                                   object primaryKeyValue, IEnumerable<string> columns)
+#if ASYNC
+        private async Task<int> ExecuteUpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, object primaryKeyValue, IEnumerable<string> columns)
         {
             try
             {
@@ -2400,18 +2401,24 @@ private async Task<int> ExecuteUpdateAsync(CancellationToken cancellationToken,
                 return -1;
             }
         }
-
 #endif
 
-#endregion
+        #endregion
 
-#region operation: Delete
+        #region Delete, DeleteAsync
+
+        /// <inheritdoc/>
+        public int Delete(object poco)
+        {
+            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
+            return Delete(pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, poco);
+        }
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public int Delete(string tableName, string primaryKeyName, object poco)
             => Delete(tableName, primaryKeyName, poco, null);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public int Delete(string tableName, string primaryKeyName, object poco, object primaryKeyValue)
         {
             if (primaryKeyValue == null)
@@ -2425,15 +2432,8 @@ public int Delete(string tableName, string primaryKeyName, object poco, object p
             return Execute(sql, primaryKeyValue);
         }
 
-        /// <inheritdoc />
-        public int Delete(object poco)
-        {
-            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
-            return Delete(pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, poco);
-        }
-
-        /// <inheritdoc />
-        public int Delete<T>(object pocoOrPrimaryKey)
+        /// <inheritdoc/>
+        public int Delete<T>(object pocoOrPrimaryKey)
         {
             if (pocoOrPrimaryKey.GetType() == typeof(T))
                 return Delete(pocoOrPrimaryKey);
@@ -2453,35 +2453,57 @@ public int Delete<T>(object pocoOrPrimaryKey)
             return Delete(pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, null, pocoOrPrimaryKey);
         }
 
-        /// <inheritdoc />
-        public int Delete<T>(string sql, params object[] args)
+        /// <inheritdoc/>
+        public int Delete<T>(Sql sql)
         {
             var pd = PocoData.ForType(typeof(T), _defaultMapper);
-            return Execute($"DELETE FROM {_provider.EscapeTableName(pd.TableInfo.TableName)} {sql}", args);
+            return Execute(new Sql($"DELETE FROM {_provider.EscapeTableName(pd.TableInfo.TableName)}").Append(sql));
         }
 
-        /// <inheritdoc />
-        public int Delete<T>(Sql sql)
+        /// <inheritdoc/>
+        public int Delete<T>(string sql, params object[] args)
         {
             var pd = PocoData.ForType(typeof(T), _defaultMapper);
-            return Execute(new Sql($"DELETE FROM {_provider.EscapeTableName(pd.TableInfo.TableName)}").Append(sql));
+            return Execute($"DELETE FROM {_provider.EscapeTableName(pd.TableInfo.TableName)} {sql}", args);
         }
 
 #if ASYNC
+        /// <inheritdoc/>
+        public Task<int> DeleteAsync(object poco)
+            => DeleteAsync(CancellationToken.None, poco);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public Task<int> DeleteAsync(string tableName, string primaryKeyName, object poco)
             => DeleteAsync(CancellationToken.None, tableName, primaryKeyName, poco);
 
-        /// <inheritdoc />
-        public Task<int> DeleteAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco)
-            => DeleteAsync(cancellationToken, tableName, primaryKeyName, poco, null);
-
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public Task<int> DeleteAsync(string tableName, string primaryKeyName, object poco, object primaryKeyValue)
             => DeleteAsync(CancellationToken.None, tableName, primaryKeyName, poco, primaryKeyValue);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
+        public Task<int> DeleteAsync<T>(object pocoOrPrimaryKey)
+            => DeleteAsync<T>(CancellationToken.None, pocoOrPrimaryKey);
+
+        /// <inheritdoc/>
+        public Task<int> DeleteAsync<T>(Sql sql)
+            => DeleteAsync<T>(CancellationToken.None, sql);
+
+        /// <inheritdoc/>
+        public Task<int> DeleteAsync<T>(string sql, params object[] args)
+            => DeleteAsync<T>(CancellationToken.None, sql, args);
+
+        /// <inheritdoc/>
+        public Task<int> DeleteAsync(CancellationToken cancellationToken, object poco)
+        {
+            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
+            return DeleteAsync(cancellationToken, pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, poco);
+        }
+
+        /// <inheritdoc/>
+        public Task<int> DeleteAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco)
+            => DeleteAsync(cancellationToken, tableName, primaryKeyName, poco, null);
+
+        /// <inheritdoc/>
         public Task<int> DeleteAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, object primaryKeyValue)
         {
             if (primaryKeyValue == null)
@@ -2495,22 +2517,7 @@ public Task<int> DeleteAsync(CancellationToken cancellationToken, string tableNa
             return ExecuteAsync(cancellationToken, sql, primaryKeyValue);
         }
 
-        /// <inheritdoc />
-        public Task<int> DeleteAsync(object poco)
-            => DeleteAsync(CancellationToken.None, poco);
-
-        /// <inheritdoc />
-        public Task<int> DeleteAsync(CancellationToken cancellationToken, object poco)
-        {
-            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
-            return DeleteAsync(cancellationToken, pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, poco);
-        }
-
-        /// <inheritdoc />
-        public Task<int> DeleteAsync<T>(object pocoOrPrimaryKey)
-            => DeleteAsync<T>(CancellationToken.None, pocoOrPrimaryKey);
-
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public Task<int> DeleteAsync<T>(CancellationToken cancellationToken, object pocoOrPrimaryKey)
         {
             if (pocoOrPrimaryKey.GetType() == typeof(T))
@@ -2531,59 +2538,56 @@ public Task<int> DeleteAsync<T>(CancellationToken cancellationToken, object poco
             return DeleteAsync(cancellationToken, pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, null, pocoOrPrimaryKey);
         }
 
-        /// <inheritdoc />
-        public Task<int> DeleteAsync<T>(string sql, params object[] args)
-            => DeleteAsync<T>(CancellationToken.None, sql, args);
-
-        /// <inheritdoc />
-        public Task<int> DeleteAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
+        /// <inheritdoc/>
+        public Task<int> DeleteAsync<T>(CancellationToken cancellationToken, Sql sql)
         {
             var pd = PocoData.ForType(typeof(T), _defaultMapper);
-            return ExecuteAsync(cancellationToken, $"DELETE FROM {_provider.EscapeTableName(pd.TableInfo.TableName)} {sql}", args);
+            return ExecuteAsync(cancellationToken, new Sql($"DELETE FROM {_provider.EscapeTableName(pd.TableInfo.TableName)}").Append(sql));
         }
 
-        /// <inheritdoc />
-        public Task<int> DeleteAsync<T>(Sql sql)
-            => DeleteAsync<T>(CancellationToken.None, sql);
-
-        /// <inheritdoc />
-        public Task<int> DeleteAsync<T>(CancellationToken cancellationToken, Sql sql)
+        /// <inheritdoc/>
+        public Task<int> DeleteAsync<T>(CancellationToken cancellationToken, string sql, params object[] args)
         {
             var pd = PocoData.ForType(typeof(T), _defaultMapper);
-            return ExecuteAsync(cancellationToken, new Sql($"DELETE FROM {_provider.EscapeTableName(pd.TableInfo.TableName)}").Append(sql));
+            return ExecuteAsync(cancellationToken, $"DELETE FROM {_provider.EscapeTableName(pd.TableInfo.TableName)} {sql}", args);
         }
-
 #endif
 
-#endregion
+        #endregion
 
-#region operation: IsNew
+        #region IsNew
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="poco"/> is null.</exception>
-        /// <exception cref="ArgumentException">Thrown if <paramref name="primaryKeyName"/> is null or empty.</exception>
-        public bool IsNew(string primaryKeyName, object poco)
+        public bool IsNew(object poco)
         {
             if (poco == null)
                 throw new ArgumentNullException(nameof(poco));
 
-            if (string.IsNullOrEmpty(primaryKeyName))
-                throw new ArgumentException("primaryKeyName");
-
-            return IsNew(primaryKeyName, PocoData.ForObject(poco, primaryKeyName, _defaultMapper), poco);
+            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
+            return IsNew(pd.TableInfo.PrimaryKey, pd, poco);
         }
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="poco"/> is null.</exception>
-        public bool IsNew(object poco)
+        /// <exception cref="ArgumentException">Thrown if <paramref name="primaryKeyName"/> is null or empty.</exception>
+        public bool IsNew(string primaryKeyName, object poco)
         {
             if (poco == null)
                 throw new ArgumentNullException(nameof(poco));
 
-            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
-            return IsNew(pd.TableInfo.PrimaryKey, pd, poco);
+            if (string.IsNullOrEmpty(primaryKeyName))
+                throw new ArgumentException("primaryKeyName");
+
+            return IsNew(primaryKeyName, PocoData.ForObject(poco, primaryKeyName, _defaultMapper), poco);
         }
 
+        /// <inheritdoc cref="IAlterPoco.IsNew(string, object)" />
+        /// <param name="primaryKeyName">The name of the primary key column.</param>
+        /// <param name="pd">A PocoData object for the object instance.</param>
+        /// <param name="poco">The object instance whose "newness" is to be tested.</param>
+        /// <exception cref="InvalidOperationException">Thrown when the table represented by the given <paramref name="poco"/> has no auto-incrementing primary key column.</exception>
+        /// <exception cref="ArgumentException">Thrown when the <paramref name="poco"/> doesn't have a property matching the primary key column name.</exception>
         protected virtual bool IsNew(string primaryKeyName, PocoData pd, object poco)
         {
             if (string.IsNullOrEmpty(primaryKeyName) || poco is ExpandoObject)
@@ -2634,11 +2638,18 @@ protected virtual bool IsNew(string primaryKeyName, PocoData pd, object poco)
             return pk == Activator.CreateInstance(pk.GetType());
         }
 
-#endregion
+        #endregion
 
-#region operation: Save
+        #region Save, SaveAsync
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
+        public void Save(object poco)
+        {
+            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
+            Save(pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, poco);
+        }
+
+        /// <inheritdoc/>
         public void Save(string tableName, string primaryKeyName, object poco)
         {
             if (IsNew(primaryKeyName, poco))
@@ -2647,20 +2658,23 @@ public void Save(string tableName, string primaryKeyName, object poco)
                 Update(tableName, primaryKeyName, poco);
         }
 
-        /// <inheritdoc />
-        public void Save(object poco)
-        {
-            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
-            Save(pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, poco);
-        }
-
 #if ASYNC
+        /// <inheritdoc/>
+        public Task SaveAsync(object poco)
+            => SaveAsync(CancellationToken.None, poco);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
         public Task SaveAsync(string tableName, string primaryKeyName, object poco)
             => SaveAsync(CancellationToken.None, tableName, primaryKeyName, poco);
 
-        /// <inheritdoc />
+        /// <inheritdoc/>
+        public Task SaveAsync(CancellationToken cancellationToken, object poco)
+        {
+            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
+            return SaveAsync(cancellationToken, pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, poco);
+        }
+
+        /// <inheritdoc/>
         public Task SaveAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco)
         {
             if (IsNew(primaryKeyName, poco))
@@ -2668,312 +2682,385 @@ public Task SaveAsync(CancellationToken cancellationToken, string tableName, str
 
             return UpdateAsync(cancellationToken, tableName, primaryKeyName, poco);
         }
-
-        /// <inheritdoc />
-        public Task SaveAsync(object poco)
-            => SaveAsync(CancellationToken.None, poco);
-
-        /// <inheritdoc />
-        public Task SaveAsync(CancellationToken cancellationToken, object poco)
-        {
-            var pd = PocoData.ForType(poco.GetType(), _defaultMapper);
-            return SaveAsync(cancellationToken, pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, poco);
-        }
-
 #endif
 
-#endregion
+        #endregion
 
-#region operation: Multi-Poco Query/Fetch
+        #region StoredProcedures, StoredProceduresAsync
 
-        /// <inheritdoc />
-        public List<TRet> Fetch<T1, T2, TRet>(Func<T1, T2, TRet> cb, string sql, params object[] args)
-            => Query(cb, sql, args).ToList();
+        /// <inheritdoc/>
+        public int ExecuteNonQueryProc(string storedProcedureName, params object[] args)
+            => ExecuteInternal(CommandType.StoredProcedure, storedProcedureName, args);
 
-        /// <inheritdoc />
-        public List<TRet> Fetch<T1, T2, T3, TRet>(Func<T1, T2, T3, TRet> cb, string sql, params object[] args)
-            => Query(cb, sql, args).ToList();
+        /// <inheritdoc/>
+        public T ExecuteScalarProc<T>(string storedProcedureName, params object[] args)
+            => ExecuteScalarInternal<T>(CommandType.StoredProcedure, storedProcedureName, args);
 
-        /// <inheritdoc />
-        public List<TRet> Fetch<T1, T2, T3, T4, TRet>(Func<T1, T2, T3, T4, TRet> cb, string sql, params object[] args)
-            => Query(cb, sql, args).ToList();
+        /// <inheritdoc/>
+        public IEnumerable<T> QueryProc<T>(string storedProcedureName, params object[] args)
+            => ExecuteReader<T>(CommandType.StoredProcedure, storedProcedureName, args);
 
-        /// <inheritdoc />
-        public List<TRet> Fetch<T1, T2, T3, T4, T5, TRet>(Func<T1, T2, T3, T4, T5, TRet> cb, string sql, params object[] args)
-            => Query(cb, sql, args).ToList();
+        /// <inheritdoc/>
+        public List<T> FetchProc<T>(string storedProcedureName, params object[] args)
+            => QueryProc<T>(storedProcedureName, args).ToList();
 
-        /// <inheritdoc />
-        public IEnumerable<TRet> Query<T1, T2, TRet>(Func<T1, T2, TRet> cb, string sql, params object[] args)
-            => Query<TRet>(new[] { typeof(T1), typeof(T2) }, cb, sql, args);
+#if ASYNC
+        /// <inheritdoc/>
+        public Task<int> ExecuteNonQueryProcAsync(string storedProcedureName, params object[] args)
+            => ExecuteNonQueryProcAsync(CancellationToken.None, storedProcedureName, args);
 
-        /// <inheritdoc />
-        public IEnumerable<TRet> Query<T1, T2, T3, TRet>(Func<T1, T2, T3, TRet> cb, string sql, params object[] args)
-            => Query<TRet>(new[] { typeof(T1), typeof(T2), typeof(T3) }, cb, sql, args);
+        /// <inheritdoc/>
+        public Task<T> ExecuteScalarProcAsync<T>(string storedProcedureName, params object[] args)
+            => ExecuteScalarProcAsync<T>(CancellationToken.None, storedProcedureName, args);
 
-        /// <inheritdoc />
-        public IEnumerable<TRet> Query<T1, T2, T3, T4, TRet>(Func<T1, T2, T3, T4, TRet> cb, string sql, params object[] args)
-            => Query<TRet>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4) }, cb, sql, args);
+        /// <inheritdoc/>
+        public Task<IAsyncReader<T>> QueryProcAsync<T>(string storedProcedureName, params object[] args)
+            => QueryProcAsync<T>(CancellationToken.None, storedProcedureName, args);
 
-        public IEnumerable<TRet> Query<T1, T2, T3, T4, T5, TRet>(Func<T1, T2, T3, T4, T5, TRet> cb, string sql, params object[] args)
-            => Query<TRet>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4), typeof(T5) }, cb, sql, args);
+        /// <inheritdoc/>
+        public Task QueryProcAsync<T>(Action<T> receivePocoCallback, string storedProcedureName, params object[] args)
+            => QueryProcAsync(receivePocoCallback, CancellationToken.None, storedProcedureName, args);
 
-        /// <inheritdoc />
-        public List<TRet> Fetch<T1, T2, TRet>(Func<T1, T2, TRet> cb, Sql sql)
-            => Query(cb, sql.SQL, sql.Arguments).ToList();
+        /// <inheritdoc/>
+        public Task<List<T>> FetchProcAsync<T>(string storedProcedureName, params object[] args)
+            => FetchProcAsync<T>(CancellationToken.None, storedProcedureName, args);
 
-        /// <inheritdoc />
-        public List<TRet> Fetch<T1, T2, T3, TRet>(Func<T1, T2, T3, TRet> cb, Sql sql)
-            => Query(cb, sql.SQL, sql.Arguments).ToList();
+        /// <inheritdoc/>
+        public Task<int> ExecuteNonQueryProcAsync(CancellationToken cancellationToken, string storedProcedureName, params object[] args)
+            => ExecuteInternalAsync(cancellationToken, CommandType.StoredProcedure, storedProcedureName, args);
 
-        /// <inheritdoc />
-        public List<TRet> Fetch<T1, T2, T3, T4, TRet>(Func<T1, T2, T3, T4, TRet> cb, Sql sql)
-            => Query(cb, sql.SQL, sql.Arguments).ToList();
+        /// <inheritdoc/>
+        public Task<T> ExecuteScalarProcAsync<T>(CancellationToken cancellationToken, string storedProcedureName, params object[] args)
+            => ExecuteScalarInternalAsync<T>(cancellationToken, CommandType.StoredProcedure, storedProcedureName, args);
 
-        public List<TRet> Fetch<T1, T2, T3, T4, T5, TRet>(Func<T1, T2, T3, T4, T5, TRet> cb, Sql sql)
-            => Query(cb, sql.SQL, sql.Arguments).ToList();
+        /// <inheritdoc/>
+        public Task<IAsyncReader<T>> QueryProcAsync<T>(CancellationToken cancellationToken, string storedProcedureName, params object[] args)
+            => ExecuteReaderAsync<T>(cancellationToken, CommandType.StoredProcedure, storedProcedureName, args);
 
-        /// <inheritdoc />
-        public IEnumerable<TRet> Query<T1, T2, TRet>(Func<T1, T2, TRet> cb, Sql sql)
-            => Query<TRet>(new[] { typeof(T1), typeof(T2) }, cb, sql.SQL, sql.Arguments);
+        /// <inheritdoc/>
+        public Task QueryProcAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, string storedProcedureName, params object[] args)
+            => ExecuteReaderAsync(receivePocoCallback, cancellationToken, CommandType.StoredProcedure, storedProcedureName, args);
 
-        /// <inheritdoc />
-        public IEnumerable<TRet> Query<T1, T2, T3, TRet>(Func<T1, T2, T3, TRet> cb, Sql sql)
-            => Query<TRet>(new[] { typeof(T1), typeof(T2), typeof(T3) }, cb, sql.SQL, sql.Arguments);
+        /// <inheritdoc/>
+        public async Task<List<T>> FetchProcAsync<T>(CancellationToken cancellationToken, string storedProcedureName, params object[] args)
+        {
+            var pocos = new List<T>();
+            await ExecuteReaderAsync<T>(p => pocos.Add(p), cancellationToken, CommandType.StoredProcedure, storedProcedureName, args);
+            return pocos;
+        }
+#endif
 
-        /// <inheritdoc />
-        public IEnumerable<TRet> Query<T1, T2, T3, T4, TRet>(Func<T1, T2, T3, T4, TRet> cb, Sql sql)
-            => Query<TRet>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4) }, cb, sql.SQL, sql.Arguments);
+        #endregion
 
-        /// <inheritdoc />
-        public IEnumerable<TRet> Query<T1, T2, T3, T4, T5, TRet>(Func<T1, T2, T3, T4, T5, TRet> cb, Sql sql)
-            => Query<TRet>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4), typeof(T5) }, cb, sql.SQL, sql.Arguments);
+        #region Command & Parameter Creation
 
-        /// <inheritdoc />
-        public List<T1> Fetch<T1, T2>(string sql, params object[] args)
-            => Query<T1, T2>(sql, args).ToList();
+        public IDbCommand CreateCommand(IDbConnection connection, string sql, params object[] args)
+            => CreateCommand(connection, CommandType.Text, sql, args);
 
-        /// <inheritdoc />
-        public List<T1> Fetch<T1, T2, T3>(string sql, params object[] args)
-            => Query<T1, T2, T3>(sql, args).ToList();
+        public IDbCommand CreateCommand(IDbConnection connection, CommandType commandType, string sql, params object[] args)
+        {
+            var cmd = connection.CreateCommand();
 
-        /// <inheritdoc />
-        public List<T1> Fetch<T1, T2, T3, T4>(string sql, params object[] args)
-            => Query<T1, T2, T3, T4>(sql, args).ToList();
+            try
+            {
+                cmd.CommandType = commandType;
+                cmd.Transaction = _transaction;
 
-        /// <inheritdoc />
-        public List<T1> Fetch<T1, T2, T3, T4, T5>(string sql, params object[] args)
-            => Query<T1, T2, T3, T4, T5>(sql, args).ToList();
+                switch (commandType)
+                {
+                    case CommandType.Text:
+                        // Perform named argument replacements
+                        if (EnableNamedParams)
+                        {
+                            var newArgs = new List<object>();
+                            sql = ParametersHelper.ProcessQueryParams(sql, args, newArgs);
+                            args = newArgs.ToArray();
+                        }
 
-        /// <inheritdoc />
-        public IEnumerable<T1> Query<T1, T2>(string sql, params object[] args)
-            => Query<T1>(new[] { typeof(T1), typeof(T2) }, null, sql, args);
+                        // Perform parameter prefix replacements
+                        if (_paramPrefix != "@")
+                            sql = sql.ReplaceParamPrefix(_paramPrefix);
+                        sql = sql.Replace("@@", "@"); // <- double @@ escapes a single @
+                        break;
+                    case CommandType.StoredProcedure:
+                        args = ParametersHelper.ProcessStoredProcParams(cmd, args, SetParameterProperties);
+                        break;
+                    case CommandType.TableDirect:
+                        break;
+                }
 
-        /// <inheritdoc />
-        public IEnumerable<T1> Query<T1, T2, T3>(string sql, params object[] args)
-            => Query<T1>(new[] { typeof(T1), typeof(T2), typeof(T3) }, null, sql, args);
+                cmd.CommandText = sql;
 
-        /// <inheritdoc />
-        public IEnumerable<T1> Query<T1, T2, T3, T4>(string sql, params object[] args)
-            => Query<T1>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4) }, null, sql, args);
+                foreach (var item in args)
+                    AddParam(cmd, item, null);
 
-        /// <inheritdoc />
-        public IEnumerable<T1> Query<T1, T2, T3, T4, T5>(string sql, params object[] args)
-            => Query<T1>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4), typeof(T5) }, null, sql, args);
+                return cmd;
+            }
+            catch
+            {
+                cmd.Dispose();
+                throw;
+            }
+        }
 
-        /// <inheritdoc />
-        public List<T1> Fetch<T1, T2>(Sql sql)
-            => Query<T1, T2>(sql.SQL, sql.Arguments).ToList();
+        /// <summary>
+        /// Creates an IDbDataParameter with default values.
+        /// </summary>
+        /// <returns>The IDbDataParameter.</returns>
+        public IDbDataParameter CreateParameter()
+            => _factory.CreateParameter();
 
-        /// <inheritdoc />
-        public List<T1> Fetch<T1, T2, T3>(Sql sql)
-            => Query<T1, T2, T3>(sql.SQL, sql.Arguments).ToList();
+        /// <summary>
+        /// Creates an IDbDataParameter with the given name and value.
+        /// </summary>
+        /// <param name="name">The parameter name.</param>
+        /// <param name="value">The parameter value.</param>
+        /// <returns>The IDbDataParameter.</returns>
+        public IDbDataParameter CreateParameter(string name, object value)
+            => CreateParameter(name, value, ParameterDirection.Input);
 
-        /// <inheritdoc />
-        public List<T1> Fetch<T1, T2, T3, T4>(Sql sql)
-            => Query<T1, T2, T3, T4>(sql.SQL, sql.Arguments).ToList();
+        /// <summary>
+        /// Creates an IDbDataParameter with the given name and direction.
+        /// </summary>
+        /// <param name="name">The parameter name.</param>
+        /// <param name="direction">The parameter direction.</param>
+        /// <returns>The IDbDataParameter.</returns>
+        public IDbDataParameter CreateParameter(string name, ParameterDirection direction)
+            => CreateParameter(name, null, direction);
 
-        /// <inheritdoc />
-        public List<T1> Fetch<T1, T2, T3, T4, T5>(Sql sql)
-            => Query<T1, T2, T3, T4, T5>(sql.SQL, sql.Arguments).ToList();
+        /// <summary>
+        /// Create an IDbParameter with the given ParameterName, Value, and Direction.
+        /// </summary>
+        /// <param name="name">The parameter name.</param>
+        /// <param name="value">The parameter value.</param>
+        /// <param name="direction">The parameter direction.</param>
+        /// <returns>The IDbDataParameter.</returns>
+        public IDbDataParameter CreateParameter(string name, object value, ParameterDirection direction)
+        {
+            var result = CreateParameter();
+            result.ParameterName = name;
+            result.Value = value;
+            result.Direction = direction;
+            return result;
+        }
 
-        /// <inheritdoc />
-        public IEnumerable<T1> Query<T1, T2>(Sql sql)
-            => Query<T1>(new[] { typeof(T1), typeof(T2) }, null, sql.SQL, sql.Arguments);
+        private void SetParameterProperties(IDbDataParameter p, object value, PocoColumn pc)
+        {
+            // Assign the parameter value
+            if (value == null)
+            {
+                p.Value = DBNull.Value;
 
-        /// <inheritdoc />
-        public IEnumerable<T1> Query<T1, T2, T3>(Sql sql)
-            => Query<T1>(new[] { typeof(T1), typeof(T2), typeof(T3) }, null, sql.SQL, sql.Arguments);
+                if (pc?.PropertyInfo.PropertyType.Name == "Byte[]")
+                    p.DbType = DbType.Binary;
+            }
+            else
+            {
+                // Give the database type first crack at converting to DB required type
+                value = _provider.MapParameterValue(value);
 
-        public IEnumerable<T1> Query<T1, T2, T3, T4>(Sql sql)
-            => Query<T1>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4) }, null, sql.SQL, sql.Arguments);
+                var t = value.GetType();
 
-        /// <inheritdoc />
-        public IEnumerable<T1> Query<T1, T2, T3, T4, T5>(Sql sql)
-            => Query<T1>(new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4), typeof(T5) }, null, sql.SQL, sql.Arguments);
+                if (t == typeof(string) && pc?.ForceToAnsiString == true)
+                {
+                    t = typeof(AnsiString);
+                    value = value.ToAnsiString();
+                }
+                if (t == typeof(DateTime) && pc?.ForceToDateTime2 == true)
+                {
+                    t = typeof(DateTime2);
+                    value = ((DateTime)value).ToDateTime2();
+                }
 
-        /// <inheritdoc />
-        public IEnumerable<TRet> Query<TRet>(Type[] types, object cb, string sql, params object[] args)
-        {
-            OpenSharedConnection();
-            try
-            {
-                using (var cmd = CreateCommand(_sharedConnection, sql, args))
+                if (t.IsEnum) // PostgreSQL .NET driver wont cast enum to int
                 {
-                    IDataReader r;
-                    try
+                    p.Value = Convert.ChangeType(value, ((Enum)value).GetTypeCode());
+                }
+                else if (t == typeof(Guid) && !_provider.HasNativeGuidSupport)
+                {
+                    p.Value = value.ToString();
+                    p.DbType = DbType.String;
+                    p.Size = 40;
+                }
+                else if (t == typeof(string))
+                {
+                    // out of memory exception occurs if trying to save more than 4000 characters to SQL Server CE NText column. Set before attempting to set Size, or Size will always max out at 4000
+                    if ((value as string).Length + 1 > 4000 && p.GetType().Name == "SqlCeParameter")
+                        p.GetType().GetProperty("SqlDbType").SetValue(p, SqlDbType.NText, null);
+
+                    p.Size = Math.Max((value as string).Length + 1, 4000); // Help query plan caching by using common size
+                    p.Value = value;
+                }
+                else if (t == typeof(AnsiString))
+                {
+                    var asValue = (value as AnsiString).Value;
+                    if (asValue == null)
                     {
-                        r = ExecuteReaderHelper(cmd);
+                        p.Size = 0;
+                        p.Value = DBNull.Value;
                     }
-                    catch (Exception x)
+                    else
                     {
-                        if (OnException(x))
-                            throw;
-                        yield break;
+                        p.Size = Math.Max(asValue.Length + 1, 4000);
+                        p.Value = asValue;
                     }
+                    // Thanks @DataChomp for pointing out the SQL Server indexing performance hit of using wrong string type on varchar
+                    p.DbType = DbType.AnsiString;
+                }
+                else if (t == typeof(DateTime2))
+                {
+                    var dt2Value = (value as DateTime2)?.Value;
+                    p.Value = dt2Value ?? (object)DBNull.Value;
+                    p.DbType = DbType.DateTime2;
+                }
+                else if (value.GetType().Name == "SqlGeography") //SqlGeography is a CLR Type
+                {
+                    p.GetType().GetProperty("UdtTypeName").SetValue(p, "geography", null); //geography is the equivalent SQL Server Type
+                    p.Value = value;
+                }
+                else if (value.GetType().Name == "SqlGeometry") //SqlGeometry is a CLR Type
+                {
+                    p.GetType().GetProperty("UdtTypeName").SetValue(p, "geometry", null); //geography is the equivalent SQL Server Type
+                    p.Value = value;
+                }
+                else if (t == typeof(byte[]))
+                {
+                    p.Value = value;
+                    p.DbType = DbType.Binary;
+                }
+                else
+                {
+                    p.Value = value;
+                }
+            }
+        }
 
-                    var factory = MultiPocoFactory.GetFactory<TRet>(types, _sharedConnection.ConnectionString, sql, r, _defaultMapper);
-                    if (cb == null)
-                        cb = MultiPocoFactory.GetAutoMapper(types.ToArray());
-                    var bNeedTerminator = false;
-                    using (r)
-                    {
-                        while (true)
-                        {
-                            TRet poco;
-                            try
-                            {
-                                if (!r.Read())
-                                    break;
-                                poco = factory(r, cb);
-                            }
-                            catch (Exception x)
-                            {
-                                if (OnException(x))
-                                    throw;
-                                yield break;
-                            }
+        /// <summary>
+        /// Adds a parameter to a DB command.
+        /// </summary>
+        /// <param name="cmd">A reference to the IDbCommand to which the parameter is to be added.</param>
+        /// <param name="value">The value to assign to the parameter.</param>
+        /// <param name="pc">Optional, a reference to the property info of the POCO property from which the value is coming.</param>
+        private void AddParam(IDbCommand cmd, object value, PocoColumn pc)
+        {
+            // Convert value to from poco type to db type
+            if (pc != null)
+            {
+                var mapper = Mappers.GetMapper(pc.PropertyInfo.DeclaringType, _defaultMapper);
+                var fn = mapper.GetToDbConverter(pc.PropertyInfo);
+                if (fn != null)
+                    value = fn(value);
+            }
 
-                            if (poco != null)
-                                yield return poco;
-                            else
-                                bNeedTerminator = true;
-                        }
+            // Support passed in parameters
+            if (value is IDbDataParameter idbParam)
+            {
+                if (cmd.CommandType == CommandType.Text)
+                    idbParam.ParameterName = cmd.Parameters.Count.EnsureParamPrefix(_paramPrefix);
+                else if (idbParam.ParameterName?.StartsWith(_paramPrefix) != true)
+                    idbParam.ParameterName = idbParam.ParameterName.EnsureParamPrefix(_paramPrefix);
 
-                        if (bNeedTerminator)
-                        {
-                            var poco = (TRet) (cb as Delegate).DynamicInvoke(new object[types.Length]);
-                            if (poco != null)
-                                yield return poco;
-                            else
-                                yield break;
-                        }
-                    }
-                }
+                cmd.Parameters.Add(idbParam);
             }
-            finally
+            else
             {
-                CloseSharedConnection();
+                var p = cmd.CreateParameter();
+                p.ParameterName = cmd.Parameters.Count.EnsureParamPrefix(_paramPrefix);
+                SetParameterProperties(p, value, pc);
+
+                cmd.Parameters.Add(p);
             }
         }
 
-#endregion
+        #endregion
 
-#region operation: Multi-Result Set
+        #region Execute Command Helpers
 
-        public IGridReader QueryMultiple(Sql sql)
-            => QueryMultiple(sql.SQL, sql.Arguments);
+        internal protected IDataReader ExecuteReaderHelper(IDbCommand cmd)
+        {
+            return (IDataReader)CommandHelper(cmd, c => c.ExecuteReader());
+        }
 
-        public IGridReader QueryMultiple(string sql, params object[] args)
+        internal protected int ExecuteNonQueryHelper(IDbCommand cmd)
         {
-            OpenSharedConnection();
+            return (int)CommandHelper(cmd, c => c.ExecuteNonQuery());
+        }
 
-            GridReader result = null;
+        internal protected object ExecuteScalarHelper(IDbCommand cmd)
+        {
+            return CommandHelper(cmd, c => c.ExecuteScalar());
+        }
 
-            var cmd = CreateCommand(_sharedConnection, sql, args);
+        private object CommandHelper(IDbCommand cmd, Func<IDbCommand, object> cmdFunc)
+        {
+            DoPreExecute(cmd);
+            var result = cmdFunc(cmd);
+            OnExecutedCommand(cmd);
+            return result;
+        }
 
-            try
+#if ASYNC
+        internal protected async Task<IDataReader> ExecuteReaderHelperAsync(CancellationToken cancellationToken, IDbCommand cmd)
+        {
+            if (cmd is DbCommand dbCommand)
             {
-                var reader = ExecuteReaderHelper(cmd);
-                result = new GridReader(this, cmd, reader, _defaultMapper);
+                var task = CommandHelper(cancellationToken, dbCommand,
+                    async (t, c) => await c.ExecuteReaderAsync(t).ConfigureAwait(false));
+                return (IDataReader)await task.ConfigureAwait(false);
             }
-            catch (Exception x)
+            else
+                return ExecuteReaderHelper(cmd);
+        }
+
+        internal protected async Task<int> ExecuteNonQueryHelperAsync(CancellationToken cancellationToken, IDbCommand cmd)
+        {
+            if (cmd is DbCommand dbCommand)
             {
-                if (OnException(x))
-                    throw;
+                var task = CommandHelper(cancellationToken, dbCommand,
+                    async (t, c) => await c.ExecuteNonQueryAsync(t).ConfigureAwait(false));
+                return (int)await task.ConfigureAwait(false);
             }
-
-            return result;
+            else
+                return ExecuteNonQueryHelper(cmd);
         }
 
-#endregion
-
-#region operation: StoredProc
-
-        /// <inheritdoc />
-        public IEnumerable<T> QueryProc<T>(string storedProcedureName, params object[] args)
-            => ExecuteReader<T>(CommandType.StoredProcedure, storedProcedureName, args);
-
-        /// <inheritdoc />
-        public List<T> FetchProc<T>(string storedProcedureName, params object[] args)
-            => QueryProc<T>(storedProcedureName, args).ToList();
-
-        /// <inheritdoc />
-        public T ExecuteScalarProc<T>(string storedProcedureName, params object[] args)
-            => ExecuteScalarInternal<T>(CommandType.StoredProcedure, storedProcedureName, args);
-
-        /// <inheritdoc />
-        public int ExecuteNonQueryProc(string storedProcedureName, params object[] args)
-            => ExecuteInternal(CommandType.StoredProcedure, storedProcedureName, args);
-
-#if ASYNC
-        /// <inheritdoc />
-        public Task QueryProcAsync<T>(Action<T> receivePocoCallback, string storedProcedureName, params object[] args)
-            => QueryProcAsync(receivePocoCallback, CancellationToken.None, storedProcedureName, args);
-
-        /// <inheritdoc />
-        public Task QueryProcAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, string storedProcedureName, params object[] args)
-            => ExecuteReaderAsync(receivePocoCallback, cancellationToken, CommandType.StoredProcedure, storedProcedureName, args);
-
-        /// <inheritdoc />
-        public Task<IAsyncReader<T>> QueryProcAsync<T>(string storedProcedureName, params object[] args)
-            => QueryProcAsync<T>(CancellationToken.None, storedProcedureName, args);
-
-        /// <inheritdoc />
-        public Task<IAsyncReader<T>> QueryProcAsync<T>(CancellationToken cancellationToken, string storedProcedureName, params object[] args)
-            => ExecuteReaderAsync<T>(cancellationToken, CommandType.StoredProcedure, storedProcedureName, args);
-
-        /// <inheritdoc />
-        public Task<List<T>> FetchProcAsync<T>(string storedProcedureName, params object[] args)
-            => FetchProcAsync<T>(CancellationToken.None, storedProcedureName, args);
-
-        /// <inheritdoc />
-        public async Task<List<T>> FetchProcAsync<T>(CancellationToken cancellationToken, string storedProcedureName, params object[] args)
+        internal protected Task<object> ExecuteScalarHelperAsync(CancellationToken cancellationToken, IDbCommand cmd)
         {
-            var pocos = new List<T>();
-            await ExecuteReaderAsync<T>(p => pocos.Add(p), cancellationToken, CommandType.StoredProcedure, storedProcedureName, args);
-            return pocos;
+            if (cmd is DbCommand dbCommand)
+                return CommandHelper(cancellationToken, dbCommand,
+                    async (t, c) => await c.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false));
+            else
+                return Task.FromResult(ExecuteScalarHelper(cmd));
         }
 
-        /// <inheritdoc />
-        public Task<T> ExecuteScalarProcAsync<T>(string storedProcedureName, params object[] args)
-            => ExecuteScalarProcAsync<T>(CancellationToken.None, storedProcedureName, args);
+        private async Task<object> CommandHelper(CancellationToken cancellationToken, DbCommand cmd,
+            Func<CancellationToken, DbCommand, Task<object>> cmdFunc)
+        {
+            DoPreExecute(cmd);
+            var result = await cmdFunc(cancellationToken, cmd).ConfigureAwait(false);
+            OnExecutedCommand(cmd);
+            return result;
+        }
+#endif
 
-        /// <inheritdoc />
-        public Task<T> ExecuteScalarProcAsync<T>(CancellationToken cancellationToken, string storedProcedureName, params object[] args)
-            => ExecuteScalarInternalAsync<T>(cancellationToken, CommandType.StoredProcedure, storedProcedureName, args);
+        #endregion
 
-        /// <inheritdoc />
-        public Task<int> ExecuteNonQueryProcAsync(string storedProcedureName, params object[] args)
-            => ExecuteNonQueryProcAsync(CancellationToken.None, storedProcedureName, args);
+        internal void DoPreExecute(IDbCommand cmd)
+        {
+            if (CommandTimeout > 0 || OneTimeCommandTimeout > 0)
+            {
+                cmd.CommandTimeout = OneTimeCommandTimeout > 0 ? OneTimeCommandTimeout : CommandTimeout;
+                OneTimeCommandTimeout = 0;
+            }
 
-        /// <inheritdoc />
-        public Task<int> ExecuteNonQueryProcAsync(CancellationToken cancellationToken, string storedProcedureName, params object[] args)
-            => ExecuteInternalAsync(cancellationToken, CommandType.StoredProcedure, storedProcedureName, args);
-#endif
+            _provider.PreExecute(cmd);
+            OnExecutingCommand(cmd);
 
-#endregion
+            _lastSql = cmd.CommandText;
+            _lastArgs = cmd.Parameters.Cast<IDataParameter>().Select(parameter => parameter.Value).ToArray();
+        }
 
-#region Last Command
+        #region Last Command, Format Command
 
         /// <summary>
         /// Gets the SQL used for the most recently executed statement.
@@ -2990,10 +3077,6 @@ public Task<int> ExecuteNonQueryProcAsync(CancellationToken cancellationToken, s
         /// </summary>
         public string LastCommand => FormatCommand(_lastSql, _lastArgs);
 
-#endregion
-
-#region FormatCommand
-
         /// <summary>
         /// Formats the contents of a DB command for display.
         /// </summary>
@@ -3030,9 +3113,9 @@ public string FormatCommand(string sql, object[] args)
             return sb.ToString();
         }
 
-#endregion
+        #endregion
 
-#region Public Properties
+        #region Configuration Properties
 
         /// <summary>
         /// Gets the default mapper.
@@ -3040,35 +3123,15 @@ public string FormatCommand(string sql, object[] args)
         public IMapper DefaultMapper => _defaultMapper;
 
         /// <summary>
-        /// When set to <see langword="true"/>, PetaPoco will automatically create the "SELECT columns" part of any query that looks like it needs it.
-        /// </summary>
-        public bool EnableAutoSelect { get; set; }
-
-        /// <summary>
-        /// When set to <see langword="true"/>, parameters can be named <c>?myparam</c> and populated from properties of the passed-in argument values.
-        /// </summary>
-        public bool EnableNamedParams { get; set; }
-
-        /// <summary>
-        /// Gets or sets the timeout value for all SQL statements.
-        /// </summary>
-        public int CommandTimeout { get; set; }
-
-        /// <summary>
-        /// Gets or sets the timeout value for the next (and only next) SQL statement.
+        /// Gets the connection string.
         /// </summary>
-        public int OneTimeCommandTimeout { get; set; }
+        public string ConnectionString => _connectionString;
 
         /// <summary>
         /// Gets the loaded database provider.
         /// </summary>
         public IProvider Provider => _provider;
 
-        /// <summary>
-        /// Gets the connection string.
-        /// </summary>
-        public string ConnectionString => _connectionString;
-
         /// <summary>
         /// Gets or sets the transaction isolation level.
         /// </summary>
@@ -3085,79 +3148,35 @@ public IsolationLevel? IsolationLevel
             }
         }
 
-#endregion
-
-#region Helpers
-        internal protected IDataReader ExecuteReaderHelper(IDbCommand cmd)
-        {
-            return (IDataReader)CommandHelper(cmd, c => c.ExecuteReader());
-        }
-
-        internal protected int ExecuteNonQueryHelper(IDbCommand cmd)
-        {
-            return (int)CommandHelper(cmd, c => c.ExecuteNonQuery());
-        }
-
-        internal protected object ExecuteScalarHelper(IDbCommand cmd)
-        {
-            return CommandHelper(cmd, c => c.ExecuteScalar());
-        }
-
-        private object CommandHelper(IDbCommand cmd, Func<IDbCommand, object> cmdFunc)
-        {
-            DoPreExecute(cmd);
-            var result = cmdFunc(cmd);
-            OnExecutedCommand(cmd);
-            return result;
-        }
+        /// <summary>
+        /// When set to <see langword="true"/> the first opened connection is kept alive until <see cref="CloseSharedConnection" /> or <see cref="Dispose" /> is called.
+        /// </summary>
+        /// <seealso cref="OpenSharedConnection" />
+        public bool KeepConnectionAlive { get; set; }
 
-#if ASYNC
-        internal protected async Task<IDataReader> ExecuteReaderHelperAsync(CancellationToken cancellationToken, IDbCommand cmd)
-        {
-            if (cmd is DbCommand dbCommand)
-            {
-                var task = CommandHelper(cancellationToken, dbCommand,
-                    async (t, c) => await c.ExecuteReaderAsync(t).ConfigureAwait(false));
-                return (IDataReader)await task.ConfigureAwait(false);
-            }
-            else
-                return ExecuteReaderHelper(cmd);
-        }
+        /// <summary>
+        /// When set to <see langword="true"/>, PetaPoco will automatically create the "SELECT columns" part of any query that looks like it needs it.
+        /// </summary>
+        public bool EnableAutoSelect { get; set; }
 
-        internal protected async Task<int> ExecuteNonQueryHelperAsync(CancellationToken cancellationToken, IDbCommand cmd)
-        {
-            if (cmd is DbCommand dbCommand)
-            {
-                var task = CommandHelper(cancellationToken, dbCommand,
-                    async (t, c) => await c.ExecuteNonQueryAsync(t).ConfigureAwait(false));
-                return (int)await task.ConfigureAwait(false);
-            }
-            else
-                return ExecuteNonQueryHelper(cmd);
-        }
+        /// <summary>
+        /// When set to <see langword="true"/>, parameters can be named <c>?myparam</c> and populated from properties of the passed-in argument values.
+        /// </summary>
+        public bool EnableNamedParams { get; set; }
 
-        internal protected Task<object> ExecuteScalarHelperAsync(CancellationToken cancellationToken, IDbCommand cmd)
-        {
-            if (cmd is DbCommand dbCommand)
-                return CommandHelper(cancellationToken, dbCommand,
-                    async (t, c) => await c.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false));
-            else
-                return Task.FromResult(ExecuteScalarHelper(cmd));
-        }
+        /// <summary>
+        /// Gets or sets the timeout value for all SQL statements.
+        /// </summary>
+        public int CommandTimeout { get; set; }
 
-        private async Task<object> CommandHelper(CancellationToken cancellationToken, DbCommand cmd,
-            Func<CancellationToken, DbCommand, Task<object>> cmdFunc)
-        {
-            DoPreExecute(cmd);
-            var result = await cmdFunc(cancellationToken, cmd).ConfigureAwait(false);
-            OnExecutedCommand(cmd);
-            return result;
-        }
-#endif
+        /// <summary>
+        /// Gets or sets the timeout value for the next (and only next) SQL statement.
+        /// </summary>
+        public int OneTimeCommandTimeout { get; set; }
 
-#endregion
+        #endregion
 
-#region Events
+        #region Events
 
         /// <inheritdoc/>
         public event EventHandler<DbTransactionEventArgs> TransactionStarted;
@@ -3172,18 +3191,18 @@ private async Task<object> CommandHelper(CancellationToken cancellationToken, Db
         public event EventHandler<DbCommandEventArgs> CommandExecuted;
 
         /// <inheritdoc/>
-        public event EventHandler<DbConnectionEventArgs> ConnectionClosing;
+        public event EventHandler<DbConnectionEventArgs> ConnectionOpening;
 
         /// <inheritdoc/>
         public event EventHandler<DbConnectionEventArgs> ConnectionOpened;
 
         /// <inheritdoc/>
-        public event EventHandler<DbConnectionEventArgs> ConnectionOpening;
+        public event EventHandler<DbConnectionEventArgs> ConnectionClosing;
 
         /// <inheritdoc/>
         public event EventHandler<ExceptionEventArgs> ExceptionThrown;
 
-#endregion
+        #endregion
     }
 
     /// <inheritdoc/>
diff --git a/PetaPoco/DatabaseConfigurationExtensions.cs b/PetaPoco/DatabaseConfigurationExtensions.cs
index 85d40bfe..5fa286ea 100644
--- a/PetaPoco/DatabaseConfigurationExtensions.cs
+++ b/PetaPoco/DatabaseConfigurationExtensions.cs
@@ -12,13 +12,13 @@ public static class DatabaseConfigurationExtensions
         internal const string CommandTimeout = "CommandTimeout";
         internal const string EnableAutoSelect = "EnableAutoSelect";
         internal const string EnableNamedParams = "EnableNamedParams";
-        internal const string Provider = "Provider";
-        internal const string ConnectionString = "ConnectionString";
-        internal const string ProviderName = "ProviderName";
 
 #if !NETSTANDARD
         internal const string ConnectionStringName = "ConnectionStringName";
 #endif
+        internal const string ConnectionString = "ConnectionString";
+        internal const string ProviderName = "ProviderName";
+        internal const string Provider = "Provider";
 
         internal const string DefaultMapper = "DefaultMapper";
         internal const string IsolationLevel = "IsolationLevel";
@@ -37,6 +37,8 @@ private static void SetSetting(this IDatabaseBuildConfiguration source, string k
             ((IBuildConfigurationSettings) source).SetSetting(key, value);
         }
 
+        #region Timeout Settings
+
         /// <summary>
         /// Adds a command timeout - see <see cref="IDatabase.CommandTimeout" />.
         /// </summary>
@@ -52,208 +54,223 @@ public static IDatabaseBuildConfiguration UsingCommandTimeout(this IDatabaseBuil
             return source;
         }
 
+        #endregion
+
+        #region AutoSelect Settings
+
         /// <summary>
-        /// Enables named params - see <see cref="IDatabase.EnableNamedParams" />.
+        /// Enables auto select <see cref="IDatabase.EnableAutoSelect" />.
         /// </summary>
         /// <param name="source">The configuration source.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        public static IDatabaseBuildConfiguration WithNamedParams(this IDatabaseBuildConfiguration source)
+        public static IDatabaseBuildConfiguration WithAutoSelect(this IDatabaseBuildConfiguration source)
         {
-            source.SetSetting(EnableNamedParams, true);
+            source.SetSetting(EnableAutoSelect, true);
             return source;
         }
 
         /// <summary>
-        /// Disables named params - see <see cref="IDatabase.EnableNamedParams" />.
+        /// Disables auto select - see <see cref="IDatabase.EnableAutoSelect" />.
         /// </summary>
         /// <param name="source">The configuration source.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        public static IDatabaseBuildConfiguration WithoutNamedParams(this IDatabaseBuildConfiguration source)
+        public static IDatabaseBuildConfiguration WithoutAutoSelect(this IDatabaseBuildConfiguration source)
         {
-            source.SetSetting(EnableNamedParams, false);
+            source.SetSetting(EnableAutoSelect, false);
             return source;
         }
 
+        #endregion
+
+        #region NamedParams Settings
+
         /// <summary>
-        /// Specifies the provider to be used. - see <see cref="IDatabase.Provider" />. This takes precedence over <see cref="UsingProviderName(IDatabaseBuildConfiguration, string)" />.
+        /// Enables named params - see <see cref="IDatabase.EnableNamedParams" />.
         /// </summary>
         /// <param name="source">The configuration source.</param>
-        /// <param name="provider">The provider to use.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="provider" /> is null.</exception>
-        public static IDatabaseBuildConfiguration UsingProvider<T>(this IDatabaseBuildConfiguration source, T provider) where T : class, IProvider
+        public static IDatabaseBuildConfiguration WithNamedParams(this IDatabaseBuildConfiguration source)
         {
-            if (provider == null)
-                throw new ArgumentNullException(nameof(provider));
-            source.SetSetting(Provider, provider);
+            source.SetSetting(EnableNamedParams, true);
             return source;
         }
 
         /// <summary>
-        /// Specifies the provider to be used. - see <see cref="IDatabase.Provider" />. This takes precedence over <see cref="UsingProviderName(IDatabaseBuildConfiguration, string)" />.
+        /// Disables named params - see <see cref="IDatabase.EnableNamedParams" />.
         /// </summary>
-        /// <typeparam name="T">The provider type.</typeparam>
         /// <param name="source">The configuration source.</param>
-        /// <param name="configure">The configure provider callback.</param>
-        /// <param name="provider">The provider to use.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="provider" /> is null.</exception>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="configure" /> is null.</exception>
-        public static IDatabaseBuildConfiguration UsingProvider<T>(this IDatabaseBuildConfiguration source, T provider, Action<T> configure) where T : class, IProvider
+        public static IDatabaseBuildConfiguration WithoutNamedParams(this IDatabaseBuildConfiguration source)
         {
-            if (provider == null)
-                throw new ArgumentNullException(nameof(provider));
-            if (configure == null)
-                throw new ArgumentNullException(nameof(configure));
-            configure(provider);
-            source.SetSetting(Provider, provider);
+            source.SetSetting(EnableNamedParams, false);
             return source;
         }
 
+        #endregion
+
+        #region Connection Settings
+
+#if !NETSTANDARD
         /// <summary>
-        /// Specifies the provider to be used. - see <see cref="IDatabase.Provider" />. This takes precedence over <see cref="UsingProviderName(IDatabaseBuildConfiguration, string)" />.
+        /// Adds a connection string name.
         /// </summary>
-        /// <typeparam name="T">The provider type.</typeparam>
         /// <param name="source">The configuration source.</param>
+        /// <param name="connectionStringName">The connection string name.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        public static IDatabaseBuildConfiguration UsingProvider<T>(this IDatabaseBuildConfiguration source) where T : class, IProvider, new()
+        /// <exception cref="ArgumentException">Thrown when <paramref name="connectionStringName" /> is null or empty.</exception>
+        public static IDatabaseBuildConfiguration UsingConnectionStringName(this IDatabaseBuildConfiguration source, string connectionStringName)
         {
-            source.SetSetting(Provider, new T());
+            if (string.IsNullOrEmpty(connectionStringName))
+                throw new ArgumentException("Argument is null or empty", nameof(connectionStringName));
+            source.SetSetting(ConnectionStringName, connectionStringName);
             return source;
         }
+#endif
 
         /// <summary>
-        /// Specifies the <see cref="IDatabase.Provider" /> to use, with an accompanying configuration provider custom callback.
+        /// Adds a connection string - see <see cref="IDatabase.ConnectionString" />.
         /// </summary>
-        /// <typeparam name="T">The provider type, constrained to a class deriving from <see cref="IProvider"/>.</typeparam>
         /// <param name="source">The configuration source.</param>
-        /// <param name="configure">The configure provider callback.</param>
+        /// <param name="connectionString">The connection string.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="configure" /> is null.</exception>
-        public static IDatabaseBuildConfiguration UsingProvider<T>(this IDatabaseBuildConfiguration source, Action<T> configure) where T : class, IProvider, new()
+        /// <exception cref="ArgumentException">Thrown when <paramref name="connectionString" /> is null or empty.</exception>
+        public static IDatabaseBuildConfiguration UsingConnectionString(this IDatabaseBuildConfiguration source, string connectionString)
         {
-            if (configure == null)
-                throw new ArgumentNullException(nameof(configure));
-            var provider = new T();
-            configure(provider);
-            source.SetSetting(Provider, provider);
+            if (string.IsNullOrEmpty(connectionString))
+                throw new ArgumentException("Argument is null or empty", nameof(connectionString));
+            source.SetSetting(ConnectionString, connectionString);
             return source;
         }
 
         /// <summary>
-        /// Enables auto select <see cref="IDatabase.EnableAutoSelect" />.
+        /// Specifies an <see cref="IDbConnection" /> to use.
         /// </summary>
         /// <param name="source">The configuration source.</param>
+        /// <param name="connection">The connection to use.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        public static IDatabaseBuildConfiguration WithAutoSelect(this IDatabaseBuildConfiguration source)
+        public static IDatabaseBuildConfiguration UsingConnection(this IDatabaseBuildConfiguration source, IDbConnection connection)
         {
-            source.SetSetting(EnableAutoSelect, true);
+            if (connection == null)
+                throw new ArgumentNullException(nameof(connection));
+
+            source.SetSetting(Connection, connection);
             return source;
         }
 
+        #endregion
+
+        #region Provider Settings
+
         /// <summary>
-        /// Disables auto select - see <see cref="IDatabase.EnableAutoSelect" />.
+        /// Adds a provider name string - see <see cref="DatabaseProvider.Resolve(string, bool, string)" />.
         /// </summary>
         /// <param name="source">The configuration source.</param>
+        /// <param name="providerName">The provider name.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        public static IDatabaseBuildConfiguration WithoutAutoSelect(this IDatabaseBuildConfiguration source)
+        /// <exception cref="ArgumentException">Thrown when <paramref name="providerName" /> is null or empty.</exception>
+        public static IDatabaseBuildConfiguration UsingProviderName(this IDatabaseBuildConfiguration source, string providerName)
         {
-            source.SetSetting(EnableAutoSelect, false);
+            if (string.IsNullOrEmpty(providerName))
+                throw new ArgumentException("Argument is null or empty", nameof(providerName));
+            source.SetSetting(ProviderName, providerName);
             return source;
         }
 
         /// <summary>
-        /// Adds a connection string - see <see cref="IDatabase.ConnectionString" />.
+        /// Specifies the provider to be used. - see <see cref="IDatabase.Provider" />. This takes precedence over <see cref="UsingProviderName(IDatabaseBuildConfiguration, string)" />.
         /// </summary>
+        /// <typeparam name="T">The provider type.</typeparam>
         /// <param name="source">The configuration source.</param>
-        /// <param name="connectionString">The connection string.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        /// <exception cref="ArgumentException">Thrown when <paramref name="connectionString" /> is null or empty.</exception>
-        public static IDatabaseBuildConfiguration UsingConnectionString(this IDatabaseBuildConfiguration source, string connectionString)
+        public static IDatabaseBuildConfiguration UsingProvider<T>(this IDatabaseBuildConfiguration source) where T : class, IProvider, new()
         {
-            if (string.IsNullOrEmpty(connectionString))
-                throw new ArgumentException("Argument is null or empty", nameof(connectionString));
-            source.SetSetting(ConnectionString, connectionString);
+            source.SetSetting(Provider, new T());
             return source;
         }
 
-#if !NETSTANDARD
         /// <summary>
-        /// Adds a connection string name.
+        /// Specifies the <see cref="IDatabase.Provider" /> to use, with an accompanying configuration provider custom callback.
         /// </summary>
+        /// <typeparam name="T">The provider type, constrained to a class deriving from <see cref="IProvider"/>.</typeparam>
         /// <param name="source">The configuration source.</param>
-        /// <param name="connectionStringName">The connection string name.</param>
+        /// <param name="configure">The configure provider callback.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        /// <exception cref="ArgumentException">Thrown when <paramref name="connectionStringName" /> is null or empty.</exception>
-        public static IDatabaseBuildConfiguration UsingConnectionStringName(this IDatabaseBuildConfiguration source, string connectionStringName)
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="configure" /> is null.</exception>
+        public static IDatabaseBuildConfiguration UsingProvider<T>(this IDatabaseBuildConfiguration source, Action<T> configure) where T : class, IProvider, new()
         {
-            if (string.IsNullOrEmpty(connectionStringName))
-                throw new ArgumentException("Argument is null or empty", nameof(connectionStringName));
-            source.SetSetting(ConnectionStringName, connectionStringName);
+            if (configure == null)
+                throw new ArgumentNullException(nameof(configure));
+            var provider = new T();
+            configure(provider);
+            source.SetSetting(Provider, provider);
             return source;
         }
-#endif
 
         /// <summary>
-        /// Adds a provider name string - see <see cref="DatabaseProvider.Resolve(string, bool, string)" />.
+        /// Specifies the provider to be used. - see <see cref="IDatabase.Provider" />. This takes precedence over <see cref="UsingProviderName(IDatabaseBuildConfiguration, string)" />.
         /// </summary>
         /// <param name="source">The configuration source.</param>
-        /// <param name="providerName">The provider name.</param>
+        /// <param name="provider">The provider to use.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        /// <exception cref="ArgumentException">Thrown when <paramref name="providerName" /> is null or empty.</exception>
-        public static IDatabaseBuildConfiguration UsingProviderName(this IDatabaseBuildConfiguration source, string providerName)
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="provider" /> is null.</exception>
+        public static IDatabaseBuildConfiguration UsingProvider<T>(this IDatabaseBuildConfiguration source, T provider) where T : class, IProvider
         {
-            if (string.IsNullOrEmpty(providerName))
-                throw new ArgumentException("Argument is null or empty", nameof(providerName));
-            source.SetSetting(ProviderName, providerName);
+            if (provider == null)
+                throw new ArgumentNullException(nameof(provider));
+            source.SetSetting(Provider, provider);
             return source;
         }
 
         /// <summary>
-        /// Specifies an <see cref="IDbConnection" /> to use.
+        /// Specifies the provider to be used. - see <see cref="IDatabase.Provider" />. This takes precedence over <see cref="UsingProviderName(IDatabaseBuildConfiguration, string)" />.
         /// </summary>
+        /// <typeparam name="T">The provider type.</typeparam>
         /// <param name="source">The configuration source.</param>
-        /// <param name="connection">The connection to use.</param>
+        /// <param name="configure">The configure provider callback.</param>
+        /// <param name="provider">The provider to use.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        public static IDatabaseBuildConfiguration UsingConnection(this IDatabaseBuildConfiguration source, IDbConnection connection)
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="provider" /> is null.</exception>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="configure" /> is null.</exception>
+        public static IDatabaseBuildConfiguration UsingProvider<T>(this IDatabaseBuildConfiguration source, T provider, Action<T> configure) where T : class, IProvider
         {
-            if (connection == null)
-                throw new ArgumentNullException(nameof(connection));
-
-            source.SetSetting(Connection, connection);
+            if (provider == null)
+                throw new ArgumentNullException(nameof(provider));
+            if (configure == null)
+                throw new ArgumentNullException(nameof(configure));
+            configure(provider);
+            source.SetSetting(Provider, provider);
             return source;
         }
 
+        #endregion
+
+        #region Mapper Settings
+
         /// <summary>
         /// Specifies the default mapper to use when no specific mapper has been registered.
         /// </summary>
+        /// <typeparam name="T">The mapper type.</typeparam>
         /// <param name="source">The configuration source.</param>
-        /// <param name="mapper">The mapper to use as the default.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="mapper" /> is null.</exception>
-        public static IDatabaseBuildConfiguration UsingDefaultMapper<T>(this IDatabaseBuildConfiguration source, T mapper) where T : class, IMapper
+        public static IDatabaseBuildConfiguration UsingDefaultMapper<T>(this IDatabaseBuildConfiguration source) where T : class, IMapper, new()
         {
-            if (mapper == null)
-                throw new ArgumentNullException(nameof(mapper));
-            source.SetSetting(DefaultMapper, mapper);
+            source.SetSetting(DefaultMapper, new T());
             return source;
         }
 
         /// <summary>
         /// Specifies the default mapper to use when no specific mapper has been registered.
         /// </summary>
+        /// <typeparam name="T">The type of the mapper. This type must be a class that implements the <see cref="IMapper"/> interface.</typeparam>
         /// <param name="source">The configuration source.</param>
-        /// <param name="mapper">The mapper to use as the default.</param>
-        /// <param name="configure">The configure mapper callback.</param>
+        /// <param name="configure">A callback function to configure the mapper.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="mapper" /> is null.</exception>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="configure" /> is null.</exception>
-        public static IDatabaseBuildConfiguration UsingDefaultMapper<T>(this IDatabaseBuildConfiguration source, T mapper, Action<T> configure) where T : class, IMapper
+        /// <exception cref="ArgumentNullException">Thrown if the <paramref name="configure"/> callback function is null.</exception>
+        public static IDatabaseBuildConfiguration UsingDefaultMapper<T>(this IDatabaseBuildConfiguration source, Action<T> configure) where T : class, IMapper, new()
         {
-            if (mapper == null)
-                throw new ArgumentNullException(nameof(mapper));
             if (configure == null)
                 throw new ArgumentNullException(nameof(configure));
+            var mapper = new T();
             configure(mapper);
             source.SetSetting(DefaultMapper, mapper);
             return source;
@@ -262,33 +279,42 @@ public static IDatabaseBuildConfiguration UsingDefaultMapper<T>(this IDatabaseBu
         /// <summary>
         /// Specifies the default mapper to use when no specific mapper has been registered.
         /// </summary>
-        /// <typeparam name="T">The mapper type.</typeparam>
         /// <param name="source">The configuration source.</param>
+        /// <param name="mapper">The mapper to use as the default.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        public static IDatabaseBuildConfiguration UsingDefaultMapper<T>(this IDatabaseBuildConfiguration source) where T : class, IMapper, new()
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="mapper" /> is null.</exception>
+        public static IDatabaseBuildConfiguration UsingDefaultMapper<T>(this IDatabaseBuildConfiguration source, T mapper) where T : class, IMapper
         {
-            source.SetSetting(DefaultMapper, new T());
+            if (mapper == null)
+                throw new ArgumentNullException(nameof(mapper));
+            source.SetSetting(DefaultMapper, mapper);
             return source;
         }
 
         /// <summary>
         /// Specifies the default mapper to use when no specific mapper has been registered.
         /// </summary>
-        /// <typeparam name="T">The type of the mapper. This type must be a class that implements the <see cref="IMapper"/> interface.</typeparam>
         /// <param name="source">The configuration source.</param>
-        /// <param name="configure">A callback function to configure the mapper.</param>
+        /// <param name="mapper">The mapper to use as the default.</param>
+        /// <param name="configure">The configure mapper callback.</param>
         /// <returns>The original <paramref name="source"/> configuration, to form a fluent interface.</returns>
-        /// <exception cref="ArgumentNullException">Thrown if the <paramref name="configure"/> callback function is null.</exception>
-        public static IDatabaseBuildConfiguration UsingDefaultMapper<T>(this IDatabaseBuildConfiguration source, Action<T> configure) where T : class, IMapper, new()
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="mapper" /> is null.</exception>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="configure" /> is null.</exception>
+        public static IDatabaseBuildConfiguration UsingDefaultMapper<T>(this IDatabaseBuildConfiguration source, T mapper, Action<T> configure) where T : class, IMapper
         {
+            if (mapper == null)
+                throw new ArgumentNullException(nameof(mapper));
             if (configure == null)
                 throw new ArgumentNullException(nameof(configure));
-            var mapper = new T();
             configure(mapper);
             source.SetSetting(DefaultMapper, mapper);
             return source;
         }
 
+        #endregion
+
+        #region Transaction Settings
+
         /// <summary>
         /// Specifies the transaction isolation level to use.
         /// </summary>
@@ -301,6 +327,10 @@ public static IDatabaseBuildConfiguration UsingIsolationLevel(this IDatabaseBuil
             return source;
         }
 
+        #endregion
+
+        #region Event Settings
+
         /// <summary>
         /// Specifies an event handler to use when a new transaction has been started.
         /// </summary>
@@ -397,6 +427,10 @@ public static IDatabaseBuildConfiguration UsingExceptionThrown(this IDatabaseBui
             return source;
         }
 
+        #endregion
+
+        #region Finalize Fluent Configuration
+
         /// <summary>
         /// Creates an instance of PetaPoco using the specified <paramref name="source" />.
         /// </summary>
@@ -406,5 +440,7 @@ public static IDatabase Create(this IDatabaseBuildConfiguration source)
         {
             return new Database(source);
         }
+
+        #endregion
     }
 }
diff --git a/PetaPoco/IAlterPoco.cs b/PetaPoco/IAlterPoco.cs
index cbdaa0b4..30240182 100644
--- a/PetaPoco/IAlterPoco.cs
+++ b/PetaPoco/IAlterPoco.cs
@@ -6,6 +6,16 @@ public interface IAlterPoco
     {
         #region Insert
 
+        /// <summary>
+        /// Performs an SQL Insert.
+        /// </summary>
+        /// <remarks>
+        /// The name of the table, its primary key and whether it's an auto-allocated primary key are retrieved from the POCO's attributes
+        /// </remarks>
+        /// <param name="poco">A POCO object containing the column values to be inserted.</param>
+        /// <returns>The auto allocated primary key of the new record, or <see langword="null"/> for non-auto-increment tables.</returns>
+        object Insert(object poco);
+
         /// <summary>
         /// Performs an SQL Insert.
         /// </summary>
@@ -36,16 +46,6 @@ public interface IAlterPoco
         /// <returns>The auto allocated primary key of the new record, or <see langword="null"/> for non-auto-increment tables.</returns>
         object Insert(string tableName, string primaryKeyName, bool autoIncrement, object poco);
 
-        /// <summary>
-        /// Performs an SQL Insert.
-        /// </summary>
-        /// <remarks>
-        /// The name of the table, its primary key and whether it's an auto-allocated primary key are retrieved from the POCO's attributes
-        /// </remarks>
-        /// <param name="poco">A POCO object containing the column values to be inserted.</param>
-        /// <returns>The auto allocated primary key of the new record, or <see langword="null"/> for non-auto-increment tables.</returns>
-        object Insert(object poco);
-
         #endregion
 
         #region Update
@@ -53,96 +53,103 @@ public interface IAlterPoco
         /// <summary>
         /// Performs an SQL update.
         /// </summary>
-        /// <param name="tableName">The name of the table to update.</param>
-        /// <param name="primaryKeyName">The name of the primary key column of the table.</param>
         /// <param name="poco">A POCO object containing the column values to be updated.</param>
-        /// <param name="primaryKeyValue">The primary key of the record to be updated.</param>
-        /// <returns>The number of affected records.</returns>
-        int Update(string tableName, string primaryKeyName, object poco, object primaryKeyValue);
+        /// <returns>The number of affected rows.</returns>
+        int Update(object poco);
 
         /// <summary>
         /// Performs an SQL update.
         /// </summary>
-        /// <param name="tableName">The name of the table to update.</param>
-        /// <param name="primaryKeyName">The name of the primary key column of the table.</param>
         /// <param name="poco">A POCO object containing the column values to be updated.</param>
-        /// <param name="primaryKeyValue">The primary key of the record to be updated.</param>
         /// <param name="columns">The column names of the columns to be updated, or <see langword="null"/> for all.</param>
         /// <returns>The number of affected rows.</returns>
-        int Update(string tableName, string primaryKeyName, object poco, object primaryKeyValue, IEnumerable<string> columns);
+        int Update(object poco, IEnumerable<string> columns);
 
         /// <summary>
         /// Performs an SQL update.
         /// </summary>
-        /// <param name="tableName">The name of the table to update.</param>
-        /// <param name="primaryKeyName">The name of the primary key column of the table.</param>
         /// <param name="poco">A POCO object containing the column values to be updated.</param>
+        /// <param name="primaryKeyValue">The primary key of the record to be updated.</param>
         /// <returns>The number of affected rows.</returns>
-        int Update(string tableName, string primaryKeyName, object poco);
+        int Update(object poco, object primaryKeyValue);
 
         /// <summary>
         /// Performs an SQL update.
         /// </summary>
-        /// <param name="tableName">The name of the table to update.</param>
-        /// <param name="primaryKeyName">The name of the primary key column of the table.</param>
         /// <param name="poco">A POCO object containing the column values to be updated.</param>
+        /// <param name="primaryKeyValue">The primary key of the record to be updated.</param>
         /// <param name="columns">The column names of the columns to be updated, or <see langword="null"/> for all.</param>
         /// <returns>The number of affected rows.</returns>
-        int Update(string tableName, string primaryKeyName, object poco, IEnumerable<string> columns);
+        int Update(object poco, object primaryKeyValue, IEnumerable<string> columns);
 
         /// <summary>
         /// Performs an SQL update.
         /// </summary>
+        /// <param name="tableName">The name of the table to update.</param>
+        /// <param name="primaryKeyName">The name of the primary key column of the table.</param>
         /// <param name="poco">A POCO object containing the column values to be updated.</param>
-        /// <param name="columns">The column names of the columns to be updated, or <see langword="null"/> for all.</param>
         /// <returns>The number of affected rows.</returns>
-        int Update(object poco, IEnumerable<string> columns);
+        int Update(string tableName, string primaryKeyName, object poco);
 
         /// <summary>
         /// Performs an SQL update.
         /// </summary>
+        /// <param name="tableName">The name of the table to update.</param>
+        /// <param name="primaryKeyName">The name of the primary key column of the table.</param>
         /// <param name="poco">A POCO object containing the column values to be updated.</param>
+        /// <param name="columns">The column names of the columns to be updated, or <see langword="null"/> for all.</param>
         /// <returns>The number of affected rows.</returns>
-        int Update(object poco);
+        int Update(string tableName, string primaryKeyName, object poco, IEnumerable<string> columns);
 
         /// <summary>
         /// Performs an SQL update.
         /// </summary>
+        /// <param name="tableName">The name of the table to update.</param>
+        /// <param name="primaryKeyName">The name of the primary key column of the table.</param>
         /// <param name="poco">A POCO object containing the column values to be updated.</param>
         /// <param name="primaryKeyValue">The primary key of the record to be updated.</param>
-        /// <returns>The number of affected rows.</returns>
-        int Update(object poco, object primaryKeyValue);
+        /// <returns>The number of affected records.</returns>
+        int Update(string tableName, string primaryKeyName, object poco, object primaryKeyValue);
 
         /// <summary>
         /// Performs an SQL update.
         /// </summary>
+        /// <param name="tableName">The name of the table to update.</param>
+        /// <param name="primaryKeyName">The name of the primary key column of the table.</param>
         /// <param name="poco">A POCO object containing the column values to be updated.</param>
         /// <param name="primaryKeyValue">The primary key of the record to be updated.</param>
         /// <param name="columns">The column names of the columns to be updated, or <see langword="null"/> for all.</param>
         /// <returns>The number of affected rows.</returns>
-        int Update(object poco, object primaryKeyValue, IEnumerable<string> columns);
+        int Update(string tableName, string primaryKeyName, object poco, object primaryKeyValue, IEnumerable<string> columns);
 
         /// <summary>
         /// Performs an SQL update.
         /// </summary>
         /// <typeparam name="T">The POCO class whose attributes specify the name of the table to update.</typeparam>
-        /// <param name="sql">The SQL update and condition clause (everything after <c>UPDATE tablename</c>).</param>
-        /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
+        /// <param name="sql">An SQL builder object representing the SQL update and condition clause (everything after <c>UPDATE tablename</c>).</param>
         /// <returns>The number of affected rows.</returns>
-        int Update<T>(string sql, params object[] args);
+        int Update<T>(Sql sql);
 
         /// <summary>
         /// Performs an SQL update.
         /// </summary>
         /// <typeparam name="T">The POCO class whose attributes specify the name of the table to update.</typeparam>
-        /// <param name="sql">An SQL builder object representing the SQL update and condition clause (everything after <c>UPDATE tablename</c>).</param>
+        /// <param name="sql">The SQL update and condition clause (everything after <c>UPDATE tablename</c>).</param>
+        /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>The number of affected rows.</returns>
-        int Update<T>(Sql sql);
+        int Update<T>(string sql, params object[] args);
 
         #endregion
 
         #region Delete
 
+        /// <summary>
+        /// Performs an SQL Delete.
+        /// </summary>
+        /// <param name="poco">A POCO object specifying the table name and primary key value of the row to be deleted.</param>
+        /// <returns>The number of rows affected.</returns>
+        int Delete(object poco);
+
         /// <summary>
         /// Performs an SQL Delete.
         /// </summary>
@@ -162,13 +169,6 @@ public interface IAlterPoco
         /// <returns>The number of rows affected.</returns>
         int Delete(string tableName, string primaryKeyName, object poco, object primaryKeyValue);
 
-        /// <summary>
-        /// Performs an SQL Delete.
-        /// </summary>
-        /// <param name="poco">A POCO object specifying the table name and primary key value of the row to be deleted.</param>
-        /// <returns>The number of rows affected.</returns>
-        int Delete(object poco);
-
         /// <summary>
         /// Performs an SQL Delete.
         /// </summary>
@@ -181,18 +181,18 @@ public interface IAlterPoco
         /// Performs an SQL Delete.
         /// </summary>
         /// <typeparam name="T">The POCO class whose attributes specify the name of the table to delete from.</typeparam>
-        /// <param name="sql">The SQL condition clause identifying the row to delete (everything after <c>DELETE FROM tablename</c>).</param>
-        /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
+        /// <param name="sql">An SQL builder object representing the SQL condition clause identifying the row to delete (everything after <c>DELETE FROM tablename</c>).</param>
         /// <returns>The number of affected rows.</returns>
-        int Delete<T>(string sql, params object[] args);
+        int Delete<T>(Sql sql);
 
         /// <summary>
         /// Performs an SQL Delete.
         /// </summary>
         /// <typeparam name="T">The POCO class whose attributes specify the name of the table to delete from.</typeparam>
-        /// <param name="sql">An SQL builder object representing the SQL condition clause identifying the row to delete (everything after <c>DELETE FROM tablename</c>).</param>
+        /// <param name="sql">The SQL condition clause identifying the row to delete (everything after <c>DELETE FROM tablename</c>).</param>
+        /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>The number of affected rows.</returns>
-        int Delete<T>(Sql sql);
+        int Delete<T>(string sql, params object[] args);
 
         #endregion
 
@@ -204,10 +204,9 @@ public interface IAlterPoco
         /// <remarks>
         /// This method simply tests if the POCO's primary key column property has a non-default value.
         /// </remarks>
-        /// <param name="primaryKeyName">The name of the primary key column.</param>
         /// <param name="poco">The object instance whose "newness" is to be tested.</param>
         /// <returns><see langword="true"/> if the POCO represents a record already in the database.</returns>
-        bool IsNew(string primaryKeyName, object poco);
+        bool IsNew(object poco);
 
         /// <summary>
         /// Checks if a poco represents a new row.
@@ -215,9 +214,10 @@ public interface IAlterPoco
         /// <remarks>
         /// This method simply tests if the POCO's primary key column property has a non-default value.
         /// </remarks>
+        /// <param name="primaryKeyName">The name of the primary key column.</param>
         /// <param name="poco">The object instance whose "newness" is to be tested.</param>
         /// <returns><see langword="true"/> if the POCO represents a record already in the database.</returns>
-        bool IsNew(object poco);
+        bool IsNew(string primaryKeyName, object poco);
 
         #endregion
 
@@ -226,16 +226,16 @@ public interface IAlterPoco
         /// <summary>
         /// Saves a POCO by performing either an INSERT or UPDATE operation.
         /// </summary>
-        /// <param name="tableName">The name of the table to be updated.</param>
-        /// <param name="primaryKeyName">The name of the primary key column.</param>
         /// <param name="poco">The POCO object to be saved.</param>
-        void Save(string tableName, string primaryKeyName, object poco);
+        void Save(object poco);
 
         /// <summary>
         /// Saves a POCO by performing either an INSERT or UPDATE operation.
         /// </summary>
+        /// <param name="tableName">The name of the table to be updated.</param>
+        /// <param name="primaryKeyName">The name of the primary key column.</param>
         /// <param name="poco">The POCO object to be saved.</param>
-        void Save(object poco);
+        void Save(string tableName, string primaryKeyName, object poco);
 
         #endregion
     }
diff --git a/PetaPoco/IAlterPocoAsync.cs b/PetaPoco/IAlterPocoAsync.cs
index d0cd4918..16ccb2ad 100644
--- a/PetaPoco/IAlterPocoAsync.cs
+++ b/PetaPoco/IAlterPocoAsync.cs
@@ -7,17 +7,17 @@ namespace PetaPoco
 #if ASYNC
     public interface IAlterPocoAsync
     {
-        #region Insert
+        #region InsertAsync
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Insert(string, object)" />.
+        /// Async version of <see cref="IAlterPoco.Insert(object)" />.
         /// </summary>
-        Task<object> InsertAsync(string tableName, object poco);
+        Task<object> InsertAsync(object poco);
 
         /// <summary>
         /// Async version of <see cref="IAlterPoco.Insert(string, object)" />.
         /// </summary>
-        Task<object> InsertAsync(CancellationToken cancellationToken, string tableName, object poco);
+        Task<object> InsertAsync(string tableName, object poco);
 
         /// <summary>
         /// Async version of <see cref="IAlterPoco.Insert(string, string, object)" />.
@@ -25,88 +25,83 @@ public interface IAlterPocoAsync
         Task<object> InsertAsync(string tableName, string primaryKeyName, object poco);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Insert(string, string, object)" />.
+        /// Async version of <see cref="IAlterPoco.Insert(string, string, bool, object)" />.
         /// </summary>
-        Task<object> InsertAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco);
+        Task<object> InsertAsync(string tableName, string primaryKeyName, bool autoIncrement, object poco);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Insert(string, string, bool, object)" />.
+        /// Async version of <see cref="IAlterPoco.Insert(object)" />.
         /// </summary>
-        Task<object> InsertAsync(string tableName, string primaryKeyName, bool autoIncrement, object poco);
+        Task<object> InsertAsync(CancellationToken cancellationToken, object poco);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Insert(string, string, bool, object)" />.
+        /// Async version of <see cref="IAlterPoco.Insert(string, object)" />.
         /// </summary>
-        Task<object> InsertAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, bool autoIncrement, object poco);
+        Task<object> InsertAsync(CancellationToken cancellationToken, string tableName, object poco);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Insert(object)" />.
+        /// Async version of <see cref="IAlterPoco.Insert(string, string, object)" />.
         /// </summary>
-        Task<object> InsertAsync(object poco);
+        Task<object> InsertAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Insert(object)" />.
+        /// Async version of <see cref="IAlterPoco.Insert(string, string, bool, object)" />.
         /// </summary>
-        Task<object> InsertAsync(CancellationToken cancellationToken, object poco);
+        Task<object> InsertAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, bool autoIncrement, object poco);
 
         #endregion
 
-        #region Update
+        #region UpdateAsync
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Update(string, string, object, object)" />.
+        /// Async version of <see cref="IAlterPoco.Update(object)" />.
         /// </summary>
-        Task<int> UpdateAsync(string tableName, string primaryKeyName, object poco, object primaryKeyValue);
+        Task<int> UpdateAsync(object poco);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Update(string, string, object, object)" />.
+        /// Async version of <see cref="IAlterPoco.Update(object, IEnumerable{string})" />.
         /// </summary>
-        Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, object primaryKeyValue);
+        Task<int> UpdateAsync(object poco, IEnumerable<string> columns);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Update(string, string, object, object, IEnumerable{string})" />.
+        /// Async version of <see cref="IAlterPoco.Update(object, object)" />.
         /// </summary>
-        Task<int> UpdateAsync(string tableName, string primaryKeyName, object poco, object primaryKeyValue, IEnumerable<string> columns);
+        Task<int> UpdateAsync(object poco, object primaryKeyValue);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Update(string, string, object, object, IEnumerable{string})" />.
+        /// Async version of <see cref="IAlterPoco.Update(object, object, IEnumerable{string})" />.
         /// </summary>
-        Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, object primaryKeyValue, IEnumerable<string> columns);
+        Task<int> UpdateAsync(object poco, object primaryKeyValue, IEnumerable<string> columns);
 
         /// <summary>
         /// Async version of <see cref="IAlterPoco.Update(string, string, object)" />.
         /// </summary>
         Task<int> UpdateAsync(string tableName, string primaryKeyName, object poco);
 
-        /// <summary>
-        /// Async version of <see cref="IAlterPoco.Update(string, string, object)" />.
-        /// </summary>
-        Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco);
-
         /// <summary>
         /// Async version of <see cref="IAlterPoco.Update(string, string, object, IEnumerable{string})" />.
         /// </summary>
         Task<int> UpdateAsync(string tableName, string primaryKeyName, object poco, IEnumerable<string> columns);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Update(string, string, object, IEnumerable{string})" />.
+        /// Async version of <see cref="IAlterPoco.Update(string, string, object, object)" />.
         /// </summary>
-        Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, IEnumerable<string> columns);
+        Task<int> UpdateAsync(string tableName, string primaryKeyName, object poco, object primaryKeyValue);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Update(object, IEnumerable{string})" />.
+        /// Async version of <see cref="IAlterPoco.Update(string, string, object, object, IEnumerable{string})" />.
         /// </summary>
-        Task<int> UpdateAsync(object poco, IEnumerable<string> columns);
+        Task<int> UpdateAsync(string tableName, string primaryKeyName, object poco, object primaryKeyValue, IEnumerable<string> columns);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Update(object, IEnumerable{string})" />.
+        /// Async version of <see cref="IAlterPoco.Update{t}(Sql)" />.
         /// </summary>
-        Task<int> UpdateAsync(CancellationToken cancellationToken, object poco, IEnumerable<string> columns);
+        Task<int> UpdateAsync<T>(Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Update(object)" />.
+        /// Async version of <see cref="IAlterPoco.Update{t}(string, object[])" />.
         /// </summary>
-        Task<int> UpdateAsync(object poco);
+        Task<int> UpdateAsync<T>(string sql, params object[] args);
 
         /// <summary>
         /// Async version of <see cref="IAlterPoco.Update(object)" />.
@@ -114,9 +109,9 @@ public interface IAlterPocoAsync
         Task<int> UpdateAsync(CancellationToken cancellationToken, object poco);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Update(object, object)" />.
+        /// Async version of <see cref="IAlterPoco.Update(object, IEnumerable{string})" />.
         /// </summary>
-        Task<int> UpdateAsync(object poco, object primaryKeyValue);
+        Task<int> UpdateAsync(CancellationToken cancellationToken, object poco, IEnumerable<string> columns);
 
         /// <summary>
         /// Async version of <see cref="IAlterPoco.Update(object, object)" />.
@@ -126,46 +121,51 @@ public interface IAlterPocoAsync
         /// <summary>
         /// Async version of <see cref="IAlterPoco.Update(object, object, IEnumerable{string})" />.
         /// </summary>
-        Task<int> UpdateAsync(object poco, object primaryKeyValue, IEnumerable<string> columns);
+        Task<int> UpdateAsync(CancellationToken cancellationToken, object poco, object primaryKeyValue, IEnumerable<string> columns);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Update(object, object, IEnumerable{string})" />.
+        /// Async version of <see cref="IAlterPoco.Update(string, string, object)" />.
         /// </summary>
-        Task<int> UpdateAsync(CancellationToken cancellationToken, object poco, object primaryKeyValue, IEnumerable<string> columns);
+        Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Update{t}(string, object[])" />.
+        /// Async version of <see cref="IAlterPoco.Update(string, string, object, IEnumerable{string})" />.
         /// </summary>
-        Task<int> UpdateAsync<T>(string sql, params object[] args);
+        Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, IEnumerable<string> columns);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Update{t}(string, object[])" />.
+        /// Async version of <see cref="IAlterPoco.Update(string, string, object, object)" />.
         /// </summary>
-        Task<int> UpdateAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
+        Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, object primaryKeyValue);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Update{t}(Sql)" />.
+        /// Async version of <see cref="IAlterPoco.Update(string, string, object, object, IEnumerable{string})" />.
         /// </summary>
-        Task<int> UpdateAsync<T>(Sql sql);
+        Task<int> UpdateAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, object primaryKeyValue, IEnumerable<string> columns);
 
         /// <summary>
         /// Async version of <see cref="IAlterPoco.Update{t}(Sql)" />.
         /// </summary>
         Task<int> UpdateAsync<T>(CancellationToken cancellationToken, Sql sql);
 
+        /// <summary>
+        /// Async version of <see cref="IAlterPoco.Update{t}(string, object[])" />.
+        /// </summary>
+        Task<int> UpdateAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
+
         #endregion
 
-        #region Delete
+        #region DeleteAsync
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Delete(string, string, object)" />.
+        /// Async version of <see cref="IAlterPoco.Delete(object)" />.
         /// </summary>
-        Task<int> DeleteAsync(string tableName, string primaryKeyName, object poco);
+        Task<int> DeleteAsync(object poco);
 
         /// <summary>
         /// Async version of <see cref="IAlterPoco.Delete(string, string, object)" />.
         /// </summary>
-        Task<int> DeleteAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco);
+        Task<int> DeleteAsync(string tableName, string primaryKeyName, object poco);
 
         /// <summary>
         /// Async version of <see cref="IAlterPoco.Delete(string, string, object, object)" />.
@@ -173,73 +173,73 @@ public interface IAlterPocoAsync
         Task<int> DeleteAsync(string tableName, string primaryKeyName, object poco, object primaryKeyValue);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Delete(string, string, object, object)" />.
+        /// Async version of <see cref="IAlterPoco.Delete{t}(object)" />.
         /// </summary>
-        Task<int> DeleteAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, object primaryKeyValue);
+        Task<int> DeleteAsync<T>(object pocoOrPrimaryKey);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Delete(object)" />.
+        /// Async version of <see cref="IAlterPoco.Delete{t}(Sql)" />.
         /// </summary>
-        Task<int> DeleteAsync(object poco);
+        Task<int> DeleteAsync<T>(Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Delete(object)" />.
+        /// Async version of <see cref="IAlterPoco.Delete{t}(string, object[])" />.
         /// </summary>
-        Task<int> DeleteAsync(CancellationToken cancellationToken, object poco);
+        Task<int> DeleteAsync<T>(string sql, params object[] args);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Delete{t}(object)" />.
+        /// Async version of <see cref="IAlterPoco.Delete(object)" />.
         /// </summary>
-        Task<int> DeleteAsync<T>(object pocoOrPrimaryKey);
+        Task<int> DeleteAsync(CancellationToken cancellationToken, object poco);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Delete{t}(object)" />.
+        /// Async version of <see cref="IAlterPoco.Delete(string, string, object)" />.
         /// </summary>
-        Task<int> DeleteAsync<T>(CancellationToken cancellationToken, object pocoOrPrimaryKey);
+        Task<int> DeleteAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Delete{t}(string, object[])" />.
+        /// Async version of <see cref="IAlterPoco.Delete(string, string, object, object)" />.
         /// </summary>
-        Task<int> DeleteAsync<T>(string sql, params object[] args);
+        Task<int> DeleteAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco, object primaryKeyValue);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Delete{t}(string, object[])" />.
+        /// Async version of <see cref="IAlterPoco.Delete{t}(object)" />.
         /// </summary>
-        Task<int> DeleteAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
+        Task<int> DeleteAsync<T>(CancellationToken cancellationToken, object pocoOrPrimaryKey);
 
         /// <summary>
         /// Async version of <see cref="IAlterPoco.Delete{t}(Sql)" />.
         /// </summary>
-        Task<int> DeleteAsync<T>(Sql sql);
+        Task<int> DeleteAsync<T>(CancellationToken cancellationToken, Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Delete{t}(Sql)" />.
+        /// Async version of <see cref="IAlterPoco.Delete{t}(string, object[])" />.
         /// </summary>
-        Task<int> DeleteAsync<T>(CancellationToken cancellationToken, Sql sql);
+        Task<int> DeleteAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
 
         #endregion
 
-        #region Save
+        #region SaveAsync
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Save(string, string, object)" />.
+        /// Async version of <see cref="IAlterPoco.Save(object)" />.
         /// </summary>
-        Task SaveAsync(string tableName, string primaryKeyName, object poco);
+        Task SaveAsync(object poco);
 
         /// <summary>
         /// Async version of <see cref="IAlterPoco.Save(string, string, object)" />.
         /// </summary>
-        Task SaveAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco);
+        Task SaveAsync(string tableName, string primaryKeyName, object poco);
 
         /// <summary>
         /// Async version of <see cref="IAlterPoco.Save(object)" />.
         /// </summary>
-        Task SaveAsync(object poco);
+        Task SaveAsync(CancellationToken cancellationToken, object poco);
 
         /// <summary>
-        /// Async version of <see cref="IAlterPoco.Save(object)" />.
+        /// Async version of <see cref="IAlterPoco.Save(string, string, object)" />.
         /// </summary>
-        Task SaveAsync(CancellationToken cancellationToken, object poco);
+        Task SaveAsync(CancellationToken cancellationToken, string tableName, string primaryKeyName, object poco);
 
         #endregion
     }
diff --git a/PetaPoco/IDatabase.cs b/PetaPoco/IDatabase.cs
index 01f8cb96..5d04de0b 100644
--- a/PetaPoco/IDatabase.cs
+++ b/PetaPoco/IDatabase.cs
@@ -139,6 +139,18 @@ public interface IDatabase : IDisposable, IQuery, IAlterPoco, IExecute, ITransac
         /// </remarks>
         void BeginTransaction();
 
+#if ASYNC
+        /// <summary>
+        /// Async version of <see cref="BeginTransaction" />.
+        /// </summary>
+        Task BeginTransactionAsync();
+
+        /// <summary>
+        /// Async version of <see cref="BeginTransaction" />.
+        /// </summary>
+        Task BeginTransactionAsync(CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Aborts the entire outermost transaction scope.
         /// </summary>
@@ -177,31 +189,19 @@ public interface IDatabase : IDisposable, IQuery, IAlterPoco, IExecute, ITransac
         /// </summary>
         event EventHandler<DbCommandEventArgs> CommandExecuted;
 
-        /// <summary>
-        /// Occurs when a database connection is about to be closed.
-        /// </summary>
-        event EventHandler<DbConnectionEventArgs> ConnectionClosing;
-
         /// <summary>
         /// Occurs when a database connection has been opened.
         /// </summary>
         event EventHandler<DbConnectionEventArgs> ConnectionOpened;
 
         /// <summary>
-        /// Occurs when a database exception has been thrown.
-        /// </summary>
-        event EventHandler<ExceptionEventArgs> ExceptionThrown;
-
-#if ASYNC
-        /// <summary>
-        /// Async version of <see cref="BeginTransaction" />.
+        /// Occurs when a database connection is about to be closed.
         /// </summary>
-        Task BeginTransactionAsync();
+        event EventHandler<DbConnectionEventArgs> ConnectionClosing;
 
         /// <summary>
-        /// Async version of <see cref="BeginTransaction" />.
+        /// Occurs when a database exception has been thrown.
         /// </summary>
-        Task BeginTransactionAsync(CancellationToken cancellationToken);
-#endif
+        event EventHandler<ExceptionEventArgs> ExceptionThrown;
     }
 }
diff --git a/PetaPoco/IExecute.cs b/PetaPoco/IExecute.cs
index 17e3657b..9fe2154b 100644
--- a/PetaPoco/IExecute.cs
+++ b/PetaPoco/IExecute.cs
@@ -11,33 +11,33 @@ public interface IExecute
         /// <summary>
         /// Executes a non-query command.
         /// </summary>
-        /// <param name="sql">The SQL statement to execute.</param>
-        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
+        /// <param name="sql">An Sql builder object representing the SQL statement and its arguments.</param>
         /// <returns>The number of rows affected.</returns>
-        int Execute(string sql, params object[] args);
+        int Execute(Sql sql);
 
         /// <summary>
         /// Executes a non-query command.
         /// </summary>
-        /// <param name="sql">An Sql builder object representing the SQL statement and its arguments.</param>
+        /// <param name="sql">The SQL statement to execute.</param>
+        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
         /// <returns>The number of rows affected.</returns>
-        int Execute(Sql sql);
+        int Execute(string sql, params object[] args);
 
         /// <summary>
         /// Executes the query and returns the first column of the first row in the result set.
         /// </summary>
         /// <typeparam name="T">The type that the result value should be cast to.</typeparam>
-        /// <param name="sql">The SQL query to execute.</param>
-        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
+        /// <param name="sql">An Sql builder object representing the SQL query and its arguments.</param>
         /// <returns>The scalar value cast to <typeparamref name="T"/>.</returns>
-        T ExecuteScalar<T>(string sql, params object[] args);
+        T ExecuteScalar<T>(Sql sql);
 
         /// <summary>
         /// Executes the query and returns the first column of the first row in the result set.
         /// </summary>
         /// <typeparam name="T">The type that the result value should be cast to.</typeparam>
-        /// <param name="sql">An Sql builder object representing the SQL query and its arguments.</param>
+        /// <param name="sql">The SQL query to execute.</param>
+        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
         /// <returns>The scalar value cast to <typeparamref name="T"/>.</returns>
-        T ExecuteScalar<T>(Sql sql);
+        T ExecuteScalar<T>(string sql, params object[] args);
     }
 }
diff --git a/PetaPoco/IExecuteAsync.cs b/PetaPoco/IExecuteAsync.cs
index b82629e5..38e00178 100644
--- a/PetaPoco/IExecuteAsync.cs
+++ b/PetaPoco/IExecuteAsync.cs
@@ -12,53 +12,53 @@ namespace PetaPoco
     /// </remarks>
     public interface IExecuteAsync
     {
+        /// <inheritdoc cref="ExecuteAsync(CancellationToken, Sql)"/>
+        Task<int> ExecuteAsync(Sql sql);
+
         /// <inheritdoc cref="ExecuteAsync(CancellationToken, string, object[])"/>
         Task<int> ExecuteAsync(string sql, params object[] args);
 
+        /// <inheritdoc cref="ExecuteScalarAsync(CancellationToken, Sql)"/>
+        Task<T> ExecuteScalarAsync<T>(Sql sql);
+
+        /// <inheritdoc cref="ExecuteScalarAsync(CancellationToken, string, object[])"/>
+        Task<T> ExecuteScalarAsync<T>(string sql, params object[] args);
+
         /// <summary>
         /// Asynchronously executes a non-query command with a cancellation token.
         /// </summary>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
-        /// <param name="sql">The SQL statement to execute.</param>
-        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
+        /// <param name="sql">An Sql builder object representing the SQL statement and its arguments.</param>
         /// <returns>A task that represents the asynchronous operation. The task result is the number of rows affected.</returns>
-        Task<int> ExecuteAsync(CancellationToken cancellationToken, string sql, params object[] args);
-
-        /// <inheritdoc cref="ExecuteAsync(CancellationToken, Sql)"/>
-        Task<int> ExecuteAsync(Sql sql);
+        Task<int> ExecuteAsync(CancellationToken cancellationToken, Sql sql);
 
         /// <summary>
         /// Asynchronously executes a non-query command with a cancellation token.
         /// </summary>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
-        /// <param name="sql">An Sql builder object representing the SQL statement and its arguments.</param>
+        /// <param name="sql">The SQL statement to execute.</param>
+        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
         /// <returns>A task that represents the asynchronous operation. The task result is the number of rows affected.</returns>
-        Task<int> ExecuteAsync(CancellationToken cancellationToken, Sql sql);
-
-        /// <inheritdoc cref="ExecuteScalarAsync(CancellationToken, string, object[])"/>
-        Task<T> ExecuteScalarAsync<T>(string sql, params object[] args);
+        Task<int> ExecuteAsync(CancellationToken cancellationToken, string sql, params object[] args);
 
         /// <summary>
         /// Asynchronously executes the query with a cancellation token and returns the first column of the first row in the result set.
         /// </summary>
         /// <typeparam name="T">The type that the result value should be cast to.</typeparam>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
-        /// <param name="sql">The SQL query to execute.</param>
-        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
+        /// <param name="sql">An Sql builder object representing the SQL query and its arguments.</param>
         /// <returns>A task that represents the asynchronous operation. The task result is the scalar value cast to <typeparamref name="T"/>.</returns>
-        Task<T> ExecuteScalarAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
-
-        /// <inheritdoc cref="ExecuteScalarAsync(CancellationToken, Sql)"/>
-        Task<T> ExecuteScalarAsync<T>(Sql sql);
+        Task<T> ExecuteScalarAsync<T>(CancellationToken cancellationToken, Sql sql);
 
         /// <summary>
         /// Asynchronously executes the query with a cancellation token and returns the first column of the first row in the result set.
         /// </summary>
         /// <typeparam name="T">The type that the result value should be cast to.</typeparam>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
-        /// <param name="sql">An Sql builder object representing the SQL query and its arguments.</param>
+        /// <param name="sql">The SQL query to execute.</param>
+        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
         /// <returns>A task that represents the asynchronous operation. The task result is the scalar value cast to <typeparamref name="T"/>.</returns>
-        Task<T> ExecuteScalarAsync<T>(CancellationToken cancellationToken, Sql sql);
+        Task<T> ExecuteScalarAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
     }
 #endif
 }
diff --git a/PetaPoco/IQuery.cs b/PetaPoco/IQuery.cs
index 5829f74b..d2bd1a98 100644
--- a/PetaPoco/IQuery.cs
+++ b/PetaPoco/IQuery.cs
@@ -5,7 +5,7 @@ namespace PetaPoco
 {
     public interface IQuery
     {
-        #region Query
+        #region Query : Single-Poco
 
         /// <summary>
         /// Streams the result of a select all query (SELECT *).
@@ -24,10 +24,9 @@ public interface IQuery
         /// For some DB providers, care should be taken to not start a new Query before finishing with and disposing of the previous one. In cases where this is an issue, consider using Fetch, which returns the results as a List rather than an IEnumerable.
         /// </remarks>
         /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
-        /// <param name="sql">The SQL query.</param>
-        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
+        /// <param name="sql">An SQL builder object representing the base SQL query and its arguments.</param>
         /// <returns>An IEnumerable collection of POCOs.</returns>
-        IEnumerable<T> Query<T>(string sql, params object[] args);
+        IEnumerable<T> Query<T>(Sql sql);
 
         /// <summary>
         /// Runs an SQL query, returning the results as an IEnumerable collection.
@@ -36,21 +35,66 @@ public interface IQuery
         /// For some DB providers, care should be taken to not start a new Query before finishing with and disposing of the previous one. In cases where this is an issue, consider using Fetch, which returns the results as a List rather than an IEnumerable.
         /// </remarks>
         /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
-        /// <param name="sql">An SQL builder object representing the base SQL query and its arguments.</param>
+        /// <param name="sql">The SQL query.</param>
+        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
         /// <returns>An IEnumerable collection of POCOs.</returns>
-        IEnumerable<T> Query<T>(Sql sql);
+        IEnumerable<T> Query<T>(string sql, params object[] args);
+
+        #endregion
+
+        #region Query : Multi-Poco
+
+        /// <summary>
+        /// Perform a multi-poco query.
+        /// </summary>
+        /// <typeparam name="T1">The first POCO type.</typeparam>
+        /// <typeparam name="T2">The second POCO type.</typeparam>
+        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
+        /// <returns>A collection of POCOs as an IEnumerable.</returns>
+        IEnumerable<T1> Query<T1, T2>(Sql sql);
+
+        /// <summary>
+        /// Perform a multi-poco query.
+        /// </summary>
+        /// <typeparam name="T1">The first POCO type.</typeparam>
+        /// <typeparam name="T2">The second POCO type.</typeparam>
+        /// <typeparam name="T3">The third POCO type.</typeparam>
+        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
+        /// <returns>A collection of POCOs as an IEnumerable.</returns>
+        IEnumerable<T1> Query<T1, T2, T3>(Sql sql);
+
+        /// <summary>
+        /// Perform a multi-poco query.
+        /// </summary>
+        /// <typeparam name="T1">The first POCO type.</typeparam>
+        /// <typeparam name="T2">The second POCO type.</typeparam>
+        /// <typeparam name="T3">The third POCO type.</typeparam>
+        /// <typeparam name="T4">The fourth POCO type.</typeparam>
+        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
+        /// <returns>A collection of POCOs as an IEnumerable.</returns>
+        IEnumerable<T1> Query<T1, T2, T3, T4>(Sql sql);
+
+        /// <summary>
+        /// Perform a multi-poco query.
+        /// </summary>
+        /// <typeparam name="T1">The first POCO type.</typeparam>
+        /// <typeparam name="T2">The second POCO type.</typeparam>
+        /// <typeparam name="T3">The third POCO type.</typeparam>
+        /// <typeparam name="T4">The fourth POCO type.</typeparam>
+        /// <typeparam name="T5">The fifth POCO type.</typeparam>
+        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
+        /// <returns>A collection of POCOs as an IEnumerable.</returns>
+        IEnumerable<T1> Query<T1, T2, T3, T4, T5>(Sql sql);
 
         /// <summary>
         /// Perform a multi-poco query.
         /// </summary>
         /// <typeparam name="T1">The first POCO type.</typeparam>
         /// <typeparam name="T2">The second POCO type.</typeparam>
-        /// <typeparam name="TRet">The type of objects in the returned IEnumerable.</typeparam>
-        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as an IEnumerable.</returns>
-        IEnumerable<TRet> Query<T1, T2, TRet>(Func<T1, T2, TRet> cb, string sql, params object[] args);
+        IEnumerable<T1> Query<T1, T2>(string sql, params object[] args);
 
         /// <summary>
         /// Perform a multi-poco query.
@@ -58,12 +102,10 @@ public interface IQuery
         /// <typeparam name="T1">The first POCO type.</typeparam>
         /// <typeparam name="T2">The second POCO type.</typeparam>
         /// <typeparam name="T3">The third POCO type.</typeparam>
-        /// <typeparam name="TRet">The type of objects in the returned IEnumerable.</typeparam>
-        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as an IEnumerable.</returns>
-        IEnumerable<TRet> Query<T1, T2, T3, TRet>(Func<T1, T2, T3, TRet> cb, string sql, params object[] args);
+        IEnumerable<T1> Query<T1, T2, T3>(string sql, params object[] args);
 
         /// <summary>
         /// Perform a multi-poco query.
@@ -72,12 +114,10 @@ public interface IQuery
         /// <typeparam name="T2">The second POCO type.</typeparam>
         /// <typeparam name="T3">The third POCO type.</typeparam>
         /// <typeparam name="T4">The fourth POCO type.</typeparam>
-        /// <typeparam name="TRet">The type of objects in the returned IEnumerable.</typeparam>
-        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as an IEnumerable.</returns>
-        IEnumerable<TRet> Query<T1, T2, T3, T4, TRet>(Func<T1, T2, T3, T4, TRet> cb, string sql, params object[] args);
+        IEnumerable<T1> Query<T1, T2, T3, T4>(string sql, params object[] args);
 
         /// <summary>
         /// Perform a multi-poco query.
@@ -87,12 +127,10 @@ public interface IQuery
         /// <typeparam name="T3">The third POCO type.</typeparam>
         /// <typeparam name="T4">The fourth POCO type.</typeparam>
         /// <typeparam name="T5">The fifth POCO type.</typeparam>
-        /// <typeparam name="TRet">The type of objects in the returned IEnumerable.</typeparam>
-        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as an IEnumerable.</returns>
-        IEnumerable<TRet> Query<T1, T2, T3, T4, T5, TRet>(Func<T1, T2, T3, T4, T5, TRet> cb, string sql, params object[] args);
+        IEnumerable<T1> Query<T1, T2, T3, T4, T5>(string sql, params object[] args);
 
         /// <summary>
         /// Perform a multi-poco query.
@@ -149,10 +187,12 @@ public interface IQuery
         /// </summary>
         /// <typeparam name="T1">The first POCO type.</typeparam>
         /// <typeparam name="T2">The second POCO type.</typeparam>
+        /// <typeparam name="TRet">The type of objects in the returned IEnumerable.</typeparam>
+        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as an IEnumerable.</returns>
-        IEnumerable<T1> Query<T1, T2>(string sql, params object[] args);
+        IEnumerable<TRet> Query<T1, T2, TRet>(Func<T1, T2, TRet> cb, string sql, params object[] args);
 
         /// <summary>
         /// Perform a multi-poco query.
@@ -160,10 +200,12 @@ public interface IQuery
         /// <typeparam name="T1">The first POCO type.</typeparam>
         /// <typeparam name="T2">The second POCO type.</typeparam>
         /// <typeparam name="T3">The third POCO type.</typeparam>
+        /// <typeparam name="TRet">The type of objects in the returned IEnumerable.</typeparam>
+        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as an IEnumerable.</returns>
-        IEnumerable<T1> Query<T1, T2, T3>(string sql, params object[] args);
+        IEnumerable<TRet> Query<T1, T2, T3, TRet>(Func<T1, T2, T3, TRet> cb, string sql, params object[] args);
 
         /// <summary>
         /// Perform a multi-poco query.
@@ -172,10 +214,12 @@ public interface IQuery
         /// <typeparam name="T2">The second POCO type.</typeparam>
         /// <typeparam name="T3">The third POCO type.</typeparam>
         /// <typeparam name="T4">The fourth POCO type.</typeparam>
+        /// <typeparam name="TRet">The type of objects in the returned IEnumerable.</typeparam>
+        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as an IEnumerable.</returns>
-        IEnumerable<T1> Query<T1, T2, T3, T4>(string sql, params object[] args);
+        IEnumerable<TRet> Query<T1, T2, T3, T4, TRet>(Func<T1, T2, T3, T4, TRet> cb, string sql, params object[] args);
 
         /// <summary>
         /// Perform a multi-poco query.
@@ -185,67 +229,46 @@ public interface IQuery
         /// <typeparam name="T3">The third POCO type.</typeparam>
         /// <typeparam name="T4">The fourth POCO type.</typeparam>
         /// <typeparam name="T5">The fifth POCO type.</typeparam>
+        /// <typeparam name="TRet">The type of objects in the returned IEnumerable.</typeparam>
+        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as an IEnumerable.</returns>
-        IEnumerable<T1> Query<T1, T2, T3, T4, T5>(string sql, params object[] args);
+        IEnumerable<TRet> Query<T1, T2, T3, T4, T5, TRet>(Func<T1, T2, T3, T4, T5, TRet> cb, string sql, params object[] args);
 
         /// <summary>
-        /// Perform a multi-poco query.
+        /// Performs a multi-poco query.
         /// </summary>
-        /// <typeparam name="T1">The first POCO type.</typeparam>
-        /// <typeparam name="T2">The second POCO type.</typeparam>
-        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
+        /// <typeparam name="TRet">The type of objects in the returned IEnumerable.</typeparam>
+        /// <param name="types">An array of Types representing the POCO types of the returned result set.</param>
+        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
+        /// <param name="sql">The SQL query to be executed.</param>
+        /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as an IEnumerable.</returns>
-        IEnumerable<T1> Query<T1, T2>(Sql sql);
+        IEnumerable<TRet> Query<TRet>(Type[] types, object cb, string sql, params object[] args);
 
-        /// <summary>
-        /// Perform a multi-poco query.
-        /// </summary>
-        /// <typeparam name="T1">The first POCO type.</typeparam>
-        /// <typeparam name="T2">The second POCO type.</typeparam>
-        /// <typeparam name="T3">The third POCO type.</typeparam>
-        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
-        /// <returns>A collection of POCOs as an IEnumerable.</returns>
-        IEnumerable<T1> Query<T1, T2, T3>(Sql sql);
+        #endregion
 
-        /// <summary>
-        /// Perform a multi-poco query.
-        /// </summary>
-        /// <typeparam name="T1">The first POCO type.</typeparam>
-        /// <typeparam name="T2">The second POCO type.</typeparam>
-        /// <typeparam name="T3">The third POCO type.</typeparam>
-        /// <typeparam name="T4">The fourth POCO type.</typeparam>
-        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
-        /// <returns>A collection of POCOs as an IEnumerable.</returns>
-        IEnumerable<T1> Query<T1, T2, T3, T4>(Sql sql);
+        #region QueryMultiple : Multi-POCO Result Set IGridReader
 
         /// <summary>
-        /// Perform a multi-poco query.
+        /// Perform a multi-results set query.
         /// </summary>
-        /// <typeparam name="T1">The first POCO type.</typeparam>
-        /// <typeparam name="T2">The second POCO type.</typeparam>
-        /// <typeparam name="T3">The third POCO type.</typeparam>
-        /// <typeparam name="T4">The fourth POCO type.</typeparam>
-        /// <typeparam name="T5">The fifth POCO type.</typeparam>
         /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
-        /// <returns>A collection of POCOs as an IEnumerable.</returns>
-        IEnumerable<T1> Query<T1, T2, T3, T4, T5>(Sql sql);
+        /// <returns>A GridReader to be queried.</returns>
+        IGridReader QueryMultiple(Sql sql);
 
         /// <summary>
-        /// Performs a multi-poco query.
+        /// Perform a multi-results set query.
         /// </summary>
-        /// <typeparam name="TRet">The type of objects in the returned IEnumerable.</typeparam>
-        /// <param name="types">An array of Types representing the POCO types of the returned result set.</param>
-        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
-        /// <returns>A collection of POCOs as an IEnumerable.</returns>
-        IEnumerable<TRet> Query<TRet>(Type[] types, object cb, string sql, params object[] args);
+        /// <returns>A GridReader to be queried.</returns>
+        IGridReader QueryMultiple(string sql, params object[] args);
 
         #endregion
 
-        #region Fetch
+        #region Fetch : Single-Poco
 
         /// <summary>
         /// Runs a SELECT * query and returns the result set as a typed list.
@@ -254,6 +277,14 @@ public interface IQuery
         /// <returns>A List holding the results of the query.</returns>
         List<T> Fetch<T>();
 
+        /// <summary>
+        /// Runs a query and returns the result set as a typed list.
+        /// </summary>
+        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
+        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
+        /// <returns>A List holding the results of the query.</returns>
+        List<T> Fetch<T>(Sql sql);
+
         /// <summary>
         /// Runs a query and returns the result set as a typed list.
         /// </summary>
@@ -263,64 +294,61 @@ public interface IQuery
         /// <returns>A List holding the results of the query.</returns>
         List<T> Fetch<T>(string sql, params object[] args);
 
+        #endregion
+
+        #region Fetch : Multi-Poco
+
         /// <summary>
-        /// Runs a query and returns the result set as a typed list.
+        /// Perform a multi-poco fetch.
         /// </summary>
-        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
+        /// <typeparam name="T1">The first POCO type.</typeparam>
+        /// <typeparam name="T2">The second POCO type.</typeparam>
         /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
-        /// <returns>A List holding the results of the query.</returns>
-        List<T> Fetch<T>(Sql sql);
+        /// <returns>A collection of POCOs as a List.</returns>
+        List<T1> Fetch<T1, T2>(Sql sql);
 
         /// <summary>
-        /// Retrieves a page of records (without the total count).
+        /// Perform a multi-poco fetch.
         /// </summary>
-        /// <remarks>
-        /// PetaPoco will automatically modify a default SELECT * statement to only retrieve the records for the specified page.
-        /// </remarks>
-        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
-        /// <param name="page">The 1-based page number to retrieve.</param>
-        /// <param name="itemsPerPage">The number of records per page.</param>
-        /// <returns>A List of results.</returns>
-        List<T> Fetch<T>(long page, long itemsPerPage);
+        /// <typeparam name="T1">The first POCO type.</typeparam>
+        /// <typeparam name="T2">The second POCO type.</typeparam>
+        /// <typeparam name="T3">The third POCO type.</typeparam>
+        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
+        /// <returns>A collection of POCOs as a List.</returns>
+        List<T1> Fetch<T1, T2, T3>(Sql sql);
 
         /// <summary>
-        /// Retrieves a page of records (without the total count).
+        /// Perform a multi-poco fetch.
         /// </summary>
-        /// <remarks>
-        /// PetaPoco will automatically modify the supplied SELECT statement to only retrieve the records for the specified page.
-        /// </remarks>
-        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
-        /// <param name="page">The 1-based page number to retrieve.</param>
-        /// <param name="itemsPerPage">The number of records per page.</param>
-        /// <param name="sql">The base SQL query.</param>
-        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
-        /// <returns>A List of results.</returns>
-        List<T> Fetch<T>(long page, long itemsPerPage, string sql, params object[] args);
+        /// <typeparam name="T1">The first POCO type.</typeparam>
+        /// <typeparam name="T2">The second POCO type.</typeparam>
+        /// <typeparam name="T3">The third POCO type.</typeparam>
+        /// <typeparam name="T4">The fourth POCO type.</typeparam>
+        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
+        /// <returns>A collection of POCOs as a List.</returns>
+        List<T1> Fetch<T1, T2, T3, T4>(Sql sql);
 
         /// <summary>
-        /// Retrieves a page of records (without the total count).
+        /// Perform a multi-poco fetch.
         /// </summary>
-        /// <remarks>
-        /// PetaPoco will automatically modify the supplied SELECT statement to only retrieve the records for the specified page.
-        /// </remarks>
-        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
-        /// <param name="page">The 1-based page number to retrieve.</param>
-        /// <param name="itemsPerPage">The number of records per page.</param>
-        /// <param name="sql">An SQL builder object representing the base SQL query and its arguments.</param>
-        /// <returns>A List of results.</returns>
-        List<T> Fetch<T>(long page, long itemsPerPage, Sql sql);
+        /// <typeparam name="T1">The first POCO type.</typeparam>
+        /// <typeparam name="T2">The second POCO type.</typeparam>
+        /// <typeparam name="T3">The third POCO type.</typeparam>
+        /// <typeparam name="T4">The fourth POCO type.</typeparam>
+        /// <typeparam name="T5">The fourth POCO type.</typeparam>
+        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
+        /// <returns>A collection of POCOs as a List.</returns>
+        List<T1> Fetch<T1, T2, T3, T4, T5>(Sql sql);
 
         /// <summary>
         /// Perform a multi-poco fetch.
         /// </summary>
         /// <typeparam name="T1">The first POCO type.</typeparam>
         /// <typeparam name="T2">The second POCO type.</typeparam>
-        /// <typeparam name="TRet">The returned list POCO type.</typeparam>
-        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as a List.</returns>
-        List<TRet> Fetch<T1, T2, TRet>(Func<T1, T2, TRet> cb, string sql, params object[] args);
+        List<T1> Fetch<T1, T2>(string sql, params object[] args);
 
         /// <summary>
         /// Perform a multi-poco fetch.
@@ -328,12 +356,10 @@ public interface IQuery
         /// <typeparam name="T1">The first POCO type.</typeparam>
         /// <typeparam name="T2">The second POCO type.</typeparam>
         /// <typeparam name="T3">The third POCO type.</typeparam>
-        /// <typeparam name="TRet">The returned list POCO type.</typeparam>
-        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as a List.</returns>
-        List<TRet> Fetch<T1, T2, T3, TRet>(Func<T1, T2, T3, TRet> cb, string sql, params object[] args);
+        List<T1> Fetch<T1, T2, T3>(string sql, params object[] args);
 
         /// <summary>
         /// Perform a multi-poco fetch.
@@ -342,12 +368,10 @@ public interface IQuery
         /// <typeparam name="T2">The second POCO type.</typeparam>
         /// <typeparam name="T3">The third POCO type.</typeparam>
         /// <typeparam name="T4">The fourth POCO type.</typeparam>
-        /// <typeparam name="TRet">The returned list POCO type.</typeparam>
-        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as a List.</returns>
-        List<TRet> Fetch<T1, T2, T3, T4, TRet>(Func<T1, T2, T3, T4, TRet> cb, string sql, params object[] args);
+        List<T1> Fetch<T1, T2, T3, T4>(string sql, params object[] args);
 
         /// <summary>
         /// Perform a multi-poco fetch.
@@ -357,12 +381,10 @@ public interface IQuery
         /// <typeparam name="T3">The third POCO type.</typeparam>
         /// <typeparam name="T4">The fourth POCO type.</typeparam>
         /// <typeparam name="T5">The fifth POCO type.</typeparam>
-        /// <typeparam name="TRet">The returned list POCO type.</typeparam>
-        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as a List.</returns>
-        List<TRet> Fetch<T1, T2, T3, T4, T5, TRet>(Func<T1, T2, T3, T4, T5, TRet> cb, string sql, params object[] args);
+        List<T1> Fetch<T1, T2, T3, T4, T5>(string sql, params object[] args);
 
         /// <summary>
         /// Perform a multi-poco fetch.
@@ -419,10 +441,12 @@ public interface IQuery
         /// </summary>
         /// <typeparam name="T1">The first POCO type.</typeparam>
         /// <typeparam name="T2">The second POCO type.</typeparam>
+        /// <typeparam name="TRet">The returned list POCO type.</typeparam>
+        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as a List.</returns>
-        List<T1> Fetch<T1, T2>(string sql, params object[] args);
+        List<TRet> Fetch<T1, T2, TRet>(Func<T1, T2, TRet> cb, string sql, params object[] args);
 
         /// <summary>
         /// Perform a multi-poco fetch.
@@ -430,10 +454,12 @@ public interface IQuery
         /// <typeparam name="T1">The first POCO type.</typeparam>
         /// <typeparam name="T2">The second POCO type.</typeparam>
         /// <typeparam name="T3">The third POCO type.</typeparam>
+        /// <typeparam name="TRet">The returned list POCO type.</typeparam>
+        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as a List.</returns>
-        List<T1> Fetch<T1, T2, T3>(string sql, params object[] args);
+        List<TRet> Fetch<T1, T2, T3, TRet>(Func<T1, T2, T3, TRet> cb, string sql, params object[] args);
 
         /// <summary>
         /// Perform a multi-poco fetch.
@@ -442,10 +468,12 @@ public interface IQuery
         /// <typeparam name="T2">The second POCO type.</typeparam>
         /// <typeparam name="T3">The third POCO type.</typeparam>
         /// <typeparam name="T4">The fourth POCO type.</typeparam>
+        /// <typeparam name="TRet">The returned list POCO type.</typeparam>
+        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as a List.</returns>
-        List<T1> Fetch<T1, T2, T3, T4>(string sql, params object[] args);
+        List<TRet> Fetch<T1, T2, T3, T4, TRet>(Func<T1, T2, T3, T4, TRet> cb, string sql, params object[] args);
 
         /// <summary>
         /// Perform a multi-poco fetch.
@@ -455,52 +483,55 @@ public interface IQuery
         /// <typeparam name="T3">The third POCO type.</typeparam>
         /// <typeparam name="T4">The fourth POCO type.</typeparam>
         /// <typeparam name="T5">The fifth POCO type.</typeparam>
+        /// <typeparam name="TRet">The returned list POCO type.</typeparam>
+        /// <param name="cb">A callback function to connect the POCO instances, or <see langword="null"/> to automatically guess the relationships.</param>
         /// <param name="sql">The SQL query to be executed.</param>
         /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
         /// <returns>A collection of POCOs as a List.</returns>
-        List<T1> Fetch<T1, T2, T3, T4, T5>(string sql, params object[] args);
+        List<TRet> Fetch<T1, T2, T3, T4, T5, TRet>(Func<T1, T2, T3, T4, T5, TRet> cb, string sql, params object[] args);
 
-        /// <summary>
-        /// Perform a multi-poco fetch.
-        /// </summary>
-        /// <typeparam name="T1">The first POCO type.</typeparam>
-        /// <typeparam name="T2">The second POCO type.</typeparam>
-        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
-        /// <returns>A collection of POCOs as a List.</returns>
-        List<T1> Fetch<T1, T2>(Sql sql);
+        #endregion
+
+        #region Fetch : Paged SkipTake
 
         /// <summary>
-        /// Perform a multi-poco fetch.
+        /// Retrieves a page of records (without the total count).
         /// </summary>
-        /// <typeparam name="T1">The first POCO type.</typeparam>
-        /// <typeparam name="T2">The second POCO type.</typeparam>
-        /// <typeparam name="T3">The third POCO type.</typeparam>
-        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
-        /// <returns>A collection of POCOs as a List.</returns>
-        List<T1> Fetch<T1, T2, T3>(Sql sql);
+        /// <remarks>
+        /// PetaPoco will automatically modify a default SELECT * statement to only retrieve the records for the specified page.
+        /// </remarks>
+        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
+        /// <param name="page">The 1-based page number to retrieve.</param>
+        /// <param name="itemsPerPage">The number of records per page.</param>
+        /// <returns>A List of results.</returns>
+        List<T> Fetch<T>(long page, long itemsPerPage);
 
         /// <summary>
-        /// Perform a multi-poco fetch.
+        /// Retrieves a page of records (without the total count).
         /// </summary>
-        /// <typeparam name="T1">The first POCO type.</typeparam>
-        /// <typeparam name="T2">The second POCO type.</typeparam>
-        /// <typeparam name="T3">The third POCO type.</typeparam>
-        /// <typeparam name="T4">The fourth POCO type.</typeparam>
-        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
-        /// <returns>A collection of POCOs as a List.</returns>
-        List<T1> Fetch<T1, T2, T3, T4>(Sql sql);
+        /// <remarks>
+        /// PetaPoco will automatically modify the supplied SELECT statement to only retrieve the records for the specified page.
+        /// </remarks>
+        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
+        /// <param name="page">The 1-based page number to retrieve.</param>
+        /// <param name="itemsPerPage">The number of records per page.</param>
+        /// <param name="sql">An SQL builder object representing the base SQL query and its arguments.</param>
+        /// <returns>A List of results.</returns>
+        List<T> Fetch<T>(long page, long itemsPerPage, Sql sql);
 
         /// <summary>
-        /// Perform a multi-poco fetch.
+        /// Retrieves a page of records (without the total count).
         /// </summary>
-        /// <typeparam name="T1">The first POCO type.</typeparam>
-        /// <typeparam name="T2">The second POCO type.</typeparam>
-        /// <typeparam name="T3">The third POCO type.</typeparam>
-        /// <typeparam name="T4">The fourth POCO type.</typeparam>
-        /// <typeparam name="T5">The fourth POCO type.</typeparam>
-        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
-        /// <returns>A collection of POCOs as a List.</returns>
-        List<T1> Fetch<T1, T2, T3, T4, T5>(Sql sql);
+        /// <remarks>
+        /// PetaPoco will automatically modify the supplied SELECT statement to only retrieve the records for the specified page.
+        /// </remarks>
+        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
+        /// <param name="page">The 1-based page number to retrieve.</param>
+        /// <param name="itemsPerPage">The number of records per page.</param>
+        /// <param name="sql">The base SQL query.</param>
+        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
+        /// <returns>A List of results.</returns>
+        List<T> Fetch<T>(long page, long itemsPerPage, string sql, params object[] args);
 
         #endregion
 
@@ -510,29 +541,26 @@ public interface IQuery
         /// Retrieves a page of records and the total number of available records.
         /// </summary>
         /// <remarks>
-        /// This method allows separate SQL statements to be explicitly provided for the two parts of the page query. The page and itemsPerPage parameters are not used directly and are used simply to populate the returned Page object.
+        /// PetaPoco will automatically modify a default SELECT * statement to only retrieve the records for the specified page.  It will also execute a second query to retrieve the total number of records in the result set.
         /// </remarks>
         /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
         /// <param name="page">The 1-based page number to retrieve.</param>
         /// <param name="itemsPerPage">The number of records per page.</param>
-        /// <param name="sqlCount">The SQL to retrieve the total number of records.</param>
-        /// <param name="countArgs">Arguments to any embedded parameters in the sqlCount statement.</param>
-        /// <param name="sqlPage">The SQL to retrieve a single page of results.</param>
-        /// <param name="pageArgs">Arguments to any embedded parameters in the sqlPage statement.</param>
         /// <returns>A Page of results.</returns>
-        Page<T> Page<T>(long page, long itemsPerPage, string sqlCount, object[] countArgs, string sqlPage, object[] pageArgs);
+        Page<T> Page<T>(long page, long itemsPerPage);
 
         /// <summary>
         /// Retrieves a page of records and the total number of available records.
         /// </summary>
         /// <remarks>
-        /// PetaPoco will automatically modify a default SELECT * statement to only retrieve the records for the specified page.  It will also execute a second query to retrieve the total number of records in the result set.
+        /// PetaPoco will automatically modify the supplied SELECT statement to only retrieve the records for the specified page.  It will also execute a second query to retrieve the total number of records in the result set.
         /// </remarks>
         /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
         /// <param name="page">The 1-based page number to retrieve.</param>
         /// <param name="itemsPerPage">The number of records per page.</param>
+        /// <param name="sql">An SQL builder object representing the base SQL query and its arguments.</param>
         /// <returns>A Page of results.</returns>
-        Page<T> Page<T>(long page, long itemsPerPage);
+        Page<T> Page<T>(long page, long itemsPerPage, Sql sql);
 
         /// <summary>
         /// Retrieves a page of records and the total number of available records.
@@ -552,14 +580,15 @@ public interface IQuery
         /// Retrieves a page of records and the total number of available records.
         /// </summary>
         /// <remarks>
-        /// PetaPoco will automatically modify the supplied SELECT statement to only retrieve the records for the specified page.  It will also execute a second query to retrieve the total number of records in the result set.
+        /// This method allows separate SQL statements to be explicitly provided for the two parts of the page query. The page and itemsPerPage parameters are not used directly and are used simply to populate the returned Page object.
         /// </remarks>
         /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
         /// <param name="page">The 1-based page number to retrieve.</param>
         /// <param name="itemsPerPage">The number of records per page.</param>
-        /// <param name="sql">An SQL builder object representing the base SQL query and its arguments.</param>
+        /// <param name="sqlCount">An SQL builder object representing the SQL to retrieve the total number of records.</param>
+        /// <param name="sqlPage">An SQL builder object representing the SQL to retrieve a single page of results.</param>
         /// <returns>A Page of results.</returns>
-        Page<T> Page<T>(long page, long itemsPerPage, Sql sql);
+        Page<T> Page<T>(long page, long itemsPerPage, Sql sqlCount, Sql sqlPage);
 
         /// <summary>
         /// Retrieves a page of records and the total number of available records.
@@ -570,10 +599,12 @@ public interface IQuery
         /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
         /// <param name="page">The 1-based page number to retrieve.</param>
         /// <param name="itemsPerPage">The number of records per page.</param>
-        /// <param name="sqlCount">An SQL builder object representing the SQL to retrieve the total number of records.</param>
-        /// <param name="sqlPage">An SQL builder object representing the SQL to retrieve a single page of results.</param>
+        /// <param name="sqlCount">The SQL to retrieve the total number of records.</param>
+        /// <param name="countArgs">Arguments to any embedded parameters in the sqlCount statement.</param>
+        /// <param name="sqlPage">The SQL to retrieve a single page of results.</param>
+        /// <param name="pageArgs">Arguments to any embedded parameters in the sqlPage statement.</param>
         /// <returns>A Page of results.</returns>
-        Page<T> Page<T>(long page, long itemsPerPage, Sql sqlCount, Sql sqlPage);
+        Page<T> Page<T>(long page, long itemsPerPage, string sqlCount, object[] countArgs, string sqlPage, object[] pageArgs);
 
         #endregion
 
@@ -600,10 +631,9 @@ public interface IQuery
         /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
         /// <param name="skip">The number of rows at the start of the result set to skip over.</param>
         /// <param name="take">The number of rows to retrieve.</param>
-        /// <param name="sql">The base SQL query.</param>
-        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
+        /// <param name="sql">An SQL builder object representing the base SQL query and its arguments.</param>
         /// <returns>A List of results.</returns>
-        List<T> SkipTake<T>(long skip, long take, string sql, params object[] args);
+        List<T> SkipTake<T>(long skip, long take, Sql sql);
 
         /// <summary>
         /// Retrieves a range of records from result set.
@@ -614,9 +644,10 @@ public interface IQuery
         /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
         /// <param name="skip">The number of rows at the start of the result set to skip over.</param>
         /// <param name="take">The number of rows to retrieve.</param>
-        /// <param name="sql">An SQL builder object representing the base SQL query and its arguments.</param>
+        /// <param name="sql">The base SQL query.</param>
+        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
         /// <returns>A List of results.</returns>
-        List<T> SkipTake<T>(long skip, long take, Sql sql);
+        List<T> SkipTake<T>(long skip, long take, string sql, params object[] args);
 
         #endregion
 
@@ -658,37 +689,29 @@ public interface IQuery
         /// Runs a query that should always return a single row.
         /// </summary>
         /// <remarks>
-        /// Throws an exception if there is not exactly one record
+        /// Throws an exception if there is not exactly one matching record
         /// </remarks>
         /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
-        /// <param name="sql">The SQL query.</param>
-        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
+        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
         /// <returns>The single record matching the specified SQL query.</returns>
-        T Single<T>(string sql, params object[] args);
+        T Single<T>(Sql sql);
 
         /// <summary>
         /// Runs a query that should always return a single row.
         /// </summary>
         /// <remarks>
-        /// Throws an exception if there is not exactly one matching record
+        /// Throws an exception if there is not exactly one record
         /// </remarks>
         /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
-        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
+        /// <param name="sql">The SQL query.</param>
+        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
         /// <returns>The single record matching the specified SQL query.</returns>
-        T Single<T>(Sql sql);
+        T Single<T>(string sql, params object[] args);
 
         #endregion
 
         #region SingleOrDefault
 
-        /// <summary>
-        /// Runs a query that should always return either a single row, or no rows.
-        /// </summary>
-        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
-        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
-        /// <returns>The single record matching the specified primary key value, or default(T) if no matching rows.</returns>
-        T SingleOrDefault<T>(Sql sql);
-
         /// <summary>
         /// Returns the record with the specified primary key value, or the default value if not found.
         /// </summary>
@@ -700,6 +723,14 @@ public interface IQuery
         /// <returns>The single record matching the specified primary key value.</returns>
         T SingleOrDefault<T>(object primaryKey);
 
+        /// <summary>
+        /// Runs a query that should always return either a single row, or no rows.
+        /// </summary>
+        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
+        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
+        /// <returns>The single record matching the specified primary key value, or default(T) if no matching rows.</returns>
+        T SingleOrDefault<T>(Sql sql);
+
         /// <summary>
         /// Runs a query that should always return either a single row, or no rows.
         /// </summary>
@@ -717,18 +748,18 @@ public interface IQuery
         /// Runs a query that should always return at least one record.
         /// </summary>
         /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
-        /// <param name="sql">The SQL query.</param>
-        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
+        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
         /// <returns>The first record in the result set.</returns>
-        T First<T>(string sql, params object[] args);
+        T First<T>(Sql sql);
 
         /// <summary>
         /// Runs a query that should always return at least one record.
         /// </summary>
         /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
-        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
+        /// <param name="sql">The SQL query.</param>
+        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
         /// <returns>The first record in the result set.</returns>
-        T First<T>(Sql sql);
+        T First<T>(string sql, params object[] args);
 
         #endregion
 
@@ -738,37 +769,18 @@ public interface IQuery
         /// Runs a query and returns the first record, or the default value if no matching records.
         /// </summary>
         /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
-        /// <param name="sql">The SQL query.</param>
-        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
+        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
         /// <returns>The first record in the result set, or default(T) if no matching rows.</returns>
-        T FirstOrDefault<T>(string sql, params object[] args);
+        T FirstOrDefault<T>(Sql sql);
 
         /// <summary>
         /// Runs a query and returns the first record, or the default value if no matching records.
         /// </summary>
         /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
-        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
+        /// <param name="sql">The SQL query.</param>
+        /// <param name="args">Arguments to any embedded parameters in the SQL statement.</param>
         /// <returns>The first record in the result set, or default(T) if no matching rows.</returns>
-        T FirstOrDefault<T>(Sql sql);
-
-        #endregion
-
-        #region QueryMultiple
-
-        /// <summary>
-        /// Perform a multi-results set query.
-        /// </summary>
-        /// <param name="sql">An SQL builder object representing the query and its arguments.</param>
-        /// <returns>A GridReader to be queried.</returns>
-        IGridReader QueryMultiple(Sql sql);
-
-        /// <summary>
-        /// Perform a multi-results set query.
-        /// </summary>
-        /// <param name="sql">The SQL query to be executed.</param>
-        /// <param name="args">Arguments to any embedded parameters in the SQL.</param>
-        /// <returns>A GridReader to be queried.</returns>
-        IGridReader QueryMultiple(string sql, params object[] args);
+        T FirstOrDefault<T>(string sql, params object[] args);
 
         #endregion
     }
diff --git a/PetaPoco/IQueryAsync.cs b/PetaPoco/IQueryAsync.cs
index 1d033b56..1dd74562 100644
--- a/PetaPoco/IQueryAsync.cs
+++ b/PetaPoco/IQueryAsync.cs
@@ -9,131 +9,151 @@ namespace PetaPoco
 #if ASYNC
     public interface IQueryAsync
     {
-        #region Query
+        #region QueryAsync : Single-Poco
 
         /// <summary>
         /// Async version of <see cref="IQuery.Query{T}()" />.
         /// </summary>
-        Task QueryAsync<T>(Action<T> receivePocoCallback);
+        Task<IAsyncReader<T>> QueryAsync<T>();
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}()" />.
+        /// Async version of <see cref="IQuery.Query{T}(Sql)" />.
         /// </summary>
-        Task QueryAsync<T>(Action<T> receivePocoCallback, CommandType commandType);
+        Task<IAsyncReader<T>> QueryAsync<T>(Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}()" />.
+        /// Async version of <see cref="IQuery.Query{T}(string, object[])" />.
         /// </summary>
-        Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken);
+        Task<IAsyncReader<T>> QueryAsync<T>(string sql, params object[] args);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Query{T}()" />.
         /// </summary>
-        Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, CommandType commandType);
+        Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}(string, object[])" />.
+        /// Async version of <see cref="IQuery.Query{T}(Sql)" />.
         /// </summary>
-        Task QueryAsync<T>(Action<T> receivePocoCallback, string sql, params object[] args);
+        Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, Sql sql);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Query{T}(string, object[])" />.
         /// </summary>
-        Task QueryAsync<T>(Action<T> receivePocoCallback, CommandType commandType, string sql, params object[] args);
+        Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
+
+        #endregion
+
+        #region QueryAsync : Single-Poco as CommandType
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}(string, object[])" />.
+        /// Async version of <see cref="IQuery.Query{T}()" />.
         /// </summary>
-        Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, string sql, params object[] args);
+        Task<IAsyncReader<T>> QueryAsync<T>(CommandType commandType);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}(string, object[])" />.
+        /// Async version of <see cref="IQuery.Query{T}(Sql)" />.
         /// </summary>
-        Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, CommandType commandType, string sql, params object[] args);
+        Task<IAsyncReader<T>> QueryAsync<T>(CommandType commandType, Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}(Sql)" />.
+        /// Async version of <see cref="IQuery.Query{T}(string, object[])" />.
         /// </summary>
-        Task QueryAsync<T>(Action<T> receivePocoCallback, Sql sql);
+        Task<IAsyncReader<T>> QueryAsync<T>(CommandType commandType, string sql, params object[] args);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}(Sql)" />.
+        /// Async version of <see cref="IQuery.Query{T}()" />.
         /// </summary>
-        Task QueryAsync<T>(Action<T> receivePocoCallback, CommandType commandType, Sql sql);
+        Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, CommandType commandType);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Query{T}(Sql)" />.
         /// </summary>
-        Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, Sql sql);
+        Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, CommandType commandType, Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}(Sql)" />.
+        /// Async version of <see cref="IQuery.Query{T}(string, object[])" />.
         /// </summary>
-        Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, CommandType commandType, Sql sql);
+        Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, CommandType commandType, string sql, params object[] args);
+
+        #endregion
+
+        #region QueryAsync with Action : Single-Poco
 
         /// <summary>
         /// Async version of <see cref="IQuery.Query{T}()" />.
         /// </summary>
-        Task<IAsyncReader<T>> QueryAsync<T>();
+        Task QueryAsync<T>(Action<T> receivePocoCallback);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}()" />.
+        /// Async version of <see cref="IQuery.Query{T}(Sql)" />.
         /// </summary>
-        Task<IAsyncReader<T>> QueryAsync<T>(CommandType commandType);
+        Task QueryAsync<T>(Action<T> receivePocoCallback, Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}()" />.
+        /// Async version of <see cref="IQuery.Query{T}(string, object[])" />.
         /// </summary>
-        Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken);
+        Task QueryAsync<T>(Action<T> receivePocoCallback, string sql, params object[] args);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Query{T}()" />.
         /// </summary>
-        Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, CommandType commandType);
+        Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}(string, object[])" />.
+        /// Async version of <see cref="IQuery.Query{T}(Sql)" />.
         /// </summary>
-        Task<IAsyncReader<T>> QueryAsync<T>(string sql, params object[] args);
+        Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, Sql sql);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Query{T}(string, object[])" />.
         /// </summary>
-        Task<IAsyncReader<T>> QueryAsync<T>(CommandType commandType, string sql, params object[] args);
+        Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, string sql, params object[] args);
+
+        #endregion
+
+        #region QueryAsync with Action : Single-Poco as CommandType
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}(string, object[])" />.
+        /// Async version of <see cref="IQuery.Query{T}()" />.
         /// </summary>
-        Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
+        Task QueryAsync<T>(Action<T> receivePocoCallback, CommandType commandType);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}(string, object[])" />.
+        /// Async version of <see cref="IQuery.Query{T}(Sql)" />.
         /// </summary>
-        Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, CommandType commandType, string sql, params object[] args);
+        Task QueryAsync<T>(Action<T> receivePocoCallback, CommandType commandType, Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}(Sql)" />.
+        /// Async version of <see cref="IQuery.Query{T}(string, object[])" />.
         /// </summary>
-        Task<IAsyncReader<T>> QueryAsync<T>(Sql sql);
+        Task QueryAsync<T>(Action<T> receivePocoCallback, CommandType commandType, string sql, params object[] args);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}(Sql)" />.
+        /// Async version of <see cref="IQuery.Query{T}()" />.
         /// </summary>
-        Task<IAsyncReader<T>> QueryAsync<T>(CommandType commandType, Sql sql);
+        Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, CommandType commandType);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Query{T}(Sql)" />.
         /// </summary>
-        Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, Sql sql);
+        Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, CommandType commandType, Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Query{T}(Sql)" />.
+        /// Async version of <see cref="IQuery.Query{T}(string, object[])" />.
         /// </summary>
-        Task<IAsyncReader<T>> QueryAsync<T>(CancellationToken cancellationToken, CommandType commandType, Sql sql);
+        Task QueryAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, CommandType commandType, string sql, params object[] args);
+
+        #endregion
+
+        #region QueryAsync : Multi-Poco
+
+        #endregion
+
+        #region QueryMultipleAsync : Multi-POCO Result Set
 
         #endregion
 
-        #region Fetch
+        #region FetchAsync : Single-Poco
 
         /// <summary>
         /// Async version of <see cref="IQuery.Fetch{T}()" />.
@@ -141,59 +161,71 @@ public interface IQueryAsync
         Task<List<T>> FetchAsync<T>();
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Fetch{T}()" />.
+        /// Async version of <see cref="IQuery.Fetch{T}(Sql)" />.
         /// </summary>
-        Task<List<T>> FetchAsync<T>(CommandType commandType);
+        Task<List<T>> FetchAsync<T>(Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Fetch{T}()" />.
+        /// Async version of <see cref="IQuery.Fetch{T}(string, object[])" />.
         /// </summary>
-        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken);
+        Task<List<T>> FetchAsync<T>(string sql, params object[] args);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Fetch{T}()" />.
         /// </summary>
-        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, CommandType commandType);
+        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Fetch{T}(string, object[])" />.
+        /// Async version of <see cref="IQuery.Fetch{T}()" />.
         /// </summary>
-        Task<List<T>> FetchAsync<T>(string sql, params object[] args);
+        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, Sql sql);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Fetch{T}()" />.
         /// </summary>
-        Task<List<T>> FetchAsync<T>(CommandType commandType, string sql, params object[] args);
+        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
+
+        #endregion
+
+        #region FetchAsync : Single-Poco as CommandType
 
         /// <summary>
         /// Async version of <see cref="IQuery.Fetch{T}()" />.
         /// </summary>
-        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
+        Task<List<T>> FetchAsync<T>(CommandType commandType);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Fetch{T}()" />.
         /// </summary>
-        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, CommandType commandType, string sql, params object[] args);
+        Task<List<T>> FetchAsync<T>(CommandType commandType, Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Fetch{T}(Sql)" />.
+        /// Async version of <see cref="IQuery.Fetch{T}()" />.
         /// </summary>
-        Task<List<T>> FetchAsync<T>(Sql sql);
+        Task<List<T>> FetchAsync<T>(CommandType commandType, string sql, params object[] args);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Fetch{T}()" />.
         /// </summary>
-        Task<List<T>> FetchAsync<T>(CommandType commandType, Sql sql);
+        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, CommandType commandType);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Fetch{T}()" />.
         /// </summary>
-        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, Sql sql);
+        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, CommandType commandType, Sql sql);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Fetch{T}()" />.
         /// </summary>
-        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, CommandType commandType, Sql sql);
+        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, CommandType commandType, string sql, params object[] args);
+
+        #endregion
+
+        #region FetchAsync : Multi-Poco
+
+        #endregion
+
+        #region FetchAsync : Paged SkipTake
 
         /// <summary>
         /// Async version of <see cref="IQuery.Fetch{T}(long, long)" />.
@@ -201,9 +233,9 @@ public interface IQueryAsync
         Task<List<T>> FetchAsync<T>(long page, long itemsPerPage);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Fetch{T}(long, long)" />.
+        /// Async version of <see cref="IQuery.Fetch{T}(long, long, string, object[])" />.
         /// </summary>
-        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage);
+        Task<List<T>> FetchAsync<T>(long page, long itemsPerPage, Sql sql);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Fetch{T}(long, long, string, object[])" />.
@@ -211,33 +243,23 @@ public interface IQueryAsync
         Task<List<T>> FetchAsync<T>(long page, long itemsPerPage, string sql, params object[] args);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Fetch{T}(long, long, string, object[])" />.
+        /// Async version of <see cref="IQuery.Fetch{T}(long, long)" />.
         /// </summary>
-        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, string sql, params object[] args);
+        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Fetch{T}(long, long, string, object[])" />.
         /// </summary>
-        Task<List<T>> FetchAsync<T>(long page, long itemsPerPage, Sql sql);
+        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, Sql sql);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Fetch{T}(long, long, string, object[])" />.
         /// </summary>
-        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, Sql sql);
+        Task<List<T>> FetchAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, string sql, params object[] args);
 
         #endregion
 
-        #region Page
-
-        /// <summary>
-        /// Async version of <see cref="IQuery.Page{T}(long,long,string,object[],string,object[])" />.
-        /// </summary>
-        Task<Page<T>> PageAsync<T>(long page, long itemsPerPage, string sqlCount, object[] countArgs, string sqlPage, object[] pageArgs);
-
-        /// <summary>
-        /// Async version of <see cref="IQuery.Page{T}(long,long,string,object[],string,object[])" />.
-        /// </summary>
-        Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, string sqlCount, object[] countArgs, string sqlPage, object[] pageArgs);
+        #region PageAsync
 
         /// <summary>
         /// Async version of <see cref="IQuery.Page{T}(long,long)" />.
@@ -245,9 +267,9 @@ public interface IQueryAsync
         Task<Page<T>> PageAsync<T>(long page, long itemsPerPage);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Page{T}(long,long)" />.
+        /// Async version of <see cref="IQuery.Page{T}(long,long,Sql)" />.
         /// </summary>
-        Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage);
+        Task<Page<T>> PageAsync<T>(long page, long itemsPerPage, Sql sql);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Page{T}(long,long,string,object[])" />.
@@ -255,14 +277,19 @@ public interface IQueryAsync
         Task<Page<T>> PageAsync<T>(long page, long itemsPerPage, string sql, params object[] args);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Page{T}(long,long,string,object[])" />.
+        /// Async version of <see cref="IQuery.Page{T}(long,long,Sql,Sql)" />.
         /// </summary>
-        Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, string sql, params object[] args);
+        Task<Page<T>> PageAsync<T>(long page, long itemsPerPage, Sql sqlCount, Sql sqlPage);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Page{T}(long,long,Sql)" />.
+        /// Async version of <see cref="IQuery.Page{T}(long,long,string,object[],string,object[])" />.
         /// </summary>
-        Task<Page<T>> PageAsync<T>(long page, long itemsPerPage, Sql sql);
+        Task<Page<T>> PageAsync<T>(long page, long itemsPerPage, string sqlCount, object[] countArgs, string sqlPage, object[] pageArgs);
+
+        /// <summary>
+        /// Async version of <see cref="IQuery.Page{T}(long,long)" />.
+        /// </summary>
+        Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Page{T}(long,long,Sql)" />.
@@ -270,18 +297,23 @@ public interface IQueryAsync
         Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Page{T}(long,long,Sql,Sql)" />.
+        /// Async version of <see cref="IQuery.Page{T}(long,long,string,object[])" />.
         /// </summary>
-        Task<Page<T>> PageAsync<T>(long page, long itemsPerPage, Sql sqlCount, Sql sqlPage);
+        Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, string sql, params object[] args);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Page{T}(long,long,Sql,Sql)" />.
         /// </summary>
         Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, Sql sqlCount, Sql sqlPage);
 
+        /// <summary>
+        /// Async version of <see cref="IQuery.Page{T}(long,long,string,object[],string,object[])" />.
+        /// </summary>
+        Task<Page<T>> PageAsync<T>(CancellationToken cancellationToken, long page, long itemsPerPage, string sqlCount, object[] countArgs, string sqlPage, object[] pageArgs);
+
         #endregion
 
-        #region SkipTake
+        #region SkipTakeAsync
 
         /// <summary>
         /// Async version of <see cref="IQuery.SkipTake{T}(long,long)" />.
@@ -289,9 +321,9 @@ public interface IQueryAsync
         Task<List<T>> SkipTakeAsync<T>(long skip, long take);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.SkipTake{T}(long,long)" />.
+        /// Async version of <see cref="IQuery.SkipTake{T}(long,long,Sql)" />.
         /// </summary>
-        Task<List<T>> SkipTakeAsync<T>(CancellationToken cancellationToken, long skip, long take);
+        Task<List<T>> SkipTakeAsync<T>(long skip, long take, Sql sql);
 
         /// <summary>
         /// Async version of <see cref="IQuery.SkipTake{T}(long,long,string,object[])" />.
@@ -299,23 +331,23 @@ public interface IQueryAsync
         Task<List<T>> SkipTakeAsync<T>(long skip, long take, string sql, params object[] args);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.SkipTake{T}(long,long,string,object[])" />.
+        /// Async version of <see cref="IQuery.SkipTake{T}(long,long)" />.
         /// </summary>
-        Task<List<T>> SkipTakeAsync<T>(CancellationToken cancellationToken, long skip, long take, string sql, params object[] args);
+        Task<List<T>> SkipTakeAsync<T>(CancellationToken cancellationToken, long skip, long take);
 
         /// <summary>
         /// Async version of <see cref="IQuery.SkipTake{T}(long,long,Sql)" />.
         /// </summary>
-        Task<List<T>> SkipTakeAsync<T>(long skip, long take, Sql sql);
+        Task<List<T>> SkipTakeAsync<T>(CancellationToken cancellationToken, long skip, long take, Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.SkipTake{T}(long,long,Sql)" />.
+        /// Async version of <see cref="IQuery.SkipTake{T}(long,long,string,object[])" />.
         /// </summary>
-        Task<List<T>> SkipTakeAsync<T>(CancellationToken cancellationToken, long skip, long take, Sql sql);
+        Task<List<T>> SkipTakeAsync<T>(CancellationToken cancellationToken, long skip, long take, string sql, params object[] args);
 
         #endregion
 
-        #region Exists
+        #region ExistsAsync
 
         /// <summary>
         /// Async version of <see cref="IQuery.Exists{T}(object)" />.
@@ -323,14 +355,14 @@ public interface IQueryAsync
         Task<bool> ExistsAsync<T>(object primaryKey);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Exists{T}(object)" />.
+        /// Async version of <see cref="IQuery.Exists{T}(string, object[])" />.
         /// </summary>
-        Task<bool> ExistsAsync<T>(CancellationToken cancellationToken, object primaryKey);
+        Task<bool> ExistsAsync<T>(string sqlCondition, params object[] args);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Exists{T}(string, object[])" />.
+        /// Async version of <see cref="IQuery.Exists{T}(object)" />.
         /// </summary>
-        Task<bool> ExistsAsync<T>(string sqlCondition, params object[] args);
+        Task<bool> ExistsAsync<T>(CancellationToken cancellationToken, object primaryKey);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Exists{T}(string, object[])" />.
@@ -339,7 +371,7 @@ public interface IQueryAsync
 
         #endregion
 
-        #region Single
+        #region SingleAsync
 
         /// <summary>
         /// Async version of <see cref="IQuery.Single{T}(object)" />.
@@ -347,9 +379,9 @@ public interface IQueryAsync
         Task<T> SingleAsync<T>(object primaryKey);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Single{T}(object)" />.
+        /// Async version of <see cref="IQuery.Single{T}(Sql)" />.
         /// </summary>
-        Task<T> SingleAsync<T>(CancellationToken cancellationToken, object primaryKey);
+        Task<T> SingleAsync<T>(Sql sql);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Single{T}(string, object[])" />.
@@ -357,38 +389,38 @@ public interface IQueryAsync
         Task<T> SingleAsync<T>(string sql, params object[] args);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Single{T}(string, object[])" />.
+        /// Async version of <see cref="IQuery.Single{T}(object)" />.
         /// </summary>
-        Task<T> SingleAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
+        Task<T> SingleAsync<T>(CancellationToken cancellationToken, object primaryKey);
 
         /// <summary>
         /// Async version of <see cref="IQuery.Single{T}(Sql)" />.
         /// </summary>
-        Task<T> SingleAsync<T>(Sql sql);
+        Task<T> SingleAsync<T>(CancellationToken cancellationToken, Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.Single{T}(Sql)" />.
+        /// Async version of <see cref="IQuery.Single{T}(string, object[])" />.
         /// </summary>
-        Task<T> SingleAsync<T>(CancellationToken cancellationToken, Sql sql);
+        Task<T> SingleAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
 
         #endregion
 
-        #region SingleOrDefault
+        #region SingleOrDefaultAsync
 
         /// <summary>
-        /// Async version of <see cref="IQuery.SingleOrDefault{T}(Sql)" />.
+        /// Async version of <see cref="IQuery.SingleOrDefault{T}(object)" />.
         /// </summary>
-        Task<T> SingleOrDefaultAsync<T>(Sql sql);
+        Task<T> SingleOrDefaultAsync<T>(object primaryKey);
 
         /// <summary>
         /// Async version of <see cref="IQuery.SingleOrDefault{T}(Sql)" />.
         /// </summary>
-        Task<T> SingleOrDefaultAsync<T>(CancellationToken cancellationToken, Sql sql);
+        Task<T> SingleOrDefaultAsync<T>(Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.SingleOrDefault{T}(object)" />.
+        /// Async version of <see cref="IQuery.SingleOrDefault{T}(string, object[])" />.
         /// </summary>
-        Task<T> SingleOrDefaultAsync<T>(object primaryKey);
+        Task<T> SingleOrDefaultAsync<T>(string sql, params object[] args);
 
         /// <summary>
         /// Async version of <see cref="IQuery.SingleOrDefault{T}(object)" />.
@@ -396,9 +428,9 @@ public interface IQueryAsync
         Task<T> SingleOrDefaultAsync<T>(CancellationToken cancellationToken, object primaryKey);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.SingleOrDefault{T}(string, object[])" />.
+        /// Async version of <see cref="IQuery.SingleOrDefault{T}(Sql)" />.
         /// </summary>
-        Task<T> SingleOrDefaultAsync<T>(string sql, params object[] args);
+        Task<T> SingleOrDefaultAsync<T>(CancellationToken cancellationToken, Sql sql);
 
         /// <summary>
         /// Async version of <see cref="IQuery.SingleOrDefault{T}(string, object[])" />.
@@ -407,55 +439,51 @@ public interface IQueryAsync
 
         #endregion
 
-        #region First
+        #region FirstAsync
 
         /// <summary>
-        /// Async version of <see cref="IQuery.First{T}(string,object[])" />.
+        /// Async version of <see cref="IQuery.First{T}(Sql)" />.
         /// </summary>
-        Task<T> FirstAsync<T>(string sql, params object[] args);
+        Task<T> FirstAsync<T>(Sql sql);
 
         /// <summary>
         /// Async version of <see cref="IQuery.First{T}(string,object[])" />.
         /// </summary>
-        Task<T> FirstAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
+        Task<T> FirstAsync<T>(string sql, params object[] args);
 
         /// <summary>
         /// Async version of <see cref="IQuery.First{T}(Sql)" />.
         /// </summary>
-        Task<T> FirstAsync<T>(Sql sql);
+        Task<T> FirstAsync<T>(CancellationToken cancellationToken, Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.First{T}(Sql)" />.
+        /// Async version of <see cref="IQuery.First{T}(string,object[])" />.
         /// </summary>
-        Task<T> FirstAsync<T>(CancellationToken cancellationToken, Sql sql);
+        Task<T> FirstAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
 
         #endregion
 
-        #region FirstOrDefault
+        #region FirstOrDefaultAsync
 
         /// <summary>
-        /// Async version of <see cref="IQuery.FirstOrDefault{T}(string,object[])" />.
+        /// Async version of <see cref="IQuery.FirstOrDefault{T}(Sql)" />.
         /// </summary>
-        Task<T> FirstOrDefaultAsync<T>(string sql, params object[] args);
+        Task<T> FirstOrDefaultAsync<T>(Sql sql);
 
         /// <summary>
         /// Async version of <see cref="IQuery.FirstOrDefault{T}(string,object[])" />.
         /// </summary>
-        Task<T> FirstOrDefaultAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
+        Task<T> FirstOrDefaultAsync<T>(string sql, params object[] args);
 
         /// <summary>
         /// Async version of <see cref="IQuery.FirstOrDefault{T}(Sql)" />.
         /// </summary>
-        Task<T> FirstOrDefaultAsync<T>(Sql sql);
+        Task<T> FirstOrDefaultAsync<T>(CancellationToken cancellationToken, Sql sql);
 
         /// <summary>
-        /// Async version of <see cref="IQuery.FirstOrDefault{T}(Sql)" />.
+        /// Async version of <see cref="IQuery.FirstOrDefault{T}(string,object[])" />.
         /// </summary>
-        Task<T> FirstOrDefaultAsync<T>(CancellationToken cancellationToken, Sql sql);
-
-        #endregion
-
-        #region QueryMultiple
+        Task<T> FirstOrDefaultAsync<T>(CancellationToken cancellationToken, string sql, params object[] args);
 
         #endregion
     }
diff --git a/PetaPoco/IStoredProc.cs b/PetaPoco/IStoredProc.cs
index 7dbc7ccf..54e0830d 100644
--- a/PetaPoco/IStoredProc.cs
+++ b/PetaPoco/IStoredProc.cs
@@ -8,50 +8,50 @@ namespace PetaPoco
     public interface IStoredProc
     {
         /// <summary>
-        /// Executes a stored procedure and returns the result as an IEnumerable of type T.
+        /// Executes a non-query stored procedure and returns the number of rows affected.
         /// </summary>
         /// <remarks>
         /// For any arguments which are POCOs, each readable property will be turned into a named parameter for the stored procedure. Arguments which are IDbDataParameters will be passed through. Any other argument types will throw an exception.
         /// </remarks>
-        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
         /// <param name="storedProcedureName">The name of the stored procedure to execute.</param>
         /// <param name="args">The arguments to pass to the stored procedure.</param>
-        /// <returns>An IEnumerable of type T containing the result set of the stored procedure.</returns>
-        IEnumerable<T> QueryProc<T>(string storedProcedureName, params object[] args);
+        /// <returns>The number of rows affected by the stored procedure.</returns>
+        int ExecuteNonQueryProc(string storedProcedureName, params object[] args);
 
         /// <summary>
-        /// Executes a stored procedure and returns the result as a List of type T.
+        /// Executes a stored procedure and returns the first column of the first row in the result set as type T.
         /// </summary>
         /// <remarks>
         /// For any arguments which are POCOs, each readable property will be turned into a named parameter for the stored procedure. Arguments which are IDbDataParameters will be passed through. Any other argument types will throw an exception.
         /// </remarks>
-        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
+        /// <typeparam name="T">The type that the result value should be cast to.</typeparam>
         /// <param name="storedProcedureName">The name of the stored procedure to execute.</param>
         /// <param name="args">The arguments to pass to the stored procedure.</param>
-        /// <returns>A List of type T containing the result set of the stored procedure.</returns>
-        List<T> FetchProc<T>(string storedProcedureName, params object[] args);
+        /// <returns>The scalar result of the stored procedure of type T.</returns>
+        T ExecuteScalarProc<T>(string storedProcedureName, params object[] args);
 
         /// <summary>
-        /// Executes a stored procedure and returns the first column of the first row in the result set as type T.
+        /// Executes a stored procedure and returns the result as an IEnumerable of type T.
         /// </summary>
         /// <remarks>
         /// For any arguments which are POCOs, each readable property will be turned into a named parameter for the stored procedure. Arguments which are IDbDataParameters will be passed through. Any other argument types will throw an exception.
         /// </remarks>
-        /// <typeparam name="T">The type that the result value should be cast to.</typeparam>
+        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
         /// <param name="storedProcedureName">The name of the stored procedure to execute.</param>
         /// <param name="args">The arguments to pass to the stored procedure.</param>
-        /// <returns>The scalar result of the stored procedure of type T.</returns>
-        T ExecuteScalarProc<T>(string storedProcedureName, params object[] args);
+        /// <returns>An IEnumerable of type T containing the result set of the stored procedure.</returns>
+        IEnumerable<T> QueryProc<T>(string storedProcedureName, params object[] args);
 
         /// <summary>
-        /// Executes a non-query stored procedure and returns the number of rows affected.
+        /// Executes a stored procedure and returns the result as a List of type T.
         /// </summary>
         /// <remarks>
         /// For any arguments which are POCOs, each readable property will be turned into a named parameter for the stored procedure. Arguments which are IDbDataParameters will be passed through. Any other argument types will throw an exception.
         /// </remarks>
+        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
         /// <param name="storedProcedureName">The name of the stored procedure to execute.</param>
         /// <param name="args">The arguments to pass to the stored procedure.</param>
-        /// <returns>The number of rows affected by the stored procedure.</returns>
-        int ExecuteNonQueryProc(string storedProcedureName, params object[] args);
+        /// <returns>A List of type T containing the result set of the stored procedure.</returns>
+        List<T> FetchProc<T>(string storedProcedureName, params object[] args);
     }
 }
diff --git a/PetaPoco/IStoredProcAsync.cs b/PetaPoco/IStoredProcAsync.cs
index 10f199d7..b9e6b9ff 100644
--- a/PetaPoco/IStoredProcAsync.cs
+++ b/PetaPoco/IStoredProcAsync.cs
@@ -11,44 +11,48 @@ namespace PetaPoco
     /// </summary>
     public interface IStoredProcAsync
     {
+        /// <inheritdoc cref="ExecuteNonQueryProcAsync(CancellationToken, string, object[])"/>
+        Task<int> ExecuteNonQueryProcAsync(string storedProcedureName, params object[] args);
+
+        /// <inheritdoc cref="ExecuteScalarProcAsync{T}(CancellationToken, string, object[])"/>
+        Task<T> ExecuteScalarProcAsync<T>(string storedProcedureName, params object[] args);
+
+        /// <inheritdoc cref="QueryProcAsync{T}(CancellationToken, string, object[])"/>
+        Task<IAsyncReader<T>> QueryProcAsync<T>(string storedProcedureName, params object[] args);
+
         /// <inheritdoc cref="QueryProcAsync{T}(Action{T}, CancellationToken, string, object[])"/>
         Task QueryProcAsync<T>(Action<T> receivePocoCallback, string storedProcedureName, params object[] args);
 
+        /// <inheritdoc cref="FetchProcAsync{T}(CancellationToken, string, object[])"/>
+        Task<List<T>> FetchProcAsync<T>(string storedProcedureName, params object[] args);
+
         /// <summary>
-        /// Asynchronously executes a stored procedure and returns the result as an IAsyncReader of type T.
+        /// Asynchronously executes a non-query stored procedure and returns the number of rows affected.
         /// </summary>
         /// <remarks>
         /// For any arguments which are POCOs, each readable property will be turned into a named parameter for the stored procedure. Arguments which are IDbDataParameters will be passed through. Any other argument types will throw an exception.
         /// </remarks>
-        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
-        /// <param name="receivePocoCallback">An action callback to execute on each POCO in the result set.</param>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
         /// <param name="storedProcedureName">The name of the stored procedure to execute.</param>
         /// <param name="args">The arguments to pass to the stored procedure.</param>
-        /// <returns>A task representing the asynchronous operation. The task result is an IAsyncReader of type T containing the result set of the stored procedure.</returns>
-        Task QueryProcAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, string storedProcedureName, params object[] args);
-
-        /// <inheritdoc cref="QueryProcAsync{T}(CancellationToken, string, object[])"/>
-        Task<IAsyncReader<T>> QueryProcAsync<T>(string storedProcedureName, params object[] args);
+        /// <returns>A task representing the asynchronous operation. The task result is the number of rows affected by the stored procedure.</returns>
+        Task<int> ExecuteNonQueryProcAsync(CancellationToken cancellationToken, string storedProcedureName, params object[] args);
 
         /// <summary>
-        /// Asynchronously executes a stored procedure and returns the result as an IAsyncReader of type T.
+        /// Asynchronously executes a stored procedure and returns the first column of the first row in the result set as type T.
         /// </summary>
         /// <remarks>
         /// For any arguments which are POCOs, each readable property will be turned into a named parameter for the stored procedure. Arguments which are IDbDataParameters will be passed through. Any other argument types will throw an exception.
         /// </remarks>
-        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
+        /// <typeparam name="T">The type that the result value should be cast to.</typeparam>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
         /// <param name="storedProcedureName">The name of the stored procedure to execute.</param>
         /// <param name="args">The arguments to pass to the stored procedure.</param>
-        /// <returns>A task representing the asynchronous operation. The task result is an IAsyncReader of type T containing the result set of the stored procedure.</returns>
-        Task<IAsyncReader<T>> QueryProcAsync<T>(CancellationToken cancellationToken, string storedProcedureName, params object[] args);
-
-        /// <inheritdoc cref="FetchProcAsync{T}(CancellationToken, string, object[])"/>
-        Task<List<T>> FetchProcAsync<T>(string storedProcedureName, params object[] args);
+        /// <returns>A task representing the asynchronous operation. The task result is the scalar result of the stored procedure of type T.</returns>
+        Task<T> ExecuteScalarProcAsync<T>(CancellationToken cancellationToken, string storedProcedureName, params object[] args);
 
         /// <summary>
-        /// Asynchronously executes a stored procedure and returns the result as a List of type T.
+        /// Asynchronously executes a stored procedure and returns the result as an IAsyncReader of type T.
         /// </summary>
         /// <remarks>
         /// For any arguments which are POCOs, each readable property will be turned into a named parameter for the stored procedure. Arguments which are IDbDataParameters will be passed through. Any other argument types will throw an exception.
@@ -57,39 +61,35 @@ public interface IStoredProcAsync
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
         /// <param name="storedProcedureName">The name of the stored procedure to execute.</param>
         /// <param name="args">The arguments to pass to the stored procedure.</param>
-        /// <returns>A task representing the asynchronous operation. The task result is a List of type T containing the result set of the stored procedure.</returns>
-        Task<List<T>> FetchProcAsync<T>(CancellationToken cancellationToken, string storedProcedureName, params object[] args);
-
-        /// <inheritdoc cref="ExecuteScalarProcAsync{T}(CancellationToken, string, object[])"/>
-        Task<T> ExecuteScalarProcAsync<T>(string storedProcedureName, params object[] args);
+        /// <returns>A task representing the asynchronous operation. The task result is an IAsyncReader of type T containing the result set of the stored procedure.</returns>
+        Task<IAsyncReader<T>> QueryProcAsync<T>(CancellationToken cancellationToken, string storedProcedureName, params object[] args);
 
         /// <summary>
-        /// Asynchronously executes a stored procedure and returns the first column of the first row in the result set as type T.
+        /// Asynchronously executes a stored procedure and returns the result as an IAsyncReader of type T.
         /// </summary>
         /// <remarks>
         /// For any arguments which are POCOs, each readable property will be turned into a named parameter for the stored procedure. Arguments which are IDbDataParameters will be passed through. Any other argument types will throw an exception.
         /// </remarks>
-        /// <typeparam name="T">The type that the result value should be cast to.</typeparam>
+        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
+        /// <param name="receivePocoCallback">An action callback to execute on each POCO in the result set.</param>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
         /// <param name="storedProcedureName">The name of the stored procedure to execute.</param>
         /// <param name="args">The arguments to pass to the stored procedure.</param>
-        /// <returns>A task representing the asynchronous operation. The task result is the scalar result of the stored procedure of type T.</returns>
-        Task<T> ExecuteScalarProcAsync<T>(CancellationToken cancellationToken, string storedProcedureName, params object[] args);
-
-        /// <inheritdoc cref="ExecuteNonQueryProcAsync(CancellationToken, string, object[])"/>
-        Task<int> ExecuteNonQueryProcAsync(string storedProcedureName, params object[] args);
+        /// <returns>A task representing the asynchronous operation. The task result is an IAsyncReader of type T containing the result set of the stored procedure.</returns>
+        Task QueryProcAsync<T>(Action<T> receivePocoCallback, CancellationToken cancellationToken, string storedProcedureName, params object[] args);
 
         /// <summary>
-        /// Asynchronously executes a non-query stored procedure and returns the number of rows affected.
+        /// Asynchronously executes a stored procedure and returns the result as a List of type T.
         /// </summary>
         /// <remarks>
         /// For any arguments which are POCOs, each readable property will be turned into a named parameter for the stored procedure. Arguments which are IDbDataParameters will be passed through. Any other argument types will throw an exception.
         /// </remarks>
+        /// <typeparam name="T">The Type representing a row in the result set.</typeparam>
         /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
         /// <param name="storedProcedureName">The name of the stored procedure to execute.</param>
         /// <param name="args">The arguments to pass to the stored procedure.</param>
-        /// <returns>A task representing the asynchronous operation. The task result is the number of rows affected by the stored procedure.</returns>
-        Task<int> ExecuteNonQueryProcAsync(CancellationToken cancellationToken, string storedProcedureName, params object[] args);
+        /// <returns>A task representing the asynchronous operation. The task result is a List of type T containing the result set of the stored procedure.</returns>
+        Task<List<T>> FetchProcAsync<T>(CancellationToken cancellationToken, string storedProcedureName, params object[] args);
     }
 #endif
 }
diff --git a/PetaPoco/Utilities/AsyncReader.cs b/PetaPoco/Utilities/AsyncReader.cs
index b1bb0fe7..485794fd 100644
--- a/PetaPoco/Utilities/AsyncReader.cs
+++ b/PetaPoco/Utilities/AsyncReader.cs
@@ -14,8 +14,8 @@ public class AsyncReader<T> : IAsyncReader<T>
     {
         private readonly bool _isAsync;
         private readonly Func<IDataReader, T> _pocoFactory;
-        private IDbCommand _cmd;
         private IDatabase _db;
+        private IDbCommand _cmd;
         private IDataReader _reader;
         private DbDataReader Reader => (DbDataReader)_reader;
 
diff --git a/PetaPoco/Utilities/AutoSelectHelper.cs b/PetaPoco/Utilities/AutoSelectHelper.cs
index 7a18f63d..1d85257d 100644
--- a/PetaPoco/Utilities/AutoSelectHelper.cs
+++ b/PetaPoco/Utilities/AutoSelectHelper.cs
@@ -9,7 +9,8 @@ internal static class AutoSelectHelper
         private static Regex rxSelect = new Regex(@"\A\s*(SELECT|EXECUTE|CALL|WITH|SET|DECLARE)\s",
             RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase | RegexOptions.Multiline);
 
-        private static Regex rxFrom = new Regex(@"\A\s*FROM\s", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase | RegexOptions.Multiline);
+        private static Regex rxFrom = new Regex(@"\A\s*FROM\s",
+            RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase | RegexOptions.Multiline);
 
         public static string AddSelectClause<T>(IProvider provider, string sql, IMapper defaultMapper)
         {
@@ -30,4 +31,4 @@ public static string AddSelectClause<T>(IProvider provider, string sql, IMapper
             return sql;
         }
     }
-}
\ No newline at end of file
+}