diff --git a/AmalgamationTool/DynamORM.Amalgamation.cs b/AmalgamationTool/DynamORM.Amalgamation.cs
index dccfcbe..e3d0fe6 100644
--- a/AmalgamationTool/DynamORM.Amalgamation.cs
+++ b/AmalgamationTool/DynamORM.Amalgamation.cs
@@ -902,7 +902,7 @@ namespace DynamORM
         /// to be used after a connection is opened.</summary>
         public string Database
         {
-            get { throw new NotImplementedException(); }
+            get { return Connection.Database; }
         }
 
         /// <summary>Gets the current state of the connection.</summary>
@@ -1767,6 +1767,247 @@ namespace DynamORM
 
         #endregion From/Insert/Update/Delete
 
+        #region Procedure
+
+        /// <summary>Execute stored procedure.</summary>
+        /// <param name="procName">Name of stored procedure to execute.</param>
+        /// <returns>Number of affected rows.</returns>
+        public virtual int Procedure(string procName)
+        {
+            return Procedure(procName, (DynamicExpando)null);
+        }
+
+        /// <summary>Execute stored procedure.</summary>
+        /// <param name="procName">Name of stored procedure to execute.</param>
+        /// <param name="args">Arguments (parameters) in form of expando object.</param>
+        /// <returns>Number of affected rows.</returns>
+        public virtual int Procedure(string procName, params object[] args)
+        {
+            if ((Options & DynamicDatabaseOptions.SupportStoredProcedures) != DynamicDatabaseOptions.SupportStoredProcedures)
+                throw new InvalidOperationException("Database connection desn't support stored procedures.");
+
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            {
+                return cmd
+                    .SetCommand(CommandType.StoredProcedure, procName)
+                    .AddParameters(this, args)
+                    .ExecuteNonQuery();
+            }
+        }
+
+        /// <summary>Execute stored procedure.</summary>
+        /// <param name="procName">Name of stored procedure to execute.</param>
+        /// <param name="args">Arguments (parameters) in form of expando object.</param>
+        /// <returns>Number of affected rows.</returns>
+        public virtual int Procedure(string procName, DynamicExpando args)
+        {
+            if ((Options & DynamicDatabaseOptions.SupportStoredProcedures) != DynamicDatabaseOptions.SupportStoredProcedures)
+                throw new InvalidOperationException("Database connection desn't support stored procedures.");
+
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            {
+                return cmd
+                    .SetCommand(CommandType.StoredProcedure, procName)
+                    .AddParameters(this, args)
+                    .ExecuteNonQuery();
+            }
+        }
+
+        /// <summary>Execute stored procedure.</summary>
+        /// <param name="procName">Name of stored procedure to execute.</param>
+        /// <param name="args">Arguments (parameters) in form of expando object.</param>
+        /// <returns>Number of affected rows.</returns>
+        public virtual int Procedure(string procName, ExpandoObject args)
+        {
+            if ((Options & DynamicDatabaseOptions.SupportStoredProcedures) != DynamicDatabaseOptions.SupportStoredProcedures)
+                throw new InvalidOperationException("Database connection desn't support stored procedures.");
+
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            {
+                return cmd
+                    .SetCommand(CommandType.StoredProcedure, procName)
+                    .AddParameters(this, args)
+                    .ExecuteNonQuery();
+            }
+        }
+
+        #endregion Procedure
+
+        #region Execute
+
+        /// <summary>Execute non query.</summary>
+        /// <param name="sql">SQL query containing numbered parameters in format provided by
+        /// <see cref="DynamicDatabase.GetParameterName(object)"/> methods. Also names should be formatted with
+        /// <see cref="DynamicDatabase.DecorateName(string)"/> method.</param>
+        /// <param name="args">Arguments (parameters).</param>
+        /// <returns>Number of affected rows.</returns>
+        public virtual int Execute(string sql, params object[] args)
+        {
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            {
+                return cmd
+                    .SetCommand(sql).AddParameters(this, args)
+                    .ExecuteNonQuery();
+            }
+        }
+
+        /// <summary>Execute non query.</summary>
+        /// <param name="builder">Command builder.</param>
+        /// <returns>Number of affected rows.</returns>
+        public virtual int Execute(IDynamicQueryBuilder builder)
+        {
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            {
+                return cmd
+                    .SetCommand(builder)
+                    .ExecuteNonQuery();
+            }
+        }
+
+        /// <summary>Execute non query.</summary>
+        /// <param name="builders">Command builders.</param>
+        /// <returns>Number of affected rows.</returns>
+        public virtual int Execute(IDynamicQueryBuilder[] builders)
+        {
+            int ret = 0;
+
+            using (var con = Open())
+            {
+                using (var trans = con.BeginTransaction())
+                {
+                    foreach (var builder in builders)
+                    {
+                        using (var cmd = con.CreateCommand())
+                        {
+                            ret += cmd
+                               .SetCommand(builder)
+                               .ExecuteNonQuery();
+                        }
+                    }
+
+                    trans.Commit();
+                }
+            }
+
+            return ret;
+        }
+
+        #endregion Execute
+
+        #region Scalar
+
+        /// <summary>Returns a single result.</summary>
+        /// <param name="sql">SQL query containing numbered parameters in format provided by
+        /// <see cref="DynamicDatabase.GetParameterName(object)"/> methods. Also names should be formatted with
+        /// <see cref="DynamicDatabase.DecorateName(string)"/> method.</param>
+        /// <param name="args">Arguments (parameters).</param>
+        /// <returns>Result of a query.</returns>
+        public virtual object Scalar(string sql, params object[] args)
+        {
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            {
+                return cmd
+                    .SetCommand(sql).AddParameters(this, args)
+                    .ExecuteScalar();
+            }
+        }
+
+        /// <summary>Returns a single result.</summary>
+        /// <param name="builder">Command builder.</param>
+        /// <returns>Result of a query.</returns>
+        public virtual object Scalar(IDynamicQueryBuilder builder)
+        {
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            {
+                return cmd
+                    .SetCommand(builder)
+                    .ExecuteScalar();
+            }
+        }
+
+        #endregion Scalar
+
+        #region Query
+
+        /// <summary>Enumerate the reader and yield the result.</summary>
+        /// <param name="sql">SQL query containing numbered parameters in format provided by
+        /// <see cref="DynamicDatabase.GetParameterName(object)"/> methods. Also names should be formatted with
+        /// <see cref="DynamicDatabase.DecorateName(string)"/> method.</param>
+        /// <param name="args">Arguments (parameters).</param>
+        /// <returns>Enumerator of objects expanded from query.</returns>
+        public virtual IEnumerable<dynamic> Query(string sql, params object[] args)
+        {
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            using (var rdr = cmd
+                .SetCommand(sql)
+                .AddParameters(this, args)
+                .ExecuteReader())
+                while (rdr.Read())
+                {
+                    dynamic val = null;
+
+                    // Work around to avoid yield being in try...catch block:
+                    // http://stackoverflow.com/questions/346365/why-cant-yield-return-appear-inside-a-try-block-with-a-catch
+                    try
+                    {
+                        val = rdr.RowToDynamic();
+                    }
+                    catch (ArgumentException argex)
+                    {
+                        var sb = new StringBuilder();
+                        cmd.Dump(sb);
+
+                        throw new ArgumentException(string.Format("{0}{1}{2}", argex.Message, Environment.NewLine, sb),
+                            argex.InnerException.NullOr(a => a, argex));
+                    }
+
+                    yield return val;
+                }
+        }
+
+        /// <summary>Enumerate the reader and yield the result.</summary>
+        /// <param name="builder">Command builder.</param>
+        /// <returns>Enumerator of objects expanded from query.</returns>
+        public virtual IEnumerable<dynamic> Query(IDynamicQueryBuilder builder)
+        {
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            using (var rdr = cmd
+                .SetCommand(builder)
+                .ExecuteReader())
+                while (rdr.Read())
+                {
+                    dynamic val = null;
+
+                    // Work around to avoid yield being in try...catch block:
+                    // http://stackoverflow.com/questions/346365/why-cant-yield-return-appear-inside-a-try-block-with-a-catch
+                    try
+                    {
+                        val = rdr.RowToDynamic();
+                    }
+                    catch (ArgumentException argex)
+                    {
+                        var sb = new StringBuilder();
+                        cmd.Dump(sb);
+
+                        throw new ArgumentException(string.Format("{0}{1}{2}", argex.Message, Environment.NewLine, sb),
+                            argex.InnerException.NullOr(a => a, argex));
+                    }
+
+                    yield return val;
+                }
+        }
+
+        #endregion Query
+
         #region Schema
 
         /// <summary>Builds query cache if necessary and returns it.</summary>
@@ -4480,33 +4721,7 @@ namespace DynamORM
         /// <returns>Enumerator of objects expanded from query.</returns>
         public virtual IEnumerable<dynamic> Query(string sql, params object[] args)
         {
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            using (var rdr = cmd
-                .SetCommand(sql)
-                .AddParameters(Database, args)
-                .ExecuteReader())
-                while (rdr.Read())
-                {
-                    dynamic val = null;
-
-                    // Work around to avoid yield being in try...catch block:
-                    // http://stackoverflow.com/questions/346365/why-cant-yield-return-appear-inside-a-try-block-with-a-catch
-                    try
-                    {
-                        val = rdr.RowToDynamic();
-                    }
-                    catch (ArgumentException argex)
-                    {
-                        var sb = new StringBuilder();
-                        cmd.Dump(sb);
-
-                        throw new ArgumentException(string.Format("{0}{1}{2}", argex.Message, Environment.NewLine, sb),
-                            argex.InnerException.NullOr(a => a, argex));
-                    }
-
-                    yield return val;
-                }
+            return Database.Query(sql, args);
         }
 
         /// <summary>Enumerate the reader and yield the result.</summary>
@@ -4514,32 +4729,7 @@ namespace DynamORM
         /// <returns>Enumerator of objects expanded from query.</returns>
         public virtual IEnumerable<dynamic> Query(IDynamicQueryBuilder builder)
         {
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            using (var rdr = cmd
-                .SetCommand(builder)
-                .ExecuteReader())
-                while (rdr.Read())
-                {
-                    dynamic val = null;
-
-                    // Work around to avoid yield being in try...catch block:
-                    // http://stackoverflow.com/questions/346365/why-cant-yield-return-appear-inside-a-try-block-with-a-catch
-                    try
-                    {
-                        val = rdr.RowToDynamic();
-                    }
-                    catch (ArgumentException argex)
-                    {
-                        var sb = new StringBuilder();
-                        cmd.Dump(sb);
-
-                        throw new ArgumentException(string.Format("{0}{1}{2}", argex.Message, Environment.NewLine, sb),
-                            argex.InnerException.NullOr(a => a, argex));
-                    }
-
-                    yield return val;
-                }
+            return Database.Query(builder);
         }
 
         /// <summary>Create new <see cref="DynamicSelectQueryBuilder"/>.</summary>
@@ -4563,13 +4753,7 @@ namespace DynamORM
         /// <returns>Result of a query.</returns>
         public virtual object Scalar(string sql, params object[] args)
         {
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(sql).AddParameters(Database, args)
-                    .ExecuteScalar();
-            }
+            return Database.Scalar(sql, args);
         }
 
         /// <summary>Returns a single result.</summary>
@@ -4577,13 +4761,7 @@ namespace DynamORM
         /// <returns>Result of a query.</returns>
         public virtual object Scalar(IDynamicQueryBuilder builder)
         {
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(builder)
-                    .ExecuteScalar();
-            }
+            return Database.Scalar(builder);
         }
 
         /// <summary>Execute stored procedure.</summary>
@@ -4591,16 +4769,7 @@ namespace DynamORM
         /// <returns>Number of affected rows.</returns>
         public virtual int Procedure(string procName)
         {
-            if ((Database.Options & DynamicDatabaseOptions.SupportStoredProcedures) != DynamicDatabaseOptions.SupportStoredProcedures)
-                throw new InvalidOperationException("Database connection desn't support stored procedures.");
-
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(CommandType.StoredProcedure, procName)
-                    .ExecuteNonQuery();
-            }
+            return Database.Procedure(procName);
         }
 
         /// <summary>Execute stored procedure.</summary>
@@ -4609,17 +4778,7 @@ namespace DynamORM
         /// <returns>Number of affected rows.</returns>
         public virtual int Procedure(string procName, params object[] args)
         {
-            if ((Database.Options & DynamicDatabaseOptions.SupportStoredProcedures) != DynamicDatabaseOptions.SupportStoredProcedures)
-                throw new InvalidOperationException("Database connection desn't support stored procedures.");
-
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(CommandType.StoredProcedure, procName)
-                    .AddParameters(Database, args)
-                    .ExecuteNonQuery();
-            }
+            return Database.Procedure(procName, args);
         }
 
         /// <summary>Execute stored procedure.</summary>
@@ -4628,17 +4787,7 @@ namespace DynamORM
         /// <returns>Number of affected rows.</returns>
         public virtual int Procedure(string procName, DynamicExpando args)
         {
-            if ((Database.Options & DynamicDatabaseOptions.SupportStoredProcedures) != DynamicDatabaseOptions.SupportStoredProcedures)
-                throw new InvalidOperationException("Database connection desn't support stored procedures.");
-
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(CommandType.StoredProcedure, procName)
-                    .AddParameters(Database, args)
-                    .ExecuteNonQuery();
-            }
+            return Database.Procedure(procName, args);
         }
 
         /// <summary>Execute stored procedure.</summary>
@@ -4647,17 +4796,7 @@ namespace DynamORM
         /// <returns>Number of affected rows.</returns>
         public virtual int Procedure(string procName, ExpandoObject args)
         {
-            if ((Database.Options & DynamicDatabaseOptions.SupportStoredProcedures) != DynamicDatabaseOptions.SupportStoredProcedures)
-                throw new InvalidOperationException("Database connection desn't support stored procedures.");
-
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(CommandType.StoredProcedure, procName)
-                    .AddParameters(Database, args)
-                    .ExecuteNonQuery();
-            }
+            return Database.Procedure(procName, args);
         }
 
         /// <summary>Execute non query.</summary>
@@ -4668,13 +4807,7 @@ namespace DynamORM
         /// <returns>Number of affected rows.</returns>
         public virtual int Execute(string sql, params object[] args)
         {
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(sql).AddParameters(Database, args)
-                    .ExecuteNonQuery();
-            }
+            return Database.Execute(sql, args);
         }
 
         /// <summary>Execute non query.</summary>
@@ -4682,41 +4815,15 @@ namespace DynamORM
         /// <returns>Number of affected rows.</returns>
         public virtual int Execute(IDynamicQueryBuilder builder)
         {
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(builder)
-                    .ExecuteNonQuery();
-            }
+            return Database.Execute(builder);
         }
 
         /// <summary>Execute non query.</summary>
-        /// <param name="builers">Command builders.</param>
+        /// <param name="builders">Command builders.</param>
         /// <returns>Number of affected rows.</returns>
-        public virtual int Execute(IDynamicQueryBuilder[] builers)
+        public virtual int Execute(IDynamicQueryBuilder[] builders)
         {
-            int ret = 0;
-
-            using (var con = Database.Open())
-            {
-                using (var trans = con.BeginTransaction())
-                {
-                    foreach (var builder in builers)
-                    {
-                        using (var cmd = con.CreateCommand())
-                        {
-                            ret += cmd
-                               .SetCommand(builder)
-                               .ExecuteNonQuery();
-                        }
-                    }
-
-                    trans.Commit();
-                }
-            }
-
-            return ret;
+            return Database.Execute(builders);
         }
 
         #endregion Basic Queries
diff --git a/DynamORM/DynamicConnection.cs b/DynamORM/DynamicConnection.cs
index dd84cd0..bd01537 100644
--- a/DynamORM/DynamicConnection.cs
+++ b/DynamORM/DynamicConnection.cs
@@ -148,7 +148,7 @@ namespace DynamORM
         /// to be used after a connection is opened.</summary>
         public string Database
         {
-            get { throw new NotImplementedException(); }
+            get { return Connection.Database; }
         }
 
         /// <summary>Gets the current state of the connection.</summary>
diff --git a/DynamORM/DynamicDatabase.cs b/DynamORM/DynamicDatabase.cs
index 57fc47f..751f14f 100644
--- a/DynamORM/DynamicDatabase.cs
+++ b/DynamORM/DynamicDatabase.cs
@@ -30,6 +30,7 @@ using System;
 using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
+using System.Dynamic;
 using System.Linq;
 using System.Text;
 using DynamORM.Builders;
@@ -878,6 +879,247 @@ namespace DynamORM
 
         #endregion From/Insert/Update/Delete
 
+        #region Procedure
+
+        /// <summary>Execute stored procedure.</summary>
+        /// <param name="procName">Name of stored procedure to execute.</param>
+        /// <returns>Number of affected rows.</returns>
+        public virtual int Procedure(string procName)
+        {
+            return Procedure(procName, (DynamicExpando)null);
+        }
+
+        /// <summary>Execute stored procedure.</summary>
+        /// <param name="procName">Name of stored procedure to execute.</param>
+        /// <param name="args">Arguments (parameters) in form of expando object.</param>
+        /// <returns>Number of affected rows.</returns>
+        public virtual int Procedure(string procName, params object[] args)
+        {
+            if ((Options & DynamicDatabaseOptions.SupportStoredProcedures) != DynamicDatabaseOptions.SupportStoredProcedures)
+                throw new InvalidOperationException("Database connection desn't support stored procedures.");
+
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            {
+                return cmd
+                    .SetCommand(CommandType.StoredProcedure, procName)
+                    .AddParameters(this, args)
+                    .ExecuteNonQuery();
+            }
+        }
+
+        /// <summary>Execute stored procedure.</summary>
+        /// <param name="procName">Name of stored procedure to execute.</param>
+        /// <param name="args">Arguments (parameters) in form of expando object.</param>
+        /// <returns>Number of affected rows.</returns>
+        public virtual int Procedure(string procName, DynamicExpando args)
+        {
+            if ((Options & DynamicDatabaseOptions.SupportStoredProcedures) != DynamicDatabaseOptions.SupportStoredProcedures)
+                throw new InvalidOperationException("Database connection desn't support stored procedures.");
+
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            {
+                return cmd
+                    .SetCommand(CommandType.StoredProcedure, procName)
+                    .AddParameters(this, args)
+                    .ExecuteNonQuery();
+            }
+        }
+
+        /// <summary>Execute stored procedure.</summary>
+        /// <param name="procName">Name of stored procedure to execute.</param>
+        /// <param name="args">Arguments (parameters) in form of expando object.</param>
+        /// <returns>Number of affected rows.</returns>
+        public virtual int Procedure(string procName, ExpandoObject args)
+        {
+            if ((Options & DynamicDatabaseOptions.SupportStoredProcedures) != DynamicDatabaseOptions.SupportStoredProcedures)
+                throw new InvalidOperationException("Database connection desn't support stored procedures.");
+
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            {
+                return cmd
+                    .SetCommand(CommandType.StoredProcedure, procName)
+                    .AddParameters(this, args)
+                    .ExecuteNonQuery();
+            }
+        }
+
+        #endregion Procedure
+
+        #region Execute
+
+        /// <summary>Execute non query.</summary>
+        /// <param name="sql">SQL query containing numbered parameters in format provided by
+        /// <see cref="DynamicDatabase.GetParameterName(object)"/> methods. Also names should be formatted with
+        /// <see cref="DynamicDatabase.DecorateName(string)"/> method.</param>
+        /// <param name="args">Arguments (parameters).</param>
+        /// <returns>Number of affected rows.</returns>
+        public virtual int Execute(string sql, params object[] args)
+        {
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            {
+                return cmd
+                    .SetCommand(sql).AddParameters(this, args)
+                    .ExecuteNonQuery();
+            }
+        }
+
+        /// <summary>Execute non query.</summary>
+        /// <param name="builder">Command builder.</param>
+        /// <returns>Number of affected rows.</returns>
+        public virtual int Execute(IDynamicQueryBuilder builder)
+        {
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            {
+                return cmd
+                    .SetCommand(builder)
+                    .ExecuteNonQuery();
+            }
+        }
+
+        /// <summary>Execute non query.</summary>
+        /// <param name="builders">Command builders.</param>
+        /// <returns>Number of affected rows.</returns>
+        public virtual int Execute(IDynamicQueryBuilder[] builders)
+        {
+            int ret = 0;
+
+            using (var con = Open())
+            {
+                using (var trans = con.BeginTransaction())
+                {
+                    foreach (var builder in builders)
+                    {
+                        using (var cmd = con.CreateCommand())
+                        {
+                            ret += cmd
+                               .SetCommand(builder)
+                               .ExecuteNonQuery();
+                        }
+                    }
+
+                    trans.Commit();
+                }
+            }
+
+            return ret;
+        }
+
+        #endregion Execute
+
+        #region Scalar
+
+        /// <summary>Returns a single result.</summary>
+        /// <param name="sql">SQL query containing numbered parameters in format provided by
+        /// <see cref="DynamicDatabase.GetParameterName(object)"/> methods. Also names should be formatted with
+        /// <see cref="DynamicDatabase.DecorateName(string)"/> method.</param>
+        /// <param name="args">Arguments (parameters).</param>
+        /// <returns>Result of a query.</returns>
+        public virtual object Scalar(string sql, params object[] args)
+        {
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            {
+                return cmd
+                    .SetCommand(sql).AddParameters(this, args)
+                    .ExecuteScalar();
+            }
+        }
+
+        /// <summary>Returns a single result.</summary>
+        /// <param name="builder">Command builder.</param>
+        /// <returns>Result of a query.</returns>
+        public virtual object Scalar(IDynamicQueryBuilder builder)
+        {
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            {
+                return cmd
+                    .SetCommand(builder)
+                    .ExecuteScalar();
+            }
+        }
+
+        #endregion Scalar
+
+        #region Query
+
+        /// <summary>Enumerate the reader and yield the result.</summary>
+        /// <param name="sql">SQL query containing numbered parameters in format provided by
+        /// <see cref="DynamicDatabase.GetParameterName(object)"/> methods. Also names should be formatted with
+        /// <see cref="DynamicDatabase.DecorateName(string)"/> method.</param>
+        /// <param name="args">Arguments (parameters).</param>
+        /// <returns>Enumerator of objects expanded from query.</returns>
+        public virtual IEnumerable<dynamic> Query(string sql, params object[] args)
+        {
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            using (var rdr = cmd
+                .SetCommand(sql)
+                .AddParameters(this, args)
+                .ExecuteReader())
+                while (rdr.Read())
+                {
+                    dynamic val = null;
+
+                    // Work around to avoid yield being in try...catch block:
+                    // http://stackoverflow.com/questions/346365/why-cant-yield-return-appear-inside-a-try-block-with-a-catch
+                    try
+                    {
+                        val = rdr.RowToDynamic();
+                    }
+                    catch (ArgumentException argex)
+                    {
+                        var sb = new StringBuilder();
+                        cmd.Dump(sb);
+
+                        throw new ArgumentException(string.Format("{0}{1}{2}", argex.Message, Environment.NewLine, sb),
+                            argex.InnerException.NullOr(a => a, argex));
+                    }
+
+                    yield return val;
+                }
+        }
+
+        /// <summary>Enumerate the reader and yield the result.</summary>
+        /// <param name="builder">Command builder.</param>
+        /// <returns>Enumerator of objects expanded from query.</returns>
+        public virtual IEnumerable<dynamic> Query(IDynamicQueryBuilder builder)
+        {
+            using (var con = Open())
+            using (var cmd = con.CreateCommand())
+            using (var rdr = cmd
+                .SetCommand(builder)
+                .ExecuteReader())
+                while (rdr.Read())
+                {
+                    dynamic val = null;
+
+                    // Work around to avoid yield being in try...catch block:
+                    // http://stackoverflow.com/questions/346365/why-cant-yield-return-appear-inside-a-try-block-with-a-catch
+                    try
+                    {
+                        val = rdr.RowToDynamic();
+                    }
+                    catch (ArgumentException argex)
+                    {
+                        var sb = new StringBuilder();
+                        cmd.Dump(sb);
+
+                        throw new ArgumentException(string.Format("{0}{1}{2}", argex.Message, Environment.NewLine, sb),
+                            argex.InnerException.NullOr(a => a, argex));
+                    }
+
+                    yield return val;
+                }
+        }
+
+        #endregion Query
+
         #region Schema
 
         /// <summary>Builds query cache if necessary and returns it.</summary>
diff --git a/DynamORM/DynamicTable.cs b/DynamORM/DynamicTable.cs
index b8f9721..afcc320 100644
--- a/DynamORM/DynamicTable.cs
+++ b/DynamORM/DynamicTable.cs
@@ -28,10 +28,8 @@
 
 using System;
 using System.Collections.Generic;
-using System.Data;
 using System.Dynamic;
 using System.Linq;
-using System.Text;
 using DynamORM.Builders;
 using DynamORM.Builders.Extensions;
 using DynamORM.Builders.Implementation;
@@ -348,33 +346,7 @@ namespace DynamORM
         /// <returns>Enumerator of objects expanded from query.</returns>
         public virtual IEnumerable<dynamic> Query(string sql, params object[] args)
         {
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            using (var rdr = cmd
-                .SetCommand(sql)
-                .AddParameters(Database, args)
-                .ExecuteReader())
-                while (rdr.Read())
-                {
-                    dynamic val = null;
-
-                    // Work around to avoid yield being in try...catch block:
-                    // http://stackoverflow.com/questions/346365/why-cant-yield-return-appear-inside-a-try-block-with-a-catch
-                    try
-                    {
-                        val = rdr.RowToDynamic();
-                    }
-                    catch (ArgumentException argex)
-                    {
-                        var sb = new StringBuilder();
-                        cmd.Dump(sb);
-
-                        throw new ArgumentException(string.Format("{0}{1}{2}", argex.Message, Environment.NewLine, sb),
-                            argex.InnerException.NullOr(a => a, argex));
-                    }
-
-                    yield return val;
-                }
+            return Database.Query(sql, args);
         }
 
         /// <summary>Enumerate the reader and yield the result.</summary>
@@ -382,32 +354,7 @@ namespace DynamORM
         /// <returns>Enumerator of objects expanded from query.</returns>
         public virtual IEnumerable<dynamic> Query(IDynamicQueryBuilder builder)
         {
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            using (var rdr = cmd
-                .SetCommand(builder)
-                .ExecuteReader())
-                while (rdr.Read())
-                {
-                    dynamic val = null;
-
-                    // Work around to avoid yield being in try...catch block:
-                    // http://stackoverflow.com/questions/346365/why-cant-yield-return-appear-inside-a-try-block-with-a-catch
-                    try
-                    {
-                        val = rdr.RowToDynamic();
-                    }
-                    catch (ArgumentException argex)
-                    {
-                        var sb = new StringBuilder();
-                        cmd.Dump(sb);
-
-                        throw new ArgumentException(string.Format("{0}{1}{2}", argex.Message, Environment.NewLine, sb),
-                            argex.InnerException.NullOr(a => a, argex));
-                    }
-
-                    yield return val;
-                }
+            return Database.Query(builder);
         }
 
         /// <summary>Create new <see cref="DynamicSelectQueryBuilder"/>.</summary>
@@ -431,13 +378,7 @@ namespace DynamORM
         /// <returns>Result of a query.</returns>
         public virtual object Scalar(string sql, params object[] args)
         {
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(sql).AddParameters(Database, args)
-                    .ExecuteScalar();
-            }
+            return Database.Scalar(sql, args);
         }
 
         /// <summary>Returns a single result.</summary>
@@ -445,13 +386,7 @@ namespace DynamORM
         /// <returns>Result of a query.</returns>
         public virtual object Scalar(IDynamicQueryBuilder builder)
         {
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(builder)
-                    .ExecuteScalar();
-            }
+            return Database.Scalar(builder);
         }
 
         /// <summary>Execute stored procedure.</summary>
@@ -459,16 +394,7 @@ namespace DynamORM
         /// <returns>Number of affected rows.</returns>
         public virtual int Procedure(string procName)
         {
-            if ((Database.Options & DynamicDatabaseOptions.SupportStoredProcedures) != DynamicDatabaseOptions.SupportStoredProcedures)
-                throw new InvalidOperationException("Database connection desn't support stored procedures.");
-
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(CommandType.StoredProcedure, procName)
-                    .ExecuteNonQuery();
-            }
+            return Database.Procedure(procName);
         }
 
         /// <summary>Execute stored procedure.</summary>
@@ -477,17 +403,7 @@ namespace DynamORM
         /// <returns>Number of affected rows.</returns>
         public virtual int Procedure(string procName, params object[] args)
         {
-            if ((Database.Options & DynamicDatabaseOptions.SupportStoredProcedures) != DynamicDatabaseOptions.SupportStoredProcedures)
-                throw new InvalidOperationException("Database connection desn't support stored procedures.");
-
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(CommandType.StoredProcedure, procName)
-                    .AddParameters(Database, args)
-                    .ExecuteNonQuery();
-            }
+            return Database.Procedure(procName, args);
         }
 
         /// <summary>Execute stored procedure.</summary>
@@ -496,17 +412,7 @@ namespace DynamORM
         /// <returns>Number of affected rows.</returns>
         public virtual int Procedure(string procName, DynamicExpando args)
         {
-            if ((Database.Options & DynamicDatabaseOptions.SupportStoredProcedures) != DynamicDatabaseOptions.SupportStoredProcedures)
-                throw new InvalidOperationException("Database connection desn't support stored procedures.");
-
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(CommandType.StoredProcedure, procName)
-                    .AddParameters(Database, args)
-                    .ExecuteNonQuery();
-            }
+            return Database.Procedure(procName, args);
         }
 
         /// <summary>Execute stored procedure.</summary>
@@ -515,17 +421,7 @@ namespace DynamORM
         /// <returns>Number of affected rows.</returns>
         public virtual int Procedure(string procName, ExpandoObject args)
         {
-            if ((Database.Options & DynamicDatabaseOptions.SupportStoredProcedures) != DynamicDatabaseOptions.SupportStoredProcedures)
-                throw new InvalidOperationException("Database connection desn't support stored procedures.");
-
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(CommandType.StoredProcedure, procName)
-                    .AddParameters(Database, args)
-                    .ExecuteNonQuery();
-            }
+            return Database.Procedure(procName, args);
         }
 
         /// <summary>Execute non query.</summary>
@@ -536,13 +432,7 @@ namespace DynamORM
         /// <returns>Number of affected rows.</returns>
         public virtual int Execute(string sql, params object[] args)
         {
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(sql).AddParameters(Database, args)
-                    .ExecuteNonQuery();
-            }
+            return Database.Execute(sql, args);
         }
 
         /// <summary>Execute non query.</summary>
@@ -550,41 +440,15 @@ namespace DynamORM
         /// <returns>Number of affected rows.</returns>
         public virtual int Execute(IDynamicQueryBuilder builder)
         {
-            using (var con = Database.Open())
-            using (var cmd = con.CreateCommand())
-            {
-                return cmd
-                    .SetCommand(builder)
-                    .ExecuteNonQuery();
-            }
+            return Database.Execute(builder);
         }
 
         /// <summary>Execute non query.</summary>
-        /// <param name="builers">Command builders.</param>
+        /// <param name="builders">Command builders.</param>
         /// <returns>Number of affected rows.</returns>
-        public virtual int Execute(IDynamicQueryBuilder[] builers)
+        public virtual int Execute(IDynamicQueryBuilder[] builders)
         {
-            int ret = 0;
-
-            using (var con = Database.Open())
-            {
-                using (var trans = con.BeginTransaction())
-                {
-                    foreach (var builder in builers)
-                    {
-                        using (var cmd = con.CreateCommand())
-                        {
-                            ret += cmd
-                               .SetCommand(builder)
-                               .ExecuteNonQuery();
-                        }
-                    }
-
-                    trans.Commit();
-                }
-            }
-
-            return ret;
+            return Database.Execute(builders);
         }
 
         #endregion Basic Queries