diff --git a/src/Umbraco.Core/DatabaseContext.cs b/src/Umbraco.Core/DatabaseContext.cs
index 8f94c993ba..c77f3f2002 100644
--- a/src/Umbraco.Core/DatabaseContext.cs
+++ b/src/Umbraco.Core/DatabaseContext.cs
@@ -20,55 +20,40 @@ using Umbraco.Core.Services;
 namespace Umbraco.Core
 {
     /// <summary>
-    /// The Umbraco Database context
+    /// Represents the Umbraco database.
     /// </summary>
-    /// <remarks>
-    /// One per AppDomain, represents the Umbraco database
-    /// </remarks>
+    /// <remarks>One per AppDomain. Ensures that the database is available.</remarks>
     public class DatabaseContext
     {
         private readonly IDatabaseFactory _factory;
         private readonly ILogger _logger;
-        private readonly SqlSyntaxProviders _syntaxProviders;
-        private bool _configured;
-        private string _connectionString;
-        private string _providerName;
-        private DatabaseSchemaResult _result;
+        private DatabaseSchemaResult _databaseSchemaValidationResult;
 
         /// <summary>
-        /// Default constructor
+        /// Initializes a new instance of the <see cref="DatabaseContext"/> class with a database factory and a logger.
         /// </summary>
-        /// <param name="factory"></param>
-        /// <param name="logger"></param>
-        /// <param name="syntaxProviders"></param>
-        public DatabaseContext(IDatabaseFactory factory, ILogger logger, SqlSyntaxProviders syntaxProviders)
+        /// <param name="factory">A database factory.</param>
+        /// <param name="logger">A logger.</param>
+        /// <remarks>The database factory will try to configure itself but may fail eg if the default
+        /// Umbraco connection string is not available because we are installing. In which case this
+        /// database context must sort things out and configure the database factory before it can be
+        /// used.</remarks>
+        public DatabaseContext(IDatabaseFactory factory, ILogger logger)
         {
-            if (factory == null) throw new ArgumentNullException("factory");
-            if (logger == null) throw new ArgumentNullException("logger");
-            if (syntaxProviders == null) throw new ArgumentNullException("syntaxProviders");
+            if (factory == null) throw new ArgumentNullException(nameof(factory));
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
 
             _factory = factory;
             _logger = logger;
-            _syntaxProviders = syntaxProviders;
+
+            if (_factory.Configured == false)
+                GiveLegacyAChance();
         }
 
         /// <summary>
-        /// Create a configured DatabaseContext
+        /// Gets the database sql syntax.
         /// </summary>
-        /// <param name="factory"></param>
-        /// <param name="logger"></param>
-        /// <param name="sqlSyntax"></param>
-        /// <param name="providerName"></param>
-        public DatabaseContext(IDatabaseFactory factory, ILogger logger, ISqlSyntaxProvider sqlSyntax, string providerName)
-        {
-            _providerName = providerName;
-            SqlSyntax = sqlSyntax;
-            _factory = factory;
-            _logger = logger;
-            _configured = true;
-        }
-
-        public ISqlSyntaxProvider SqlSyntax { get; private set; }
+        public ISqlSyntaxProvider SqlSyntax => _factory.SqlSyntax;
 
         /// <summary>
         /// Gets the <see cref="Database"/> object for doing CRUD operations
@@ -78,196 +63,152 @@ namespace Umbraco.Core
         /// This should not be used for CRUD operations or queries against the
         /// standard Umbraco tables! Use the Public services for that.
         /// </remarks>
-        public virtual UmbracoDatabase Database
-        {
-            get { return _factory.CreateDatabase(); }
-        }
+        public virtual UmbracoDatabase Database => _factory.GetDatabase();
 
         /// <summary>
-        /// Boolean indicating whether the database has been configured
+        /// Gets a value indicating whether the database is configured, ie whether it exists
+        /// and can be reached. It does not necessarily mean that Umbraco is installed nor
+        /// up-to-date.
         /// </summary>
-        public virtual bool IsDatabaseConfigured
-        {
-            get { return _configured; }
-        }
+        public bool IsDatabaseConfigured => _factory.Configured;
 
         /// <summary>
-        /// Determines if the db can be connected to
+        /// Gets a value indicating whether it is possible to connect to the database.
         /// </summary>
         public virtual bool CanConnect
         {
             get
             {
                 if (IsDatabaseConfigured == false) return false;
-                var canConnect = DbConnectionExtensions.IsConnectionAvailable(ConnectionString, DatabaseProvider);
+                var canConnect = _factory.CanConnect;
                 LogHelper.Info<DatabaseContext>("CanConnect = " + canConnect);
                 return canConnect;
             }
         }
 
-        /// <summary>
-        /// Gets the configured umbraco db connection string.
-        /// </summary>
-        public virtual string ConnectionString
-        {
-            get { return _connectionString; }
-        }
+        #region Configure Connection String
+
+        private const string EmbeddedDatabaseConnectionString = @"Data Source=|DataDirectory|\Umbraco.sdf;Flush Interval=1;";
 
         /// <summary>
-        /// Returns the name of the dataprovider from the connectionstring setting in config
-        /// </summary>
-        internal string ProviderName
-        {
-            get
-            {
-                if (string.IsNullOrEmpty(_providerName) == false)
-                    return _providerName;
-
-                _providerName = "System.Data.SqlClient";
-                if (ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName] != null)
-                {
-                    if (string.IsNullOrEmpty(ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ProviderName) == false)
-                        _providerName = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ProviderName;
-                }
-                else
-                {
-                    throw new InvalidOperationException("Can't find a connection string with the name '" + GlobalSettings.UmbracoConnectionName + "'");
-                }
-                return _providerName;
-            }
-        }
-
-        /// <summary>
-        /// Returns the Type of DatabaseProvider used
-        /// </summary>
-        public virtual DatabaseProviders DatabaseProvider
-        {
-            get
-            {
-                string dbtype = Database.Connection == null ? ProviderName : Database.Connection.GetType().Name;
-
-                if (dbtype.StartsWith("MySql")) return DatabaseProviders.MySql;
-                if (dbtype.StartsWith("SqlCe") || dbtype.Contains("SqlServerCe")) return DatabaseProviders.SqlServerCE;
-                if (dbtype.StartsWith("Npgsql")) return DatabaseProviders.PostgreSQL;
-                if (dbtype.StartsWith("Oracle") || dbtype.Contains("OracleClient")) return DatabaseProviders.Oracle;
-                if (dbtype.StartsWith("SQLite")) return DatabaseProviders.SQLite;
-                if (dbtype.Contains("Azure")) return DatabaseProviders.SqlAzure;
-
-                return DatabaseProviders.SqlServer;
-            }
-        }
-
-        /// <summary>
-        /// Configure a ConnectionString for the embedded database.
+        /// Configures a connection string for the embedded database.
         /// </summary>
         public void ConfigureEmbeddedDatabaseConnection()
         {
-            const string providerName = "System.Data.SqlServerCe.4.0";
-
-            var connectionString = GetEmbeddedDatabaseConnectionString();
-            SaveConnectionString(connectionString, providerName);
+            SaveConnectionString(EmbeddedDatabaseConnectionString, Constants.DbProviderNames.SqlCe);
 
             var path = Path.Combine(GlobalSettings.FullpathToRoot, "App_Data", "Umbraco.sdf");
             if (File.Exists(path) == false)
             {
-                var engine = new SqlCeEngine(connectionString);
-                engine.CreateDatabase();
+                // this should probably be in a "using (new SqlCeEngine)" clause but not sure
+                // of the side effects and it's been like this for quite some time now
 
-                // SD: Pretty sure this should be in a using clause but i don't want to cause unknown side-effects here
-                // since it's been like this for quite some time
-                //using (var engine = new SqlCeEngine(connectionString))
-                //{
-                //    engine.CreateDatabase();    
-                //}
+                var engine = new SqlCeEngine(EmbeddedDatabaseConnectionString);
+                engine.CreateDatabase();
             }
 
-            Initialize(providerName);
-        }
-
-        public string GetEmbeddedDatabaseConnectionString()
-        {
-            return @"Data Source=|DataDirectory|\Umbraco.sdf;Flush Interval=1;";
+            _factory.Configure(EmbeddedDatabaseConnectionString, Constants.DbProviderNames.SqlCe);
         }
 
         /// <summary>
-        /// Configure a ConnectionString that has been entered manually.
+        /// Configures a connection string that has been entered manually.
         /// </summary>
-        /// <remarks>
-        /// Please note that we currently assume that the 'System.Data.SqlClient' provider can be used.
-        /// </remarks>
-        /// <param name="connectionString"></param>
+        /// <param name="connectionString">A connection string.</param>
+        /// <remarks>Has to be either SQL Server or MySql</remarks>
         public void ConfigureDatabaseConnection(string connectionString)
         {
-            var provider = DbConnectionExtensions.DetectProviderFromConnectionString(connectionString);
-            var databaseProvider = provider.ToString();
-            var providerName = "System.Data.SqlClient";
-            if (databaseProvider.ToLower().Contains("mysql"))
-            {
-                providerName = "MySql.Data.MySqlClient";
-            }
+            var provider = DbConnectionExtensions.DetectProviderNameFromConnectionString(connectionString);
+            var providerName = provider.ToString().ToLower().Contains("mysql")
+                ? Constants.DbProviderNames.MySql
+                : Constants.DbProviderNames.SqlServer;
+
             SaveConnectionString(connectionString, providerName);
-            Initialize(string.Empty);
+            _factory.Configure(connectionString, providerName);
         }
 
         /// <summary>
-        /// Configures a ConnectionString for the Umbraco database based on the passed in properties from the installer.
+        /// Configures a connection string from the installer.
         /// </summary>
-        /// <param name="server">Name or address of the database server</param>
-        /// <param name="databaseName">Name of the database</param>
-        /// <param name="user">Database Username</param>
-        /// <param name="password">Database Password</param>
-        /// <param name="databaseProvider">Type of the provider to be used (Sql, Sql Azure, Sql Ce, MySql)</param>
+        /// <param name="server">The name or address of the database server.</param>
+        /// <param name="databaseName">The name of the database.</param>
+        /// <param name="user">The user name.</param>
+        /// <param name="password">The user password.</param>
+        /// <param name="databaseProvider">The name the provider (Sql, Sql Azure, Sql Ce, MySql).</param>
         public void ConfigureDatabaseConnection(string server, string databaseName, string user, string password, string databaseProvider)
-        {            
+        {
             string providerName;
             var connectionString = GetDatabaseConnectionString(server, databaseName, user, password, databaseProvider, out providerName);
 
             SaveConnectionString(connectionString, providerName);
-            Initialize(providerName);
-        }
-        
-        public string GetDatabaseConnectionString(string server, string databaseName, string user, string password, string databaseProvider, out string providerName)
-        {
-            providerName = "System.Data.SqlClient";
-            if (databaseProvider.ToLower().Contains("mysql"))
-            {
-                providerName = "MySql.Data.MySqlClient";
-                return string.Format("Server={0}; Database={1};Uid={2};Pwd={3}", server, databaseName, user, password);
-            }
-            if (databaseProvider.ToLower().Contains("azure"))
-            {
-                return BuildAzureConnectionString(server, databaseName, user, password);
-            }
-            return string.Format("server={0};database={1};user id={2};password={3}", server, databaseName, user, password);
+            _factory.Configure(connectionString, providerName);
         }
 
         /// <summary>
-        /// Configures a ConnectionString for the Umbraco database that uses Microsoft SQL Server integrated security.
+        /// Gets a connection string from the installer.
         /// </summary>
-        /// <param name="server">Name or address of the database server</param>
-        /// <param name="databaseName">Name of the database</param>
+        /// <param name="server">The name or address of the database server.</param>
+        /// <param name="databaseName">The name of the database.</param>
+        /// <param name="user">The user name.</param>
+        /// <param name="password">The user password.</param>
+        /// <param name="databaseProvider">The name the provider (Sql, Sql Azure, Sql Ce, MySql).</param>
+        /// <param name="providerName"></param>
+        /// <returns>A connection string.</returns>
+        public string GetDatabaseConnectionString(string server, string databaseName, string user, string password, string databaseProvider, out string providerName)
+        {
+            providerName = Constants.DbProviderNames.SqlServer;
+            var test = databaseProvider.ToLower();
+            if (test.Contains("mysql"))
+            {
+                providerName = Constants.DbProviderNames.MySql;
+                return $"Server={server}; Database={databaseName};Uid={user};Pwd={password}";
+            }
+            if (test.Contains("azure"))
+            {
+                return GetAzureConnectionString(server, databaseName, user, password);
+            }
+            return $"server={server};database={databaseName};user id={user};password={password}";
+        }
+
+        /// <summary>
+        /// Configures a connection string using Microsoft SQL Server integrated security.
+        /// </summary>
+        /// <param name="server">The name or address of the database server.</param>
+        /// <param name="databaseName">The name of the database</param>
         public void ConfigureIntegratedSecurityDatabaseConnection(string server, string databaseName)
         {
-            const string providerName = "System.Data.SqlClient";
             var connectionString = GetIntegratedSecurityDatabaseConnectionString(server, databaseName);
-            SaveConnectionString(connectionString, providerName);
-            Initialize(providerName);
+            SaveConnectionString(connectionString, Constants.DbProviderNames.SqlServer);
+            _factory.Configure(connectionString, Constants.DbProviderNames.SqlServer);
         }
 
+        /// <summary>
+        /// Gets a connection string using Microsoft SQL Server integrated security.
+        /// </summary>
+        /// <param name="server">The name or address of the database server.</param>
+        /// <param name="databaseName">The name of the database</param>
+        /// <returns>A connection string.</returns>
         public string GetIntegratedSecurityDatabaseConnectionString(string server, string databaseName)
         {
-            return String.Format("Server={0};Database={1};Integrated Security=true", server, databaseName);            
+            return $"Server={server};Database={databaseName};Integrated Security=true";
         }
 
-        internal string BuildAzureConnectionString(string server, string databaseName, string user, string password)
+        /// <summary>
+        /// Gets an Azure connection string.
+        /// </summary>
+        /// <param name="server">The name or address of the database server.</param>
+        /// <param name="databaseName">The name of the database.</param>
+        /// <param name="user">The user name.</param>
+        /// <param name="password">The user password.</param>
+        /// <returns>A connection string.</returns>
+        public string GetAzureConnectionString(string server, string databaseName, string user, string password)
         {
             if (server.Contains(".") && ServerStartsWithTcp(server) == false)
-                server = string.Format("tcp:{0}", server);
-            
+                server = $"tcp:{server}";
+
             if (server.Contains(".") == false && ServerStartsWithTcp(server))
             {
-                string serverName = server.Contains(",") 
-                                        ? server.Substring(0, server.IndexOf(",", StringComparison.Ordinal)) 
+                string serverName = server.Contains(",")
+                                        ? server.Substring(0, server.IndexOf(",", StringComparison.Ordinal))
                                         : server;
 
                 var portAddition = string.Empty;
@@ -275,14 +216,14 @@ namespace Umbraco.Core
                 if (server.Contains(","))
                     portAddition = server.Substring(server.IndexOf(",", StringComparison.Ordinal));
 
-                server = string.Format("{0}.database.windows.net{1}", serverName, portAddition);
+                server = $"{serverName}.database.windows.net{portAddition}";
             }
-            
+
             if (ServerStartsWithTcp(server) == false)
-                server = string.Format("tcp:{0}.database.windows.net", server);
-            
+                server = $"tcp:{server}.database.windows.net";
+
             if (server.Contains(",") == false)
-                server = string.Format("{0},1433", server);
+                server = $"{server},1433";
 
             if (user.Contains("@") == false)
             {
@@ -294,10 +235,10 @@ namespace Umbraco.Core
                 if (userDomain.Contains("."))
                     userDomain = userDomain.Substring(0, userDomain.IndexOf(".", StringComparison.Ordinal));
 
-                user = string.Format("{0}@{1}", user, userDomain);
+                user = $"{user}@{userDomain}";
             }
 
-            return string.Format("Server={0};Database={1};User ID={2};Password={3}", server, databaseName, user, password);
+            return $"Server={server};Database={databaseName};User ID={user};Password={password}";
         }
 
         private static bool ServerStartsWithTcp(string server)
@@ -306,36 +247,34 @@ namespace Umbraco.Core
         }
 
         /// <summary>
-        /// Saves the connection string as a proper .net ConnectionString and the legacy AppSettings key/value.
+        /// Saves the connection string as a proper .net connection string in web.config.
         /// </summary>
-        /// <remarks>
-        /// Saves the ConnectionString in the very nasty 'medium trust'-supportive way.
-        /// </remarks>
-        /// <param name="connectionString"></param>
-        /// <param name="providerName"></param>
+        /// <remarks>Saves the ConnectionString in the very nasty 'medium trust'-supportive way.</remarks>
+        /// <param name="connectionString">The connection string.</param>
+        /// <param name="providerName">The provider name.</param>
         private void SaveConnectionString(string connectionString, string providerName)
         {
-            //Set the connection string for the new datalayer
-            var connectionStringSettings = string.IsNullOrEmpty(providerName)
-                                      ? new ConnectionStringSettings(GlobalSettings.UmbracoConnectionName,
-                                                                     connectionString)
-                                      : new ConnectionStringSettings(GlobalSettings.UmbracoConnectionName,
-                                                                     connectionString, providerName);
+            if (string.IsNullOrWhiteSpace(connectionString)) throw new ArgumentException("Value cannot be null nor empty.", nameof(connectionString));
+            if (string.IsNullOrWhiteSpace(providerName)) throw new ArgumentException("Value cannot be null nor empty.", nameof(providerName));
 
-            _connectionString = connectionString;
-            _providerName = providerName;
-            
-            var fileName = IOHelper.MapPath(string.Format("{0}/web.config", SystemDirectories.Root));
+            // set the connection string for the new datalayer
+            var connectionStringSettings = new ConnectionStringSettings(GlobalSettings.UmbracoConnectionName, connectionString, providerName);
+
+            var fileName = IOHelper.MapPath($"{SystemDirectories.Root}/web.config");
             var xml = XDocument.Load(fileName, LoadOptions.PreserveWhitespace);
-            var connectionstrings = xml.Root.DescendantsAndSelf("connectionStrings").Single();
+            if (xml.Root == null) throw new Exception("Invalid web.config file.");
+            var connectionStrings = xml.Root.DescendantsAndSelf("connectionStrings").FirstOrDefault();
+            if (connectionStrings == null) throw new Exception("Invalid web.config file.");
 
-            // Update connectionString if it exists, or else create a new appSetting for the given key and value
-            var setting = connectionstrings.Descendants("add").FirstOrDefault(s => s.Attribute("name").Value == GlobalSettings.UmbracoConnectionName);
+            // update connectionString if it exists, or else create a new connectionString
+            var setting = connectionStrings.Descendants("add").FirstOrDefault(s => s.Attribute("name").Value == GlobalSettings.UmbracoConnectionName);
             if (setting == null)
-                connectionstrings.Add(new XElement("add",
+            {
+                connectionStrings.Add(new XElement("add",
                     new XAttribute("name", GlobalSettings.UmbracoConnectionName),
                     new XAttribute("connectionString", connectionStringSettings),
                     new XAttribute("providerName", providerName)));
+            }
             else
             {
                 setting.Attribute("connectionString").Value = connectionString;
@@ -343,180 +282,75 @@ namespace Umbraco.Core
             }
 
             xml.Save(fileName, SaveOptions.DisableFormatting);
-
             _logger.Info<DatabaseContext>("Configured a new ConnectionString using the '" + providerName + "' provider.");
         }
 
-        /// <summary>
-        /// Internal method to initialize the database configuration.
-        /// </summary>
-        /// <remarks>
-        /// If an Umbraco connectionstring exists the database can be configured on app startup,
-        /// but if its a new install the entry doesn't exist and the db cannot be configured.
-        /// So for new installs the Initialize() method should be called after the connectionstring
-        /// has been added to the web.config.
-        /// </remarks>
-        internal void Initialize()
+        #endregion
+
+        #region Utils
+
+        internal void GiveLegacyAChance()
         {
-            var databaseSettings = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName];
-            if (databaseSettings != null && string.IsNullOrWhiteSpace(databaseSettings.ConnectionString) == false && string.IsNullOrWhiteSpace(databaseSettings.ProviderName) == false)
-            {
-                var providerName = "System.Data.SqlClient";
-                string connString = null;
-                if (!string.IsNullOrEmpty(ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ProviderName))
-                {
-                    providerName = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ProviderName;
-                    connString = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ConnectionString;
-                }
-                Initialize(providerName, connString);
+            // look for the legacy appSettings key
+            var legacyConnString = ConfigurationManager.AppSettings[GlobalSettings.UmbracoConnectionName];
+            if (string.IsNullOrWhiteSpace(legacyConnString)) return;
 
-                DetermineSqlServerVersion();
+            var test = legacyConnString.ToLowerInvariant();
+            if (test.Contains("sqlce4umbraco"))
+            {
+                // sql ce
+                ConfigureEmbeddedDatabaseConnection();
             }
-            else if (ConfigurationManager.AppSettings.ContainsKey(GlobalSettings.UmbracoConnectionName) && string.IsNullOrEmpty(ConfigurationManager.AppSettings[GlobalSettings.UmbracoConnectionName]) == false)
+            else if (test.Contains("tcp:"))
             {
-                //A valid connectionstring does not exist, but the legacy appSettings key was found, so we'll reconfigure the conn.string.
-                var legacyConnString = ConfigurationManager.AppSettings[GlobalSettings.UmbracoConnectionName];
-                if (legacyConnString.ToLowerInvariant().Contains("sqlce4umbraco"))
-                {
-                    ConfigureEmbeddedDatabaseConnection();
-                }
-                else if (legacyConnString.ToLowerInvariant().Contains("tcp:"))
-                {
-                    //Must be sql azure
-                    SaveConnectionString(legacyConnString, "System.Data.SqlClient");
-                    Initialize("System.Data.SqlClient");
-                }
-                else if (legacyConnString.ToLowerInvariant().Contains("datalayer=mysql"))
-                {
-                    //Must be MySql
+                // sql azure
+                SaveConnectionString(legacyConnString, Constants.DbProviderNames.SqlServer);
+                _factory.Configure(legacyConnString, Constants.DbProviderNames.SqlServer);
+            }
+            else if (test.Contains("datalayer=mysql"))
+            {
+                // mysql
 
-                    //Need to strip the datalayer part off
-                    var connectionStringWithoutDatalayer = string.Empty;
-                    foreach (var variable in legacyConnString.Split(';').Where(x => x.ToLowerInvariant().StartsWith("datalayer") == false))
-                        connectionStringWithoutDatalayer = string.Format("{0}{1};", connectionStringWithoutDatalayer, variable);
+                // strip the datalayer part off
+                var connectionStringWithoutDatalayer = string.Empty;
+                // ReSharper disable once LoopCanBeConvertedToQuery
+                foreach (var variable in legacyConnString.Split(';').Where(x => x.ToLowerInvariant().StartsWith("datalayer") == false))
+                    connectionStringWithoutDatalayer = $"{connectionStringWithoutDatalayer}{variable};";
 
-                    SaveConnectionString(connectionStringWithoutDatalayer, "MySql.Data.MySqlClient");
-                    Initialize("MySql.Data.MySqlClient");
-                }
-                else
-                {
-                    //Must be sql
-                    SaveConnectionString(legacyConnString, "System.Data.SqlClient");
-                    Initialize("System.Data.SqlClient");
-                }
-
-                //Remove the legacy connection string, so we don't end up in a loop if something goes wrong.
-                GlobalSettings.RemoveSetting(GlobalSettings.UmbracoConnectionName);
-
-                DetermineSqlServerVersion();
+                SaveConnectionString(connectionStringWithoutDatalayer, Constants.DbProviderNames.MySql);
+                _factory.Configure(connectionStringWithoutDatalayer, Constants.DbProviderNames.MySql);
             }
             else
             {
-                _configured = false;
+                // sql server
+                SaveConnectionString(legacyConnString, Constants.DbProviderNames.SqlServer);
+                _factory.Configure(legacyConnString, Constants.DbProviderNames.SqlServer);
             }
+
+            // remove the legacy connection string, so we don't end up in a loop if something goes wrong
+            GlobalSettings.RemoveSetting(GlobalSettings.UmbracoConnectionName);
         }
 
-        internal void Initialize(string providerName)
-        {
-            //only configure once!
-            if (_configured == true) return;
+        #endregion
 
-            _providerName = providerName;
-
-            try
-            {
-                if (_syntaxProviders != null)
-                {
-                    SqlSyntax = _syntaxProviders.GetByProviderNameOrDefault(providerName);    
-                }
-                else if (SqlSyntax == null)
-                {
-                    throw new InvalidOperationException("No " + typeof(ISqlSyntaxProvider) + " specified or no " + typeof(SqlSyntaxProviders) + " instance specified");
-                }
-                
-                _configured = true;
-            }
-            catch (Exception e)
-            {
-                _configured = false;
-
-                _logger.Info<DatabaseContext>("Initialization of the DatabaseContext failed with following error: " + e.Message);
-                _logger.Info<DatabaseContext>(e.StackTrace);
-            }
-        }
-
-        internal void Initialize(string providerName, string connectionString)
-        {
-            _connectionString = connectionString;
-            Initialize(providerName);
-        }
-
-        /// <summary>
-        /// Set the lazy resolution of determining the SQL server version if that is the db type we're using
-        /// </summary>
-        private void DetermineSqlServerVersion()
-        {
-
-            var sqlServerSyntax = SqlSyntax as SqlServerSyntaxProvider;
-            if (sqlServerSyntax != null)
-            {
-                //this will not execute now, it is lazy so will only execute when we need to actually know
-                // the sql server version.
-                sqlServerSyntax.VersionName = new Lazy<SqlServerVersionName>(() =>
-                {
-                    try
-                    {
-                        var database = this._factory.CreateDatabase();
-
-                        var version = database.ExecuteScalar<string>("SELECT SERVERPROPERTY('productversion')");
-                        var firstPart = version.Split('.')[0];
-                        switch (firstPart)
-                        {
-                            case "11":
-                                return SqlServerVersionName.V2012;
-                            case "10":
-                                return SqlServerVersionName.V2008;
-                            case "9":
-                                return SqlServerVersionName.V2005;
-                            case "8":
-                                return SqlServerVersionName.V2000;
-                            case "7":
-                                return SqlServerVersionName.V7;
-                            default:
-                                return SqlServerVersionName.Other;
-                        }
-                    }
-                    catch (Exception)
-                    {
-                        return SqlServerVersionName.Invalid;
-                    }
-                });
-            }
-        }
+        #region Database Schema
 
         internal DatabaseSchemaResult ValidateDatabaseSchema()
         {
-            if (_configured == false || (string.IsNullOrEmpty(_connectionString) || string.IsNullOrEmpty(ProviderName)))
+            if (_factory.Configured == false)
                 return new DatabaseSchemaResult(SqlSyntax);
 
-            if (_result == null)
-            {
+            if (_databaseSchemaValidationResult != null)
+                return _databaseSchemaValidationResult;
 
-                if (SystemUtilities.GetCurrentTrustLevel() != AspNetHostingPermissionLevel.Unrestricted
-                    && ProviderName == "MySql.Data.MySqlClient")
-                {
-                    throw new InvalidOperationException("Cannot use MySql in Medium Trust configuration");
-                }
-
-                var database = new UmbracoDatabase(_connectionString, ProviderName, _logger);
-                var dbSchema = new DatabaseSchemaCreation(database, _logger, SqlSyntax);
-                _result = dbSchema.ValidateSchema();
-            }
-            return _result;
+            var database = _factory.GetDatabase();
+            var dbSchema = new DatabaseSchemaCreation(database, _logger);
+            _databaseSchemaValidationResult = dbSchema.ValidateSchema();
+            return _databaseSchemaValidationResult;
         }
 
         internal Result CreateDatabaseSchemaAndData(ApplicationContext applicationContext)
-        {   
+        {
             try
             {
                 var readyForInstall = CheckReadyForInstall();
@@ -527,14 +361,12 @@ namespace Umbraco.Core
 
                 _logger.Info<DatabaseContext>("Database configuration status: Started");
 
-                string message;
-
-                var database = new UmbracoDatabase(_connectionString, ProviderName, _logger);
+                var database = _factory.GetDatabase();
 
                 // If MySQL, we're going to ensure that database calls are maintaining proper casing as to remove the necessity for checks
                 // for case insensitive queries. In an ideal situation (which is what we're striving for), all calls would be case sensitive.
 
-                /*                
+                /*
                 var supportsCaseInsensitiveQueries = SqlSyntax.SupportsCaseInsensitiveQueries(database);
                 if (supportsCaseInsensitiveQueries  == false)
                 {
@@ -549,16 +381,14 @@ namespace Umbraco.Core
                 }
                 */
 
-                message = GetResultMessageForMySql();
-
+                var message = GetResultMessageForMySql();
                 var schemaResult = ValidateDatabaseSchema();
-                
                 var installedSchemaVersion = schemaResult.DetermineInstalledVersion();
-                
+
                 //If Configuration Status is empty and the determined version is "empty" its a new install - otherwise upgrade the existing
                 if (string.IsNullOrEmpty(GlobalSettings.ConfigurationStatus) && installedSchemaVersion.Equals(new Version(0, 0, 0)))
                 {
-                    var helper = new DatabaseSchemaHelper(database, _logger, SqlSyntax);
+                    var helper = new DatabaseSchemaHelper(database, _logger);
                     helper.CreateDatabaseSchema(true, applicationContext);
 
                     message = message + "<p>Installation completed!</p>";
@@ -573,9 +403,9 @@ namespace Umbraco.Core
                 message = "<p>Upgrading database, this may take some time...</p>";
                 return new Result
                     {
-                        RequiresUpgrade = true, 
-                        Message = message, 
-                        Success = true, 
+                        RequiresUpgrade = true,
+                        Message = message,
+                        Success = true,
                         Percentage = "30"
                     };
             }
@@ -593,7 +423,6 @@ namespace Umbraco.Core
         {
             try
             {
-
                 var readyForInstall = CheckReadyForInstall();
                 if (readyForInstall.Success == false)
                 {
@@ -602,8 +431,8 @@ namespace Umbraco.Core
 
                 _logger.Info<DatabaseContext>("Database upgrade started");
 
-                var database = new UmbracoDatabase(_connectionString, ProviderName, _logger);
-                //var supportsCaseInsensitiveQueries = SqlSyntax.SupportsCaseInsensitiveQueries(database);                
+                var database = _factory.GetDatabase();
+                //var supportsCaseInsensitiveQueries = SqlSyntax.SupportsCaseInsensitiveQueries(database);
 
                 var message = GetResultMessageForMySql();
 
@@ -615,33 +444,33 @@ namespace Umbraco.Core
                 //we cannot check the migrations table if it doesn't exist, this will occur when upgrading to 7.3
                 if (schemaResult.ValidTables.Any(x => x.InvariantEquals("umbracoMigration")))
                 {
-                    installedMigrationVersion = schemaResult.DetermineInstalledVersionByMigrations(migrationEntryService);    
+                    installedMigrationVersion = schemaResult.DetermineInstalledVersionByMigrations(migrationEntryService);
                 }
 
                 var targetVersion = UmbracoVersion.Current;
-                
+
                 //In some cases - like upgrading from 7.2.6 -> 7.3, there will be no migration information in the database and therefore it will
-                // return a version of 0.0.0 and we don't necessarily want to run all migrations from 0 -> 7.3, so we'll just ensure that the 
+                // return a version of 0.0.0 and we don't necessarily want to run all migrations from 0 -> 7.3, so we'll just ensure that the
                 // migrations are run for the target version
                 if (installedMigrationVersion == new SemVersion(new Version(0, 0, 0)) && installedSchemaVersion > new SemVersion(new Version(0, 0, 0)))
                 {
                     //set the installedMigrationVersion to be one less than the target so the latest migrations are guaranteed to execute
                     installedMigrationVersion = new SemVersion(targetVersion.SubtractRevision());
                 }
-                
+
                 //Figure out what our current installed version is. If the web.config doesn't have a version listed, then we'll use the minimum
-                // version detected between the schema installed and the migrations listed in the migration table. 
+                // version detected between the schema installed and the migrations listed in the migration table.
                 // If there is a version in the web.config, we'll take the minimum between the listed migration in the db and what
                 // is declared in the web.config.
-                
+
                 var currentInstalledVersion = string.IsNullOrEmpty(GlobalSettings.ConfigurationStatus)
                     //Take the minimum version between the detected schema version and the installed migration version
                     ? new[] {installedSchemaVersion, installedMigrationVersion}.Min()
                     //Take the minimum version between the installed migration version and the version specified in the config
                     : new[] { SemVersion.Parse(GlobalSettings.ConfigurationStatus), installedMigrationVersion }.Min();
 
-                //Ok, another edge case here. If the current version is a pre-release, 
-                // then we want to ensure all migrations for the current release are executed. 
+                //Ok, another edge case here. If the current version is a pre-release,
+                // then we want to ensure all migrations for the current release are executed.
                 if (currentInstalledVersion.Prerelease.IsNullOrWhiteSpace() == false)
                 {
                     currentInstalledVersion  = new SemVersion(currentInstalledVersion.GetVersion().SubtractRevision());
@@ -651,8 +480,8 @@ namespace Umbraco.Core
 
                 var runner = new MigrationRunner(migrationResolver, migrationEntryService, _logger, currentInstalledVersion, UmbracoVersion.GetSemanticVersion(), GlobalSettings.UmbracoMigrationName);
 
-                var upgraded = runner.Execute(database, DatabaseProvider, SqlSyntax, true);
-                
+                var upgraded = runner.Execute(database /*, true*/);
+
                 if (upgraded == false)
                 {
                     throw new ApplicationException("Upgrading failed, either an error occurred during the upgrade process or an event canceled the upgrade process, see log for full details");
@@ -716,18 +545,12 @@ namespace Umbraco.Core
 
         private Attempt<Result> CheckReadyForInstall()
         {
-            if (SystemUtilities.GetCurrentTrustLevel() != AspNetHostingPermissionLevel.Unrestricted
-                    && ProviderName == "MySql.Data.MySqlClient")
-            {
-                throw new InvalidOperationException("Cannot use MySql in Medium Trust configuration");
-            }
-
-            if (_configured == false || (string.IsNullOrEmpty(_connectionString) || string.IsNullOrEmpty(ProviderName)))
+            if (_factory.Configured == false)
             {
                 return Attempt.Fail(new Result
                 {
-                    Message =
-                        "Database configuration is invalid. Please check that the entered database exists and that the provided username and password has write access to the database.",
+                    Message = "Database configuration is invalid. Please check that the entered database exists and"
+                        + " that the provided username and password has write access to the database.",
                     Success = false,
                     Percentage = "10"
                 });
@@ -739,9 +562,9 @@ namespace Umbraco.Core
         {
             _logger.Error<DatabaseContext>("Database configuration failed", ex);
 
-            if (_result != null)
+            if (_databaseSchemaValidationResult != null)
             {
-                _logger.Info<DatabaseContext>("The database schema validation produced the following summary: \n" + _result.GetSummary());
+                _logger.Info<DatabaseContext>("The database schema validation produced the following summary: \n" + _databaseSchemaValidationResult.GetSummary());
             }
 
             return new Result
@@ -762,11 +585,13 @@ namespace Umbraco.Core
             public string Percentage { get; set; }
         }
 
+        #endregion
+
         internal bool IsConnectionStringConfigured(ConnectionStringSettings databaseSettings)
         {
             var dbIsSqlCe = false;
-            if (databaseSettings != null && databaseSettings.ProviderName != null)
-                dbIsSqlCe = databaseSettings.ProviderName == "System.Data.SqlServerCe.4.0";
+            if (databaseSettings?.ProviderName != null)
+                dbIsSqlCe = databaseSettings.ProviderName == Constants.DbProviderNames.SqlCe;
             var sqlCeDatabaseExists = false;
             if (dbIsSqlCe)
             {
@@ -776,7 +601,7 @@ namespace Umbraco.Core
                 {
                     var datasource = dataSourcePart.Replace("|DataDirectory|", AppDomain.CurrentDomain.GetData("DataDirectory").ToString());
                     var filePath = datasource.Replace("Data Source=", string.Empty);
-                    sqlCeDatabaseExists = File.Exists(filePath);                    
+                    sqlCeDatabaseExists = File.Exists(filePath);
                 }
             }
 
@@ -791,9 +616,10 @@ namespace Umbraco.Core
             return true;
         }
 
+        // fixme - kill!
         public Sql<SqlContext> Sql()
         {
-            return NPoco.Sql.BuilderFor(new SqlContext(SqlSyntax, Database));
+            return Database.Sql();
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/DependencyInjection/RepositoryCompositionRoot.cs b/src/Umbraco.Core/DependencyInjection/RepositoryCompositionRoot.cs
index f6ff4f1914..b4370b886e 100644
--- a/src/Umbraco.Core/DependencyInjection/RepositoryCompositionRoot.cs
+++ b/src/Umbraco.Core/DependencyInjection/RepositoryCompositionRoot.cs
@@ -1,9 +1,4 @@
-using System;
-using System.Linq;
 using LightInject;
-using Umbraco.Core.Cache;
-using Umbraco.Core.Configuration;
-using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
@@ -19,24 +14,42 @@ namespace Umbraco.Core.DependencyInjection
     /// </summary>
     public sealed class RepositoryCompositionRoot : ICompositionRoot
     {
+        public const string DisabledCache = "DisabledCache";
+
         public void Compose(IServiceRegistry container)
         {
-            container.RegisterSingleton<IDatabaseFactory>(factory => new DefaultDatabaseFactory(GlobalSettings.UmbracoConnectionName, factory.GetInstance<ILogger>()));
-            container.RegisterSingleton<DatabaseContext>(factory => GetDbContext(factory));
+            // register syntax providers
+            container.Register<ISqlSyntaxProvider, MySqlSyntaxProvider>("MySqlSyntaxProvider");
+            container.Register<ISqlSyntaxProvider, SqlCeSyntaxProvider>("SqlCeSyntaxProvider");
+            container.Register<ISqlSyntaxProvider, SqlServerSyntaxProvider>("SqlServerSyntaxProvider");
 
-            container.RegisterSingleton<SqlSyntaxProviders>(factory => SqlSyntaxProviders.CreateDefault(factory.GetInstance<ILogger>()));
-            container.Register<ISqlSyntaxProvider>(factory => factory.GetInstance<DatabaseContext>().SqlSyntax);
+            // register database factory
+            // will be initialized with syntax providers and a logger, and will try to configure
+            // from the default connection string name, if possible, else will remain non-configured
+            // until the database context configures it properly (eg when installing)
+            container.RegisterSingleton<IDatabaseFactory, DefaultDatabaseFactory>();
 
+            // register database context
+            container.RegisterSingleton<DatabaseContext>();
+
+            // register IUnitOfWork providers
+            // using a factory for NPocoUnitOfWorkProvider because it has another ctor accepting
+            // one single parameter - we should get rid of it but it is used hundreds of times in
+            // unit tests and I am lazy
             container.RegisterSingleton<IUnitOfWorkProvider, FileUnitOfWorkProvider>();
             container.RegisterSingleton<IDatabaseUnitOfWorkProvider>(factory => new NPocoUnitOfWorkProvider(factory.GetInstance<IDatabaseFactory>()));
 
+            // register mapping resover
+            // using a factory because... no time to clean it up at the moment
             container.RegisterSingleton<IMappingResolver>(factory => new MappingResolver(
                 factory.GetInstance<IServiceContainer>(),
                 factory.GetInstance<ILogger>(),
                 () => factory.GetInstance<PluginManager>().ResolveAssignedMapperTypes()));
-            container.Register<RepositoryFactory>();
-            container.RegisterSingleton<CacheHelper>(factory => CacheHelper.CreateDisabledCacheHelper(), "DisabledCache");
 
+            // register repository factory
+            container.RegisterSingleton<RepositoryFactory>();
+
+            // register file systems
             container.RegisterSingleton<IFileSystem>(factory => new PhysicalFileSystem(SystemDirectories.Scripts), "ScriptFileSystem");
             container.RegisterSingleton<IFileSystem>(factory => new PhysicalFileSystem(SystemDirectories.MvcViews + "/Partials/"), "PartialViewFileSystem");
             container.RegisterSingleton<IFileSystem>(factory => new PhysicalFileSystem(SystemDirectories.MvcViews + "/MacroPartials/"), "PartialViewMacroFileSystem");
@@ -44,47 +57,23 @@ namespace Umbraco.Core.DependencyInjection
             container.RegisterSingleton<IFileSystem>(factory => new PhysicalFileSystem(SystemDirectories.Masterpages), "MasterpageFileSystem");
             container.RegisterSingleton<IFileSystem>(factory => new PhysicalFileSystem(SystemDirectories.MvcViews), "ViewFileSystem");
 
-            //Repository factories:
-            //NOTE: Wondering if we can pass in parameters at resolution time with LightInject 
-            // without having to manually specify the ctor for each one, have asked here: https://github.com/seesharper/LightInject/issues/237
-            container.Register<IDatabaseUnitOfWork, INotificationsRepository>((factory, work) => new NotificationsRepository(work, factory.GetInstance<ISqlSyntaxProvider>()));
-            
-            container.Register<IDatabaseUnitOfWork, IExternalLoginRepository>((factory, work) => new ExternalLoginRepository(
-                work,   
-                factory.GetInstance<CacheHelper>(),
-                factory.GetInstance<ILogger>(),
-                factory.GetInstance<ISqlSyntaxProvider>(),
-                factory.GetInstance<IMappingResolver>()));
+            // register cache helpers
+            // the main cache helper is registered by CoreBootManager and is used by most repositories
+            // the disabled one is used by those repositories that have an annotated ctor parameter
+            container.RegisterSingleton(factory => CacheHelper.CreateDisabledCacheHelper(), DisabledCache);
 
-            //here we are using some nice IoC magic:
-            //https://github.com/seesharper/LightInject/issues/237
-            //This tells the container that anytime there is a ctor dependency for IDatabaseUnitOfWork and it's available as the first
-            //arg in the runtimeArgs, to use that. This means we donn't have to explicitly define all ctor's for all repositories which
-            //saves us a lot of code.
-            container.RegisterConstructorDependency<IDatabaseUnitOfWork>((factory, info, runtimeArguments) =>
-            {
-                var uow = runtimeArguments.Length > 0 ? runtimeArguments[0] as IDatabaseUnitOfWork : null;
-                return uow;
-            });
-            //This ensures that the correct CacheHelper is returned for the right repos
-            container.RegisterConstructorDependency<CacheHelper>((factory, info, runtimeArguments) =>
-            {
-                var declaringType = info.Member.DeclaringType;
-                var disabledCacheRepos = new[]
-                {
-                    typeof (ITaskRepository),
-                    typeof (ITaskTypeRepository),
-                    typeof (IAuditRepository),
-                    typeof (IRelationRepository),
-                    typeof (IRelationTypeRepository),
-                    typeof (IAuditRepository),
-                    typeof (IMigrationEntryRepository)
-                };
-                return disabledCacheRepos.Any(x => TypeHelper.IsTypeAssignableFrom(x, declaringType))
-                    ? factory.GetInstance<CacheHelper>("DisabledCache")
-                    : factory.GetInstance<CacheHelper>();
-            });
+            // register IDatabaseUnitOfWork
+            // resolve ctor dependency from GetInstance() runtimeArguments if possible
+            container.RegisterConstructorDependency((factory, info, runtimeArguments) =>
+                runtimeArguments.Length > 0 ? runtimeArguments[0] as IDatabaseUnitOfWork : null);
 
+            // register repositories
+            // repos depend on various things, and a IDatabaseUnitOfWork (registered above)
+            // some repositories have an annotated ctor parameter to pick the right cache helper
+
+            // repositories
+            container.Register<INotificationsRepository, NotificationsRepository>();
+            container.Register<IExternalLoginRepository, ExternalLoginRepository>();
             container.Register<IPublicAccessRepository, PublicAccessRepository>();
             container.Register<ITagRepository, TagRepository>();
             container.Register<IContentRepository, ContentRepository>();
@@ -110,47 +99,14 @@ namespace Umbraco.Core.DependencyInjection
             container.Register<IRelationRepository, RelationRepository>();
             container.Register<IRelationTypeRepository, RelationTypeRepository>();
             container.Register<IMigrationEntryRepository, MigrationEntryRepository>();
+            container.Register<IServerRegistrationRepository, ServerRegistrationRepository>();
 
-            //These repo registrations require custom injections so we need to define them:
-
-            container.Register<IDatabaseUnitOfWork, IServerRegistrationRepository>((factory, work) => new ServerRegistrationRepository(
-                work,
-                factory.GetInstance<CacheHelper>().StaticCache, //special static cache scenario
-                factory.GetInstance<ILogger>(),
-                factory.GetInstance<ISqlSyntaxProvider>(),
-                factory.GetInstance<IMappingResolver>()));
-            container.Register<IUnitOfWork, IScriptRepository>((factory, work) => new ScriptRepository(
-                work,
-                factory.GetInstance<IFileSystem>("ScriptFileSystem"),
-                factory.GetInstance<IContentSection>()));
-            container.Register<IUnitOfWork, IPartialViewRepository>((factory, work) => new PartialViewRepository(
-                work,
-                factory.GetInstance<IFileSystem>("PartialViewFileSystem")),
-                serviceName: "PartialViewRepository");
-            container.Register<IUnitOfWork, IPartialViewRepository>((factory, work) => new PartialViewMacroRepository(
-                work,
-                factory.GetInstance<IFileSystem>("PartialViewMacroFileSystem")),
-                serviceName: "PartialViewMacroRepository");
-            container.Register<IUnitOfWork, IStylesheetRepository>((factory, work) => new StylesheetRepository(
-                work,
-                factory.GetInstance<IFileSystem>("StylesheetFileSystem")));            
-        }
-
-        /// <summary>
-        /// Creates and initializes the db context when IoC requests it
-        /// </summary>
-        /// <param name="container"></param>
-        /// <returns></returns>
-        private DatabaseContext GetDbContext(IServiceFactory container)
-        {
-            var dbCtx = new DatabaseContext(
-                container.GetInstance<IDatabaseFactory>(),
-                container.GetInstance<ILogger>(),
-                container.GetInstance<SqlSyntaxProviders>());
-
-            //when it's first created we need to initialize it
-            dbCtx.Initialize();
-            return dbCtx;
+            // repositories that depend on a filesystem
+            // these have an annotated ctor parameter to pick the right file system
+            container.Register<IScriptRepository, ScriptRepository>();
+            container.Register<IPartialViewRepository, PartialViewRepository>("PartialViewRepository");
+            container.Register<IPartialViewRepository, PartialViewMacroRepository>("PartialViewMacroRepository");
+            container.Register<IStylesheetRepository, StylesheetRepository>();
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Constants-DbProviderNames.cs b/src/Umbraco.Core/Persistence/Constants-DbProviderNames.cs
new file mode 100644
index 0000000000..b79269d80e
--- /dev/null
+++ b/src/Umbraco.Core/Persistence/Constants-DbProviderNames.cs
@@ -0,0 +1,13 @@
+ // ReSharper disable once CheckNamespace
+namespace Umbraco.Core
+{
+    static partial class Constants
+    {
+        public static class DbProviderNames
+        {
+            public const string SqlServer = "System.Data.SqlClient";
+            public const string MySql = "MySql.Data.MySqlClient";
+            public const string SqlCe = "System.Data.SqlServerCe.4.0";
+        }
+    }
+}
diff --git a/src/Umbraco.Core/Persistence/DatabaseProviders.cs b/src/Umbraco.Core/Persistence/DatabaseProviders.cs
deleted file mode 100644
index ec0064b8cf..0000000000
--- a/src/Umbraco.Core/Persistence/DatabaseProviders.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-namespace Umbraco.Core.Persistence
-{
-	public enum DatabaseProviders
-    {
-        SqlServer,
-        SqlAzure,
-        SqlServerCE,
-        MySql,
-        PostgreSQL,
-        Oracle,
-        SQLite
-    }
-}
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/DatabaseSchemaHelper.cs b/src/Umbraco.Core/Persistence/DatabaseSchemaHelper.cs
index ad6af9dd0a..ba30d48548 100644
--- a/src/Umbraco.Core/Persistence/DatabaseSchemaHelper.cs
+++ b/src/Umbraco.Core/Persistence/DatabaseSchemaHelper.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Linq;
 using NPoco;
-using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models.Rdbms;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
@@ -11,30 +10,32 @@ using Umbraco.Core.Services;
 
 namespace Umbraco.Core.Persistence
 {
-
     public class DatabaseSchemaHelper
     {
-        private readonly Database _db;
+        private readonly UmbracoDatabase _database;
         private readonly ILogger _logger;
-        private readonly ISqlSyntaxProvider _syntaxProvider;
         private readonly BaseDataCreation _baseDataCreation;
 
-        public DatabaseSchemaHelper(Database db, ILogger logger, ISqlSyntaxProvider syntaxProvider)
+        public DatabaseSchemaHelper(UmbracoDatabase database, ILogger logger)
         {
-            _db = db;
+            _database = database;
             _logger = logger;
-            _syntaxProvider = syntaxProvider;
-            _baseDataCreation = new BaseDataCreation(db, logger);
+            _baseDataCreation = new BaseDataCreation(database, logger);
         }
 
+        private ISqlSyntaxProvider SqlSyntax => _database.SqlSyntax;
+
         public bool TableExist(string tableName)
         {
-            return _syntaxProvider.DoesTableExist(_db, tableName);
+            return SqlSyntax.DoesTableExist(_database, tableName);
         }
 
         internal void UninstallDatabaseSchema()
         {
-            var creation = new DatabaseSchemaCreation(_db, _logger, _syntaxProvider);
+            // fixme
+            // weird to create a DatabaseSchemaCreation here, since it creates
+            // a circular dependency with DatabaseSchemaHelper?
+            var creation = new DatabaseSchemaCreation(_database, _logger);
             creation.UninstallDatabaseSchema();
         }
 
@@ -45,7 +46,7 @@ namespace Umbraco.Core.Persistence
         /// </summary>
         public void CreateDatabaseSchema(ApplicationContext applicationContext)
         {
-            if (applicationContext == null) throw new ArgumentNullException("applicationContext");
+            if (applicationContext == null) throw new ArgumentNullException(nameof(applicationContext));
             CreateDatabaseSchema(true, applicationContext);
         }
 
@@ -58,7 +59,7 @@ namespace Umbraco.Core.Persistence
         /// <param name="applicationContext"></param>
         public void CreateDatabaseSchema(bool guardConfiguration, ApplicationContext applicationContext)
         {
-            if (applicationContext == null) throw new ArgumentNullException("applicationContext");
+            if (applicationContext == null) throw new ArgumentNullException(nameof(applicationContext));
 
             if (guardConfiguration && applicationContext.IsConfigured)
                 throw new Exception("Umbraco is already configured!");
@@ -78,7 +79,10 @@ namespace Umbraco.Core.Persistence
         {
             _logger.Info<Database>("Initializing database schema creation");
 
-            var creation = new DatabaseSchemaCreation(_db, _logger, _syntaxProvider);
+            // fixme
+            // weird to create a DatabaseSchemaCreation here, since it creates
+            // a circular dependency with DatabaseSchemaHelper?
+            var creation = new DatabaseSchemaCreation(_database, _logger);
             creation.InitializeDatabaseSchema();
 
             _logger.Info<Database>("Finalized database schema creation");
@@ -87,26 +91,26 @@ namespace Umbraco.Core.Persistence
         public void CreateTable<T>(bool overwrite)
            where T : new()
         {
-            var tableType = typeof(T);
+            var tableType = typeof (T);
             CreateTable(overwrite, tableType);
         }
 
         public void CreateTable<T>()
           where T : new()
         {
-            var tableType = typeof(T);           
+            var tableType = typeof (T);
             CreateTable(false, tableType);
         }
 
         public void CreateTable(bool overwrite, Type modelType)
         {
-            var tableDefinition = DefinitionFactory.GetTableDefinition(modelType, _syntaxProvider);
+            var tableDefinition = DefinitionFactory.GetTableDefinition(modelType, SqlSyntax);
             var tableName = tableDefinition.Name;
 
-            string createSql = _syntaxProvider.Format(tableDefinition);
-            string createPrimaryKeySql = _syntaxProvider.FormatPrimaryKey(tableDefinition);
-            var foreignSql = _syntaxProvider.Format(tableDefinition.ForeignKeys);
-            var indexSql = _syntaxProvider.Format(tableDefinition.Indexes);
+            var createSql = SqlSyntax.Format(tableDefinition);
+            var createPrimaryKeySql = SqlSyntax.FormatPrimaryKey(tableDefinition);
+            var foreignSql = SqlSyntax.Format(tableDefinition.ForeignKeys);
+            var indexSql = SqlSyntax.Format(tableDefinition.Indexes);
 
             var tableExist = TableExist(tableName);
             if (overwrite && tableExist)
@@ -117,22 +121,22 @@ namespace Umbraco.Core.Persistence
 
             if (tableExist == false)
             {
-                using (var transaction = _db.GetTransaction())
+                using (var transaction = _database.GetTransaction())
                 {
                     //Execute the Create Table sql
-                    int created = _db.Execute(new Sql(createSql));
-                    _logger.Info<Database>(string.Format("Create Table sql {0}:\n {1}", created, createSql));
+                    var created = _database.Execute(new Sql(createSql));
+                    _logger.Info<Database>($"Create Table sql {created}:\n {createSql}");
 
                     //If any statements exists for the primary key execute them here
-                    if (!string.IsNullOrEmpty(createPrimaryKeySql))
+                    if (string.IsNullOrEmpty(createPrimaryKeySql) == false)
                     {
-                        int createdPk = _db.Execute(new Sql(createPrimaryKeySql));
-                        _logger.Info<Database>(string.Format("Primary Key sql {0}:\n {1}", createdPk, createPrimaryKeySql));
+                        var createdPk = _database.Execute(new Sql(createPrimaryKeySql));
+                        _logger.Info<Database>($"Primary Key sql {createdPk}:\n {createPrimaryKeySql}");
                     }
 
                     //Turn on identity insert if db provider is not mysql
-                    if (_syntaxProvider.SupportsIdentityInsert() && tableDefinition.Columns.Any(x => x.IsIdentity))
-                        _db.Execute(new Sql(string.Format("SET IDENTITY_INSERT {0} ON ", _syntaxProvider.GetQuotedTableName(tableName))));
+                    if (SqlSyntax.SupportsIdentityInsert() && tableDefinition.Columns.Any(x => x.IsIdentity))
+                        _database.Execute(new Sql($"SET IDENTITY_INSERT {SqlSyntax.GetQuotedTableName(tableName)} ON "));
 
                     //Call the NewTable-event to trigger the insert of base/default data
                     //OnNewTable(tableName, _db, e, _logger);
@@ -140,59 +144,55 @@ namespace Umbraco.Core.Persistence
                     _baseDataCreation.InitializeBaseData(tableName);
 
                     //Turn off identity insert if db provider is not mysql
-                    if (_syntaxProvider.SupportsIdentityInsert() && tableDefinition.Columns.Any(x => x.IsIdentity))
-                        _db.Execute(new Sql(string.Format("SET IDENTITY_INSERT {0} OFF;", _syntaxProvider.GetQuotedTableName(tableName))));
+                    if (SqlSyntax.SupportsIdentityInsert() && tableDefinition.Columns.Any(x => x.IsIdentity))
+                        _database.Execute(new Sql($"SET IDENTITY_INSERT {SqlSyntax.GetQuotedTableName(tableName)} OFF;"));
 
                     //Special case for MySql
-                    if (_syntaxProvider is MySqlSyntaxProvider && tableName.Equals("umbracoUser"))
+                    if (SqlSyntax is MySqlSyntaxProvider && tableName.Equals("umbracoUser"))
                     {
-                        _db.Update<UserDto>("SET id = @IdAfter WHERE id = @IdBefore AND userLogin = @Login", new { IdAfter = 0, IdBefore = 1, Login = "admin" });
+                        _database.Update<UserDto>("SET id = @IdAfter WHERE id = @IdBefore AND userLogin = @Login", new { IdAfter = 0, IdBefore = 1, Login = "admin" });
                     }
 
                     //Loop through index statements and execute sql
                     foreach (var sql in indexSql)
                     {
-                        int createdIndex = _db.Execute(new Sql(sql));
-                        _logger.Info<Database>(string.Format("Create Index sql {0}:\n {1}", createdIndex, sql));
+                        var createdIndex = _database.Execute(new Sql(sql));
+                        _logger.Info<Database>($"Create Index sql {createdIndex}:\n {sql}");
                     }
 
                     //Loop through foreignkey statements and execute sql
                     foreach (var sql in foreignSql)
                     {
-                        int createdFk = _db.Execute(new Sql(sql));
-                        _logger.Info<Database>(string.Format("Create Foreign Key sql {0}:\n {1}", createdFk, sql));
+                        var createdFk = _database.Execute(new Sql(sql));
+                        _logger.Info<Database>($"Create Foreign Key sql {createdFk}:\n {sql}");
                     }
 
-                    
-
                     transaction.Complete();
                 }
             }
 
-            _logger.Info<Database>(string.Format("New table '{0}' was created", tableName));
+            _logger.Info<Database>($"New table '{tableName}' was created");
         }
 
         public void DropTable<T>()
             where T : new()
         {
-            Type type = typeof(T);
+            var type = typeof(T);
             var tableNameAttribute = type.FirstAttribute<TableNameAttribute>();
             if (tableNameAttribute == null)
-                throw new Exception(
-                    string.Format(
-                        "The Type '{0}' does not contain a TableNameAttribute, which is used to find the name of the table to drop. The operation could not be completed.",
-                        type.Name));
+                throw new Exception($"The Type '{type.Name}' does not contain a TableNameAttribute, which is used"
+                    + " to find the name of the table to drop. The operation could not be completed.");
 
-            string tableName = tableNameAttribute.Value;
+            var tableName = tableNameAttribute.Value;
             DropTable(tableName);
         }
 
         public void DropTable(string tableName)
         {
             var sql = new Sql(string.Format(
-                _syntaxProvider.DropTable,
-                _syntaxProvider.GetQuotedTableName(tableName)));
-            _db.Execute(sql);
+                SqlSyntax.DropTable,
+                SqlSyntax.GetQuotedTableName(tableName)));
+            _database.Execute(sql);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/DbConnectionExtensions.cs b/src/Umbraco.Core/Persistence/DbConnectionExtensions.cs
index 5145ec95c5..1a257f3ce8 100644
--- a/src/Umbraco.Core/Persistence/DbConnectionExtensions.cs
+++ b/src/Umbraco.Core/Persistence/DbConnectionExtensions.cs
@@ -1,68 +1,49 @@
 using System;
-using System.Collections.Generic;
-using System.Configuration;
 using System.Data;
 using System.Data.Common;
-using System.Data.SqlClient;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Umbraco.Core.Logging; 
+using NPoco;
+using Umbraco.Core.Logging;
 
 namespace Umbraco.Core.Persistence
 {
     internal static class DbConnectionExtensions
     {
-
-        public static DatabaseProviders DetectProviderFromConnectionString(string connString)
+        public static string DetectProviderNameFromConnectionString(string connectionString)
         {
-            var builder = new DbConnectionStringBuilder {ConnectionString = connString};
+            var builder = new DbConnectionStringBuilder { ConnectionString = connectionString };
             var allKeys = builder.Keys.Cast<string>();
 
-            var mySql = new[] {"Server", "Database", "Uid", "Pwd"};
+            var mySql = new[] { "Server", "Database", "Uid", "Pwd" };
             if (mySql.All(x => allKeys.InvariantContains(x)))
             {
-                return DatabaseProviders.MySql;
+                return Constants.DbProviderNames.MySql;
             }
 
-            if (allKeys.InvariantContains("Data Source") 
+            if (allKeys.InvariantContains("Data Source")
                 //this dictionary is case insensitive
                 && builder["Data source"].ToString().InvariantContains(".sdf"))
             {
-                return DatabaseProviders.SqlServerCE;
+                return Constants.DbProviderNames.SqlCe;
             }
 
-            return DatabaseProviders.SqlServer;
+            return Constants.DbProviderNames.SqlServer;
         }
 
-        public static bool IsConnectionAvailable(string connString, DatabaseProviders provider)
+        public static bool IsConnectionAvailable(string connectionString, string providerName)
         {
-            DbProviderFactory factory;
-            switch (provider)
-            {
-                case DatabaseProviders.SqlServer:
-                case DatabaseProviders.SqlAzure:
-                    factory = DbProviderFactories.GetFactory("System.Data.SqlClient");
-                    break;
-                case DatabaseProviders.SqlServerCE:
-                    factory = DbProviderFactories.GetFactory("System.Data.SqlServerCe.4.0");
-                    break;
-                case DatabaseProviders.MySql:
-                    factory = DbProviderFactories.GetFactory("MySql.Data.MySqlClient");
-                    break;
-                case DatabaseProviders.PostgreSQL:
-                case DatabaseProviders.Oracle:
-                case DatabaseProviders.SQLite:                    
-                default:
-                    throw new NotSupportedException("The provider " + provider + " is not supported");
-            }
+            if (providerName != Constants.DbProviderNames.SqlCe
+                && providerName != Constants.DbProviderNames.MySql
+                && providerName != Constants.DbProviderNames.SqlServer)
+                throw new NotSupportedException($"Provider \"{providerName}\" is not supported.");
 
+            var factory = DbProviderFactories.GetFactory(providerName);
             var conn = factory.CreateConnection();
+
             if (conn == null)
-            {
-                throw new InvalidOperationException("Could not create a connection for provider " + provider);
-            }
-            conn.ConnectionString = connString;
+                throw new InvalidOperationException($"Could not create a connection for provider \"{providerName}\".");
+
+            conn.ConnectionString = connectionString;
             using (var connection = conn)
             {
                 return connection.IsAvailable();
@@ -76,16 +57,16 @@ namespace Umbraco.Core.Persistence
                 connection.Open();
                 connection.Close();
             }
-            catch (DbException exc)
+            catch (DbException e)
             {
                 // Don't swallow this error, the exception is super handy for knowing "why" its not available
-                LogHelper.WarnWithException<IDbConnection>("Configured database is reporting as not being available!", exc);
+                LogHelper.WarnWithException<IDbConnection>("Configured database is reporting as not being available!", e);
                 return false;
             }
 
             return true;
         }
 
-        
+
     }
 }
diff --git a/src/Umbraco.Core/Persistence/DefaultDatabaseFactory.cs b/src/Umbraco.Core/Persistence/DefaultDatabaseFactory.cs
index f5c2ab9c4f..0de5ecebf4 100644
--- a/src/Umbraco.Core/Persistence/DefaultDatabaseFactory.cs
+++ b/src/Umbraco.Core/Persistence/DefaultDatabaseFactory.cs
@@ -1,5 +1,8 @@
 using System;
+using System.Collections.Generic;
 using System.Configuration;
+using System.Data.Common;
+using System.Linq;
 using System.Web;
 using NPoco;
 using NPoco.FluentMappings;
@@ -7,99 +10,173 @@ using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence.FaultHandling;
 using Umbraco.Core.Persistence.Mappers;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence
 {
-	/// <summary>
-	/// The default implementation for the IDatabaseFactory
-	/// </summary>
-	/// <remarks>
-	/// If we are running in an http context
-	/// it will create one per context, otherwise it will be a global singleton object which is NOT thread safe
-	/// since we need (at least) a new instance of the database object per thread.
-	/// </remarks>
-	internal class DefaultDatabaseFactory : DisposableObject, IDatabaseFactory
-	{
-	    private readonly string _connectionStringName;
+    /// <summary>
+    /// Default implementation of <see cref="IDatabaseFactory"/>.
+    /// </summary>
+    /// <remarks>
+    /// <para>This factory implementation creates and manages an "ambient" database connection. When running
+    /// within an Http context, "ambient" means "associated with that context". Otherwise, it means "static to
+    /// the current thread". In this latter case, note that the database connection object is not thread safe.</para>
+    /// <para>It wraps an NPoco DatabaseFactory which is initializes with a proper IPocoDataFactory to ensure
+    /// that NPoco's plumbing is cached appropriately for the whole application.</para>
+    /// </remarks>
+    internal class DefaultDatabaseFactory : DisposableObject, IDatabaseFactory
+    {
+        private readonly ISqlSyntaxProvider[] _sqlSyntaxProviders;
 	    private readonly ILogger _logger;
-	    private readonly DatabaseFactory _databaseFactory;
-        private readonly RetryPolicy _connectionRetryPolicy;
-        private readonly RetryPolicy _commandRetryPolicy;
+        private bool _configured;
 
-        public string ConnectionString { get; private set; }
-        public string ProviderName { get; private set; }
+	    private DatabaseFactory _databaseFactory;
+        private IPocoDataFactory _pocoDataFactory;
+        private string _connectionString;
+        private string _providerName;
+        private DbProviderFactory _dbProviderFactory;
+        private DatabaseType _databaseType;
+        private ISqlSyntaxProvider _sqlSyntax;
+        private RetryPolicy _connectionRetryPolicy;
+        private RetryPolicy _commandRetryPolicy;
 
-        //very important to have ThreadStatic:
+        // fixme - what needs to be private fields vs public properties?
+        public bool Configured => _configured;
+        public ISqlSyntaxProvider SqlSyntax => _sqlSyntax;
+
+        // very important to have ThreadStatic,
         // see: http://issues.umbraco.org/issue/U4-2172
         [ThreadStatic]
         private static Lazy<UmbracoDatabase> _nonHttpInstance;
         
-	    /// <summary>
-	    /// Constructor accepting custom connection string
-	    /// </summary>
-	    /// <param name="connectionStringName">Name of the connection string in web.config</param>
-	    /// <param name="logger"></param>
-	    public DefaultDatabaseFactory(string connectionStringName, ILogger logger)
-            : this(logger)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DefaultDatabaseFactory"/> with the default connection, and a logger.
+        /// </summary>
+        /// <param name="sqlSyntaxProviders">The collection of available sql syntax providers.</param>
+        /// <param name="logger">A logger.</param>
+        public DefaultDatabaseFactory(IEnumerable<ISqlSyntaxProvider> sqlSyntaxProviders, ILogger logger)
+        {
+            if (sqlSyntaxProviders == null) throw new ArgumentNullException(nameof(sqlSyntaxProviders));
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
+
+            _sqlSyntaxProviders = sqlSyntaxProviders.ToArray();
+            _logger = logger;
+        }
+
+        // fixme - used once by the other ctor, and 5 times in various tests
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DefaultDatabaseFactory"/> with a connection string name and a logger.
+        /// </summary>
+        /// <param name="connectionStringName">The name of the connection string in web.config.</param>
+        /// <param name="sqlSyntaxProviders">The collection of available sql syntax providers.</param>
+        /// <param name="logger">A logger</param>
+        public DefaultDatabaseFactory(string connectionStringName, IEnumerable<ISqlSyntaxProvider> sqlSyntaxProviders, ILogger logger)
+            : this(sqlSyntaxProviders, logger)
 		{
 	        Mandate.ParameterNotNullOrEmpty(connectionStringName, "connectionStringName");
-			_connectionStringName = connectionStringName;
 
-            if (ConfigurationManager.ConnectionStrings[connectionStringName] == null)
-                throw new InvalidOperationException("Can't find a connection string with the name '" + connectionStringName + "'");
-            var connectionString = ConfigurationManager.ConnectionStrings[connectionStringName].ConnectionString;
+            var settings = ConfigurationManager.ConnectionStrings[connectionStringName];
+            if (settings == null)
+                return; // not configured
 
-            _connectionRetryPolicy = RetryPolicyFactory.GetDefaultSqlConnectionRetryPolicyByConnectionString(connectionString);
-            _commandRetryPolicy = RetryPolicyFactory.GetDefaultSqlCommandRetryPolicyByConnectionString(connectionString);
+            Configure(settings.ConnectionString, settings.ProviderName);
         }
 
+        // fixme - used only once in tests
         /// <summary>
-        /// Constructor accepting custom connectino string and provider name
+        /// Initializes a new instance of the <see cref="DefaultDatabaseFactory"/> with a connection string, a provider name and a logger.
         /// </summary>
-        /// <param name="connectionString">Connection String to use with Database</param>
-        /// <param name="providerName">Database Provider for the Connection String</param>
-        /// <param name="logger"></param>
-        public DefaultDatabaseFactory(string connectionString, string providerName, ILogger logger)
-            : this(logger)
+        /// <param name="connectionString">The database connection string.</param>
+        /// <param name="providerName">The name of the database provider.</param>
+	    /// <param name="sqlSyntaxProviders">The collection of available sql syntax providers.</param>
+        /// <param name="logger">A logger.</param>
+        public DefaultDatabaseFactory(string connectionString, string providerName, IEnumerable<ISqlSyntaxProvider> sqlSyntaxProviders, ILogger logger)
+            : this(sqlSyntaxProviders, logger)
 		{
-	        Mandate.ParameterNotNullOrEmpty(connectionString, "connectionString");
-			Mandate.ParameterNotNullOrEmpty(providerName, "providerName");
-			ConnectionString = connectionString;
-			ProviderName = providerName;
+            if (string.IsNullOrWhiteSpace(connectionString) || string.IsNullOrWhiteSpace(providerName))
+                return; // not configured
 
-            _connectionRetryPolicy = RetryPolicyFactory.GetDefaultSqlConnectionRetryPolicyByConnectionString(connectionString);
-            _commandRetryPolicy = RetryPolicyFactory.GetDefaultSqlCommandRetryPolicyByConnectionString(connectionString);
-        }
+            Configure(connectionString, providerName);
+		}
 
-        private DefaultDatabaseFactory(ILogger logger)
-	    {
-            if (logger == null) throw new ArgumentNullException("logger");
-            _logger = logger;
+        public void Configure(string connectionString, string providerName)
+        {
+            if (_configured) throw new InvalidOperationException("Already configured.");
+
+            Mandate.ParameterNotNullOrEmpty(connectionString, nameof(connectionString));
+            Mandate.ParameterNotNullOrEmpty(providerName, nameof(providerName));
+
+            _connectionString = connectionString;
+            _providerName = providerName;
+
+            _connectionRetryPolicy = RetryPolicyFactory.GetDefaultSqlConnectionRetryPolicyByConnectionString(_connectionString);
+            _commandRetryPolicy = RetryPolicyFactory.GetDefaultSqlCommandRetryPolicyByConnectionString(_connectionString);
+
+            _dbProviderFactory = DbProviderFactories.GetFactory(_providerName);
+            if (_dbProviderFactory == null)
+                throw new Exception($"Can't find a provider factory for provider name \"{_providerName}\".");
+            _databaseType = DatabaseType.Resolve(_dbProviderFactory.GetType().Name, _providerName);
+            if (_databaseType == null)
+                throw new Exception($"Can't find an NPoco database type for provider name \"{_providerName}\".");
+
+            _sqlSyntax = GetSqlSyntaxProvider(_providerName);
+            if (_sqlSyntax == null)
+                throw new Exception($"Can't find a sql syntax provider for provider name \"{_providerName}\".");
 
             // ensure we have only 1 set of mappers, and 1 PocoDataFactory, for all database
             // so that everything NPoco is properly cached for the lifetime of the application
-	        var mappers = new MapperCollection { new PocoMapper() };
-	        var pocoDataFactory = new FluentPocoDataFactory((type, iPocoDataFactory) => new PocoDataBuilder(type, mappers).Init());
-            var config = new FluentConfig(xmappers => pocoDataFactory);
+            var mappers = new MapperCollection { new PocoMapper() };
+            var factory = new FluentPocoDataFactory((type, iPocoDataFactory) => new PocoDataBuilder(type, mappers).Init());
+            _pocoDataFactory = factory;
+            var config = new FluentConfig(xmappers => factory);
 
             // create the database factory
             _databaseFactory = DatabaseFactory.Config(x => x
                 .UsingDatabase(CreateDatabaseInstance) // creating UmbracoDatabase instances
                 .WithFluentConfig(config)); // with proper configuration
 
-            _nonHttpInstance = new Lazy<UmbracoDatabase>(() => (UmbracoDatabase)_databaseFactory.GetDatabase());
+            _nonHttpInstance = new Lazy<UmbracoDatabase>(() => (UmbracoDatabase) _databaseFactory.GetDatabase());
+            _configured = true;
         }
 
-	    private UmbracoDatabase CreateDatabaseInstance()
+        // gets the sql syntax provider that corresponds, from attribute
+        private ISqlSyntaxProvider GetSqlSyntaxProvider(string providerName)
+        {
+            var name = providerName.ToLowerInvariant();
+            var provider = _sqlSyntaxProviders.FirstOrDefault(x =>
+                x.GetType()
+                    .FirstAttribute<SqlSyntaxProviderAttribute>()
+                    .ProviderName.ToLowerInvariant()
+                    .Equals(name));
+            if (provider != null) return provider;
+            throw new InvalidOperationException($"Unknown provider name \"{providerName}\"");
+
+            // previously we'd try to return SqlServerSyntaxProvider by default but this is bad
+            //provider = _syntaxProviders.FirstOrDefault(x => x.GetType() == typeof(SqlServerSyntaxProvider));
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether it is possible to connect to the database.
+        /// </summary>
+        /// <returns></returns>
+        public bool CanConnect => _configured && DbConnectionExtensions.IsConnectionAvailable(_connectionString, _providerName);
+
+        // method used by NPoco's DatabaseFactory to actually create the database instance
+        private UmbracoDatabase CreateDatabaseInstance()
 	    {
-	        return string.IsNullOrEmpty(ConnectionString) == false && string.IsNullOrEmpty(ProviderName) == false
-                ? new UmbracoDatabase(ConnectionString, ProviderName, _logger, _connectionRetryPolicy, _commandRetryPolicy)
-                : new UmbracoDatabase(_connectionStringName, _logger, _connectionRetryPolicy, _commandRetryPolicy);
-        }
+	        return new UmbracoDatabase(_connectionString, _sqlSyntax, _databaseType, _dbProviderFactory, _logger, _connectionRetryPolicy, _commandRetryPolicy);
+	    }
 
-		public UmbracoDatabase CreateDatabase()
+        /// <summary>
+        /// Gets (creates or retrieves) the "ambient" database connection.
+        /// </summary>
+        /// <returns>The "ambient" database connection.</returns>
+		public UmbracoDatabase GetDatabase()
 		{
-			// no http context, create the singleton global object
+            if (_configured == false)
+                throw new InvalidOperationException("Not configured.");
+
+			// no http context, create the thread-static singleton object
 			if (HttpContext.Current == null)
 			{
 			    return _nonHttpInstance.Value;
@@ -113,17 +190,29 @@ namespace Umbraco.Core.Persistence
 
 		protected override void DisposeResources()
 		{
-			if (HttpContext.Current == null && _nonHttpInstance.IsValueCreated)
-			{
-                _nonHttpInstance.Value.Dispose();
-			}
-			else
-			{
-				if (HttpContext.Current.Items.Contains(typeof(DefaultDatabaseFactory)))
-				{
-					((UmbracoDatabase)HttpContext.Current.Items[typeof(DefaultDatabaseFactory)]).Dispose();
-				}
-			}
+            // this is weird, because _nonHttpInstance is thread-static, so we would need
+            // to dispose the factory in each thread where a database has been used - else
+            // it only disposes the current thread's database instance.
+            //
+            // besides, we don't really want to dispose the factory, which is a singleton...
+
+		    UmbracoDatabase db = null;
+
+			if (HttpContext.Current == null)
+		    {
+                if (_nonHttpInstance.IsValueCreated)
+                {
+                    db = _nonHttpInstance;
+	    	        _nonHttpInstance = null;
+                }
+		    }
+		    else
+		    {
+		        db = HttpContext.Current.Items[typeof(DefaultDatabaseFactory)] as UmbracoDatabase;
+		        HttpContext.Current.Items[typeof (DefaultDatabaseFactory)] = null;
+		    }
+
+		    db?.Dispose();
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/IDatabaseFactory.cs b/src/Umbraco.Core/Persistence/IDatabaseFactory.cs
index b0efb7f94a..9d3977bcb4 100644
--- a/src/Umbraco.Core/Persistence/IDatabaseFactory.cs
+++ b/src/Umbraco.Core/Persistence/IDatabaseFactory.cs
@@ -1,12 +1,25 @@
 using System;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence
 {
 	/// <summary>
-	/// Used to create the UmbracoDatabase for use in the DatabaseContext
+	/// Creates and manages the "ambient" database.
 	/// </summary>
 	public interface IDatabaseFactory : IDisposable
 	{
-		UmbracoDatabase CreateDatabase();
+        /// <summary>
+        /// Gets (creates or retrieves) the "ambient" database connection.
+        /// </summary>
+        /// <returns>The "ambient" database connection.</returns>
+		UmbracoDatabase GetDatabase();
+
+	    void Configure(string connectionString, string providerName);
+
+        bool Configured { get; }
+
+        bool CanConnect { get; }
+
+        ISqlSyntaxProvider SqlSyntax { get; }
 	}
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/IUmbracoDatabaseConfig.cs b/src/Umbraco.Core/Persistence/IUmbracoDatabaseConfig.cs
new file mode 100644
index 0000000000..89ce2b7863
--- /dev/null
+++ b/src/Umbraco.Core/Persistence/IUmbracoDatabaseConfig.cs
@@ -0,0 +1,13 @@
+using NPoco;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence
+{
+    public interface IUmbracoDatabaseConfig : IDatabaseConfig
+    {
+        /// <summary>
+        /// The Umbraco SqlSyntax used to handle different syntaxes in the different database providers.
+        /// </summary>
+        ISqlSyntaxProvider SqlSyntax { get; }
+    }
+}
diff --git a/src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs b/src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs
index 808a932670..3c23293d0c 100644
--- a/src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs
@@ -18,9 +18,7 @@ namespace Umbraco.Core.Persistence.Mappers
         /// <param name="assignedMapperTypes"></param>
         public MappingResolver(IServiceContainer container, ILogger logger, Func<IEnumerable<Type>> assignedMapperTypes)
             : base(container, logger, assignedMapperTypes)
-        {
-
-        }
+        { }
 
         /// <summary>
         /// Caches the type -> mapper so that we don't have to type check each time we want one or lookup the attribute
diff --git a/src/Umbraco.Core/Persistence/Migrations/IMigrationContext.cs b/src/Umbraco.Core/Persistence/Migrations/IMigrationContext.cs
index 4440e7d2e3..abc31330f3 100644
--- a/src/Umbraco.Core/Persistence/Migrations/IMigrationContext.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/IMigrationContext.cs
@@ -1,14 +1,11 @@
 using System.Collections.Generic;
-using NPoco;
-using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations
 {
     public interface IMigrationContext
     {
+        UmbracoDatabase Database { get; }
+
         ICollection<IMigrationExpression> Expressions { get; set; }
-        DatabaseProviders CurrentDatabaseProvider { get; }
-        Database Database { get; }
-        ISqlSyntaxProvider SqlSyntax { get; }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaCreation.cs b/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaCreation.cs
index e89d7367ec..9891476b40 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaCreation.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaCreation.cs
@@ -15,26 +15,25 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
     /// </summary>
     internal class DatabaseSchemaCreation
     {
+        private readonly DatabaseSchemaHelper _schemaHelper;
+        private readonly UmbracoDatabase _database;
+        private readonly ILogger _logger;
+
         /// <summary>
         /// Constructor
         /// </summary>
         /// <param name="database"></param>
         /// <param name="logger"></param>
-        /// <param name="sqlSyntaxProvider"></param>
-        public DatabaseSchemaCreation(Database database, ILogger logger, ISqlSyntaxProvider sqlSyntaxProvider)
+        public DatabaseSchemaCreation(UmbracoDatabase database, ILogger logger)
         {
             _database = database;
             _logger = logger;
-            _sqlSyntaxProvider = sqlSyntaxProvider;
-             _schemaHelper = new DatabaseSchemaHelper(database, logger, sqlSyntaxProvider);
+            _schemaHelper = new DatabaseSchemaHelper(database, logger);
         }
 
-        #region Private Members
+        private ISqlSyntaxProvider SqlSyntax => _database.SqlSyntax;
 
-        private readonly DatabaseSchemaHelper _schemaHelper;
-        private readonly Database _database;
-        private readonly ILogger _logger;
-        private readonly ISqlSyntaxProvider _sqlSyntaxProvider;
+        #region All Ordered Tables
 
         private static readonly Dictionary<int, Type> OrderedTables = new Dictionary<int, Type>
                                                                           {
@@ -44,7 +43,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                                                                               {3, typeof (ContentDto)},
                                                                               {4, typeof (ContentVersionDto)},
                                                                               {5, typeof (DocumentDto)},
-                                                                              
+
                                                                               {6, typeof (ContentTypeTemplateDto)},
                                                                               {7, typeof (DataTypeDto)},
                                                                               {8, typeof (DataTypePreValueDto)},
@@ -88,9 +87,9 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                                                                               {47, typeof (UmbracoDeployDependencyDto)}
                                                                           };
         #endregion
-        
+
         /// <summary>
-        /// Drops all Umbraco tables in the db
+        /// Drops all Umbraco tables in the db.
         /// </summary>
         internal void UninstallDatabaseSchema()
         {
@@ -100,7 +99,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
             {
                 var tableNameAttribute = item.Value.FirstAttribute<TableNameAttribute>();
 
-                string tableName = tableNameAttribute == null ? item.Value.Name : tableNameAttribute.Value;
+                var tableName = tableNameAttribute == null ? item.Value.Name : tableNameAttribute.Value;
 
                 _logger.Info<DatabaseSchemaCreation>("Uninstall" + tableName);
 
@@ -108,7 +107,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                 {
                     if (_schemaHelper.TableExist(tableName))
                     {
-                        _schemaHelper.DropTable(tableName);    
+                        _schemaHelper.DropTable(tableName);
                     }
                 }
                 catch (Exception ex)
@@ -120,17 +119,15 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
             }
         }
 
-       
-
         /// <summary>
-        /// Initialize the database by creating the umbraco db schema
+        /// Initializes the database by creating the umbraco db schema.
         /// </summary>
         public void InitializeDatabaseSchema()
         {
             var e = new DatabaseCreationEventArgs();
             FireBeforeCreation(e);
 
-            if (!e.Cancel)
+            if (e.Cancel == false)
             {
                 foreach (var item in OrderedTables.OrderBy(x => x.Key))
                 {
@@ -142,15 +139,15 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
         }
 
         /// <summary>
-        /// Validates the schema of the current database
+        /// Validates the schema of the current database.
         /// </summary>
         public DatabaseSchemaResult ValidateSchema()
         {
-            var result = new DatabaseSchemaResult(_sqlSyntaxProvider);
+            var result = new DatabaseSchemaResult(SqlSyntax);
 
             //get the db index defs
-            result.DbIndexDefinitions = _sqlSyntaxProvider.GetDefinedIndexes(_database)
-                .Select(x => new DbIndexDefinition()
+            result.DbIndexDefinitions = SqlSyntax.GetDefinedIndexes(_database)
+                .Select(x => new DbIndexDefinition
                 {
                     TableName = x.Item1,
                     IndexName = x.Item2,
@@ -158,18 +155,13 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                     IsUnique = x.Item4
                 }).ToArray();
 
-            foreach (var item in OrderedTables.OrderBy(x => x.Key))
-            {
-                var tableDefinition = DefinitionFactory.GetTableDefinition(item.Value, _sqlSyntaxProvider);
-                result.TableDefinitions.Add(tableDefinition);
-            }
+            result.TableDefinitions.AddRange(OrderedTables
+                .OrderBy(x => x.Key)
+                .Select(x => DefinitionFactory.GetTableDefinition(x.Value, SqlSyntax)));
 
             ValidateDbTables(result);
-
             ValidateDbColumns(result);
-
             ValidateDbIndexes(result);
-
             ValidateDbConstraints(result);
 
             return result;
@@ -180,11 +172,11 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
             //MySql doesn't conform to the "normal" naming of constraints, so there is currently no point in doing these checks.
             //TODO: At a later point we do other checks for MySql, but ideally it should be necessary to do special checks for different providers.
             // ALso note that to get the constraints for MySql we have to open a connection which we currently have not.
-            if (_sqlSyntaxProvider is MySqlSyntaxProvider)
+            if (SqlSyntax is MySqlSyntaxProvider)
                 return;
 
             //Check constraints in configured database against constraints in schema
-            var constraintsInDatabase = _sqlSyntaxProvider.GetConstraintsPerColumn(_database).DistinctBy(x => x.Item3).ToList();
+            var constraintsInDatabase = SqlSyntax.GetConstraintsPerColumn(_database).DistinctBy(x => x.Item3).ToList();
             var foreignKeysInDatabase = constraintsInDatabase.Where(x => x.Item3.InvariantStartsWith("FK_")).Select(x => x.Item3).ToList();
             var primaryKeysInDatabase = constraintsInDatabase.Where(x => x.Item3.InvariantStartsWith("PK_")).Select(x => x.Item3).ToList();
             var indexesInDatabase = constraintsInDatabase.Where(x => x.Item3.InvariantStartsWith("IX_")).Select(x => x.Item3).ToList();
@@ -267,7 +259,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
         private void ValidateDbColumns(DatabaseSchemaResult result)
         {
             //Check columns in configured database against columns in schema
-            var columnsInDatabase = _sqlSyntaxProvider.GetColumnsInSchema(_database);
+            var columnsInDatabase = SqlSyntax.GetColumnsInSchema(_database);
             var columnsPerTableInDatabase = columnsInDatabase.Select(x => string.Concat(x.TableName, ",", x.ColumnName)).ToList();
             var columnsPerTableInSchema = result.TableDefinitions.SelectMany(x => x.Columns.Select(y => string.Concat(y.TableName, ",", y.Name))).ToList();
             //Add valid and invalid column differences to the result object
@@ -289,7 +281,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
         private void ValidateDbTables(DatabaseSchemaResult result)
         {
             //Check tables in configured database against tables in schema
-            var tablesInDatabase = _sqlSyntaxProvider.GetTablesInSchema(_database).ToList();
+            var tablesInDatabase = SqlSyntax.GetTablesInSchema(_database).ToList();
             var tablesInSchema = result.TableDefinitions.Select(x => x.Name).ToList();
             //Add valid and invalid table differences to the result object
             var validTableDifferences = tablesInDatabase.Intersect(tablesInSchema, StringComparer.InvariantCultureIgnoreCase);
diff --git a/src/Umbraco.Core/Persistence/Migrations/MigrationBase.cs b/src/Umbraco.Core/Persistence/Migrations/MigrationBase.cs
index 966a0715c7..801e05869c 100644
--- a/src/Umbraco.Core/Persistence/Migrations/MigrationBase.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/MigrationBase.cs
@@ -15,12 +15,14 @@ namespace Umbraco.Core.Persistence.Migrations
 {
     public abstract class MigrationBase : IMigration
     {
-        public ISqlSyntaxProvider SqlSyntax { get; private set; }
+        public ISqlSyntaxProvider SqlSyntax => Context.Database.SqlSyntax;
+
+        public DatabaseType DatabaseType => Context.Database.DatabaseType;
+
         public ILogger Logger { get; private set; }
 
-        protected MigrationBase(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+        protected MigrationBase(ILogger logger)
         {
-            SqlSyntax = sqlSyntax;
             Logger = logger;
         }
 
@@ -41,49 +43,28 @@ namespace Umbraco.Core.Persistence.Migrations
             Down();
         }
 
-        public IAlterSyntaxBuilder Alter
-        {
-            get { return new AlterSyntaxBuilder(Context, SqlSyntax); }
-        }
+        public IAlterSyntaxBuilder Alter => new AlterSyntaxBuilder(Context);
 
-        public ICreateBuilder Create
-        {
-            get { return new CreateBuilder(Context); }
-        }
+        public ICreateBuilder Create => new CreateBuilder(Context);
 
-        public IDeleteBuilder Delete
-        {
-            get { return new DeleteBuilder(Context); }
-        }
+        public IDeleteBuilder Delete => new DeleteBuilder(Context);
 
-        public IExecuteBuilder Execute
-        {
-            get { return new ExecuteBuilder(Context, SqlSyntax); }
-        }
+        public IExecuteBuilder Execute => new ExecuteBuilder(Context);
 
-        public IInsertBuilder Insert
-        {
-            get { return new InsertBuilder(Context, SqlSyntax); }
-        }
+        public IInsertBuilder Insert => new InsertBuilder(Context);
 
-        public IRenameBuilder Rename
-        {
-            get { return new RenameBuilder(Context, SqlSyntax); }
-        }
+        public IRenameBuilder Rename => new RenameBuilder(Context);
 
-        public IUpdateBuilder Update
-        {
-            get { return new UpdateBuilder(Context, SqlSyntax); }
-        }
+        public IUpdateBuilder Update => new UpdateBuilder(Context);
 
-        public IIfDatabaseBuilder IfDatabase(params DatabaseProviders[] databaseProviders)
+        public IIfDatabaseBuilder IfDatabase(params DatabaseType[] supportedDatabaseTypes)
         {
-            return new IfDatabaseBuilder(Context, SqlSyntax, databaseProviders);
+            return new IfDatabaseBuilder(Context, supportedDatabaseTypes);
         }
 
         protected Sql<SqlContext> Sql()
         {
-            return NPoco.Sql.BuilderFor(new SqlContext(SqlSyntax, Context.Database));
+            return Context.Database.Sql();
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Migrations/MigrationContext.cs b/src/Umbraco.Core/Persistence/Migrations/MigrationContext.cs
index 8126a402f2..486cd87f12 100644
--- a/src/Umbraco.Core/Persistence/Migrations/MigrationContext.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/MigrationContext.cs
@@ -9,27 +9,24 @@ namespace Umbraco.Core.Persistence.Migrations
 {
     internal class MigrationContext : IMigrationContext
     {
-        public MigrationContext(DatabaseProviders databaseProvider, Database database, ILogger logger, ISqlSyntaxProvider sqlSyntax)
+        public MigrationContext(UmbracoDatabase database, ILogger logger)
         {
-            if (database == null) throw new ArgumentNullException("database");
-            if (logger == null) throw new ArgumentNullException("logger");
-            if (sqlSyntax == null) throw new ArgumentNullException("sqlSyntax");
+            if (database == null) throw new ArgumentNullException(nameof(database));
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
 
             Expressions = new Collection<IMigrationExpression>();
-            CurrentDatabaseProvider = databaseProvider;
             Database = database;
             Logger = logger;
-            SqlSyntax = sqlSyntax;
         }
 
         public ICollection<IMigrationExpression> Expressions { get; set; }
 
-        public DatabaseProviders CurrentDatabaseProvider { get; private set; }
+        public UmbracoDatabase Database { get; }
 
-        public Database Database { get; private set; }
+        public ISqlSyntaxProvider SqlSyntax => Database.SqlSyntax;
 
-        public ISqlSyntaxProvider SqlSyntax { get; private set; }
+        public DatabaseType DatabaseType => Database.DatabaseType;
 
-        public ILogger Logger { get; private set; }
+        public ILogger Logger { get; }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Migrations/MigrationExpressionBase.cs b/src/Umbraco.Core/Persistence/Migrations/MigrationExpressionBase.cs
index 8a0e0d7063..838a2f7aba 100644
--- a/src/Umbraco.Core/Persistence/Migrations/MigrationExpressionBase.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/MigrationExpressionBase.cs
@@ -1,41 +1,44 @@
 using System;
 using System.Linq;
 using NPoco;
-using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations
 {
     public abstract class MigrationExpressionBase : IMigrationExpression
     {
+        private readonly IMigrationContext _context;
 
-        //protected MigrationExpressionBase(ISqlSyntaxProvider sqlSyntax)
-        //{
-        //    SqlSyntax = sqlSyntax;
-        //}
-
-        protected MigrationExpressionBase(ISqlSyntaxProvider sqlSyntax, DatabaseProviders currentDatabaseProvider, DatabaseProviders[] supportedDatabaseProviders = null)
+        protected MigrationExpressionBase(IMigrationContext context, DatabaseType[] supportedDatabaseTypes = null)
         {
-            SupportedDatabaseProviders = supportedDatabaseProviders;
-            SqlSyntax = sqlSyntax;
-            CurrentDatabaseProvider = currentDatabaseProvider;
+            if (context == null) throw new ArgumentNullException(nameof(context));
+            _context = context;
+            SupportedDatabaseTypes = supportedDatabaseTypes;
         }
 
-        public virtual DatabaseProviders[] SupportedDatabaseProviders { get; private set; }
-        public ISqlSyntaxProvider SqlSyntax { get; private set; }
-        public virtual DatabaseProviders CurrentDatabaseProvider { get; private set; }
+        public virtual DatabaseType[] SupportedDatabaseTypes { get; }
+
+        public ISqlSyntaxProvider SqlSyntax => _context.Database.SqlSyntax;
+
+        public virtual DatabaseType CurrentDatabaseType => _context.Database.DatabaseType;
 
         public bool IsExpressionSupported()
         {
-            if (SupportedDatabaseProviders == null || SupportedDatabaseProviders.Any() == false)
-                return true;
-
-            return SupportedDatabaseProviders.Any(x => x == CurrentDatabaseProvider);
+            return SupportedDatabaseTypes == null
+                || SupportedDatabaseTypes.Length == 0
+                // beware!
+                // DatabaseType.SqlServer2005 = DatabaseTypes.SqlServerDatabaseType
+                // DatabaseType.SqlServer2012 = DatabaseTypes.SqlServer2012DatabaseType
+                // with cascading inheritance, so if SqlServer2005 is "supported" we
+                // need to accept SqlServer2012 too => cannot simply test with "Contains"
+                // and have to test the types.
+                //|| SupportedDatabaseTypes.Contains(CurrentDatabaseType);
+                || SupportedDatabaseTypes.Any(x => CurrentDatabaseType.GetType().Inherits(x.GetType()));
         }
 
         public virtual string Process(Database database)
         {
-            return this.ToString();
+            return ToString();
         }
 
         /// <summary>
diff --git a/src/Umbraco.Core/Persistence/Migrations/MigrationRunner.cs b/src/Umbraco.Core/Persistence/Migrations/MigrationRunner.cs
index dbb98c877f..12506b8f60 100644
--- a/src/Umbraco.Core/Persistence/Migrations/MigrationRunner.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/MigrationRunner.cs
@@ -53,11 +53,9 @@ namespace Umbraco.Core.Persistence.Migrations
         /// Executes the migrations against the database.
         /// </summary>
         /// <param name="database">The NPoco Database, which the migrations will be run against</param>
-        /// <param name="databaseProvider"></param>
-        /// <param name="sqlSyntaxProvider"></param>
         /// <param name="isUpgrade">Boolean indicating whether this is an upgrade or downgrade</param>
         /// <returns><c>True</c> if migrations were applied, otherwise <c>False</c></returns>
-        public virtual bool Execute(Database database, DatabaseProviders databaseProvider, ISqlSyntaxProvider sqlSyntaxProvider, bool isUpgrade = true)
+        public virtual bool Execute(UmbracoDatabase database, bool isUpgrade = true)
         {
             _logger.Info<MigrationRunner>("Initializing database migrations");
 
@@ -76,7 +74,7 @@ namespace Umbraco.Core.Persistence.Migrations
             }
 
             //Loop through migrations to generate sql
-            var migrationContext = InitializeMigrations(migrations, database, databaseProvider, sqlSyntaxProvider, isUpgrade);
+            var migrationContext = InitializeMigrations(migrations, database, isUpgrade);
 
             try
             {
@@ -87,7 +85,7 @@ namespace Umbraco.Core.Persistence.Migrations
                 //if this fails then the transaction will be rolled back, BUT if we are using MySql this is not the case,
                 //since it does not support schema changes in a transaction, see: http://dev.mysql.com/doc/refman/5.0/en/implicit-commit.html
                 //so in that case we have to downgrade
-                if (databaseProvider == DatabaseProviders.MySql)
+                if (database.DatabaseType is NPoco.DatabaseTypes.MySqlDatabaseType)
                 {
                     throw new DataLossException(
                             "An error occurred running a schema migration but the changes could not be rolled back. Error: " + ex.Message + ". In some cases, it may be required that the database be restored to it's original state before running this upgrade process again.",
@@ -166,13 +164,11 @@ namespace Umbraco.Core.Persistence.Migrations
 
         internal MigrationContext InitializeMigrations(
             List<IMigration> migrations,
-            Database database,
-            DatabaseProviders databaseProvider,
-            ISqlSyntaxProvider sqlSyntax,
+            UmbracoDatabase database,
             bool isUpgrade = true)
         {
             //Loop through migrations to generate sql
-            var context = new MigrationContext(databaseProvider, database, _logger, sqlSyntax);
+            var context = new MigrationContext(database, _logger);
 
             foreach (var migration in migrations)
             {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/AlterSyntaxBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/AlterSyntaxBuilder.cs
index e253f8e607..b4890e72ce 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/AlterSyntaxBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/AlterSyntaxBuilder.cs
@@ -1,35 +1,33 @@
-using Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column;
+using NPoco;
+using Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column;
 using Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table;
-using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter
 {
     public class AlterSyntaxBuilder : IAlterSyntaxBuilder
     {
         private readonly IMigrationContext _context;
-        private readonly ISqlSyntaxProvider _sqlSyntax;
-        private readonly DatabaseProviders[] _databaseProviders;
+        private readonly DatabaseType[] _supportedDatabaseTypes;
 
-        public AlterSyntaxBuilder(IMigrationContext context, ISqlSyntaxProvider sqlSyntax, params DatabaseProviders[] databaseProviders)
+        public AlterSyntaxBuilder(IMigrationContext context, params DatabaseType[] supportedDatabaseTypes)
         {
             _context = context;
-            _sqlSyntax = sqlSyntax;
-            _databaseProviders = databaseProviders;
+            _supportedDatabaseTypes = supportedDatabaseTypes;
         }
 
         public IAlterTableSyntax Table(string tableName)
         {
-            var expression = new AlterTableExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { TableName = tableName };
+            var expression = new AlterTableExpression(_context, _supportedDatabaseTypes) { TableName = tableName };
             //_context.Expressions.Add(expression);
-            return new AlterTableBuilder(_context, _databaseProviders, expression);
+            return new AlterTableBuilder(_context, _supportedDatabaseTypes, expression);
         }
 
         public IAlterColumnSyntax Column(string columnName)
         {
-            var expression = new AlterColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) {Column = {Name = columnName}};
+            var expression = new AlterColumnExpression(_context, _supportedDatabaseTypes) {Column = {Name = columnName}};
             //_context.Expressions.Add(expression);
-            return new AlterColumnBuilder(_context, _databaseProviders, expression);
+            return new AlterColumnBuilder(_context, _supportedDatabaseTypes, expression);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Column/AlterColumnBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Column/AlterColumnBuilder.cs
index a7077f2d35..683674da8f 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Column/AlterColumnBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Column/AlterColumnBuilder.cs
@@ -1,4 +1,5 @@
 using System.Data;
+using NPoco;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Expressions;
@@ -12,13 +13,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column
                                             IAlterColumnOptionForeignKeyCascadeSyntax
     {
         private readonly IMigrationContext _context;
-        private readonly DatabaseProviders[] _databaseProviders;
+        private readonly DatabaseType[] _supportedDatabaseTypes;
 
-        public AlterColumnBuilder(IMigrationContext context, DatabaseProviders[] databaseProviders, AlterColumnExpression expression)
+        public AlterColumnBuilder(IMigrationContext context, DatabaseType[] supportedDatabaseTypes, AlterColumnExpression expression)
             : base(expression)
         {
             _context = context;
-            _databaseProviders = databaseProviders;
+            _supportedDatabaseTypes = supportedDatabaseTypes;
         }
 
         public ForeignKeyDefinition CurrentForeignKey { get; set; }
@@ -36,7 +37,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column
 
         public IAlterColumnOptionSyntax WithDefault(SystemMethods method)
         {
-            var dc = new AlterDefaultConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax)
+            var dc = new AlterDefaultConstraintExpression(_context, _supportedDatabaseTypes)
                          {
                              TableName = Expression.TableName,
                              SchemaName = Expression.SchemaName,
@@ -54,7 +55,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column
 
         public IAlterColumnOptionSyntax WithDefaultValue(object value)
         {
-            var dc = new AlterDefaultConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax)
+            var dc = new AlterDefaultConstraintExpression(_context, _supportedDatabaseTypes)
                          {
                              TableName = Expression.TableName,
                              SchemaName = Expression.SchemaName,
@@ -84,7 +85,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column
         {
             Expression.Column.IsIndexed = true;
 
-            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            var index = new CreateIndexExpression(_context, _supportedDatabaseTypes, new IndexDefinition
             {
                 Name = indexName,
                 SchemaName = Expression.SchemaName,
@@ -135,7 +136,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column
         {
             Expression.Column.IsUnique = true;
 
-            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            var index = new CreateIndexExpression(_context, _supportedDatabaseTypes, new IndexDefinition
             {
                 Name = indexName,
                 SchemaName = Expression.SchemaName,
@@ -169,7 +170,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column
         {
             Expression.Column.IsForeignKey = true;
 
-            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            var fk = new CreateForeignKeyExpression(_context, _supportedDatabaseTypes, new ForeignKeyDefinition
             {
                 Name = foreignKeyName,
                 PrimaryTable = primaryTableName,
@@ -206,7 +207,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column
         public IAlterColumnOptionForeignKeyCascadeSyntax ReferencedBy(string foreignKeyName, string foreignTableSchema,
                                                                       string foreignTableName, string foreignColumnName)
         {
-            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            var fk = new CreateForeignKeyExpression(_context, _supportedDatabaseTypes, new ForeignKeyDefinition
             {
                 Name = foreignKeyName,
                 PrimaryTable = Expression.TableName,
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterColumnExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterColumnExpression.cs
index 1a538666ff..8b9d01513c 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterColumnExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterColumnExpression.cs
@@ -1,16 +1,15 @@
-using System;
+using NPoco;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions
 {
     public class AlterColumnExpression : MigrationExpressionBase
     {
 
-        public AlterColumnExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax, current, databaseProviders)
+        public AlterColumnExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes)
+            : base(context, supportedDatabaseTypes)
         {
-            Column = new ColumnDefinition() { ModificationType = ModificationType.Alter };
+            Column = new ColumnDefinition { ModificationType = ModificationType.Alter };
         }
 
 
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterDefaultConstraintExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterDefaultConstraintExpression.cs
index 5595b5417a..c32ec6fd50 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterDefaultConstraintExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterDefaultConstraintExpression.cs
@@ -1,18 +1,21 @@
-using Umbraco.Core.Persistence.SqlSyntax;
+using NPoco;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions
 {
     public class AlterDefaultConstraintExpression : MigrationExpressionBase
     {
-        public AlterDefaultConstraintExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax) 
-            : base(sqlSyntax, current, databaseProviders)
-        {
-        }
+        public AlterDefaultConstraintExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes) 
+            : base(context, supportedDatabaseTypes)
+        { }
 
         public virtual string SchemaName { get; set; }
+
         public virtual string TableName { get; set; }
+
         public virtual string ColumnName { get; set; }
+
         public virtual string ConstraintName { get; set; }
+
         public virtual object DefaultValue { get; set; }
 
         public override string ToString()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterTableExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterTableExpression.cs
index 6524ed0655..fc1e0a8015 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterTableExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterTableExpression.cs
@@ -1,21 +1,20 @@
-using Umbraco.Core.Persistence.SqlSyntax;
+using NPoco;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions
 {
     public class AlterTableExpression : MigrationExpressionBase
     {
-
-        public AlterTableExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax) 
-            : base(sqlSyntax, current, databaseProviders)
-        {
-        }
+        public AlterTableExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes) 
+            : base(context, supportedDatabaseTypes)
+        { }
 
         public virtual string SchemaName { get; set; }
+
         public virtual string TableName { get; set; }
 
         public override string ToString()
         {
-            return string.Format("ALTER TABLE {0}", TableName);
+            return $"ALTER TABLE {TableName}";
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Table/AlterTableBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Table/AlterTableBuilder.cs
index 7a6ab8d47a..bc11fb1099 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Table/AlterTableBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Table/AlterTableBuilder.cs
@@ -1,4 +1,5 @@
 using System.Data;
+using NPoco;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Expressions;
@@ -11,13 +12,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table
                                                IAlterTableColumnOptionForeignKeyCascadeSyntax
     {
         private readonly IMigrationContext _context;
-        private readonly DatabaseProviders[] _databaseProviders;
+        private readonly DatabaseType[] _supportedDatabaseTypes;
 
-        public AlterTableBuilder(IMigrationContext context, DatabaseProviders[] databaseProviders, AlterTableExpression expression)
+        public AlterTableBuilder(IMigrationContext context, DatabaseType[] supportedDatabaseTypes, AlterTableExpression expression)
             : base(expression)
         {
             _context = context;
-            _databaseProviders = databaseProviders;
+            _supportedDatabaseTypes = supportedDatabaseTypes;
         }
 
         public ColumnDefinition CurrentColumn { get; set; }
@@ -39,7 +40,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table
         {
             if (CurrentColumn.ModificationType == ModificationType.Alter)
             {
-                var dc = new AlterDefaultConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax)
+                var dc = new AlterDefaultConstraintExpression(_context, _supportedDatabaseTypes)
                              {
                                  TableName = Expression.TableName,
                                  SchemaName = Expression.SchemaName,
@@ -69,7 +70,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table
         {
             CurrentColumn.IsIndexed = true;
 
-            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            var index = new CreateIndexExpression(_context, _supportedDatabaseTypes, new IndexDefinition
             {
                 Name = indexName,
                 SchemaName = Expression.SchemaName,
@@ -120,7 +121,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table
         {
             CurrentColumn.IsUnique = true;
 
-            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            var index = new CreateIndexExpression(_context, _supportedDatabaseTypes, new IndexDefinition
             {
                 Name = indexName,
                 SchemaName = Expression.SchemaName,
@@ -154,7 +155,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table
         {
             CurrentColumn.IsForeignKey = true;
 
-            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            var fk = new CreateForeignKeyExpression(_context, _supportedDatabaseTypes, new ForeignKeyDefinition
             {
                 Name = foreignKeyName,
                 PrimaryTable = primaryTableName,
@@ -191,7 +192,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table
         public IAlterTableColumnOptionForeignKeyCascadeSyntax ReferencedBy(string foreignKeyName, string foreignTableSchema,
                                                                            string foreignTableName, string foreignColumnName)
         {
-            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            var fk = new CreateForeignKeyExpression(_context, _supportedDatabaseTypes, new ForeignKeyDefinition
             {
                 Name = foreignKeyName,
                 PrimaryTable = Expression.TableName,
@@ -211,7 +212,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table
         public IAlterTableColumnTypeSyntax AddColumn(string name)
         {
             var column = new ColumnDefinition { Name = name, ModificationType = ModificationType.Create };
-            var createColumn = new CreateColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax)
+            var createColumn = new CreateColumnExpression(_context, _supportedDatabaseTypes)
                                    {
                                        Column = column,
                                        SchemaName = Expression.SchemaName,
@@ -227,7 +228,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table
         public IAlterTableColumnTypeSyntax AlterColumn(string name)
         {
             var column = new ColumnDefinition { Name = name, ModificationType = ModificationType.Alter };
-            var alterColumn = new AlterColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax)
+            var alterColumn = new AlterColumnExpression(_context, _supportedDatabaseTypes)
             {
                 Column = column,
                 SchemaName = Expression.SchemaName,
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Column/CreateColumnBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Column/CreateColumnBuilder.cs
index d004cd1176..2bed05e786 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Column/CreateColumnBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Column/CreateColumnBuilder.cs
@@ -1,4 +1,5 @@
 using System.Data;
+using NPoco;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Expressions;
 using Umbraco.Core.Persistence.SqlSyntax;
@@ -11,13 +12,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Column
                                              ICreateColumnOptionForeignKeyCascadeSyntax
     {
         private readonly IMigrationContext _context;
-        private readonly DatabaseProviders[] _databaseProviders;
+        private readonly DatabaseType[] _supportedDatabaseTypes;
 
-        public CreateColumnBuilder(IMigrationContext context, DatabaseProviders[] databaseProviders, CreateColumnExpression expression)
+        public CreateColumnBuilder(IMigrationContext context, DatabaseType[] supportedDatabaseTypes, CreateColumnExpression expression)
             : base(expression)
         {
             _context = context;
-            _databaseProviders = databaseProviders;
+            _supportedDatabaseTypes = supportedDatabaseTypes;
         }
 
         public ForeignKeyDefinition CurrentForeignKey { get; set; }
@@ -59,7 +60,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Column
         {
             Expression.Column.IsIndexed = true;
 
-            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            var index = new CreateIndexExpression(_context, _supportedDatabaseTypes, new IndexDefinition
             {
                 Name = indexName,
                 SchemaName = Expression.SchemaName,
@@ -110,7 +111,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Column
         {
             Expression.Column.IsUnique = true;
 
-            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            var index = new CreateIndexExpression(_context, _supportedDatabaseTypes, new IndexDefinition
             {
                 Name = indexName,
                 SchemaName = Expression.SchemaName,
@@ -144,7 +145,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Column
         {
             Expression.Column.IsForeignKey = true;
 
-            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            var fk = new CreateForeignKeyExpression(_context, _supportedDatabaseTypes, new ForeignKeyDefinition
             {
                 Name = foreignKeyName,
                 PrimaryTable = primaryTableName,
@@ -181,7 +182,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Column
         public ICreateColumnOptionForeignKeyCascadeSyntax ReferencedBy(string foreignKeyName, string foreignTableSchema,
                                                                        string foreignTableName, string foreignColumnName)
         {
-            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            var fk = new CreateForeignKeyExpression(_context, _supportedDatabaseTypes, new ForeignKeyDefinition
             {
                 Name = foreignKeyName,
                 PrimaryTable = Expression.TableName,
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/CreateBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/CreateBuilder.cs
index f3f2f43f12..c00225a73b 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/CreateBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/CreateBuilder.cs
@@ -1,4 +1,5 @@
 using System;
+using NPoco;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Create.Column;
 using Umbraco.Core.Persistence.Migrations.Syntax.Create.Constraint;
@@ -14,67 +15,67 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create
     public class CreateBuilder : ICreateBuilder
     {
         private readonly IMigrationContext _context;
-        private readonly DatabaseProviders[] _databaseProviders;
+        private readonly DatabaseType[] _supportedDatabaseTypes;
 
-        public CreateBuilder(IMigrationContext context, params DatabaseProviders[] databaseProviders)
+        public CreateBuilder(IMigrationContext context, params DatabaseType[] supportedDatabaseTypes)
         {
-            if (context == null) throw new ArgumentNullException("context");            
+            if (context == null) throw new ArgumentNullException(nameof(context));            
             _context = context;
-            _databaseProviders = databaseProviders;
+            _supportedDatabaseTypes = supportedDatabaseTypes;
         }
 
         public ICreateTableWithColumnSyntax Table(string tableName)
         {
-            var expression = new CreateTableExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax) { TableName = tableName };
+            var expression = new CreateTableExpression(_context, _supportedDatabaseTypes) { TableName = tableName };
             _context.Expressions.Add(expression);
-            return new CreateTableBuilder(_context, _databaseProviders, expression);
+            return new CreateTableBuilder(_context, _supportedDatabaseTypes, expression);
         }
 
         public ICreateColumnOnTableSyntax Column(string columnName)
         {
-            var expression = new CreateColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax) { Column = { Name = columnName } };
+            var expression = new CreateColumnExpression(_context, _supportedDatabaseTypes) { Column = { Name = columnName } };
             _context.Expressions.Add(expression);
-            return new CreateColumnBuilder(_context, _databaseProviders, expression);
+            return new CreateColumnBuilder(_context, _supportedDatabaseTypes, expression);
         }
 
         public ICreateForeignKeyFromTableSyntax ForeignKey()
         {
-            var expression = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax);
+            var expression = new CreateForeignKeyExpression(_context, _supportedDatabaseTypes);
             _context.Expressions.Add(expression);
             return new CreateForeignKeyBuilder(expression);
         }
 
         public ICreateForeignKeyFromTableSyntax ForeignKey(string foreignKeyName)
         {
-            var expression = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax) { ForeignKey = { Name = foreignKeyName } };
+            var expression = new CreateForeignKeyExpression(_context, _supportedDatabaseTypes) { ForeignKey = { Name = foreignKeyName } };
             _context.Expressions.Add(expression);
             return new CreateForeignKeyBuilder(expression);
         }
 
         public ICreateIndexForTableSyntax Index()
         {
-            var expression = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax);
+            var expression = new CreateIndexExpression(_context, _supportedDatabaseTypes);
             _context.Expressions.Add(expression);
             return new CreateIndexBuilder(expression);
         }
 
         public ICreateIndexForTableSyntax Index(string indexName)
         {
-            var expression = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax) { Index = { Name = indexName } };
+            var expression = new CreateIndexExpression(_context, _supportedDatabaseTypes) { Index = { Name = indexName } };
             _context.Expressions.Add(expression);
             return new CreateIndexBuilder(expression);
         }
 
         public ICreateConstraintOnTableSyntax PrimaryKey()
         {
-            var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax, ConstraintType.PrimaryKey);
+            var expression = new CreateConstraintExpression(_context, _supportedDatabaseTypes, ConstraintType.PrimaryKey);
             _context.Expressions.Add(expression);
             return new CreateConstraintBuilder(expression);
         }
 
         public ICreateConstraintOnTableSyntax PrimaryKey(string primaryKeyName)
         {
-            var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax, ConstraintType.PrimaryKey);
+            var expression = new CreateConstraintExpression(_context, _supportedDatabaseTypes, ConstraintType.PrimaryKey);
             expression.Constraint.ConstraintName = primaryKeyName;
             _context.Expressions.Add(expression);
             return new CreateConstraintBuilder(expression);
@@ -82,14 +83,14 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create
 
         public ICreateConstraintOnTableSyntax UniqueConstraint()
         {
-            var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax, ConstraintType.Unique);
+            var expression = new CreateConstraintExpression(_context, _supportedDatabaseTypes, ConstraintType.Unique);
             _context.Expressions.Add(expression);
             return new CreateConstraintBuilder(expression);
         }
 
         public ICreateConstraintOnTableSyntax UniqueConstraint(string constraintName)
         {
-            var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax, ConstraintType.Unique);
+            var expression = new CreateConstraintExpression(_context, _supportedDatabaseTypes, ConstraintType.Unique);
             expression.Constraint.ConstraintName = constraintName;
             _context.Expressions.Add(expression);
             return new CreateConstraintBuilder(expression);
@@ -97,7 +98,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create
 
         public ICreateConstraintOnTableSyntax Constraint(string constraintName)
         {
-            var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax, ConstraintType.NonUnique);
+            var expression = new CreateConstraintExpression(_context, _supportedDatabaseTypes, ConstraintType.NonUnique);
             expression.Constraint.ConstraintName = constraintName;
             _context.Expressions.Add(expression);
             return new CreateConstraintBuilder(expression);
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Expressions/CreateConstraintExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Expressions/CreateConstraintExpression.cs
index 24dd72b7db..893239e822 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Expressions/CreateConstraintExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Expressions/CreateConstraintExpression.cs
@@ -1,13 +1,13 @@
 using System.Linq;
+using NPoco;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Expressions
 {
     public class CreateConstraintExpression : MigrationExpressionBase
     {
-        public CreateConstraintExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax, ConstraintType constraint) 
-            : base(sqlSyntax, current, databaseProviders)
+        public CreateConstraintExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes, ConstraintType constraint) 
+            : base(context, supportedDatabaseTypes)
         {
             Constraint = new ConstraintDefinition(constraint);
         }
@@ -27,7 +27,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Expressions
 
             var columns = new string[Constraint.Columns.Count];
 
-            for (int i = 0; i < Constraint.Columns.Count; i++)
+            for (var i = 0; i < Constraint.Columns.Count; i++)
             {
                 columns[i] = SqlSyntax.GetQuotedColumnName(Constraint.Columns.ElementAt(i));
             }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Expressions/CreateTableExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Expressions/CreateTableExpression.cs
index 68f1da2ce7..af9247f8f2 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Expressions/CreateTableExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Expressions/CreateTableExpression.cs
@@ -1,16 +1,13 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
+using NPoco;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Expressions
 {
     public class CreateTableExpression : MigrationExpressionBase
     {
-
-
-        public CreateTableExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax, current, databaseProviders)
+        public CreateTableExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes)
+            : base(context, supportedDatabaseTypes)
         {
             Columns = new List<ColumnDefinition>();
         }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Table/CreateTableBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Table/CreateTableBuilder.cs
index 86760b71bc..3d34cb9e51 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Table/CreateTableBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Table/CreateTableBuilder.cs
@@ -1,4 +1,5 @@
 using System.Data;
+using NPoco;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Create.Expressions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Expressions;
@@ -12,13 +13,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Table
                                                 ICreateTableColumnOptionForeignKeyCascadeSyntax
     {
         private readonly IMigrationContext _context;
-        private readonly DatabaseProviders[] _databaseProviders;
+        private readonly DatabaseType[] _supportedDatabaseTypes;
 
-        public CreateTableBuilder(IMigrationContext context, DatabaseProviders[] databaseProviders, CreateTableExpression expression)
+        public CreateTableBuilder(IMigrationContext context, DatabaseType[] supportedDatabaseTypes, CreateTableExpression expression)
             : base(expression)
         {
             _context = context;
-            _databaseProviders = databaseProviders;
+            _supportedDatabaseTypes = supportedDatabaseTypes;
         }
 
         public ColumnDefinition CurrentColumn { get; set; }
@@ -65,7 +66,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Table
         {
             CurrentColumn.IsIndexed = true;
 
-            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            var index = new CreateIndexExpression(_context, _supportedDatabaseTypes, new IndexDefinition
             {
                 Name = indexName,
                 SchemaName = Expression.SchemaName,
@@ -93,9 +94,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Table
             // for this, but I don't see another way around. MySQL doesn't support checking for a constraint before creating
             // it... except in a very strange way but it doesn't actually provider error feedback if it doesn't work so we cannot use
             // it.  For now, this is what I'm doing
-            if (Expression.CurrentDatabaseProvider != DatabaseProviders.MySql)
+            if (Expression.CurrentDatabaseType.IsMySql() == false)
             {
-                var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, ConstraintType.PrimaryKey)
+                var expression = new CreateConstraintExpression(_context, _supportedDatabaseTypes, ConstraintType.PrimaryKey)
                 {
                     Constraint =
                 {
@@ -122,9 +123,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Table
             // it... except in a very strange way but it doesn't actually provider error feedback if it doesn't work so we cannot use
             // it.  For now, this is what I'm doing
 
-            if (Expression.CurrentDatabaseProvider != DatabaseProviders.MySql)
+            if (Expression.CurrentDatabaseType.IsMySql() == false)
             {
-                var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, ConstraintType.PrimaryKey)
+                var expression = new CreateConstraintExpression(_context, _supportedDatabaseTypes, ConstraintType.PrimaryKey)
                 {
                     Constraint =
                 {
@@ -160,7 +161,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Table
         {
             CurrentColumn.IsUnique = true;
 
-            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            var index = new CreateIndexExpression(_context, _supportedDatabaseTypes, new IndexDefinition
             {
                 Name = indexName,
                 SchemaName = Expression.SchemaName,
@@ -194,7 +195,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Table
         {
             CurrentColumn.IsForeignKey = true;
 
-            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            var fk = new CreateForeignKeyExpression(_context, _supportedDatabaseTypes, new ForeignKeyDefinition
             {
                 Name = foreignKeyName,
                 PrimaryTable = primaryTableName,
@@ -231,7 +232,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Table
         public ICreateTableColumnOptionForeignKeyCascadeSyntax ReferencedBy(string foreignKeyName, string foreignTableSchema,
                                                                             string foreignTableName, string foreignColumnName)
         {
-            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            var fk = new CreateForeignKeyExpression(_context, _supportedDatabaseTypes, new ForeignKeyDefinition
             {
                 Name = foreignKeyName,
                 PrimaryTable = Expression.TableName,
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/DeleteBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/DeleteBuilder.cs
index ce1c07ec64..2cb2ed833c 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/DeleteBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/DeleteBuilder.cs
@@ -1,4 +1,5 @@
-using Umbraco.Core.Persistence.DatabaseModelDefinitions;
+using NPoco;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Delete.Column;
 using Umbraco.Core.Persistence.Migrations.Syntax.Delete.Constraint;
 using Umbraco.Core.Persistence.Migrations.Syntax.Delete.DefaultConstraint;
@@ -11,65 +12,65 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete
     public class DeleteBuilder : IDeleteBuilder
     {
         private readonly IMigrationContext _context;
-        private readonly DatabaseProviders[] _databaseProviders;
+        private readonly DatabaseType[] _supportedDatabaseTypes;
 
-        public DeleteBuilder(IMigrationContext context, params DatabaseProviders[] databaseProviders)
+        public DeleteBuilder(IMigrationContext context, params DatabaseType[] supportedDatabaseTypes)
         {
             _context = context;
-            _databaseProviders = databaseProviders;
+            _supportedDatabaseTypes = supportedDatabaseTypes;
         }
 
         public void Table(string tableName)
         {
-            var expression = new DeleteTableExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax) { TableName = tableName };
+            var expression = new DeleteTableExpression(_context, _supportedDatabaseTypes) { TableName = tableName };
             _context.Expressions.Add(expression);
         }
 
         public IDeleteColumnFromTableSyntax Column(string columnName)
         {
-            var expression = new DeleteColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax) {ColumnNames = {columnName}};
+            var expression = new DeleteColumnExpression(_context, _supportedDatabaseTypes) {ColumnNames = {columnName}};
             _context.Expressions.Add(expression);
             return new DeleteColumnBuilder(expression);
         }
 
         public IDeleteForeignKeyFromTableSyntax ForeignKey()
         {
-            var expression = new DeleteForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax);
+            var expression = new DeleteForeignKeyExpression(_context, _supportedDatabaseTypes);
             _context.Expressions.Add(expression);
             return new DeleteForeignKeyBuilder(expression);
         }
 
         public IDeleteForeignKeyOnTableSyntax ForeignKey(string foreignKeyName)
         {
-            var expression = new DeleteForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax) {ForeignKey = {Name = foreignKeyName}};
+            var expression = new DeleteForeignKeyExpression(_context, _supportedDatabaseTypes) {ForeignKey = {Name = foreignKeyName}};
             _context.Expressions.Add(expression);
             return new DeleteForeignKeyBuilder(expression);
         }
 
         public IDeleteDataSyntax FromTable(string tableName)
         {
-            var expression = new DeleteDataExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax) { TableName = tableName };
+            var expression = new DeleteDataExpression(_context, _supportedDatabaseTypes) { TableName = tableName };
             _context.Expressions.Add(expression);
             return new DeleteDataBuilder(expression);
         }
 
         public IDeleteIndexForTableSyntax Index()
         {
-            var expression = new DeleteIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax);
+            var expression = new DeleteIndexExpression(_context, _supportedDatabaseTypes);
             _context.Expressions.Add(expression);
             return new DeleteIndexBuilder(expression);
         }
 
         public IDeleteIndexForTableSyntax Index(string indexName)
         {
-            var expression = new DeleteIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax) { Index = { Name = indexName } };
+            var expression = new DeleteIndexExpression(_context, _supportedDatabaseTypes) { Index = { Name = indexName } };
             _context.Expressions.Add(expression);
             return new DeleteIndexBuilder(expression);
         }
 
         public IDeleteConstraintOnTableSyntax PrimaryKey(string primaryKeyName)
         {
-            var expression = new DeleteConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax, ConstraintType.PrimaryKey)
+            var expression = new DeleteConstraintExpression(_context, _supportedDatabaseTypes, ConstraintType.PrimaryKey)
             {
                 Constraint = { ConstraintName = primaryKeyName }
             };
@@ -79,7 +80,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete
 
         public IDeleteConstraintOnTableSyntax UniqueConstraint(string constraintName)
         {
-            var expression = new DeleteConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax, ConstraintType.Unique)
+            var expression = new DeleteConstraintExpression(_context, _supportedDatabaseTypes, ConstraintType.Unique)
             {
                 Constraint = { ConstraintName = constraintName }
             };
@@ -89,7 +90,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete
 
         public IDeleteDefaultConstraintOnTableSyntax DefaultConstraint()
         {
-            var expression = new DeleteDefaultConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _context.SqlSyntax);
+            var expression = new DeleteDefaultConstraintExpression(_context, _supportedDatabaseTypes);
             _context.Expressions.Add(expression);
             return new DeleteDefaultConstraintBuilder(expression);
         }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteColumnExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteColumnExpression.cs
index f972b38fea..6ebbb1353a 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteColumnExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteColumnExpression.cs
@@ -1,15 +1,14 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using Umbraco.Core.Persistence.SqlSyntax;
+using NPoco;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 {
     public class DeleteColumnExpression : MigrationExpressionBase
     {
-
-        public DeleteColumnExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax, current, databaseProviders)
+        public DeleteColumnExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes)
+            : base(context, supportedDatabaseTypes)
         {
             ColumnNames = new List<string>();
         }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteConstraintExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteConstraintExpression.cs
index 97e1cf4216..39a13ad83d 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteConstraintExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteConstraintExpression.cs
@@ -1,23 +1,22 @@
-using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Persistence.SqlSyntax;
+using NPoco;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 {
     public class DeleteConstraintExpression : MigrationExpressionBase
     {
-        
-        public DeleteConstraintExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax, ConstraintType type)
-            : base(sqlSyntax, current, databaseProviders)
+        public DeleteConstraintExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes, ConstraintType type)
+            : base(context, supportedDatabaseTypes)
         {
             Constraint = new ConstraintDefinition(type);
         }
 
-        public ConstraintDefinition Constraint { get; private set; }
+        public ConstraintDefinition Constraint { get; }
 
         public override string ToString()
         {
             // Test for MySQL primary key situation.
-            if (CurrentDatabaseProvider == DatabaseProviders.MySql)
+            if (CurrentDatabaseType.IsMySql())
             {
                 if (Constraint.IsPrimaryKeyConstraint)
                 {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDataExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDataExpression.cs
index 31d11fa0f3..b48067e255 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDataExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDataExpression.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
+using NPoco;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 {
@@ -9,19 +9,15 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
     {
         private readonly List<DeletionDataDefinition> _rows = new List<DeletionDataDefinition>();
         
-        public DeleteDataExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax) 
-            : base(sqlSyntax, current, databaseProviders)
-        {
-        }
+        public DeleteDataExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes) 
+            : base(context, supportedDatabaseTypes)
+        { }
 
         public virtual string SchemaName { get; set; }
         public string TableName { get; set; }
         public virtual bool IsAllRows { get; set; }
 
-        public List<DeletionDataDefinition> Rows
-        {
-            get { return _rows; }
-        }
+        public List<DeletionDataDefinition> Rows => _rows;
 
         public override string ToString()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDefaultConstraintExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDefaultConstraintExpression.cs
index 66e6dcaa9e..4c48847fd4 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDefaultConstraintExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDefaultConstraintExpression.cs
@@ -1,13 +1,12 @@
-using Umbraco.Core.Persistence.SqlSyntax;
+using NPoco;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 {
     public class DeleteDefaultConstraintExpression : MigrationExpressionBase
     {
-        public DeleteDefaultConstraintExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax, current, databaseProviders)
-        {
-        }
+        public DeleteDefaultConstraintExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes)
+            : base(context, supportedDatabaseTypes)
+        { }
 
         public virtual string SchemaName { get; set; }
         public virtual string TableName { get; set; }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteForeignKeyExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteForeignKeyExpression.cs
index d3a112607d..f66622dd1c 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteForeignKeyExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteForeignKeyExpression.cs
@@ -1,17 +1,14 @@
 using System;
 using System.Linq;
-using Umbraco.Core.Logging;
+using NPoco;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 {
     public class DeleteForeignKeyExpression : MigrationExpressionBase
     {
-
-
-        public DeleteForeignKeyExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax, current, databaseProviders)
+        public DeleteForeignKeyExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes)
+            : base(context, supportedDatabaseTypes)
         {   
             ForeignKey = new ForeignKeyDefinition();
         }
@@ -26,7 +23,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
             if (ForeignKey.ForeignTable == null)
                 throw new ArgumentNullException("Table name not specified, ensure you have appended the OnTable extension. Format should be Delete.ForeignKey(KeyName).OnTable(TableName)");
 
-            if (CurrentDatabaseProvider == DatabaseProviders.MySql)
+            if (CurrentDatabaseType.IsMySql())
             {
                 //MySql naming "convention" for foreignkeys, which aren't explicitly named                
                 if (string.IsNullOrEmpty(ForeignKey.Name))
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteIndexExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteIndexExpression.cs
index 4d4b1d1b14..eb900d8cf0 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteIndexExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteIndexExpression.cs
@@ -1,24 +1,23 @@
-using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Persistence.SqlSyntax;
+using NPoco;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 {
     public class DeleteIndexExpression : MigrationExpressionBase
     {
-
-        public DeleteIndexExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax, current, databaseProviders)
+        public DeleteIndexExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes)
+            : base(context, supportedDatabaseTypes)
         {
             Index = new IndexDefinition();
         }
 
-        public DeleteIndexExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax, IndexDefinition index) 
-            : base(sqlSyntax, current, databaseProviders)
+        public DeleteIndexExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes, IndexDefinition index) 
+            : base(context, supportedDatabaseTypes)
         {
             Index = index;
         }
 
-        public IndexDefinition Index { get; private set; }
+        public IndexDefinition Index { get; }
 
         public override string ToString()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteTableExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteTableExpression.cs
index 69282461ca..5a6e8dd8db 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteTableExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteTableExpression.cs
@@ -1,14 +1,12 @@
-using Umbraco.Core.Persistence.SqlSyntax;
+using NPoco;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 {
     public class DeleteTableExpression : MigrationExpressionBase
-    {
-        
-        public DeleteTableExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax) 
-            : base(sqlSyntax, current, databaseProviders)
-        {
-        }
+    {        
+        public DeleteTableExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes) 
+            : base(context, supportedDatabaseTypes)
+        { }
 
         public virtual string SchemaName { get; set; }
         public virtual string TableName { get; set; }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/ExecuteBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/ExecuteBuilder.cs
index 5d8bc6b965..7ae8f2e3d7 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/ExecuteBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/ExecuteBuilder.cs
@@ -8,25 +8,23 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Execute
     public class ExecuteBuilder : IExecuteBuilder
     {
         private readonly IMigrationContext _context;
-        private readonly ISqlSyntaxProvider _sqlSyntax;
-        private readonly DatabaseProviders[] _databaseProviders;
+        private readonly DatabaseType[] _supportedDatabaseTypes;
 
-        public ExecuteBuilder(IMigrationContext context, ISqlSyntaxProvider sqlSyntax, params DatabaseProviders[] databaseProviders)
+        public ExecuteBuilder(IMigrationContext context, params DatabaseType[] supportedDatabaseTypes)
         {
             _context = context;
-            _sqlSyntax = sqlSyntax;
-            _databaseProviders = databaseProviders;
+            _supportedDatabaseTypes = supportedDatabaseTypes;
         }
 
         public void Sql(string sqlStatement)
         {
-            var expression = new ExecuteSqlStatementExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) {SqlStatement = sqlStatement};
+            var expression = new ExecuteSqlStatementExpression(_context, _supportedDatabaseTypes) {SqlStatement = sqlStatement};
             _context.Expressions.Add(expression);
         }
 
         public void Code(Func<Database, string> codeStatement)
         {
-            var expression = new ExecuteCodeStatementExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { CodeStatement = codeStatement };
+            var expression = new ExecuteCodeStatementExpression(_context, _supportedDatabaseTypes) { CodeStatement = codeStatement };
             _context.Expressions.Add(expression);
         }
     }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/Expressions/ExecuteCodeStatementExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/Expressions/ExecuteCodeStatementExpression.cs
index 87ff16f31f..81a40e24a1 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/Expressions/ExecuteCodeStatementExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/Expressions/ExecuteCodeStatementExpression.cs
@@ -1,15 +1,13 @@
 using System;
 using NPoco;
-using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Execute.Expressions
 {
     public class ExecuteCodeStatementExpression : MigrationExpressionBase
     {
-        public ExecuteCodeStatementExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax, current, databaseProviders)
-        {
-        }
+        public ExecuteCodeStatementExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes)
+            : base(context, supportedDatabaseTypes)
+        { }
 
         public virtual Func<Database, string> CodeStatement { get; set; }
 
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/Expressions/ExecuteSqlStatementExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/Expressions/ExecuteSqlStatementExpression.cs
index 624944e53f..c52323a4a1 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/Expressions/ExecuteSqlStatementExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/Expressions/ExecuteSqlStatementExpression.cs
@@ -1,14 +1,12 @@
-using Umbraco.Core.Persistence.SqlSyntax;
+using NPoco;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Execute.Expressions
 {
     public class ExecuteSqlStatementExpression : MigrationExpressionBase
     {
-
-        public ExecuteSqlStatementExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax, current, databaseProviders)
-        {
-        }
+        public ExecuteSqlStatementExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes)
+            : base(context, supportedDatabaseTypes)
+        { }
 
         public virtual string SqlStatement { get; set; }
 
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateColumnExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateColumnExpression.cs
index e5c69762be..3bc467214d 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateColumnExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateColumnExpression.cs
@@ -1,13 +1,12 @@
-using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Persistence.SqlSyntax;
+using NPoco;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Expressions
 {
     public class CreateColumnExpression : MigrationExpressionBase
     {
-
-        public CreateColumnExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax, current, databaseProviders)
+        public CreateColumnExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes)
+            : base(context, supportedDatabaseTypes)
         {
             Column = new ColumnDefinition { ModificationType = ModificationType.Create };
         }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateForeignKeyExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateForeignKeyExpression.cs
index 71f9303c7b..03eac1dcbf 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateForeignKeyExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateForeignKeyExpression.cs
@@ -1,18 +1,18 @@
-using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Persistence.SqlSyntax;
+using NPoco;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Expressions
 {
     public class CreateForeignKeyExpression : MigrationExpressionBase
     {
-        public CreateForeignKeyExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax, ForeignKeyDefinition fkDef)
-            : base(sqlSyntax, current, databaseProviders)
+        public CreateForeignKeyExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes, ForeignKeyDefinition fkDef)
+            : base(context, supportedDatabaseTypes)
         {
             ForeignKey = fkDef;
         }
 
-        public CreateForeignKeyExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax, current, databaseProviders)
+        public CreateForeignKeyExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes)
+            : base(context, supportedDatabaseTypes)
         {
             ForeignKey = new ForeignKeyDefinition();
         }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateIndexExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateIndexExpression.cs
index 49f804f400..707ea637c6 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateIndexExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateIndexExpression.cs
@@ -1,20 +1,19 @@
-using System;
+using NPoco;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Expressions
 {
     public class CreateIndexExpression : MigrationExpressionBase
     {
 
-        public CreateIndexExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax, IndexDefinition index)
-            : base(sqlSyntax, current, databaseProviders)
+        public CreateIndexExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes, IndexDefinition index)
+            : base(context, supportedDatabaseTypes)
         {
             Index = index;
         }
 
-        public CreateIndexExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax, current, databaseProviders)
+        public CreateIndexExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes)
+            : base(context, supportedDatabaseTypes)
         {
             Index = new IndexDefinition();
         }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/IfDatabase/IfDatabaseBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/IfDatabase/IfDatabaseBuilder.cs
index 85622fd14e..670dc16f69 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/IfDatabase/IfDatabaseBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/IfDatabase/IfDatabaseBuilder.cs
@@ -1,4 +1,5 @@
-using Umbraco.Core.Persistence.Migrations.Syntax.Create;
+using NPoco;
+using Umbraco.Core.Persistence.Migrations.Syntax.Create;
 using Umbraco.Core.Persistence.Migrations.Syntax.Delete;
 using Umbraco.Core.Persistence.Migrations.Syntax.Execute;
 using Umbraco.Core.Persistence.Migrations.Syntax.Rename;
@@ -10,39 +11,22 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.IfDatabase
     public class IfDatabaseBuilder : IIfDatabaseBuilder
     {
         private readonly IMigrationContext _context;
-        private readonly ISqlSyntaxProvider _sqlSyntax;
-        private readonly DatabaseProviders[] _databaseProviders;
+        private readonly DatabaseType[] _supportedDatabaseTypes;
 
-        public IfDatabaseBuilder(IMigrationContext context, ISqlSyntaxProvider sqlSyntax, params DatabaseProviders[] databaseProviders)
+        public IfDatabaseBuilder(IMigrationContext context, params DatabaseType[] supportedDatabaseTypes)
         {
             _context = context;
-            _sqlSyntax = sqlSyntax;
-            _databaseProviders = databaseProviders;
+            _supportedDatabaseTypes = supportedDatabaseTypes;
         }
 
-        public ICreateBuilder Create
-        {
-            get { return new CreateBuilder(_context, _databaseProviders); }
-        }
+        public ICreateBuilder Create => new CreateBuilder(_context, _supportedDatabaseTypes);
 
-        public IExecuteBuilder Execute
-        {
-            get { return new ExecuteBuilder(_context, _sqlSyntax, _databaseProviders); }
-        }
+        public IExecuteBuilder Execute => new ExecuteBuilder(_context, _supportedDatabaseTypes);
 
-        public IDeleteBuilder Delete
-        {
-            get { return new DeleteBuilder(_context, _databaseProviders); }
-        }
+        public IDeleteBuilder Delete => new DeleteBuilder(_context, _supportedDatabaseTypes);
 
-        public IRenameBuilder Rename
-        {
-            get { return new RenameBuilder(_context, _sqlSyntax, _databaseProviders); }
-        }
+        public IRenameBuilder Rename => new RenameBuilder(_context, _supportedDatabaseTypes);
 
-        public IUpdateBuilder Update
-        {
-            get { return new UpdateBuilder(_context, _sqlSyntax, _databaseProviders); }
-        }
+        public IUpdateBuilder Update => new UpdateBuilder(_context, _supportedDatabaseTypes);
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/Expressions/InsertDataExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/Expressions/InsertDataExpression.cs
index 4e76887cbc..59f1bc87e3 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/Expressions/InsertDataExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/Expressions/InsertDataExpression.cs
@@ -1,8 +1,7 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Text;
+using NPoco;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Insert.Expressions
 {
@@ -10,20 +9,16 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Insert.Expressions
     {
         private readonly List<InsertionDataDefinition> _rows = new List<InsertionDataDefinition>();
         
-        public InsertDataExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax) 
-            : base(sqlSyntax, current, databaseProviders)
-        {
-        }
+        public InsertDataExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes) 
+            : base(context, supportedDatabaseTypes)
+        { }
 
         public string SchemaName { get; set; }
         public string TableName { get; set; }
         public bool EnabledIdentityInsert { get; set; }
 
-        public List<InsertionDataDefinition> Rows
-        {
-            get { return _rows; }
-        }
-        
+        public List<InsertionDataDefinition> Rows => _rows;
+
         public override string ToString()
         {
             if (IsExpressionSupported() == false)
@@ -34,7 +29,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Insert.Expressions
             if (EnabledIdentityInsert && SqlSyntax.SupportsIdentityInsert())
             {
                 sb.AppendLine(string.Format("SET IDENTITY_INSERT {0} ON;", SqlSyntax.GetQuotedTableName(TableName)));
-                if (CurrentDatabaseProvider == DatabaseProviders.SqlServer || CurrentDatabaseProvider == DatabaseProviders.SqlServerCE)
+                if (CurrentDatabaseType.IsSqlServerOrCe())
                 {
                     sb.AppendLine("GO");
                 }
@@ -60,7 +55,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Insert.Expressions
                                   cols, vals);
 
                     sb.AppendLine(string.Format("{0};", sql));
-                    if (CurrentDatabaseProvider == DatabaseProviders.SqlServer || CurrentDatabaseProvider == DatabaseProviders.SqlServerCE)
+                    if (CurrentDatabaseType.IsSqlServerOrCe())
                     {
                         sb.AppendLine("GO");
                     }
@@ -71,7 +66,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Insert.Expressions
                 if (EnabledIdentityInsert && SqlSyntax.SupportsIdentityInsert())
                 {
                     sb.AppendLine(string.Format("SET IDENTITY_INSERT {0} OFF;", SqlSyntax.GetQuotedTableName(TableName)));
-                    if (CurrentDatabaseProvider == DatabaseProviders.SqlServer || CurrentDatabaseProvider == DatabaseProviders.SqlServerCE)
+                    if (CurrentDatabaseType.IsSqlServerOrCe())
                     {
                         sb.AppendLine("GO");
                     }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/InsertBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/InsertBuilder.cs
index 2d3ce9c64d..4e2b89b958 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/InsertBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/InsertBuilder.cs
@@ -1,4 +1,5 @@
-using Umbraco.Core.Persistence.Migrations.Syntax.Insert.Expressions;
+using NPoco;
+using Umbraco.Core.Persistence.Migrations.Syntax.Insert.Expressions;
 using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Insert
@@ -7,18 +8,17 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Insert
     {
         private readonly IMigrationContext _context;
         private readonly ISqlSyntaxProvider _sqlSyntax;
-        private readonly DatabaseProviders[] _databaseProviders;
+        private readonly DatabaseType[] _supportedDatabaseTypes;
 
-        public InsertBuilder(IMigrationContext context, ISqlSyntaxProvider sqlSyntax, params DatabaseProviders[] databaseProviders)
+        public InsertBuilder(IMigrationContext context, params DatabaseType[] supportedDatabaseTypes)
         {
             _context = context;
-            _sqlSyntax = sqlSyntax;
-            _databaseProviders = databaseProviders;
+            _supportedDatabaseTypes = supportedDatabaseTypes;
         }
 
         public IInsertDataSyntax IntoTable(string tableName)
         {
-            var expression = new InsertDataExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { TableName = tableName };
+            var expression = new InsertDataExpression(_context, _supportedDatabaseTypes) { TableName = tableName };
             _context.Expressions.Add(expression);
             return new InsertDataBuilder(expression);
         }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/Expressions/RenameColumnExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/Expressions/RenameColumnExpression.cs
index db1ebde5d9..6663979ee6 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/Expressions/RenameColumnExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/Expressions/RenameColumnExpression.cs
@@ -1,14 +1,12 @@
 using NPoco;
-using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Rename.Expressions
 {
     public class RenameColumnExpression : MigrationExpressionBase
     {        
-        public RenameColumnExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax, current, databaseProviders)
-        {
-        }
+        public RenameColumnExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes)
+            : base(context, supportedDatabaseTypes)
+        { }
 
         public virtual string SchemaName { get; set; }
         public virtual string TableName { get; set; }
@@ -17,7 +15,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Rename.Expressions
 
         public override string Process(Database database)
         {
-            if (CurrentDatabaseProvider == DatabaseProviders.MySql)
+            if (CurrentDatabaseType.IsMySql())
             {
                 string columnDefinitionSql = string.Format(@"
 SELECT CONCAT(
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/Expressions/RenameTableExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/Expressions/RenameTableExpression.cs
index 96a28e339a..e8fe0ffa8b 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/Expressions/RenameTableExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/Expressions/RenameTableExpression.cs
@@ -1,13 +1,12 @@
-using Umbraco.Core.Persistence.SqlSyntax;
+using NPoco;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Rename.Expressions
 {
     public class RenameTableExpression : MigrationExpressionBase
     {
-        public RenameTableExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax, current, databaseProviders)
-        {
-        }
+        public RenameTableExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes)
+            : base(context, supportedDatabaseTypes)
+        { }
 
         public virtual string SchemaName { get; set; }
         public virtual string OldName { get; set; }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/RenameBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/RenameBuilder.cs
index ebfb08b862..ac8a7d725c 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/RenameBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/RenameBuilder.cs
@@ -1,4 +1,5 @@
-using Umbraco.Core.Persistence.Migrations.Syntax.Rename.Column;
+using NPoco;
+using Umbraco.Core.Persistence.Migrations.Syntax.Rename.Column;
 using Umbraco.Core.Persistence.Migrations.Syntax.Rename.Expressions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Rename.Table;
 using Umbraco.Core.Persistence.SqlSyntax;
@@ -8,26 +9,24 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Rename
     public class RenameBuilder : IRenameBuilder
     {
         private readonly IMigrationContext _context;
-        private readonly ISqlSyntaxProvider _sqlSyntax;
-        private readonly DatabaseProviders[] _databaseProviders;
+        private readonly DatabaseType[] _supportedDatabaseTypes;
 
-        public RenameBuilder(IMigrationContext context, ISqlSyntaxProvider sqlSyntax, params DatabaseProviders[] databaseProviders)
+        public RenameBuilder(IMigrationContext context, params DatabaseType[] supportedDatabaseTypes)
         {
             _context = context;
-            _sqlSyntax = sqlSyntax;
-            _databaseProviders = databaseProviders;
+            _supportedDatabaseTypes = supportedDatabaseTypes;
         }
 
         public IRenameTableSyntax Table(string oldName)
         {
-            var expression = new RenameTableExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { OldName = oldName };
+            var expression = new RenameTableExpression(_context, _supportedDatabaseTypes) { OldName = oldName };
             _context.Expressions.Add(expression);
             return new RenameTableBuilder(expression);
         }
 
         public IRenameColumnTableSyntax Column(string oldName)
         {
-            var expression = new RenameColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { OldName = oldName };
+            var expression = new RenameColumnExpression(_context, _supportedDatabaseTypes) { OldName = oldName };
             _context.Expressions.Add(expression);
             return new RenameColumnBuilder(expression);
         }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/Expressions/UpdateDataExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/Expressions/UpdateDataExpression.cs
index dda76a6ba1..94dd544e56 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/Expressions/UpdateDataExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/Expressions/UpdateDataExpression.cs
@@ -1,14 +1,13 @@
 using System.Collections.Generic;
-using Umbraco.Core.Persistence.SqlSyntax;
+using NPoco;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Update.Expressions
 {
     public class UpdateDataExpression : MigrationExpressionBase
     {
-        public UpdateDataExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax) 
-            : base(sqlSyntax, current, databaseProviders)
-        {
-        }
+        public UpdateDataExpression(IMigrationContext context, DatabaseType[] supportedDatabaseTypes) 
+            : base(context, supportedDatabaseTypes)
+        { }
 
         public string SchemaName { get; set; }
         public string TableName { get; set; }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/UpdateBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/UpdateBuilder.cs
index 3816e65132..e5d198d9a6 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/UpdateBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/UpdateBuilder.cs
@@ -1,4 +1,5 @@
-using Umbraco.Core.Persistence.Migrations.Syntax.Update.Expressions;
+using NPoco;
+using Umbraco.Core.Persistence.Migrations.Syntax.Update.Expressions;
 using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Update
@@ -6,19 +7,17 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Update
     public class UpdateBuilder : IUpdateBuilder
     {
         private readonly IMigrationContext _context;
-        private readonly ISqlSyntaxProvider _sqlSyntax;
-        private readonly DatabaseProviders[] _databaseProviders;
+        private readonly DatabaseType[] _supportedDatabaseTypes;
 
-        public UpdateBuilder(IMigrationContext context, ISqlSyntaxProvider sqlSyntax, params DatabaseProviders[] databaseProviders)
+        public UpdateBuilder(IMigrationContext context, params DatabaseType[] supportedDatabaseTypes)
         {
             _context = context;
-            _sqlSyntax = sqlSyntax;
-            _databaseProviders = databaseProviders;
+            _supportedDatabaseTypes = supportedDatabaseTypes;
         }
 
         public IUpdateSetSyntax Table(string tableName)
         {
-            var expression = new UpdateDataExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { TableName = tableName };
+            var expression = new UpdateDataExpression(_context, _supportedDatabaseTypes) { TableName = tableName };
             _context.Expressions.Add(expression);
             return new UpdateDataBuilder(expression, _context);
         }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionFourNineZero/RemoveUmbracoAppConstraints.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionFourNineZero/RemoveUmbracoAppConstraints.cs
index 5444b4b46b..6584e29ea3 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionFourNineZero/RemoveUmbracoAppConstraints.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionFourNineZero/RemoveUmbracoAppConstraints.cs
@@ -9,9 +9,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionFourNineZero
     [MigrationAttribute("4.9.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class RemoveUmbracoAppConstraints : MigrationBase
     {
-        public RemoveUmbracoAppConstraints(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public RemoveUmbracoAppConstraints(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
@@ -19,7 +19,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionFourNineZero
             //This will work on mysql and should work on mssql however the old keys were not named consistently with how the keys are 
             // structured now. So we need to do a check and manually remove them based on their old aliases.
 
-            if (this.Context.CurrentDatabaseProvider == DatabaseProviders.MySql)
+            if (DatabaseType.IsMySql())
             {
                 Delete.ForeignKey().FromTable("umbracoUser2app").ForeignColumn("app").ToTable("umbracoApp").PrimaryColumn("appAlias");
                 Delete.ForeignKey().FromTable("umbracoAppTree").ForeignColumn("appAlias").ToTable("umbracoApp").PrimaryColumn("appAlias");
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AddIndexToCmsMacroPropertyTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AddIndexToCmsMacroPropertyTable.cs
index 85a23f4614..3e271d7a2e 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AddIndexToCmsMacroPropertyTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AddIndexToCmsMacroPropertyTable.cs
@@ -15,15 +15,15 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     {
         private readonly bool _skipIndexCheck;
 
-        internal AddIndexToCmsMacroPropertyTable(bool skipIndexCheck, ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
+        internal AddIndexToCmsMacroPropertyTable(bool skipIndexCheck, ILogger logger)
+            : base(logger)
         {
             _skipIndexCheck = skipIndexCheck;
         }
 
-        public AddIndexToCmsMacroPropertyTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AddIndexToCmsMacroPropertyTable(ILogger logger) 
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AddIndexToCmsMacroTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AddIndexToCmsMacroTable.cs
index d18cb430c0..465c062bad 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AddIndexToCmsMacroTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AddIndexToCmsMacroTable.cs
@@ -17,15 +17,15 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     {
         private readonly bool _forTesting;
 
-        internal AddIndexToCmsMacroTable(bool forTesting, ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
+        internal AddIndexToCmsMacroTable(bool forTesting, ILogger logger)
+            : base(logger)
         {
             _forTesting = forTesting;
         }
 
-        public AddIndexToCmsMacroTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AddIndexToCmsMacroTable(ILogger logger) 
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AddPropertyEditorAliasColumn.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AddPropertyEditorAliasColumn.cs
index c2c8a9337f..5f53442bde 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AddPropertyEditorAliasColumn.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AddPropertyEditorAliasColumn.cs
@@ -9,9 +9,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     [Migration("7.0.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class AddPropertyEditorAliasColumn : MigrationBase
     {
-        public AddPropertyEditorAliasColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AddPropertyEditorAliasColumn(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterCmsMacroPropertyTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterCmsMacroPropertyTable.cs
index 88785a57dd..abe1c71be8 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterCmsMacroPropertyTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterCmsMacroPropertyTable.cs
@@ -14,15 +14,15 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
 {
     /// <summary>
     /// We are removing the cmsMacroPropertyType which the cmsMacroProperty references and the cmsMacroProperty.macroPropertyType column
-    /// needs to be changed to editorAlias, we'll do this by removing the constraint,changing the macroPropertyType to the new 
+    /// needs to be changed to editorAlias, we'll do this by removing the constraint,changing the macroPropertyType to the new
     /// editorAlias column (and maintaing data so we can reference it)
     /// </summary>
     [Migration("7.0.0", 6, GlobalSettings.UmbracoMigrationName)]
     public class AlterCmsMacroPropertyTable : MigrationBase
     {
-        public AlterCmsMacroPropertyTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AlterCmsMacroPropertyTable(ILogger logger)
+            : base(logger)
+        { }
 
 
         public override void Up()
@@ -33,7 +33,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
             //var cpt = SqlSyntaxContext.SqlSyntaxProvider.GetConstraintsPerTable(Context.Database);
             //var di = SqlSyntaxContext.SqlSyntaxProvider.GetDefinedIndexes(Context.Database);
 
-            if (Context.CurrentDatabaseProvider != DatabaseProviders.SqlServer)
+            if (DatabaseType.IsSqlServer() == false)
             {
                 Delete.DefaultConstraint().OnTable("cmsMacroProperty").OnColumn("macroPropertyHidden");
             }
@@ -42,10 +42,10 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
                 //If we are on SQLServer, we need to delete default constraints by name, older versions of umbraco did not name these default constraints
                 // consistently so we need to look up the constraint name to delete, this only pertains to SQL Server and this issue:
                 // http://issues.umbraco.org/issue/U4-4133
-                var sqlServerSyntaxProvider = new SqlServerSyntaxProvider();
+                var sqlServerSyntaxProvider = new SqlServerSyntaxProvider(new Lazy<IDatabaseFactory>(() => null));
                 var defaultConstraints = sqlServerSyntaxProvider.GetDefaultConstraintsPerColumn(Context.Database).Distinct();
 
-                //lookup the constraint we want to delete, normally would be called "DF_cmsMacroProperty_macroPropertyHidden" but 
+                //lookup the constraint we want to delete, normally would be called "DF_cmsMacroProperty_macroPropertyHidden" but
                 // we cannot be sure with really old versions
                 var constraint = defaultConstraints
                     .SingleOrDefault(x => x.Item1 == "cmsMacroProperty" && x.Item2 == "macroPropertyHidden");
@@ -57,7 +57,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
 
             Delete.Column("macroPropertyHidden").FromTable("cmsMacroProperty");
 
-            if (Context.CurrentDatabaseProvider == DatabaseProviders.MySql)
+            if (DatabaseType.IsMySql())
             {
                 Delete.ForeignKey().FromTable("cmsMacroProperty").ForeignColumn("macroPropertyType").ToTable("cmsMacroPropertyType").PrimaryColumn("id");
             }
@@ -83,7 +83,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
             {
 
                 var alias = item.macroPropertyTypeAlias;
-                //check if there's a map created 
+                //check if there's a map created
                 var newAlias = (string)LegacyParameterEditorAliasConverter.GetNewAliasFromLegacyAlias(alias);
                 if (newAlias.IsNullOrWhiteSpace() == false)
                 {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterTagRelationsTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterTagRelationsTable.cs
index 922581ee8f..0666a28d52 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterTagRelationsTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterTagRelationsTable.cs
@@ -12,9 +12,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     [Migration("7.0.0", 8, GlobalSettings.UmbracoMigrationName)]
     public class AlterTagRelationsTable : MigrationBase
     {
-        public AlterTagRelationsTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AlterTagRelationsTable(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
@@ -36,7 +36,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
             Alter.Table("cmsTagRelationship").AddColumn("propertyTypeId").AsInt32().Nullable();
 
             //drop the foreign key on umbracoNode.  Must drop foreign key first before primary key can be removed in MySql.
-            if (Context.CurrentDatabaseProvider == DatabaseProviders.MySql)
+            if (DatabaseType.IsMySql())
             {
                 Delete.ForeignKey().FromTable("cmsTagRelationship").ForeignColumn("nodeId").ToTable("umbracoNode").PrimaryColumn("id");
                 //check for another strange really old one that might have existed
@@ -61,7 +61,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
             //we need to drop the primary key, this is sql specific since MySQL has never had primary keys on this table
             // at least since 6.0 and the new installation way but perhaps it had them way back in 4.x so we need to check
             // it exists before trying to drop it.
-            if (Context.CurrentDatabaseProvider == DatabaseProviders.MySql)
+            if (DatabaseType.IsMySql())
             {
                 //this will let us know if this pk exists on this table
                 if (constraints.Count(x => x.Item1.InvariantEquals("cmsTagRelationship") && x.Item3.InvariantEquals("PRIMARY")) > 0)
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterTagsTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterTagsTable.cs
index d832cb936d..4b543de4d6 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterTagsTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterTagsTable.cs
@@ -11,9 +11,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     [Migration("7.0.0", 9, GlobalSettings.UmbracoMigrationName)]
     public class AlterTagsTable : MigrationBase
     {
-        public AlterTagsTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AlterTagsTable(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterUserTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterUserTable.cs
index 7d8105d58c..cd438d0876 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterUserTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterUserTable.cs
@@ -8,9 +8,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     [Migration("7.0.0", 3, GlobalSettings.UmbracoMigrationName)]
     public class AlterUserTable : MigrationBase
     {
-        public AlterUserTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AlterUserTable(ILogger logger)
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AssignMissingKeysAndIndexes.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AssignMissingKeysAndIndexes.cs
index 095aeec4d7..58ff6053af 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AssignMissingKeysAndIndexes.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AssignMissingKeysAndIndexes.cs
@@ -15,9 +15,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     [Migration("7.0.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class AssignMissingKeysAndIndexes : MigrationBase
     {
-        public AssignMissingKeysAndIndexes(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AssignMissingKeysAndIndexes(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
@@ -39,8 +39,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
                 Create.Index("IX_cmsContent").OnTable("cmsContent").OnColumn("nodeId").Ascending().WithOptions().Unique();
             }
 
-            if (Context.CurrentDatabaseProvider == DatabaseProviders.SqlServer
-                || Context.CurrentDatabaseProvider == DatabaseProviders.SqlServerCE)
+            if (DatabaseType.IsSqlServerOrCe())
             {
                 var constraints = SqlSyntax.GetConstraintsPerColumn(Context.Database).Distinct().ToArray();
 
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/DropControlIdColumn.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/DropControlIdColumn.cs
index 60e8db1279..d661839af0 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/DropControlIdColumn.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/DropControlIdColumn.cs
@@ -8,9 +8,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     [Migration("7.0.0", 2, GlobalSettings.UmbracoMigrationName)]
     public class DropControlIdColumn : MigrationBase
     {
-        public DropControlIdColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public DropControlIdColumn(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/RemoveCmsMacroPropertyTypeTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/RemoveCmsMacroPropertyTypeTable.cs
index 1afc8d7d57..b40327e9c1 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/RemoveCmsMacroPropertyTypeTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/RemoveCmsMacroPropertyTypeTable.cs
@@ -8,9 +8,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     [Migration("7.0.0", 7, GlobalSettings.UmbracoMigrationName)]
     public class RemoveCmsMacroPropertyTypeTable : MigrationBase
     {
-        public RemoveCmsMacroPropertyTypeTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public RemoveCmsMacroPropertyTypeTable(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/UpdateControlIdToPropertyEditorAlias.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/UpdateControlIdToPropertyEditorAlias.cs
index 8baab98c4f..b7cb1ddb4a 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/UpdateControlIdToPropertyEditorAlias.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/UpdateControlIdToPropertyEditorAlias.cs
@@ -12,9 +12,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     [Migration("7.0.0", 1, GlobalSettings.UmbracoMigrationName)]
     public class UpdateControlIdToPropertyEditorAlias : MigrationBase
     {
-        public UpdateControlIdToPropertyEditorAlias(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public UpdateControlIdToPropertyEditorAlias(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/UpdateRelatedLinksData.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/UpdateRelatedLinksData.cs
index 121d6d7ff3..9179a8f5e6 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/UpdateRelatedLinksData.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/UpdateRelatedLinksData.cs
@@ -20,9 +20,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     [Migration("7.0.0", 10, GlobalSettings.UmbracoMigrationName)]
     public class UpdateRelatedLinksData : MigrationBase
     {
-        public UpdateRelatedLinksData(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public UpdateRelatedLinksData(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/AddDataDecimalColumn.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/AddDataDecimalColumn.cs
index 442b92d2b5..45ace41dd7 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/AddDataDecimalColumn.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/AddDataDecimalColumn.cs
@@ -8,10 +8,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZer
     [Migration("7.4.0", 1, GlobalSettings.UmbracoMigrationName)]
     public class AddDataDecimalColumn : MigrationBase
     {
-        public AddDataDecimalColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public AddDataDecimalColumn(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/AddUmbracoDeployTables.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/AddUmbracoDeployTables.cs
index a39cea2ee0..8cb0d6aa51 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/AddUmbracoDeployTables.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/AddUmbracoDeployTables.cs
@@ -8,8 +8,8 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZer
     [Migration("7.4.0", 5, GlobalSettings.UmbracoMigrationName)]
     public class AddUmbracoDeployTables : MigrationBase
     {
-        public AddUmbracoDeployTables(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
+        public AddUmbracoDeployTables(ILogger logger)
+            : base(logger)
         { }
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/AddUniqueIdPropertyTypeGroupColumn.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/AddUniqueIdPropertyTypeGroupColumn.cs
index c8ba7325a6..4e52585847 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/AddUniqueIdPropertyTypeGroupColumn.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/AddUniqueIdPropertyTypeGroupColumn.cs
@@ -13,8 +13,8 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZer
     [Migration("7.4.0", 2, GlobalSettings.UmbracoMigrationName)]
     public class AddUniqueIdPropertyTypeGroupColumn : MigrationBase
     {
-        public AddUniqueIdPropertyTypeGroupColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
+        public AddUniqueIdPropertyTypeGroupColumn(ILogger logger)
+            : base(logger)
         { }
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/EnsureContentTypeUniqueIdsAreConsistent.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/EnsureContentTypeUniqueIdsAreConsistent.cs
index c040fd7349..77cdd0c43b 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/EnsureContentTypeUniqueIdsAreConsistent.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/EnsureContentTypeUniqueIdsAreConsistent.cs
@@ -16,8 +16,8 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZer
     [Migration("7.4.0", 3, GlobalSettings.UmbracoMigrationName)]
     public class EnsureContentTypeUniqueIdsAreConsistent : MigrationBase
     {
-        public EnsureContentTypeUniqueIdsAreConsistent(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
+        public EnsureContentTypeUniqueIdsAreConsistent(ILogger logger)
+            : base(logger)
         { }
         
         public override void Up()
@@ -29,7 +29,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZer
                 Constants.ObjectTypes.MemberTypeGuid,
             };
 
-            var sql = NPoco.Sql.BuilderFor(new SqlContext(SqlSyntax, Context.Database))
+            var sql = Context.Database.Sql()
                 .Select("umbracoNode.id,cmsContentType.alias,umbracoNode.nodeObjectType")
                 .From<NodeDto>()
                 .InnerJoin<ContentTypeDto>()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/FixListViewMediaSortOrder.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/FixListViewMediaSortOrder.cs
index 323248d5d5..c903ca17d1 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/FixListViewMediaSortOrder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/FixListViewMediaSortOrder.cs
@@ -10,8 +10,8 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZer
     [Migration("7.4.0", 4, GlobalSettings.UmbracoMigrationName)]
     public class FixListViewMediaSortOrder : MigrationBase
     {
-        public FixListViewMediaSortOrder(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
+        public FixListViewMediaSortOrder(ILogger logger)
+            : base(logger)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/RemoveParentIdPropertyTypeGroupColumn.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/RemoveParentIdPropertyTypeGroupColumn.cs
index 3d285c2715..fa1079b173 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/RemoveParentIdPropertyTypeGroupColumn.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/RemoveParentIdPropertyTypeGroupColumn.cs
@@ -8,8 +8,8 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZer
     [Migration("7.4.0", 4, GlobalSettings.UmbracoMigrationName)]
     public class RemoveParentIdPropertyTypeGroupColumn : MigrationBase
     {
-        public RemoveParentIdPropertyTypeGroupColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
+        public RemoveParentIdPropertyTypeGroupColumn(ILogger logger)
+            : base(logger)
         { }
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenOneZero/AssignMissingPrimaryForMySqlKeys.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenOneZero/AssignMissingPrimaryForMySqlKeys.cs
index 1f2669921a..18b794c857 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenOneZero/AssignMissingPrimaryForMySqlKeys.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenOneZero/AssignMissingPrimaryForMySqlKeys.cs
@@ -14,14 +14,14 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenOneZero
     [Migration("7.0.0", "7.1.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class AssignMissingPrimaryForMySqlKeys : MigrationBase
     {
-        public AssignMissingPrimaryForMySqlKeys(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AssignMissingPrimaryForMySqlKeys(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
         {
-            if (Context.CurrentDatabaseProvider == DatabaseProviders.MySql)
+            if (DatabaseType.IsMySql())
             {
                 var constraints = SqlSyntax.GetConstraintsPerColumn(Context.Database).Distinct().ToArray();
 
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeOne/UpdateUserLanguagesToIsoCode.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeOne/UpdateUserLanguagesToIsoCode.cs
index 5c61c03723..3f7f33b055 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeOne/UpdateUserLanguagesToIsoCode.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeOne/UpdateUserLanguagesToIsoCode.cs
@@ -13,9 +13,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeOn
     [Migration("7.3.1", 0, GlobalSettings.UmbracoMigrationName)]
     public class UpdateUserLanguagesToIsoCode : MigrationBase
     {
-        public UpdateUserLanguagesToIsoCode(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public UpdateUserLanguagesToIsoCode(ILogger logger) 
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeTwo/EnsureMigrationsTableIdentityIsCorrect.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeTwo/EnsureMigrationsTableIdentityIsCorrect.cs
index 06a3995c36..51fb881728 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeTwo/EnsureMigrationsTableIdentityIsCorrect.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeTwo/EnsureMigrationsTableIdentityIsCorrect.cs
@@ -14,9 +14,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeTw
     [Migration("7.3.2", 0, GlobalSettings.UmbracoMigrationName)]
     public class EnsureMigrationsTableIdentityIsCorrect : MigrationBase
     {
-        public EnsureMigrationsTableIdentityIsCorrect(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public EnsureMigrationsTableIdentityIsCorrect(ILogger logger) 
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddExternalLoginsTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddExternalLoginsTable.cs
index 0fbec244b2..0fcc9e8d6f 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddExternalLoginsTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddExternalLoginsTable.cs
@@ -9,10 +9,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 9, GlobalSettings.UmbracoMigrationName)]
     public class AddExternalLoginsTable : MigrationBase
     {
-        public AddExternalLoginsTable(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public AddExternalLoginsTable(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddForeignKeysForLanguageAndDictionaryTables.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddForeignKeysForLanguageAndDictionaryTables.cs
index 7bc94cdaba..6816245169 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddForeignKeysForLanguageAndDictionaryTables.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddForeignKeysForLanguageAndDictionaryTables.cs
@@ -13,10 +13,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 14, GlobalSettings.UmbracoMigrationName)]
     public class AddForeignKeysForLanguageAndDictionaryTables : MigrationBase
     {
-        public AddForeignKeysForLanguageAndDictionaryTables(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public AddForeignKeysForLanguageAndDictionaryTables(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddMigrationTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddMigrationTable.cs
index 079dbe1465..9cb15ce56d 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddMigrationTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddMigrationTable.cs
@@ -9,10 +9,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 11, GlobalSettings.UmbracoMigrationName)]
     public class AddMigrationTable : MigrationBase
     {
-        public AddMigrationTable(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public AddMigrationTable(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddPublicAccessTables.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddPublicAccessTables.cs
index 16c0a923ae..bbc2a74eec 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddPublicAccessTables.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddPublicAccessTables.cs
@@ -9,10 +9,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 6, GlobalSettings.UmbracoMigrationName)]
     public class AddPublicAccessTables : MigrationBase
     {
-        public AddPublicAccessTables(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public AddPublicAccessTables(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddRelationTypeForDocumentOnDelete.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddRelationTypeForDocumentOnDelete.cs
index c9db282d85..df37404f34 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddRelationTypeForDocumentOnDelete.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddRelationTypeForDocumentOnDelete.cs
@@ -9,10 +9,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class AddRelationTypeForDocumentOnDelete : MigrationBase
     {
-        public AddRelationTypeForDocumentOnDelete(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public AddRelationTypeForDocumentOnDelete(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddServerRegistrationColumnsAndLock.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddServerRegistrationColumnsAndLock.cs
index 118dc1fc06..d605151249 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddServerRegistrationColumnsAndLock.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddServerRegistrationColumnsAndLock.cs
@@ -10,8 +10,8 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 17, GlobalSettings.UmbracoMigrationName)]
     public class AddServerRegistrationColumnsAndLock : MigrationBase
     {
-        public AddServerRegistrationColumnsAndLock(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
+        public AddServerRegistrationColumnsAndLock(ILogger logger)
+            : base(logger)
         { }
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddUniqueIdPropertyTypeColumn.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddUniqueIdPropertyTypeColumn.cs
index 7589c7000d..f40bfbe0d0 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddUniqueIdPropertyTypeColumn.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddUniqueIdPropertyTypeColumn.cs
@@ -9,8 +9,8 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 13, GlobalSettings.UmbracoMigrationName)]
     public class AddUniqueIdPropertyTypeColumn : MigrationBase
     {
-        public AddUniqueIdPropertyTypeColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
+        public AddUniqueIdPropertyTypeColumn(ILogger logger)
+            : base(logger)
         { }
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddUserColumns.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddUserColumns.cs
index 46fde95005..c0d60254e1 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddUserColumns.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddUserColumns.cs
@@ -8,10 +8,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 10, GlobalSettings.UmbracoMigrationName)]
     public class AddUserColumns : MigrationBase
     {
-        public AddUserColumns(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public AddUserColumns(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/CleanUpCorruptedPublishedFlags.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/CleanUpCorruptedPublishedFlags.cs
index d62ad7645d..3926d03a9b 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/CleanUpCorruptedPublishedFlags.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/CleanUpCorruptedPublishedFlags.cs
@@ -14,15 +14,14 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 18, GlobalSettings.UmbracoMigrationName)]
     public class CleanUpCorruptedPublishedFlags : MigrationBase
     {
-        public CleanUpCorruptedPublishedFlags(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
-        
+        public CleanUpCorruptedPublishedFlags(ILogger logger)
+            : base(logger)
+        { }
+
         public override void Up()
         {
             //Get all cmsDocument items that have more than one published date set
-            var sql = @"SELECT * FROM cmsDocument WHERE nodeId IN 
+            var sql = @"SELECT * FROM cmsDocument WHERE nodeId IN
 (SELECT nodeId
 FROM cmsDocument
 GROUP BY nodeId
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/CreateCacheInstructionTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/CreateCacheInstructionTable.cs
index afa5a1e675..b3aa932ec3 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/CreateCacheInstructionTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/CreateCacheInstructionTable.cs
@@ -13,10 +13,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 1, GlobalSettings.UmbracoMigrationName)]
     public class CreateCacheInstructionTable : MigrationBase
     {
-        public CreateCacheInstructionTable(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public CreateCacheInstructionTable(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MigrateAndRemoveTemplateMasterColumn.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MigrateAndRemoveTemplateMasterColumn.cs
index c5ca312123..2aa9671791 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MigrateAndRemoveTemplateMasterColumn.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MigrateAndRemoveTemplateMasterColumn.cs
@@ -16,10 +16,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     public class MigrateAndRemoveTemplateMasterColumn : MigrationBase
     {
 
-        public MigrateAndRemoveTemplateMasterColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public MigrateAndRemoveTemplateMasterColumn(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
@@ -99,7 +98,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
             
 
             //now remove the master column and key
-            if (this.Context.CurrentDatabaseProvider == DatabaseProviders.MySql)
+            if (DatabaseType.IsMySql())
             {
                 //Because MySQL doesn't name keys with what you want, we need to query for the one that is associated
                 // this is required for this specific case because there are 2 foreign keys on the cmsTemplate table
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MigrateStylesheetDataToFile.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MigrateStylesheetDataToFile.cs
index 35e4befc55..23bc5fb0d4 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MigrateStylesheetDataToFile.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MigrateStylesheetDataToFile.cs
@@ -23,10 +23,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 2, GlobalSettings.UmbracoMigrationName)]
     public class MigrateStylesheetDataToFile : MigrationBase
     {
-        public MigrateStylesheetDataToFile(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public MigrateStylesheetDataToFile(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MovePublicAccessXmlDataToDb.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MovePublicAccessXmlDataToDb.cs
index 19d44ba3f9..05c8d10c05 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MovePublicAccessXmlDataToDb.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MovePublicAccessXmlDataToDb.cs
@@ -14,10 +14,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 7, GlobalSettings.UmbracoMigrationName)]
     public class MovePublicAccessXmlDataToDb : MigrationBase
     {
-        public MovePublicAccessXmlDataToDb(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public MovePublicAccessXmlDataToDb(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveHelpTextColumn.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveHelpTextColumn.cs
index d4911bd65a..6bffcc26c7 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveHelpTextColumn.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveHelpTextColumn.cs
@@ -8,10 +8,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 8, GlobalSettings.UmbracoMigrationName)]
     public class RemoveHelpTextColumn : MigrationBase
     {
-        public RemoveHelpTextColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public RemoveHelpTextColumn(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveLanguageLocaleColumn.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveLanguageLocaleColumn.cs
index a793cc6bbc..2acc354c23 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveLanguageLocaleColumn.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveLanguageLocaleColumn.cs
@@ -8,10 +8,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 4, GlobalSettings.UmbracoMigrationName)]
     public class RemoveLanguageLocaleColumn : MigrationBase
     {
-        public RemoveLanguageLocaleColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public RemoveLanguageLocaleColumn(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveStylesheetDataAndTables.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveStylesheetDataAndTables.cs
index da6d1b957d..0a9a0b9c9c 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveStylesheetDataAndTables.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveStylesheetDataAndTables.cs
@@ -9,10 +9,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 3, GlobalSettings.UmbracoMigrationName)]
     public class RemoveStylesheetDataAndTables : MigrationBase
     {
-        public RemoveStylesheetDataAndTables(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public RemoveStylesheetDataAndTables(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveUmbracoLoginsTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveUmbracoLoginsTable.cs
index b842ec041a..438be514b2 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveUmbracoLoginsTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveUmbracoLoginsTable.cs
@@ -8,10 +8,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 15, GlobalSettings.UmbracoMigrationName)]
     public class RemoveUmbracoLoginsTable : MigrationBase
     {
-        public RemoveUmbracoLoginsTable(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public RemoveUmbracoLoginsTable(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/UpdateUniqueIdToHaveCorrectIndexType.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/UpdateUniqueIdToHaveCorrectIndexType.cs
index 20e78ab1a2..9267c12cf5 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/UpdateUniqueIdToHaveCorrectIndexType.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/UpdateUniqueIdToHaveCorrectIndexType.cs
@@ -11,10 +11,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
     [Migration("7.3.0", 5, GlobalSettings.UmbracoMigrationName)]
     public class UpdateUniqueIdToHaveCorrectIndexType : MigrationBase
     {
-        public UpdateUniqueIdToHaveCorrectIndexType(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public UpdateUniqueIdToHaveCorrectIndexType(ILogger logger)
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/AddIndexToUmbracoNodeTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/AddIndexToUmbracoNodeTable.cs
index ec22dad34b..923d3e4bda 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/AddIndexToUmbracoNodeTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/AddIndexToUmbracoNodeTable.cs
@@ -11,14 +11,15 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenTwoZero
     {
         private readonly bool _skipIndexCheck;
 
-        internal AddIndexToUmbracoNodeTable(ISqlSyntaxProvider sqlSyntax, ILogger logger, bool skipIndexCheck) : base(sqlSyntax, logger)
+        internal AddIndexToUmbracoNodeTable(ILogger logger, bool skipIndexCheck) 
+            : base(logger)
         {
             _skipIndexCheck = skipIndexCheck;
         }
 
-        public AddIndexToUmbracoNodeTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AddIndexToUmbracoNodeTable(ILogger logger) 
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/AddMissingForeignKeyForContentType.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/AddMissingForeignKeyForContentType.cs
index 615c39a7e0..b9eff9df5e 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/AddMissingForeignKeyForContentType.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/AddMissingForeignKeyForContentType.cs
@@ -11,10 +11,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenTwoZero
     [Migration("7.2.0", 1, GlobalSettings.UmbracoMigrationName)]
     public class AddMissingForeignKeyForContentType : MigrationBase
     {
-        public AddMissingForeignKeyForContentType(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
-
+        public AddMissingForeignKeyForContentType(ILogger logger) 
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/AlterDataTypePreValueTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/AlterDataTypePreValueTable.cs
index b3d5476358..29be1b3aeb 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/AlterDataTypePreValueTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/AlterDataTypePreValueTable.cs
@@ -12,9 +12,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenTwoZero
     [Migration("7.2.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class AlterDataTypePreValueTable : MigrationBase
     {
-        public AlterDataTypePreValueTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AlterDataTypePreValueTable(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/RemoveCmsDocumentAliasColumn.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/RemoveCmsDocumentAliasColumn.cs
index f8b470f255..55f57801ae 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/RemoveCmsDocumentAliasColumn.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenTwoZero/RemoveCmsDocumentAliasColumn.cs
@@ -8,10 +8,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenTwoZero
     [Migration("7.2.0", 2, GlobalSettings.UmbracoMigrationName)]
     public class RemoveCmsDocumentAliasColumn : MigrationBase
     {
-        public RemoveCmsDocumentAliasColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
-
+        public RemoveCmsDocumentAliasColumn(ILogger logger) 
+            : base(logger)
+        { }
 
         public override void Up()
         {
@@ -24,7 +23,6 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenTwoZero
         }
 
         public override void Down()
-        {
-        }
+        { }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/DeleteAppTables.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/DeleteAppTables.cs
index 823bc35c4a..7344e75b9c 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/DeleteAppTables.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/DeleteAppTables.cs
@@ -9,9 +9,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSix
     [Migration("6.0.0", 10, GlobalSettings.UmbracoMigrationName)]
     public class DeleteAppTables : MigrationBase
     {
-        public DeleteAppTables(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public DeleteAppTables(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/EnsureAppsTreesUpdated.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/EnsureAppsTreesUpdated.cs
index ae25df120c..d06402c87c 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/EnsureAppsTreesUpdated.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/EnsureAppsTreesUpdated.cs
@@ -8,9 +8,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSix
     [Migration("6.0.0", 9, GlobalSettings.UmbracoMigrationName)]
     public class EnsureAppsTreesUpdated : MigrationBase
     {
-        public EnsureAppsTreesUpdated(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public EnsureAppsTreesUpdated(ILogger logger)
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/MoveMasterContentTypeData.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/MoveMasterContentTypeData.cs
index bbfe049cdf..e4afc7be31 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/MoveMasterContentTypeData.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/MoveMasterContentTypeData.cs
@@ -7,9 +7,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSix
     [Migration("6.0.0", 5, GlobalSettings.UmbracoMigrationName)]
     public class MoveMasterContentTypeData : MigrationBase
     {
-        public MoveMasterContentTypeData(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public MoveMasterContentTypeData(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/NewCmsContentType2ContentTypeTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/NewCmsContentType2ContentTypeTable.cs
index f355dcee44..9bcff9464f 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/NewCmsContentType2ContentTypeTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/NewCmsContentType2ContentTypeTable.cs
@@ -7,9 +7,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSix
     [Migration("6.0.0", 4, GlobalSettings.UmbracoMigrationName)]
     public class NewCmsContentType2ContentTypeTable : MigrationBase
     {
-        public NewCmsContentType2ContentTypeTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public NewCmsContentType2ContentTypeTable(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/RemoveMasterContentTypeColumn.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/RemoveMasterContentTypeColumn.cs
index 30c908ff16..ab423a8e34 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/RemoveMasterContentTypeColumn.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/RemoveMasterContentTypeColumn.cs
@@ -1,4 +1,5 @@
-using Umbraco.Core.Configuration;
+using NPoco;
+using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence.SqlSyntax;
 
@@ -7,15 +8,14 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSix
     [Migration("6.0.0", 6, GlobalSettings.UmbracoMigrationName)]
     public class RemoveMasterContentTypeColumn : MigrationBase
     {
-        public RemoveMasterContentTypeColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
-
+        public RemoveMasterContentTypeColumn(ILogger logger) 
+            : base(logger)
+        { }
 
         public override void Up()
         {
             //NOTE Don't think we can remove this column yet as it seems to be used by some starterkits
-            IfDatabase(DatabaseProviders.SqlAzure, DatabaseProviders.SqlServer, DatabaseProviders.SqlServerCE)
+            IfDatabase(DatabaseType.SQLCe, DatabaseType.SqlServer2005)
                 .Delete.DefaultConstraint().OnTable("cmsContentType").OnColumn("masterContentType");
 
             Delete.Column("masterContentType").FromTable("cmsContentType");
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/RenameCmsTabTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/RenameCmsTabTable.cs
index f66ec30b8d..abba5a7540 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/RenameCmsTabTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/RenameCmsTabTable.cs
@@ -7,9 +7,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSix
     [Migration("6.0.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class RenameCmsTabTable : MigrationBase
     {
-        public RenameCmsTabTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public RenameCmsTabTable(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/RenameTabIdColumn.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/RenameTabIdColumn.cs
index 791d40c08b..ba108035d6 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/RenameTabIdColumn.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/RenameTabIdColumn.cs
@@ -1,4 +1,5 @@
 using System.Data;
+using NPoco;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence.SqlSyntax;
@@ -8,74 +9,73 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSix
     [Migration("6.0.0", 7, GlobalSettings.UmbracoMigrationName)]
     public class RenameTabIdColumn : MigrationBase
     {
-        public RenameTabIdColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
-
+        public RenameTabIdColumn(ILogger logger) 
+            : base(logger)
+        { }
 
         public override void Up()
         {
             //Conditional Create-column for Sql Ce databases
-            IfDatabase(DatabaseProviders.SqlServerCE)
+            IfDatabase(DatabaseType.SQLCe)
                 .Create.Column("propertyTypeGroupId").OnTable("cmsPropertyType").AsInt16().Nullable();
 
             //Conditional Create-foreign for Sql Ce databases
-            IfDatabase(DatabaseProviders.SqlServerCE)
+            IfDatabase(DatabaseType.SQLCe)
                 .Create.ForeignKey("FK_cmsPropertyType_cmsPropertyTypeGroup")
                 .FromTable("cmsPropertyType").ForeignColumn("propertyTypeGroupId")
                 .ToTable("cmsPropertyTypeGroup").PrimaryColumn("id").OnDeleteOrUpdate(Rule.None);
 
             //Conditional Delete-foreignkey for MySql databases
-            IfDatabase(DatabaseProviders.MySql)
+            IfDatabase(DatabaseType.MySQL)
                 .Delete.ForeignKey().FromTable("cmsPropertyType").ForeignColumn("tabId").ToTable("cmsPropertyTypeGroup").PrimaryColumn("id");
 
             Rename.Column("tabId").OnTable("cmsPropertyType").To("propertyTypeGroupId");
 
             //Conditional Create-foreign for MySql databases
-            IfDatabase(DatabaseProviders.MySql)
+            IfDatabase(DatabaseType.MySQL)
                 .Create.ForeignKey("FK_cmsPropertyType_cmsPropertyTypeGroup")
                 .FromTable("cmsPropertyType").ForeignColumn("propertyTypeGroupId")
                 .ToTable("cmsPropertyTypeGroup").PrimaryColumn("id").OnDeleteOrUpdate(Rule.None);
 
             //Conditional Delete-foreignkey for Sql Ce databases
-            IfDatabase(DatabaseProviders.SqlServerCE)
+            IfDatabase(DatabaseType.SQLCe)
                 .Delete.ForeignKey("FK_cmsPropertyType_cmsTab").OnTable("cmsPropertyType");
 
             //Conditional Delete-column for Sql Ce databases
-            IfDatabase(DatabaseProviders.SqlServerCE)
+            IfDatabase(DatabaseType.SQLCe)
                 .Delete.Column("tabId").FromTable("cmsPropertyType");
         }
 
         public override void Down()
         {
             //Conditional Create-column for Sql Ce databases
-            IfDatabase(DatabaseProviders.SqlServerCE)
+            IfDatabase(DatabaseType.SQLCe)
                 .Create.Column("tabId").OnTable("cmsPropertyType").AsInt16().Nullable();
 
             //Conditional Create-foreign for Sql Ce databases
-            IfDatabase(DatabaseProviders.SqlServerCE)
+            IfDatabase(DatabaseType.SQLCe)
                 .Create.ForeignKey("FK_cmsPropertyType_cmsTab")
                 .FromTable("cmsPropertyType").ForeignColumn("tabId")
                 .ToTable("cmsTab").PrimaryColumn("id").OnDeleteOrUpdate(Rule.None);
 
             //Conditional Delete-foreignkey for MySql databases
-            IfDatabase(DatabaseProviders.MySql)
+            IfDatabase(DatabaseType.MySQL)
                 .Delete.ForeignKey().FromTable("cmsPropertyType").ForeignColumn("propertyTypeGroupId").ToTable("cmsPropertyTypeGroup").PrimaryColumn("id");
 
             Rename.Column("propertyTypeGroupId").OnTable("cmsPropertyType").To("tabId");
 
             //Conditional Create-foreign for MySql databases
-            IfDatabase(DatabaseProviders.MySql)
+            IfDatabase(DatabaseType.MySQL)
                 .Create.ForeignKey("FK_cmsPropertyType_cmsPropertyTypeGroup")
                 .FromTable("cmsPropertyType").ForeignColumn("tabId")
                 .ToTable("cmsPropertyTypeGroup").PrimaryColumn("id").OnDeleteOrUpdate(Rule.None);
 
             //Conditional Delete-foreignkey for Sql Ce databases
-            IfDatabase(DatabaseProviders.SqlServerCE)
+            IfDatabase(DatabaseType.SQLCe)
                 .Delete.ForeignKey("FK_cmsPropertyType_cmsPropertyTypeGroup").OnTable("cmsPropertyType");
 
             //Conditional Delete-column for Sql Ce databases
-            IfDatabase(DatabaseProviders.SqlServerCE)
+            IfDatabase(DatabaseType.SQLCe)
                 .Delete.Column("propertyTypeGroupId").FromTable("propertyTypeGroupId");
         }
     }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsContentTypeAllowedContentTypeTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsContentTypeAllowedContentTypeTable.cs
index aadba31130..3afd8234bc 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsContentTypeAllowedContentTypeTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsContentTypeAllowedContentTypeTable.cs
@@ -7,9 +7,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSix
     [Migration("6.0.0", 3, GlobalSettings.UmbracoMigrationName)]
     public class UpdateCmsContentTypeAllowedContentTypeTable : MigrationBase
     {
-        public UpdateCmsContentTypeAllowedContentTypeTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public UpdateCmsContentTypeAllowedContentTypeTable(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsContentTypeTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsContentTypeTable.cs
index 75c261bc81..4ecc7dd64c 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsContentTypeTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsContentTypeTable.cs
@@ -9,9 +9,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSix
     [Migration("6.0.0", 2, GlobalSettings.UmbracoMigrationName)]
     public class UpdateCmsContentTypeTable : MigrationBase
     {
-        public UpdateCmsContentTypeTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public UpdateCmsContentTypeTable(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsContentVersionTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsContentVersionTable.cs
index eb14ac526c..956b8c13e8 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsContentVersionTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsContentVersionTable.cs
@@ -7,9 +7,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSix
     [Migration("6.0.0", 8, GlobalSettings.UmbracoMigrationName)]
     public class UpdateCmsContentVersionTable : MigrationBase
     {
-        public UpdateCmsContentVersionTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public UpdateCmsContentVersionTable(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsPropertyTypeGroupTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsPropertyTypeGroupTable.cs
index 4eaca1ad20..41f542993b 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsPropertyTypeGroupTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSix/UpdateCmsPropertyTypeGroupTable.cs
@@ -8,9 +8,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSix
     [Migration("6.0.0", 1, GlobalSettings.UmbracoMigrationName)]
     public class UpdateCmsPropertyTypeGroupTable : MigrationBase
     {
-        public UpdateCmsPropertyTypeGroupTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public UpdateCmsPropertyTypeGroupTable(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixOneZero/CreateServerRegistryTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixOneZero/CreateServerRegistryTable.cs
index f6a4464c78..27011d6ce4 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixOneZero/CreateServerRegistryTable.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixOneZero/CreateServerRegistryTable.cs
@@ -13,14 +13,14 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixOneZero
     [Migration("6.1.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class CreateServerRegistryTable : MigrationBase
     {
-        public CreateServerRegistryTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public CreateServerRegistryTable(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
         {
-            var schemaHelper = new DatabaseSchemaHelper(Context.Database, Logger, SqlSyntax);
+            var schemaHelper = new DatabaseSchemaHelper(Context.Database, Logger);
 
             //NOTE: This isn't the correct way to do this but to manually create this table with the Create syntax is a pain in the arse
             schemaHelper.CreateTable<ServerRegistrationDto>();
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AddChangeDocumentTypePermission.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AddChangeDocumentTypePermission.cs
index 3b82a02c47..a445585c03 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AddChangeDocumentTypePermission.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AddChangeDocumentTypePermission.cs
@@ -11,9 +11,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixTwoZero
     [Migration("6.2.0", 3, GlobalSettings.UmbracoMigrationName)]
     public class AddChangeDocumentTypePermission : MigrationBase
     {
-        public AddChangeDocumentTypePermission(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AddChangeDocumentTypePermission(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AdditionalIndexesAndKeys.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AdditionalIndexesAndKeys.cs
index e0c462b966..d566bdd5c8 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AdditionalIndexesAndKeys.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AdditionalIndexesAndKeys.cs
@@ -12,9 +12,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixTwoZero
     [Migration("6.2.0", 1, GlobalSettings.UmbracoMigrationName)]
     public class AdditionalIndexesAndKeys : MigrationBase
     {
-        public AdditionalIndexesAndKeys(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AdditionalIndexesAndKeys(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
@@ -48,43 +48,34 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixTwoZero
                 Create.Index("IX_cmsDocument_newest").OnTable("cmsDocument").OnColumn("newest").Ascending().WithOptions().NonClustered();
             }
 
-            //We need to do this for SQL Azure V2 since it does not let you drop any clustered indexes
-            // Issue: http://issues.umbraco.org/issue/U4-5673            
-            if (Context.CurrentDatabaseProvider == DatabaseProviders.SqlServer || Context.CurrentDatabaseProvider == DatabaseProviders.SqlAzure)
+            // drop the umbracoUserLogins_Index index since it is named incorrectly
+            // and then re-create it so it follows the standard naming convention
+            var sqlServerSyntax = SqlSyntax as SqlServerSyntaxProvider;
+            if (sqlServerSyntax != null // if running sql server
+                && sqlServerSyntax.ServerVersion.IsAzure // on Azure
+                && sqlServerSyntax.ServerVersion.ProductVersion.StartsWith("11.")) // version 11.x
             {
-                var version = Context.Database.ExecuteScalar<string>("SELECT @@@@VERSION");
-                if (version.Contains("Microsoft SQL Azure"))
+                // SQL Azure v2 does not support dropping clustered indexes on a table
+                // see http://issues.umbraco.org/issue/U4-5673            
+                // and so we have to use a special method to do some manual work
+                if (dbIndexes.Any(x => x.IndexName.InvariantEquals("umbracoUserLogins_Index")))
                 {
-                    var parts = version.Split(new[] { '-' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim()).ToArray();
-                    if (parts.Length > 1)
-                    {
-                        if (parts[1].StartsWith("11."))
-                        {
-
-                            //we want to drop the umbracoUserLogins_Index index since it is named incorrectly and then re-create it so 
-                            // it follows the standard naming convention
-                            if (dbIndexes.Any(x => x.IndexName.InvariantEquals("umbracoUserLogins_Index")))
-                            {
-                                //It's the old version that doesn't support dropping a clustered index on a table, so we need to do some manual work.
-                                ExecuteSqlAzureSqlForChangingIndex();
-                            }
-
-                            return;
-                        }
-                    }   
-                }                
+                    //It's the old version that doesn't support dropping a clustered index on a table, so we need to do some manual work.
+                    ExecuteSqlAzureSqlForChangingIndex();
+                }
             }
-           
+            else
+            {
+                // any other db can delete and recreate
 
-            //we want to drop the umbracoUserLogins_Index index since it is named incorrectly and then re-create it so 
-            // it follows the standard naming convention
-            if (dbIndexes.Any(x => x.IndexName.InvariantEquals("umbracoUserLogins_Index")))
-            {
-                Delete.Index("umbracoUserLogins_Index").OnTable("umbracoUserLogins");
-            }
-            if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_umbracoUserLogins_Index")) == false)
-            {
-                Create.Index("IX_umbracoUserLogins_Index").OnTable("umbracoUserLogins").OnColumn("contextID").Ascending().WithOptions().Clustered();
+                if (dbIndexes.Any(x => x.IndexName.InvariantEquals("umbracoUserLogins_Index")))
+                {
+                    Delete.Index("umbracoUserLogins_Index").OnTable("umbracoUserLogins");
+                }
+                if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_umbracoUserLogins_Index")) == false)
+                {
+                    Create.Index("IX_umbracoUserLogins_Index").OnTable("umbracoUserLogins").OnColumn("contextID").Ascending().WithOptions().Clustered();
+                }
             }
         }
 
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AssignMissingPrimaryForMySqlKeys.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AssignMissingPrimaryForMySqlKeys.cs
index df1669f8ef..614be4d3cc 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AssignMissingPrimaryForMySqlKeys.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AssignMissingPrimaryForMySqlKeys.cs
@@ -12,14 +12,14 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixTwoZero
     [Migration("6.2.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class AssignMissingPrimaryForMySqlKeys : MigrationBase
     {
-        public AssignMissingPrimaryForMySqlKeys(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AssignMissingPrimaryForMySqlKeys(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
         {
-            if (Context.CurrentDatabaseProvider == DatabaseProviders.MySql)
+            if (DatabaseType.IsMySql())
             {
                 var constraints = SqlSyntax.GetConstraintsPerColumn(Context.Database).Distinct().ToArray();
 
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AssignMissingPrimaryForMySqlKeys2.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AssignMissingPrimaryForMySqlKeys2.cs
index fe6db6ab76..42b59d1326 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AssignMissingPrimaryForMySqlKeys2.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AssignMissingPrimaryForMySqlKeys2.cs
@@ -11,14 +11,14 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixTwoZero
     [Migration("6.0.0", "6.2.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class AssignMissingPrimaryForMySqlKeys2 : MigrationBase
     {
-        public AssignMissingPrimaryForMySqlKeys2(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AssignMissingPrimaryForMySqlKeys2(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
         {
-            if (Context.CurrentDatabaseProvider == DatabaseProviders.MySql)
+            if (DatabaseType.IsMySql())
             {
                 var constraints = SqlSyntax.GetConstraintsPerColumn(Context.Database).Distinct().ToArray();
 
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/ChangePasswordColumn.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/ChangePasswordColumn.cs
index 26c5a81dea..b32250dee5 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/ChangePasswordColumn.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/ChangePasswordColumn.cs
@@ -9,9 +9,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixTwoZero
     [Migration("6.2.0", 2, GlobalSettings.UmbracoMigrationName)]
     public class ChangePasswordColumn : MigrationBase
     {
-        public ChangePasswordColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public ChangePasswordColumn(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/UpdateToNewMemberPropertyAliases.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/UpdateToNewMemberPropertyAliases.cs
index 311672f237..30bd923fca 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/UpdateToNewMemberPropertyAliases.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/UpdateToNewMemberPropertyAliases.cs
@@ -12,10 +12,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixTwoZero
     [Migration("6.2.0", 4, GlobalSettings.UmbracoMigrationName)]
     public class UpdateToNewMemberPropertyAliases : MigrationBase
     {
-        public UpdateToNewMemberPropertyAliases(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
-
+        public UpdateToNewMemberPropertyAliases(ILogger logger) 
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixZeroOne/UpdatePropertyTypesAndGroups.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixZeroOne/UpdatePropertyTypesAndGroups.cs
index b96aedaca2..d9f1c6cdc2 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixZeroOne/UpdatePropertyTypesAndGroups.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixZeroOne/UpdatePropertyTypesAndGroups.cs
@@ -11,9 +11,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixZeroOne
     [Migration("6.0.2", 0, GlobalSettings.UmbracoMigrationName)]
     public class UpdatePropertyTypesAndGroups : MigrationBase
     {
-        public UpdatePropertyTypesAndGroups(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public UpdatePropertyTypesAndGroups(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Core/Persistence/NPocoDatabaseExtensions.cs b/src/Umbraco.Core/Persistence/NPocoDatabaseExtensions.cs
index b7e3407176..5057912c45 100644
--- a/src/Umbraco.Core/Persistence/NPocoDatabaseExtensions.cs
+++ b/src/Umbraco.Core/Persistence/NPocoDatabaseExtensions.cs
@@ -69,7 +69,7 @@ namespace Umbraco.Core.Persistence
         /// <para>Note that with proper transactions, if T2 begins after T1 then we are sure that the database will contain T2's value
         /// once T1 and T2 have completed. Whereas here, it could contain T1's value.</para>
         /// </remarks>
-        internal static RecordPersistenceType InsertOrUpdate<T>(this Database db, T poco)
+        internal static RecordPersistenceType InsertOrUpdate<T>(this IDatabase db, T poco)
             where T : class
         {
             return db.InsertOrUpdate(poco, null, null);
@@ -92,7 +92,7 @@ namespace Umbraco.Core.Persistence
         /// <para>Note that with proper transactions, if T2 begins after T1 then we are sure that the database will contain T2's value
         /// once T1 and T2 have completed. Whereas here, it could contain T1's value.</para>
         /// </remarks>
-        internal static RecordPersistenceType InsertOrUpdate<T>(this Database db,
+        internal static RecordPersistenceType InsertOrUpdate<T>(this IDatabase db,
             T poco,
             string updateCommand,
             object updateArgs)
@@ -160,7 +160,7 @@ namespace Umbraco.Core.Persistence
 
         // fixme - NPoco has BulkInsert now?
 
-        public static void BulkInsertRecords<T>(this Database db, ISqlSyntaxProvider sqlSyntax, IEnumerable<T> collection)
+        public static void BulkInsertRecords<T>(this IDatabase db, ISqlSyntaxProvider sqlSyntax, IEnumerable<T> collection)
         {
             //don't do anything if there are no records.
             if (collection.Any() == false)
@@ -182,7 +182,7 @@ namespace Umbraco.Core.Persistence
         /// <param name="collection"></param>
         /// <param name="tr"></param>
         /// <param name="commitTrans"></param>
-        public static void BulkInsertRecords<T>(this Database db, ISqlSyntaxProvider sqlSyntax, IEnumerable<T> collection, ITransaction tr, bool commitTrans = false)
+        public static void BulkInsertRecords<T>(this IDatabase db, ISqlSyntaxProvider sqlSyntax, IEnumerable<T> collection, ITransaction tr, bool commitTrans = false)
         {
             //don't do anything if there are no records.
             if (collection.Any() == false)
@@ -192,7 +192,7 @@ namespace Umbraco.Core.Persistence
             {
                 //if it is sql ce or it is a sql server version less than 2008, we need to do individual inserts.
                 var sqlServerSyntax = sqlSyntax as SqlServerSyntaxProvider;
-                if ((sqlServerSyntax != null && (int)sqlServerSyntax.VersionName.Value < (int)SqlServerVersionName.V2008)
+                if ((sqlServerSyntax != null && (int) sqlServerSyntax.ServerVersion.ProductVersionName < (int) SqlServerSyntaxProvider.VersionName.V2008)
                     || sqlSyntax is SqlCeSyntaxProvider)
                 {
                     //SqlCe doesn't support bulk insert statements!
@@ -247,7 +247,7 @@ namespace Umbraco.Core.Persistence
         /// that is max. I've reduced it to 2000 anyways.
         /// </remarks>
         internal static IDbCommand[] GenerateBulkInsertCommand<T>(
-            this Database db,
+            this IDatabase db,
             IEnumerable<T> collection,
             DbConnection connection,
             out string[] sql)
@@ -320,7 +320,7 @@ namespace Umbraco.Core.Persistence
             return commands.ToArray();
         }
 
-        public static void TruncateTable(this Database db, ISqlSyntaxProvider sqlSyntax, string tableName)
+        public static void TruncateTable(this IDatabase db, ISqlSyntaxProvider sqlSyntax, string tableName)
         {
             var sql = new Sql(string.Format(
                 sqlSyntax.TruncateTable,
@@ -328,10 +328,16 @@ namespace Umbraco.Core.Persistence
             db.Execute(sql);
         }
 
-        public static IsolationLevel GetCurrentTransactionIsolationLevel(this Database database)
+        public static IsolationLevel GetCurrentTransactionIsolationLevel(this IDatabase database)
         {
             var transaction = database.Transaction;
             return transaction == null ? IsolationLevel.Unspecified : transaction.IsolationLevel;
         }
+
+        public static IEnumerable<TResult> FetchByGroups<TResult, TSource>(this IDatabase db, IEnumerable<TSource> source, int groupSize, Func<IEnumerable<TSource>, Sql<SqlContext>> sqlFactory)
+        {
+            return source.SelectByGroups(x => db.Fetch<TResult>(sqlFactory(x)), groupSize);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/NPocoDatabaseTypeExtensions.cs b/src/Umbraco.Core/Persistence/NPocoDatabaseTypeExtensions.cs
new file mode 100644
index 0000000000..b089110193
--- /dev/null
+++ b/src/Umbraco.Core/Persistence/NPocoDatabaseTypeExtensions.cs
@@ -0,0 +1,30 @@
+using NPoco;
+
+namespace Umbraco.Core.Persistence
+{
+    internal static class NPocoDatabaseTypeExtensions
+    {
+        public static bool IsMySql(this DatabaseType databaseType)
+        {
+            return databaseType is NPoco.DatabaseTypes.MySqlDatabaseType;
+        }
+
+        public static bool IsSqlServer(this DatabaseType databaseType)
+        {
+            // note that because SqlServerDatabaseType is the base class for
+            // all Sql Server types eg SqlServer2012DatabaseType, this will
+            // test *any* version of Sql Server.
+            return databaseType is NPoco.DatabaseTypes.SqlServerDatabaseType;
+        }
+
+        public static bool IsSqlCe(this DatabaseType databaseType)
+        {
+            return databaseType is NPoco.DatabaseTypes.SqlServerCEDatabaseType;
+        }
+
+        public static bool IsSqlServerOrCe(this DatabaseType databaseType)
+        {
+            return databaseType.IsSqlServer() || databaseType.IsSqlCe();
+        }
+    }
+}
diff --git a/src/Umbraco.Core/Persistence/UmbracoSqlExtensions.cs b/src/Umbraco.Core/Persistence/NPocoSqlExtensions.cs
similarity index 99%
rename from src/Umbraco.Core/Persistence/UmbracoSqlExtensions.cs
rename to src/Umbraco.Core/Persistence/NPocoSqlExtensions.cs
index 6bb571fe6e..66f2f3da8d 100644
--- a/src/Umbraco.Core/Persistence/UmbracoSqlExtensions.cs
+++ b/src/Umbraco.Core/Persistence/NPocoSqlExtensions.cs
@@ -8,7 +8,7 @@ using Umbraco.Core.Persistence.Querying;
 
 namespace Umbraco.Core.Persistence
 {
-    public static class UmbracoSqlExtensions
+    public static class NPocoSqlExtensions
     {
         // note: here we take benefit from the fact that NPoco methods that return a Sql, such as
         // when doing "sql = sql.Where(...)" actually append to, and return, the original Sql, not
diff --git a/src/Umbraco.Core/Persistence/Repositories/AuditRepository.cs b/src/Umbraco.Core/Persistence/Repositories/AuditRepository.cs
index 4d3fc22a06..0d933aec1e 100644
--- a/src/Umbraco.Core/Persistence/Repositories/AuditRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/AuditRepository.cs
@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using LightInject;
 using NPoco;
+using Umbraco.Core.DependencyInjection;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Rdbms;
@@ -14,8 +16,8 @@ namespace Umbraco.Core.Persistence.Repositories
 {
     internal class AuditRepository : NPocoRepositoryBase<int, AuditItem>, IAuditRepository
     {
-        public AuditRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public AuditRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentPreviewRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentPreviewRepository.cs
index d07ee15926..6dfa55f569 100644
--- a/src/Umbraco.Core/Persistence/Repositories/ContentPreviewRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/ContentPreviewRepository.cs
@@ -18,8 +18,8 @@ namespace Umbraco.Core.Persistence.Repositories
     internal class ContentPreviewRepository<TContent> : NPocoRepositoryBase<int, ContentPreviewEntity<TContent>> 
         where TContent : IContentBase
     {
-        public ContentPreviewRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public ContentPreviewRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs
index c68fa123b1..f2428129c9 100644
--- a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs
@@ -41,8 +41,8 @@ namespace Umbraco.Core.Persistence.Repositories
         private readonly ContentPreviewRepository<IContent> _contentPreviewRepository;
         private readonly ContentXmlRepository<IContent> _contentXmlRepository;
 
-        public ContentRepository(IDatabaseUnitOfWork work, CacheHelper cacheHelper, ILogger logger, ISqlSyntaxProvider syntaxProvider, IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository, IContentSection contentSection, IMappingResolver mappingResolver)
-            : base(work, cacheHelper, logger, syntaxProvider, contentSection, mappingResolver)
+        public ContentRepository(IDatabaseUnitOfWork work, CacheHelper cacheHelper, ILogger logger, IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository, IContentSection contentSection, IMappingResolver mappingResolver)
+            : base(work, cacheHelper, logger, contentSection, mappingResolver)
         {
             if (contentTypeRepository == null) throw new ArgumentNullException("contentTypeRepository");
             if (templateRepository == null) throw new ArgumentNullException("templateRepository");
@@ -51,8 +51,8 @@ namespace Umbraco.Core.Persistence.Repositories
             _templateRepository = templateRepository;
             _tagRepository = tagRepository;
             _cacheHelper = cacheHelper;
-            _contentPreviewRepository = new ContentPreviewRepository<IContent>(work, CacheHelper.CreateDisabledCacheHelper(), logger, syntaxProvider, mappingResolver);
-            _contentXmlRepository = new ContentXmlRepository<IContent>(work, CacheHelper.CreateDisabledCacheHelper(), logger, syntaxProvider, mappingResolver);
+            _contentPreviewRepository = new ContentPreviewRepository<IContent>(work, CacheHelper.CreateDisabledCacheHelper(), logger, mappingResolver);
+            _contentXmlRepository = new ContentXmlRepository<IContent>(work, CacheHelper.CreateDisabledCacheHelper(), logger, mappingResolver);
 
             EnsureUniqueNaming = true;
         }
@@ -401,7 +401,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
             //Assign the same permissions to it as the parent node
             // http://issues.umbraco.org/issue/U4-2161
-            var permissionsRepo = new PermissionRepository<IContent>(UnitOfWork, _cacheHelper, SqlSyntax);
+            var permissionsRepo = new PermissionRepository<IContent>(UnitOfWork, _cacheHelper);
             var parentPermissions = permissionsRepo.GetPermissionsForEntity(entity.ParentId).ToArray();
             //if there are parent permissions then assign them, otherwise leave null and permissions will become the
             // user's default permissions.
@@ -706,7 +706,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
         public void ReplaceContentPermissions(EntityPermissionSet permissionSet)
         {
-            var repo = new PermissionRepository<IContent>(UnitOfWork, _cacheHelper, SqlSyntax);
+            var repo = new PermissionRepository<IContent>(UnitOfWork, _cacheHelper);
             repo.ReplaceEntityPermissions(permissionSet);
         }
 
@@ -729,13 +729,13 @@ namespace Umbraco.Core.Persistence.Repositories
         /// <param name="userIds"></param>
         public void AssignEntityPermission(IContent entity, char permission, IEnumerable<int> userIds)
         {
-            var repo = new PermissionRepository<IContent>(UnitOfWork, _cacheHelper, SqlSyntax);
+            var repo = new PermissionRepository<IContent>(UnitOfWork, _cacheHelper);
             repo.AssignEntityPermission(entity, permission, userIds);
         }
 
         public IEnumerable<EntityPermission> GetPermissionsForEntity(int entityId)
         {
-            var repo = new PermissionRepository<IContent>(UnitOfWork, _cacheHelper, SqlSyntax);
+            var repo = new PermissionRepository<IContent>(UnitOfWork, _cacheHelper);
             return repo.GetPermissionsForEntity(entityId);
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs
index 5856bea59a..a446a0a390 100644
--- a/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs
@@ -31,8 +31,8 @@ namespace Umbraco.Core.Persistence.Repositories
     internal abstract class ContentTypeBaseRepository<TEntity> : NPocoRepositoryBase<int, TEntity>, IReadRepository<Guid, TEntity>
         where TEntity : class, IContentTypeComposition
     {
-        protected ContentTypeBaseRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        protected ContentTypeBaseRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs
index 02941434db..40cf02af38 100644
--- a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs
@@ -26,8 +26,8 @@ namespace Umbraco.Core.Persistence.Repositories
     {
         private readonly ITemplateRepository _templateRepository;
 
-        public ContentTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, ITemplateRepository templateRepository, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public ContentTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ITemplateRepository templateRepository, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
             _templateRepository = templateRepository;
         }
diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentXmlRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentXmlRepository.cs
index c6258fe9a8..7175623dae 100644
--- a/src/Umbraco.Core/Persistence/Repositories/ContentXmlRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/ContentXmlRepository.cs
@@ -18,8 +18,8 @@ namespace Umbraco.Core.Persistence.Repositories
     internal class ContentXmlRepository<TContent> : NPocoRepositoryBase<int, ContentXmlEntity<TContent>> 
         where TContent : IContentBase
     {
-        public ContentXmlRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public ContentXmlRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs b/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs
index d6c9d05d54..67e245ac81 100644
--- a/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs
@@ -31,12 +31,12 @@ namespace Umbraco.Core.Persistence.Repositories
         private readonly IContentTypeRepository _contentTypeRepository;
         private readonly DataTypePreValueRepository _preValRepository;
 
-        public DataTypeDefinitionRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax,
+        public DataTypeDefinitionRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger,
             IContentTypeRepository contentTypeRepository, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
             _contentTypeRepository = contentTypeRepository;
-            _preValRepository = new DataTypePreValueRepository(work, CacheHelper.CreateDisabledCacheHelper(), logger, sqlSyntax, mappingResolver);
+            _preValRepository = new DataTypePreValueRepository(work, CacheHelper.CreateDisabledCacheHelper(), logger, mappingResolver);
         }
 
         #region Overrides of RepositoryBase<int,DataTypeDefinition>
@@ -530,8 +530,8 @@ AND umbracoNode.id <> @id",
         /// </summary>
         private class DataTypePreValueRepository : NPocoRepositoryBase<int, PreValueEntity>
         {
-            public DataTypePreValueRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-                : base(work, cache, logger, sqlSyntax, mappingResolver)
+            public DataTypePreValueRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+                : base(work, cache, logger, mappingResolver)
             {
             }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs b/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs
index c210a783fa..e753d8a346 100644
--- a/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs
@@ -23,8 +23,8 @@ namespace Umbraco.Core.Persistence.Repositories
     {
         private readonly IMappingResolver _mappingResolver;
 
-        public DictionaryRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider syntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, syntax, mappingResolver)
+        public DictionaryRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
             _mappingResolver = mappingResolver;
         }
@@ -246,7 +246,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
         public IDictionaryItem Get(Guid uniqueId)
         {
-            using (var uniqueIdRepo = new DictionaryByUniqueIdRepository(this, UnitOfWork, RepositoryCache, Logger, SqlSyntax, _mappingResolver))
+            using (var uniqueIdRepo = new DictionaryByUniqueIdRepository(this, UnitOfWork, RepositoryCache, Logger, _mappingResolver))
             {
                 return uniqueIdRepo.Get(uniqueId);
             }
@@ -254,7 +254,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
         public IDictionaryItem Get(string key)
         {
-            using (var keyRepo = new DictionaryByKeyRepository(this, UnitOfWork, RepositoryCache, Logger, SqlSyntax, _mappingResolver))
+            using (var keyRepo = new DictionaryByKeyRepository(this, UnitOfWork, RepositoryCache, Logger, _mappingResolver))
             {
                 return keyRepo.Get(key);
             }
@@ -303,8 +303,8 @@ namespace Umbraco.Core.Persistence.Repositories
         {
             private readonly DictionaryRepository _dictionaryRepository;
 
-            public DictionaryByUniqueIdRepository(DictionaryRepository dictionaryRepository, IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-                : base(work, cache, logger, sqlSyntax, mappingResolver)
+            public DictionaryByUniqueIdRepository(DictionaryRepository dictionaryRepository, IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+                : base(work, cache, logger, mappingResolver)
             {
                 _dictionaryRepository = dictionaryRepository;
             }
@@ -361,8 +361,8 @@ namespace Umbraco.Core.Persistence.Repositories
         {
             private readonly DictionaryRepository _dictionaryRepository;
 
-            public DictionaryByKeyRepository(DictionaryRepository dictionaryRepository, IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-                : base(work, cache, logger, sqlSyntax, mappingResolver)
+            public DictionaryByKeyRepository(DictionaryRepository dictionaryRepository, IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+                : base(work, cache, logger, mappingResolver)
             {
                 _dictionaryRepository = dictionaryRepository;
             }
diff --git a/src/Umbraco.Core/Persistence/Repositories/DomainRepository.cs b/src/Umbraco.Core/Persistence/Repositories/DomainRepository.cs
index 29de099ab9..b703bab20e 100644
--- a/src/Umbraco.Core/Persistence/Repositories/DomainRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/DomainRepository.cs
@@ -20,8 +20,8 @@ namespace Umbraco.Core.Persistence.Repositories
 
     internal class DomainRepository : NPocoRepositoryBase<int, IDomain>, IDomainRepository
     {
-        public DomainRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public DomainRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {           
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/EntityContainerRepository.cs b/src/Umbraco.Core/Persistence/Repositories/EntityContainerRepository.cs
index 353caedc00..9ff81061a4 100644
--- a/src/Umbraco.Core/Persistence/Repositories/EntityContainerRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/EntityContainerRepository.cs
@@ -22,8 +22,8 @@ namespace Umbraco.Core.Persistence.Repositories
     {
         private readonly Guid _containerObjectType;
 
-        public EntityContainerRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver, Guid containerObjectType) 
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public EntityContainerRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver, Guid containerObjectType) 
+            : base(work, cache, logger, mappingResolver)
         {
             var allowedContainers = new[] {Constants.ObjectTypes.DocumentTypeContainerGuid, Constants.ObjectTypes.MediaTypeContainerGuid, Constants.ObjectTypes.DataTypeContainerGuid};
             _containerObjectType = containerObjectType;
diff --git a/src/Umbraco.Core/Persistence/Repositories/EntityRepository.cs b/src/Umbraco.Core/Persistence/Repositories/EntityRepository.cs
index d79fc8aec4..c706d780df 100644
--- a/src/Umbraco.Core/Persistence/Repositories/EntityRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/EntityRepository.cs
@@ -21,18 +21,16 @@ namespace Umbraco.Core.Persistence.Repositories
     /// </remarks>
     internal class EntityRepository : DisposableObject, IEntityRepository
     {
-        private readonly ISqlSyntaxProvider _sqlSyntax;
         private readonly QueryFactory _queryFactory;
 
-        public EntityRepository(IDatabaseUnitOfWork work, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
+        public EntityRepository(IDatabaseUnitOfWork work, IMappingResolver mappingResolver)
         {
             UnitOfWork = work;
-            _sqlSyntax = sqlSyntax;
-            _queryFactory = new QueryFactory(_sqlSyntax, mappingResolver);
+            _queryFactory = new QueryFactory(work.Database.SqlSyntax, mappingResolver);
         }
 
         /// <summary>
-        /// Returns the Unit of Work added to the repository
+        /// Gets the repository's unit of work.
         /// </summary>
         protected internal IDatabaseUnitOfWork UnitOfWork { get; }
 
@@ -45,7 +43,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
         public Query<IUmbracoEntity> Query => _queryFactory.Create<IUmbracoEntity>();
 
-        public Sql<SqlContext> Sql() { return NPoco.Sql.BuilderFor(new SqlContext(_sqlSyntax, UnitOfWork.Database));}
+        public Sql<SqlContext> Sql() { return UnitOfWork.Database.Sql();}
 
         public IUmbracoEntity GetByKey(Guid key)
         {
diff --git a/src/Umbraco.Core/Persistence/Repositories/ExternalLoginRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ExternalLoginRepository.cs
index aa5340232d..9c67f2473e 100644
--- a/src/Umbraco.Core/Persistence/Repositories/ExternalLoginRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/ExternalLoginRepository.cs
@@ -17,8 +17,8 @@ namespace Umbraco.Core.Persistence.Repositories
 {
     internal class ExternalLoginRepository : NPocoRepositoryBase<int, IIdentityUserLogin>, IExternalLoginRepository
     {
-        public ExternalLoginRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public ExternalLoginRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/LanguageRepository.cs b/src/Umbraco.Core/Persistence/Repositories/LanguageRepository.cs
index f0304ffa58..a97d61eb1b 100644
--- a/src/Umbraco.Core/Persistence/Repositories/LanguageRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/LanguageRepository.cs
@@ -21,8 +21,8 @@ namespace Umbraco.Core.Persistence.Repositories
     /// </summary>
     internal class LanguageRepository : NPocoRepositoryBase<int, ILanguage>, ILanguageRepository
     {
-        public LanguageRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public LanguageRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/MacroRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MacroRepository.cs
index f3dbf6ec34..c9881a9fdd 100644
--- a/src/Umbraco.Core/Persistence/Repositories/MacroRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/MacroRepository.cs
@@ -18,8 +18,8 @@ namespace Umbraco.Core.Persistence.Repositories
     internal class MacroRepository : NPocoRepositoryBase<int, IMacro>, IMacroRepository
     {
 
-        public MacroRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public MacroRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs
index fbdbb8ca55..7afa96c746 100644
--- a/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs
@@ -35,15 +35,15 @@ namespace Umbraco.Core.Persistence.Repositories
         private readonly ContentXmlRepository<IMedia> _contentXmlRepository;
         private readonly ContentPreviewRepository<IMedia> _contentPreviewRepository;
 
-        public MediaRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository, IContentSection contentSection, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, contentSection, mappingResolver)
+        public MediaRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository, IContentSection contentSection, IMappingResolver mappingResolver)
+            : base(work, cache, logger, contentSection, mappingResolver)
         {
             if (mediaTypeRepository == null) throw new ArgumentNullException("mediaTypeRepository");
             if (tagRepository == null) throw new ArgumentNullException("tagRepository");
             _mediaTypeRepository = mediaTypeRepository;
             _tagRepository = tagRepository;
-            _contentXmlRepository = new ContentXmlRepository<IMedia>(work, CacheHelper.CreateDisabledCacheHelper(), logger, sqlSyntax, mappingResolver);
-            _contentPreviewRepository = new ContentPreviewRepository<IMedia>(work, CacheHelper.CreateDisabledCacheHelper(), logger, sqlSyntax, mappingResolver);
+            _contentXmlRepository = new ContentXmlRepository<IMedia>(work, CacheHelper.CreateDisabledCacheHelper(), logger, mappingResolver);
+            _contentPreviewRepository = new ContentPreviewRepository<IMedia>(work, CacheHelper.CreateDisabledCacheHelper(), logger, mappingResolver);
             EnsureUniqueNaming = contentSection.EnsureUniqueNaming;
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs
index 3d7eedd246..68f3dcfd05 100644
--- a/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs
@@ -25,8 +25,8 @@ namespace Umbraco.Core.Persistence.Repositories
     internal class MediaTypeRepository : ContentTypeBaseRepository<IMediaType>, IMediaTypeRepository
     {
 
-        public MediaTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public MediaTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/MemberGroupRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MemberGroupRepository.cs
index 1ff51447ec..835fe0ab8a 100644
--- a/src/Umbraco.Core/Persistence/Repositories/MemberGroupRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/MemberGroupRepository.cs
@@ -22,8 +22,8 @@ namespace Umbraco.Core.Persistence.Repositories
 
     internal class MemberGroupRepository : NPocoRepositoryBase<int, IMemberGroup>, IMemberGroupRepository
     {
-        public MemberGroupRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public MemberGroupRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs
index a97c716894..5052784485 100644
--- a/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs
@@ -35,16 +35,16 @@ namespace Umbraco.Core.Persistence.Repositories
         private readonly ContentXmlRepository<IMember> _contentXmlRepository;
         private readonly ContentPreviewRepository<IMember> _contentPreviewRepository;
 
-        public MemberRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMemberTypeRepository memberTypeRepository, IMemberGroupRepository memberGroupRepository, ITagRepository tagRepository, IContentSection contentSection, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, contentSection, mappingResolver)
+        public MemberRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMemberTypeRepository memberTypeRepository, IMemberGroupRepository memberGroupRepository, ITagRepository tagRepository, IContentSection contentSection, IMappingResolver mappingResolver)
+            : base(work, cache, logger, contentSection, mappingResolver)
         {
             if (memberTypeRepository == null) throw new ArgumentNullException("memberTypeRepository");
             if (tagRepository == null) throw new ArgumentNullException("tagRepository");
             _memberTypeRepository = memberTypeRepository;
             _tagRepository = tagRepository;
             _memberGroupRepository = memberGroupRepository;
-            _contentXmlRepository = new ContentXmlRepository<IMember>(work, CacheHelper.CreateDisabledCacheHelper(), logger, sqlSyntax, mappingResolver);
-            _contentPreviewRepository = new ContentPreviewRepository<IMember>(work, CacheHelper.CreateDisabledCacheHelper(), logger, sqlSyntax, mappingResolver);
+            _contentXmlRepository = new ContentXmlRepository<IMember>(work, CacheHelper.CreateDisabledCacheHelper(), logger, mappingResolver);
+            _contentPreviewRepository = new ContentPreviewRepository<IMember>(work, CacheHelper.CreateDisabledCacheHelper(), logger, mappingResolver);
         }
 
         #region Overrides of RepositoryBase<int, IMembershipUser>
diff --git a/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs
index 21f46eb800..95f26447c4 100644
--- a/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs
@@ -23,8 +23,8 @@ namespace Umbraco.Core.Persistence.Repositories
     internal class MemberTypeRepository : ContentTypeBaseRepository<IMemberType>, IMemberTypeRepository
     {
 
-        public MemberTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public MemberTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/MigrationEntryRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MigrationEntryRepository.cs
index 1749ae8be3..ad8a1cf24c 100644
--- a/src/Umbraco.Core/Persistence/Repositories/MigrationEntryRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/MigrationEntryRepository.cs
@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using LightInject;
 using NPoco;
 using Semver;
+using Umbraco.Core.DependencyInjection;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Rdbms;
@@ -16,8 +18,8 @@ namespace Umbraco.Core.Persistence.Repositories
 {
     internal class MigrationEntryRepository : NPocoRepositoryBase<int, IMigrationEntry>, IMigrationEntryRepository
     {
-        public MigrationEntryRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public MigrationEntryRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/NPocoRepositoryBase.cs b/src/Umbraco.Core/Persistence/Repositories/NPocoRepositoryBase.cs
index 24eeb93fd9..d9392417b6 100644
--- a/src/Umbraco.Core/Persistence/Repositories/NPocoRepositoryBase.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/NPocoRepositoryBase.cs
@@ -19,37 +19,52 @@ namespace Umbraco.Core.Persistence.Repositories
     internal abstract class NPocoRepositoryBase<TId, TEntity> : RepositoryBase<TId, TEntity>
         where TEntity : class, IAggregateRoot
     {
-        public ISqlSyntaxProvider SqlSyntax { get; }
-
         /// <summary>
-        /// Returns the Query factory
+        /// Initializes a new instance of the <see cref="NPocoRepositoryBase{TId, TEntity}"/>.
         /// </summary>
-        public override QueryFactory QueryFactory { get; }
-
-        /// <summary>
-        /// Used to create a new query instance
-        /// </summary>
-        /// <returns></returns>
-        public override Query<TEntity> Query => QueryFactory.Create<TEntity>();
-
-        protected NPocoRepositoryBase(IUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
+        /// <param name="work">A database unit of work.</param>
+        /// <param name="cache">A cache helper.</param>
+        /// <param name="logger">A logger.</param>
+        /// <param name="mappingResolver">A mapping resolver.</param>
+        protected NPocoRepositoryBase(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
             : base(work, cache, logger)
         {
-            if (sqlSyntax == null) throw new ArgumentNullException(nameof(sqlSyntax));
-            SqlSyntax = sqlSyntax;
             QueryFactory = new QueryFactory(SqlSyntax, mappingResolver);
         }
 
         /// <summary>
-		/// Returns the database Unit of Work added to the repository
+		/// Gets the repository's unit of work.
 		/// </summary>
 		protected internal new IDatabaseUnitOfWork UnitOfWork => (IDatabaseUnitOfWork) base.UnitOfWork;
 
+        /// <summary>
+        /// Gets the repository's database.
+        /// </summary>
         protected UmbracoDatabase Database => UnitOfWork.Database;
 
+        /// <summary>
+        /// Gets the repository's database sql syntax.
+        /// </summary>
+        public ISqlSyntaxProvider SqlSyntax => Database.SqlSyntax;
+
+        /// <summary>
+        /// Gets the repository's query factory.
+        /// </summary>
+        public override QueryFactory QueryFactory { get; }
+
+        /// <summary>
+        /// Creates a new query.
+        /// </summary>
+        /// <returns>A new query.</returns>
+        public override Query<TEntity> Query => QueryFactory.Create<TEntity>();
+
+        /// <summary>
+        /// Creates a new Sql statement.
+        /// </summary>
+        /// <returns>A new Sql statement.</returns>
         protected Sql<SqlContext> Sql()
         {
-            return NPoco.Sql.BuilderFor(new SqlContext(SqlSyntax, Database));
+            return Database.Sql();
         }
 
         #region Abstract Methods
diff --git a/src/Umbraco.Core/Persistence/Repositories/NotificationsRepository.cs b/src/Umbraco.Core/Persistence/Repositories/NotificationsRepository.cs
index 67b36caa86..1736932456 100644
--- a/src/Umbraco.Core/Persistence/Repositories/NotificationsRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/NotificationsRepository.cs
@@ -14,17 +14,15 @@ namespace Umbraco.Core.Persistence.Repositories
     public class NotificationsRepository : INotificationsRepository
     {
         private readonly IDatabaseUnitOfWork _unitOfWork;
-        private readonly ISqlSyntaxProvider _sqlSyntax;
 
-        public NotificationsRepository(IDatabaseUnitOfWork unitOfWork, ISqlSyntaxProvider sqlSyntax)
+        public NotificationsRepository(IDatabaseUnitOfWork unitOfWork)
         {
             _unitOfWork = unitOfWork;
-            _sqlSyntax = sqlSyntax;
         }
 
         public IEnumerable<Notification> GetUserNotifications(IUser user)
         {
-            var sql = NPoco.Sql.BuilderFor(new SqlContext(_sqlSyntax, _unitOfWork.Database))
+            var sql = _unitOfWork.Database.Sql()
                 .Select("DISTINCT umbracoNode.id, umbracoUser2NodeNotify.userId, umbracoNode.nodeObjectType, umbracoUser2NodeNotify.action")
                 .From<User2NodeNotifyDto>()
                 .InnerJoin<NodeDto>()
@@ -51,7 +49,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
         public IEnumerable<Notification> GetEntityNotifications(IEntity entity)
         {
-            var sql = NPoco.Sql.BuilderFor(new SqlContext(_sqlSyntax, _unitOfWork.Database))
+            var sql = _unitOfWork.Database.Sql()
                 .Select("DISTINCT umbracoNode.id, umbracoUser2NodeNotify.userId, umbracoNode.nodeObjectType, umbracoUser2NodeNotify.action")
                 .From<User2NodeNotifyDto>()
                 .InnerJoin<NodeDto>()
@@ -82,7 +80,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
         public Notification CreateNotification(IUser user, IEntity entity, string action)
         {
-            var sql = NPoco.Sql.BuilderFor(new SqlContext(_sqlSyntax, _unitOfWork.Database))
+            var sql = _unitOfWork.Database.Sql()
                 .Select("DISTINCT nodeObjectType")
                 .From<NodeDto>()
                 .Where<NodeDto>(nodeDto => nodeDto.NodeId == entity.Id);
diff --git a/src/Umbraco.Core/Persistence/Repositories/PartialViewMacroRepository.cs b/src/Umbraco.Core/Persistence/Repositories/PartialViewMacroRepository.cs
index e1f3be2077..82131bd9f1 100644
--- a/src/Umbraco.Core/Persistence/Repositories/PartialViewMacroRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/PartialViewMacroRepository.cs
@@ -1,4 +1,5 @@
 using System.Threading;
+using LightInject;
 using Umbraco.Core.IO;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence.UnitOfWork;
@@ -8,11 +9,10 @@ namespace Umbraco.Core.Persistence.Repositories
     internal class PartialViewMacroRepository : PartialViewRepository 
     {
         
-        public PartialViewMacroRepository(IUnitOfWork work, IFileSystem fileSystem)
+        public PartialViewMacroRepository(IUnitOfWork work, [Inject("PartialViewMacroFileSystem")] IFileSystem fileSystem)
             : base(work, fileSystem)
-        {
-        }
+        { }
 
-        protected override PartialViewType ViewType { get { return PartialViewType.PartialViewMacro; } }
+        protected override PartialViewType ViewType => PartialViewType.PartialViewMacro;
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Repositories/PartialViewRepository.cs b/src/Umbraco.Core/Persistence/Repositories/PartialViewRepository.cs
index 7c9d607e6b..48288ddc19 100644
--- a/src/Umbraco.Core/Persistence/Repositories/PartialViewRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/PartialViewRepository.cs
@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
+using LightInject;
 using Umbraco.Core.IO;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence.UnitOfWork;
@@ -12,11 +13,10 @@ namespace Umbraco.Core.Persistence.Repositories
     internal class PartialViewRepository : FileRepository<string, IPartialView>, IPartialViewRepository
     {      
 
-        public PartialViewRepository(IUnitOfWork work, IFileSystem fileSystem) : base(work, fileSystem)
-        {
-        }
+        public PartialViewRepository(IUnitOfWork work, [Inject("PartialViewFileSystem")] IFileSystem fileSystem) : base(work, fileSystem)
+        { }
 
-        protected virtual PartialViewType ViewType { get { return PartialViewType.PartialView; } }
+        protected virtual PartialViewType ViewType => PartialViewType.PartialView;
 
         public override IPartialView Get(string id)
         {
diff --git a/src/Umbraco.Core/Persistence/Repositories/PermissionRepository.cs b/src/Umbraco.Core/Persistence/Repositories/PermissionRepository.cs
index 8b37a2b6f1..9a8eb6fa04 100644
--- a/src/Umbraco.Core/Persistence/Repositories/PermissionRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/PermissionRepository.cs
@@ -29,16 +29,16 @@ namespace Umbraco.Core.Persistence.Repositories
     {
         private readonly IDatabaseUnitOfWork _unitOfWork;
         private readonly IRuntimeCacheProvider _runtimeCache;
-        private readonly ISqlSyntaxProvider _sqlSyntax;
 
-        internal PermissionRepository(IDatabaseUnitOfWork unitOfWork, CacheHelper cache, ISqlSyntaxProvider sqlSyntax)
+        internal PermissionRepository(IDatabaseUnitOfWork unitOfWork, CacheHelper cache)
         {
             _unitOfWork = unitOfWork;
             //Make this repository use an isolated cache
             _runtimeCache = cache.IsolatedRuntimeCache.GetOrCreateCache<EntityPermission>();
-            _sqlSyntax = sqlSyntax;
         }
 
+        private ISqlSyntaxProvider SqlSyntax => _unitOfWork.Database.SqlSyntax;
+
         /// <summary>
         /// Returns permissions for a given user for any number of nodes
         /// </summary>
@@ -56,7 +56,7 @@ namespace Umbraco.Core.Persistence.Repositories
                     var whereBuilder = new StringBuilder();
             
                     //where userId = @userId AND
-                    whereBuilder.Append(_sqlSyntax.GetQuotedColumnName("userId"));
+                    whereBuilder.Append(SqlSyntax.GetQuotedColumnName("userId"));
                     whereBuilder.Append("=");
                     whereBuilder.Append(userId);
 
@@ -69,7 +69,7 @@ namespace Umbraco.Core.Persistence.Repositories
                         for (var index = 0; index < entityIds.Length; index++)
                         {
                             var entityId = entityIds[index];
-                            whereBuilder.Append(_sqlSyntax.GetQuotedColumnName("nodeId"));
+                            whereBuilder.Append(SqlSyntax.GetQuotedColumnName("nodeId"));
                             whereBuilder.Append("=");
                             whereBuilder.Append(entityId);
                             if (index < entityIds.Length - 1)
@@ -80,7 +80,7 @@ namespace Umbraco.Core.Persistence.Repositories
                         whereBuilder.Append(")");
                     }
 
-                    var sql = NPoco.Sql.BuilderFor(new SqlContext(_sqlSyntax, _unitOfWork.Database))
+                    var sql = _unitOfWork.Database.Sql()
                         .SelectAll()
                         .From<User2NodePermissionDto>()
                         .Where(whereBuilder.ToString());
@@ -105,7 +105,7 @@ namespace Umbraco.Core.Persistence.Repositories
         /// <returns></returns>
         public IEnumerable<EntityPermission> GetPermissionsForEntity(int entityId)
         {
-            var sql = NPoco.Sql.BuilderFor(new SqlContext(_sqlSyntax, _unitOfWork.Database))
+            var sql = _unitOfWork.Database.Sql()
                 .SelectAll()
                 .From<User2NodePermissionDto>()
                 .Where<User2NodePermissionDto>(dto => dto.NodeId == entityId)
@@ -151,7 +151,7 @@ namespace Umbraco.Core.Persistence.Repositories
                     }
                 }
 
-                _unitOfWork.Database.BulkInsertRecords(_sqlSyntax, toInsert, trans);
+                _unitOfWork.Database.BulkInsertRecords(SqlSyntax, toInsert, trans);
 
                 trans.Complete();
 
@@ -187,7 +187,7 @@ namespace Umbraco.Core.Persistence.Repositories
                     UserId = userId
                 }).ToArray();
 
-                _unitOfWork.Database.BulkInsertRecords(_sqlSyntax, actions, trans);
+                _unitOfWork.Database.BulkInsertRecords(SqlSyntax, actions, trans);
 
                 trans.Complete();
 
@@ -223,7 +223,7 @@ namespace Umbraco.Core.Persistence.Repositories
                     UserId = id
                 }).ToArray();
 
-                _unitOfWork.Database.BulkInsertRecords(_sqlSyntax, actions, trans);
+                _unitOfWork.Database.BulkInsertRecords(SqlSyntax, actions, trans);
 
                 trans.Complete();
 
@@ -255,7 +255,7 @@ namespace Umbraco.Core.Persistence.Repositories
                     UserId = p.UserId
                 }).ToArray();
 
-                _unitOfWork.Database.BulkInsertRecords(_sqlSyntax, actions, trans);
+                _unitOfWork.Database.BulkInsertRecords(SqlSyntax, actions, trans);
 
                 trans.Complete();
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/PublicAccessRepository.cs b/src/Umbraco.Core/Persistence/Repositories/PublicAccessRepository.cs
index c389bce2f7..4d9b68e6a9 100644
--- a/src/Umbraco.Core/Persistence/Repositories/PublicAccessRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/PublicAccessRepository.cs
@@ -16,8 +16,8 @@ namespace Umbraco.Core.Persistence.Repositories
 {
     internal class PublicAccessRepository : NPocoRepositoryBase<Guid, PublicAccessEntry>, IPublicAccessRepository
     {
-        public PublicAccessRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public PublicAccessRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {            
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs b/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs
index 5f6be8eca7..d07d55303a 100644
--- a/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs
@@ -1,17 +1,10 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using NPoco;
-using Umbraco.Core.Configuration;
 using Umbraco.Core.Configuration.UmbracoSettings;
-using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Models.Rdbms;
 using Umbraco.Core.Persistence.Mappers;
-using Umbraco.Core.Persistence.Querying;
-using Umbraco.Core.Persistence.SqlSyntax;
 using Umbraco.Core.Persistence.UnitOfWork;
 
 namespace Umbraco.Core.Persistence.Repositories
@@ -19,8 +12,8 @@ namespace Umbraco.Core.Persistence.Repositories
     internal abstract class RecycleBinRepository<TId, TEntity> : VersionableRepositoryBase<TId, TEntity>, IRecycleBinRepository<TEntity> 
         where TEntity : class, IUmbracoEntity
     {
-        protected RecycleBinRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IContentSection contentSection, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, contentSection, mappingResolver)
+        protected RecycleBinRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IContentSection contentSection, IMappingResolver mappingResolver)
+            : base(work, cache, logger, contentSection, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs b/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs
index a021aca520..831d3b7e34 100644
--- a/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/RelationRepository.cs
@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using LightInject;
 using NPoco;
+using Umbraco.Core.DependencyInjection;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.EntityBase;
@@ -22,8 +24,8 @@ namespace Umbraco.Core.Persistence.Repositories
     {
         private readonly IRelationTypeRepository _relationTypeRepository;
 
-        public RelationRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IRelationTypeRepository relationTypeRepository, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public RelationRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IRelationTypeRepository relationTypeRepository, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
             _relationTypeRepository = relationTypeRepository;
         }
diff --git a/src/Umbraco.Core/Persistence/Repositories/RelationTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/RelationTypeRepository.cs
index db3bf84620..8a14d4c70c 100644
--- a/src/Umbraco.Core/Persistence/Repositories/RelationTypeRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/RelationTypeRepository.cs
@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using LightInject;
 using NPoco;
+using Umbraco.Core.DependencyInjection;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.EntityBase;
@@ -21,8 +23,8 @@ namespace Umbraco.Core.Persistence.Repositories
     internal class RelationTypeRepository : NPocoRepositoryBase<int, IRelationType>, IRelationTypeRepository
     {
 
-        public RelationTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public RelationTypeRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/ScriptRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ScriptRepository.cs
index 13b2877c50..215e1ffc6d 100644
--- a/src/Umbraco.Core/Persistence/Repositories/ScriptRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/ScriptRepository.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using LightInject;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.IO;
 using Umbraco.Core.Models;
@@ -15,10 +16,10 @@ namespace Umbraco.Core.Persistence.Repositories
     {
         private readonly IContentSection _contentConfig;
 
-        public ScriptRepository(IUnitOfWork work, IFileSystem fileSystem, IContentSection contentConfig)
+        public ScriptRepository(IUnitOfWork work, [Inject("ScriptFileSystem")] IFileSystem fileSystem, IContentSection contentConfig)
 			: base(work, fileSystem)
         {
-            if (contentConfig == null) throw new ArgumentNullException("contentConfig");
+            if (contentConfig == null) throw new ArgumentNullException(nameof(contentConfig));
             _contentConfig = contentConfig;
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs
index dd576ce899..37f249df6e 100644
--- a/src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs
@@ -19,10 +19,10 @@ namespace Umbraco.Core.Persistence.Repositories
     {
         private readonly ICacheProvider _staticCache;
 
-        public ServerRegistrationRepository(IDatabaseUnitOfWork work, ICacheProvider staticCache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, CacheHelper.CreateDisabledCacheHelper(), logger, sqlSyntax, mappingResolver)
+        public ServerRegistrationRepository(IDatabaseUnitOfWork work, CacheHelper cacheHelper, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, CacheHelper.CreateDisabledCacheHelper(), logger, mappingResolver)
         {
-            _staticCache = staticCache;
+            _staticCache = cacheHelper.StaticCache;
         }
 
         protected override int PerformCount(IQuery<IServerRegistration> query)
diff --git a/src/Umbraco.Core/Persistence/Repositories/SimpleGetRepository.cs b/src/Umbraco.Core/Persistence/Repositories/SimpleGetRepository.cs
index e5d941ba4b..89ee102299 100644
--- a/src/Umbraco.Core/Persistence/Repositories/SimpleGetRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/SimpleGetRepository.cs
@@ -19,8 +19,8 @@ namespace Umbraco.Core.Persistence.Repositories
         where TDto: class
     {
 
-        protected SimpleGetRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        protected SimpleGetRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/StylesheetRepository.cs b/src/Umbraco.Core/Persistence/Repositories/StylesheetRepository.cs
index 6f9138de9a..9c84a38a12 100644
--- a/src/Umbraco.Core/Persistence/Repositories/StylesheetRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/StylesheetRepository.cs
@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
+using LightInject;
 using Umbraco.Core.IO;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Rdbms;
@@ -15,10 +16,9 @@ namespace Umbraco.Core.Persistence.Repositories
     /// </summary>
     internal class StylesheetRepository : FileRepository<string, Stylesheet>, IStylesheetRepository
     {
-        public StylesheetRepository(IUnitOfWork work, IFileSystem fileSystem)
+        public StylesheetRepository(IUnitOfWork work, [Inject("StylesheetFileSystem")] IFileSystem fileSystem)
             : base(work, fileSystem)
-        {
-        }
+        { }
 
         #region Overrides of FileRepository<string,Stylesheet>
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/TagRepository.cs b/src/Umbraco.Core/Persistence/Repositories/TagRepository.cs
index df5cc4883f..5b016a80dc 100644
--- a/src/Umbraco.Core/Persistence/Repositories/TagRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/TagRepository.cs
@@ -18,8 +18,8 @@ namespace Umbraco.Core.Persistence.Repositories
 {
     internal class TagRepository : NPocoRepositoryBase<int, ITag>, ITagRepository
     {
-        public TagRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public TagRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/TaskRepository.cs b/src/Umbraco.Core/Persistence/Repositories/TaskRepository.cs
index f87dacc911..f6d24c717b 100644
--- a/src/Umbraco.Core/Persistence/Repositories/TaskRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/TaskRepository.cs
@@ -2,7 +2,9 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using AutoMapper;
+using LightInject;
 using NPoco;
+using Umbraco.Core.DependencyInjection;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.EntityBase;
@@ -17,8 +19,8 @@ namespace Umbraco.Core.Persistence.Repositories
 {
     internal class TaskRepository : NPocoRepositoryBase<int, Task>, ITaskRepository
     {
-        public TaskRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public TaskRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/TaskTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/TaskTypeRepository.cs
index cc26450962..3cf4ba95ab 100644
--- a/src/Umbraco.Core/Persistence/Repositories/TaskTypeRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/TaskTypeRepository.cs
@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using LightInject;
 using NPoco;
+using Umbraco.Core.DependencyInjection;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Rdbms;
@@ -15,8 +17,8 @@ namespace Umbraco.Core.Persistence.Repositories
 {
     internal class TaskTypeRepository : NPocoRepositoryBase<int, TaskType>, ITaskTypeRepository
     {
-        public TaskTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public TaskTypeRepository(IDatabaseUnitOfWork work, [Inject(RepositoryCompositionRoot.DisabledCache)] CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs b/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs
index e4379119c2..329b53d042 100644
--- a/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs
@@ -36,8 +36,8 @@ namespace Umbraco.Core.Persistence.Repositories
         private readonly ViewHelper _viewHelper;
         private readonly MasterPageHelper _masterPageHelper;
 
-        public TemplateRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IFileSystem masterpageFileSystem, IFileSystem viewFileSystem, ITemplatesSection templateConfig, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public TemplateRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IFileSystem masterpageFileSystem, IFileSystem viewFileSystem, ITemplatesSection templateConfig, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
             _masterpagesFileSystem = masterpageFileSystem;
             _viewsFileSystem = viewFileSystem;
diff --git a/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs b/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs
index 72333289c7..1c7b001996 100644
--- a/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs
@@ -26,8 +26,8 @@ namespace Umbraco.Core.Persistence.Repositories
         private readonly IUserTypeRepository _userTypeRepository;
         private readonly CacheHelper _cacheHelper;
 
-        public UserRepository(IDatabaseUnitOfWork work, CacheHelper cacheHelper, ILogger logger, ISqlSyntaxProvider sqlSyntax, IUserTypeRepository userTypeRepository, IMappingResolver mappingResolver)
-            : base(work, cacheHelper, logger, sqlSyntax, mappingResolver)
+        public UserRepository(IDatabaseUnitOfWork work, CacheHelper cacheHelper, ILogger logger, IUserTypeRepository userTypeRepository, IMappingResolver mappingResolver)
+            : base(work, cacheHelper, logger, mappingResolver)
         {
             _userTypeRepository = userTypeRepository;
             _cacheHelper = cacheHelper;
@@ -377,7 +377,7 @@ namespace Umbraco.Core.Persistence.Repositories
         /// <returns></returns>
         public IEnumerable<EntityPermission> GetUserPermissionsForEntities(int userId, params int[] entityIds)
         {
-            var repo = new PermissionRepository<IContent>(UnitOfWork, _cacheHelper, SqlSyntax);
+            var repo = new PermissionRepository<IContent>(UnitOfWork, _cacheHelper);
             return repo.GetUserPermissionsForEntities(userId, entityIds);
         }
 
@@ -389,7 +389,7 @@ namespace Umbraco.Core.Persistence.Repositories
         /// <param name="entityIds"></param>
         public void ReplaceUserPermissions(int userId, IEnumerable<char> permissions, params int[] entityIds)
         {
-            var repo = new PermissionRepository<IContent>(UnitOfWork, _cacheHelper, SqlSyntax);
+            var repo = new PermissionRepository<IContent>(UnitOfWork, _cacheHelper);
             repo.ReplaceUserPermissions(userId, permissions, entityIds);
         }
 
@@ -401,7 +401,7 @@ namespace Umbraco.Core.Persistence.Repositories
         /// <param name="entityIds"></param>
         public void AssignUserPermission(int userId, char permission, params int[] entityIds)
         {
-            var repo = new PermissionRepository<IContent>(UnitOfWork, _cacheHelper, SqlSyntax);
+            var repo = new PermissionRepository<IContent>(UnitOfWork, _cacheHelper);
             repo.AssignUserPermission(userId, permission, entityIds);
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/UserTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/UserTypeRepository.cs
index 497eef779b..ab163ec4d9 100644
--- a/src/Umbraco.Core/Persistence/Repositories/UserTypeRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/UserTypeRepository.cs
@@ -19,8 +19,8 @@ namespace Umbraco.Core.Persistence.Repositories
     /// </summary>
     internal class UserTypeRepository : NPocoRepositoryBase<int, IUserType>, IUserTypeRepository
     {
-        public UserTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        public UserTypeRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs b/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs
index 53a3884431..f5954d1821 100644
--- a/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs
@@ -52,8 +52,8 @@ namespace Umbraco.Core.Persistence.Repositories
     {
         private readonly IContentSection _contentSection;
 
-        protected VersionableRepositoryBase(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IContentSection contentSection, IMappingResolver mappingResolver)
-            : base(work, cache, logger, sqlSyntax, mappingResolver)
+        protected VersionableRepositoryBase(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, IContentSection contentSection, IMappingResolver mappingResolver)
+            : base(work, cache, logger, mappingResolver)
         {
             _contentSection = contentSection;
         }
diff --git a/src/Umbraco.Core/Persistence/RepositoryFactory.cs b/src/Umbraco.Core/Persistence/RepositoryFactory.cs
index fe7c2de754..fa4599b95f 100644
--- a/src/Umbraco.Core/Persistence/RepositoryFactory.cs
+++ b/src/Umbraco.Core/Persistence/RepositoryFactory.cs
@@ -1,30 +1,25 @@
-using Umbraco.Core.Configuration;
 using System;
-using Umbraco.Core.Cache;
 using LightInject;
-using Umbraco.Core.Configuration.UmbracoSettings;
-using Umbraco.Core.IO;
-using Umbraco.Core.Logging;
-using Umbraco.Core.Persistence.Mappers;
-using Umbraco.Core.Persistence.Querying;
 using Umbraco.Core.Persistence.Repositories;
-using Umbraco.Core.Persistence.SqlSyntax;
 using Umbraco.Core.Persistence.UnitOfWork;
 
 namespace Umbraco.Core.Persistence
 {
     /// <summary>
-    /// Used to instantiate each repository type
+    /// Instanciates repositories.
     /// </summary>
-    public class RepositoryFactory 
+    public class RepositoryFactory
     {
         private readonly IServiceContainer _container;
-        public ISqlSyntaxProvider SqlSyntax { get; private set; }
-        
-        public RepositoryFactory(ISqlSyntaxProvider sqlSyntax, IServiceContainer container)
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RepositoryFactory"/> class with a container.
+        /// </summary>
+        /// <param name="container">A container.</param>
+        public RepositoryFactory(IServiceContainer container)
         {
+            if (container == null) throw new ArgumentNullException(nameof(container));
             _container = container;
-            SqlSyntax = sqlSyntax;
         }
 
         public virtual INotificationsRepository CreateNotificationsRepository(IDatabaseUnitOfWork uow)
diff --git a/src/Umbraco.Core/Persistence/SqlContext.cs b/src/Umbraco.Core/Persistence/SqlContext.cs
index 927d6b469e..f0d8dd8326 100644
--- a/src/Umbraco.Core/Persistence/SqlContext.cs
+++ b/src/Umbraco.Core/Persistence/SqlContext.cs
@@ -17,12 +17,10 @@ namespace Umbraco.Core.Persistence
             DatabaseType = databaseType;
         }
 
-        public SqlContext(ISqlSyntaxProvider sqlSyntax, IDatabaseConfig database)
+        public SqlContext(IUmbracoDatabaseConfig database)
         {
-            if (sqlSyntax == null) throw new ArgumentNullException(nameof(sqlSyntax));
             if (database == null) throw new ArgumentNullException(nameof(database));
-
-            SqlSyntax = sqlSyntax;
+            SqlSyntax = database.SqlSyntax;
             PocoDataFactory = database.PocoDataFactory;
             DatabaseType = database.DatabaseType;
         }
diff --git a/src/Umbraco.Core/Persistence/SqlSyntax/MySqlSyntaxProvider.cs b/src/Umbraco.Core/Persistence/SqlSyntax/MySqlSyntaxProvider.cs
index 6e21881f0c..e294b3bc78 100644
--- a/src/Umbraco.Core/Persistence/SqlSyntax/MySqlSyntaxProvider.cs
+++ b/src/Umbraco.Core/Persistence/SqlSyntax/MySqlSyntaxProvider.cs
@@ -11,7 +11,7 @@ namespace Umbraco.Core.Persistence.SqlSyntax
     /// <summary>
     /// Represents an SqlSyntaxProvider for MySql
     /// </summary>
-    [SqlSyntaxProviderAttribute("MySql.Data.MySqlClient")]
+    [SqlSyntaxProviderAttribute(Constants.DbProviderNames.MySql)]
     public class MySqlSyntaxProvider : SqlSyntaxProviderBase<MySqlSyntaxProvider>
     {
         private readonly ILogger _logger;
diff --git a/src/Umbraco.Core/Persistence/SqlSyntax/SqlCeSyntaxProvider.cs b/src/Umbraco.Core/Persistence/SqlSyntax/SqlCeSyntaxProvider.cs
index 41b88abec9..0bf8a0a0f7 100644
--- a/src/Umbraco.Core/Persistence/SqlSyntax/SqlCeSyntaxProvider.cs
+++ b/src/Umbraco.Core/Persistence/SqlSyntax/SqlCeSyntaxProvider.cs
@@ -11,7 +11,7 @@ namespace Umbraco.Core.Persistence.SqlSyntax
     /// <summary>
     /// Represents an SqlSyntaxProvider for Sql Ce
     /// </summary>
-    [SqlSyntaxProviderAttribute("System.Data.SqlServerCe.4.0")]
+    [SqlSyntaxProviderAttribute(Constants.DbProviderNames.SqlCe)]
     public class SqlCeSyntaxProvider : MicrosoftSqlSyntaxProviderBase<SqlCeSyntaxProvider>
     {
         public SqlCeSyntaxProvider()
diff --git a/src/Umbraco.Core/Persistence/SqlSyntax/SqlServerSyntaxProvider.cs b/src/Umbraco.Core/Persistence/SqlSyntax/SqlServerSyntaxProvider.cs
index 8ea169e997..61479627fe 100644
--- a/src/Umbraco.Core/Persistence/SqlSyntax/SqlServerSyntaxProvider.cs
+++ b/src/Umbraco.Core/Persistence/SqlSyntax/SqlServerSyntaxProvider.cs
@@ -9,18 +9,123 @@ namespace Umbraco.Core.Persistence.SqlSyntax
     /// <summary>
     /// Represents an SqlSyntaxProvider for Sql Server
     /// </summary>
-    [SqlSyntaxProviderAttribute("System.Data.SqlClient")]
+    [SqlSyntaxProvider(Constants.DbProviderNames.SqlServer)]
     public class SqlServerSyntaxProvider : MicrosoftSqlSyntaxProviderBase<SqlServerSyntaxProvider>
     {
-        public SqlServerSyntaxProvider()
+        // IDatabaseFactory to be lazily injected
+        public SqlServerSyntaxProvider(Lazy<IDatabaseFactory> lazyFactory)
         {
-            
+            _serverVersion = new Lazy<ServerVersionInfo>(() =>
+            {
+                var factory = lazyFactory.Value;
+                if (factory == null)
+                    throw new InvalidOperationException("Failed to determine Sql Server version (no database factory).");
+                return DetermineVersion(factory);
+            });
         }
 
-        /// <summary>
-        /// Gets/sets the version of the current SQL server instance
-        /// </summary>
-        internal Lazy<SqlServerVersionName> VersionName { get; set; }
+        private readonly Lazy<ServerVersionInfo> _serverVersion;
+
+        internal ServerVersionInfo ServerVersion => _serverVersion.Value;
+
+        internal enum VersionName
+        {
+            Invalid = -1,
+            Unknown = 0,
+            V7 = 1,
+            V2000 = 2,
+            V2005 = 3,
+            V2008 = 4,
+            V2012 = 5,
+            V2014 = 6,
+            Other = 99
+        }
+
+        internal enum EngineEdition
+        {
+            Unknown = 0,
+            Desktop = 1,
+            Standard = 2,
+            Enterprise = 3,
+            Express = 4,
+            Azure = 5
+        }
+
+        internal class ServerVersionInfo
+        {
+            public string Edition { get; set; }
+            public string InstanceName { get; set; }
+            public string ProductVersion { get; set; }
+            public VersionName ProductVersionName { get; private set; }
+            public EngineEdition EngineEdition { get; set; }
+            public bool IsAzure => EngineEdition == EngineEdition.Azure;
+            public string MachineName { get; set; }
+            public string ProductLevel { get; set; }
+
+            public void Initialize()
+            {
+                var firstPart = string.IsNullOrWhiteSpace(ProductVersion) ? "??" : ProductVersion.Split('.')[0];
+                switch (firstPart)
+                {
+                    case "??":
+                        ProductVersionName = VersionName.Invalid;
+                        break;
+                    case "12":
+                        ProductVersionName = VersionName.V2014;
+                        break;
+                    case "11":
+                        ProductVersionName = VersionName.V2012;
+                        break;
+                    case "10":
+                        ProductVersionName = VersionName.V2008;
+                        break;
+                    case "9":
+                        ProductVersionName = VersionName.V2005;
+                        break;
+                    case "8":
+                        ProductVersionName = VersionName.V2000;
+                        break;
+                    case "7":
+                        ProductVersionName = VersionName.V7;
+                        break;
+                    default:
+                        ProductVersionName = VersionName.Other;
+                        break;
+                }
+            }
+        }
+
+        private static ServerVersionInfo DetermineVersion(IDatabaseFactory factory)
+        {
+            // Edition: "Express Edition", "Windows Azure SQL Database..."
+            // EngineEdition: 1/Desktop 2/Standard 3/Enterprise 4/Express 5/Azure
+            // ProductLevel: RTM, SPx, CTP...
+
+            const string sql = @"select 
+	SERVERPROPERTY('Edition') Edition,
+	SERVERPROPERTY('EditionID') EditionId,
+	SERVERPROPERTY('InstanceName') InstanceName,
+	SERVERPROPERTY('ProductVersion') ProductVersion,
+	SERVERPROPERTY('BuildClrVersion') BuildClrVersion,
+	SERVERPROPERTY('EngineEdition') EngineEdition,
+	SERVERPROPERTY('IsClustered') IsClustered,
+	SERVERPROPERTY('MachineName') MachineName,
+	SERVERPROPERTY('ResourceLastUpdateDateTime') ResourceLastUpdateDateTime,
+	SERVERPROPERTY('ProductLevel') ProductLevel;";
+
+            try
+            {
+                var database = factory.GetDatabase();
+                var version = database.Fetch<ServerVersionInfo>(sql).First();
+                version.Initialize();
+                return version;
+            }
+            catch (Exception e)
+            {
+                // can't ignore, really
+                throw new Exception("Failed to determine Sql Server version (see inner exception).", e);
+            }
+        }
 
         /// <summary>
         /// SQL Server stores default values assigned to columns as constraints, it also stores them with named values, this is the only
@@ -127,16 +232,11 @@ order by T.name, I.name");
             return null;
         }
 
-        public override string DeleteDefaultConstraint
-        {
-            get { return "ALTER TABLE [{0}] DROP CONSTRAINT [DF_{0}_{1}]"; }
-        }
+        public override string DeleteDefaultConstraint => "ALTER TABLE [{0}] DROP CONSTRAINT [DF_{0}_{1}]";
 
-        
-        public override string DropIndex { get { return "DROP INDEX {0} ON {1}"; } }
 
-        public override string RenameColumn { get { return "sp_rename '{0}.{1}', '{2}', 'COLUMN'"; } }
+        public override string DropIndex => "DROP INDEX {0} ON {1}";
 
-        
+        public override string RenameColumn => "sp_rename '{0}.{1}', '{2}', 'COLUMN'";
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxProviders.cs b/src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxProviders.cs
index 9f3d337d67..f5e118e653 100644
--- a/src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxProviders.cs
+++ b/src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxProviders.cs
@@ -1,58 +1,20 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using Umbraco.Core.Logging;
-using Umbraco.Core.ObjectResolution;
 
 namespace Umbraco.Core.Persistence.SqlSyntax
 {
-    /// <summary>
-    /// Used to return the correct syntax provider for a given provider name
-    /// </summary>
+    // fixme - this exists ONLY for unit tests at the moment!
     public sealed class SqlSyntaxProviders 
     {
-        private readonly IEnumerable<ISqlSyntaxProvider> _syntaxProviders;
-
-        internal static SqlSyntaxProviders CreateDefault(ILogger logger)
+        public static IEnumerable<ISqlSyntaxProvider> GetDefaultProviders(ILogger logger)
         {
-            return new SqlSyntaxProviders(new ISqlSyntaxProvider[]
+            return new ISqlSyntaxProvider[]
             {
                 new MySqlSyntaxProvider(logger),
                 new SqlCeSyntaxProvider(),
-                new SqlServerSyntaxProvider()
-            });
-        }
-
-        /// <summary>
-		/// Constructor
-		/// </summary>
-        /// <param name="syntaxProviders"></param>
-        public SqlSyntaxProviders(IEnumerable<ISqlSyntaxProvider> syntaxProviders)
-        {
-            if (syntaxProviders == null) throw new ArgumentNullException("syntaxProviders");
-            _syntaxProviders = syntaxProviders;
-        }
-
-        /// <summary>
-        /// Gets a <see cref="ISqlSyntaxProvider"/> by its attributed provider.
-        /// </summary>
-        /// <param name="providerName">ProviderName from the ConnectionString settings</param>
-        /// <returns><see cref="ISqlSyntaxProvider"/> that corresponds to the attributed provider or the default Sql Server Syntax Provider.</returns>
-        public ISqlSyntaxProvider GetByProviderNameOrDefault(string providerName)
-        {
-            var provider =
-                _syntaxProviders.FirstOrDefault(
-                    x =>
-                    x.GetType()
-                     .FirstAttribute<SqlSyntaxProviderAttribute>()
-                     .ProviderName.ToLowerInvariant()
-                     .Equals(providerName.ToLowerInvariant()));
-
-            if (provider != null)
-                return provider;
-
-            //default
-            return _syntaxProviders.First(x => x.GetType() == typeof(SqlServerSyntaxProvider));
+                new SqlServerSyntaxProvider(new Lazy<IDatabaseFactory>(() => null))
+            };
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/UmbracoDatabase.cs b/src/Umbraco.Core/Persistence/UmbracoDatabase.cs
index eaf637df4b..9ad14529f6 100644
--- a/src/Umbraco.Core/Persistence/UmbracoDatabase.cs
+++ b/src/Umbraco.Core/Persistence/UmbracoDatabase.cs
@@ -1,13 +1,11 @@
 using System;
-using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
-using System.Linq;
 using NPoco;
 using StackExchange.Profiling;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence.FaultHandling;
-using Umbraco.Core.Persistence.Mappers;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence
 {
@@ -18,14 +16,15 @@ namespace Umbraco.Core.Persistence
     /// <para>Is used everywhere in place of the original NPoco Database object, and provides additional features
     /// such as profiling, retry policies, logging, etc.</para>
     /// <para>Is never created directly but obtained from the <see cref="DefaultDatabaseFactory"/>.</para>
+    /// <para>It implements IDisposeOnRequestEnd which means it will be disposed when the request ends, which
+    /// automatically closes the connection - as implemented by NPoco Database.Dispose().</para>
     /// </remarks>
-    public class UmbracoDatabase : Database, IDisposeOnRequestEnd
+    public class UmbracoDatabase : Database, IDisposeOnRequestEnd, IUmbracoDatabaseConfig
     {
         // Umbraco's default isolation level is RepeatableRead
         private const IsolationLevel DefaultIsolationLevel = IsolationLevel.RepeatableRead;
 
         private readonly ILogger _logger;
-        private readonly Guid _instanceId = Guid.NewGuid();
         private readonly RetryPolicy _connectionRetryPolicy;
         private readonly RetryPolicy _commandRetryPolicy;
         private bool _enableCount;
@@ -33,10 +32,9 @@ namespace Umbraco.Core.Persistence
         /// <summary>
         /// Used for testing
         /// </summary>
-        internal Guid InstanceId
-        {
-            get { return _instanceId; }
-        }
+        internal Guid InstanceId { get; } = Guid.NewGuid();
+
+        public ISqlSyntaxProvider SqlSyntax { get; }
 
         /// <summary>
         /// Generally used for testing, will output all SQL statements executed to the logger
@@ -68,29 +66,28 @@ namespace Umbraco.Core.Persistence
         // used by DefaultDatabaseFactory
         // creates one instance per request
         // also used by DatabaseContext for creating DBs and upgrading
-        public UmbracoDatabase(string connectionString, string providerName, ILogger logger, RetryPolicy connectionRetryPolicy = null, RetryPolicy commandRetryPolicy = null)
-            : base(connectionString, providerName, DefaultIsolationLevel)
+        public UmbracoDatabase(string connectionString,
+            ISqlSyntaxProvider sqlSyntax, DatabaseType databaseType, DbProviderFactory provider,
+            ILogger logger,
+            RetryPolicy connectionRetryPolicy = null, RetryPolicy commandRetryPolicy = null)
+            : base(connectionString, databaseType, provider, DefaultIsolationLevel)
         {
+            SqlSyntax = sqlSyntax;
             _logger = logger;
             _connectionRetryPolicy = connectionRetryPolicy;
             _commandRetryPolicy = commandRetryPolicy;
             EnableSqlTrace = false;
         }
 
-        // used by DefaultDatabaseFactory
-        // creates one instance per request
-        public UmbracoDatabase(string connectionStringName, ILogger logger, RetryPolicy connectionRetryPolicy = null, RetryPolicy commandRetryPolicy = null)
-            : base(connectionStringName, DefaultIsolationLevel)
+        // fixme: that could be an extension method of IUmbracoDatabaseConfig
+        public Sql<SqlContext> Sql()
         {
-            _logger = logger;
-            _connectionRetryPolicy = connectionRetryPolicy;
-            _commandRetryPolicy = commandRetryPolicy;
-            EnableSqlTrace = false;
+            return NPoco.Sql.BuilderFor(new SqlContext(this));
         }
 
         protected override DbConnection OnConnectionOpened(DbConnection connection)
         {
-            if (connection == null) throw new ArgumentNullException("connection");
+            if (connection == null) throw new ArgumentNullException(nameof(connection));
 
             // wrap the connection with a profiling connection that tracks timings
             connection = new StackExchange.Profiling.Data.ProfiledDbConnection(connection, MiniProfiler.Current);
@@ -130,10 +127,5 @@ namespace Umbraco.Core.Persistence
             }
             base.OnExecutedCommand(cmd);
         }
-
-        public IEnumerable<TResult> FetchByGroups<TResult, TSource>(IEnumerable<TSource> source, int groupSize, Func<IEnumerable<TSource>, Sql<SqlContext>> sqlFactory)
-        {
-            return source.SelectByGroups(x => Fetch<TResult>(sqlFactory(x)), groupSize);
-        }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/UnitOfWork/NPocoUnitOfWorkProvider.cs b/src/Umbraco.Core/Persistence/UnitOfWork/NPocoUnitOfWorkProvider.cs
index c8407eb08d..d6ac4cc36f 100644
--- a/src/Umbraco.Core/Persistence/UnitOfWork/NPocoUnitOfWorkProvider.cs
+++ b/src/Umbraco.Core/Persistence/UnitOfWork/NPocoUnitOfWorkProvider.cs
@@ -1,44 +1,52 @@
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.UnitOfWork
 {
     /// <summary>
-    /// Represents a Unit of Work Provider for creating a <see cref="NPocoUnitOfWork"/>.
+    /// Represents a <see cref="IDatabaseUnitOfWork"/> provider that creates <see cref="NPocoUnitOfWork"/> instances.
     /// </summary>
     public class NPocoUnitOfWorkProvider : IDatabaseUnitOfWorkProvider
     {
         private readonly IDatabaseFactory _dbFactory;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="NPocoUnitOfWorkProvider"/> class with an <see cref="IDatabaseFactory"/>.
+        /// Initializes a new instance of the <see cref="NPocoUnitOfWorkProvider"/> class with a database factory.
         /// </summary>
-        /// <param name="dbFactory"></param>
+        /// <param name="dbFactory">A database factory implementation.</param>
         public NPocoUnitOfWorkProvider(IDatabaseFactory dbFactory)
         {
-            Mandate.ParameterNotNull(dbFactory, "dbFactory");
+            Mandate.ParameterNotNull(dbFactory, nameof(dbFactory));
             _dbFactory = dbFactory;
         }
 
-        // for unit tests only
-        // will re-create a new DefaultDatabaseFactory each time it is called
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NPocoUnitOfWorkProvider"/> class with a logger.
+        /// </summary>
+        /// <param name="logger">A logger.</param>
+        /// <remarks>
+        /// <para>FOR UNIT TESTS ONLY</para>
+        /// <para>Creates a new <see cref="IDatabaseFactory"/> each time it is called, by initializing a new
+        /// <see cref="DefaultDatabaseFactory"/> with the default connection name, and default sql syntax providers.</para>
+        /// </remarks>
         internal NPocoUnitOfWorkProvider(ILogger logger)
-            : this(new DefaultDatabaseFactory(GlobalSettings.UmbracoConnectionName, logger))
+            : this(new DefaultDatabaseFactory(GlobalSettings.UmbracoConnectionName, SqlSyntaxProviders.GetDefaultProviders(logger), logger))
         { }
 
-        #region Implementation of IUnitOfWorkProvider
+        #region Implement IUnitOfWorkProvider
 
         /// <summary>
         /// Creates a unit of work around a database obtained from the database factory.
         /// </summary>
         /// <returns>A unit of work.</returns>
-        /// <remarks>The unit of work will execute on the current database returned by the database factory.</remarks>
+        /// <remarks>The unit of work will execute on the database returned by the database factory.</remarks>
         public IDatabaseUnitOfWork GetUnitOfWork()
         {
             // get a database from the factory - might be the "ambient" database eg
             // the one that's enlisted with the HttpContext - so it's not always a
             // "new" database.
-            var database = _dbFactory.CreateDatabase();
+            var database = _dbFactory.GetDatabase();
             return new NPocoUnitOfWork(database);
         }
 
diff --git a/src/Umbraco.Core/Services/EntityService.cs b/src/Umbraco.Core/Services/EntityService.cs
index 5f24eac64b..6fa5e521b9 100644
--- a/src/Umbraco.Core/Services/EntityService.cs
+++ b/src/Umbraco.Core/Services/EntityService.cs
@@ -87,7 +87,7 @@ namespace Umbraco.Core.Services
                         case UmbracoObjectTypes.DataType:
                         case UmbracoObjectTypes.DocumentTypeContainer:
                             return uow.Database.ExecuteScalar<int?>(
-                                 NPoco.Sql.BuilderFor(new SqlContext(RepositoryFactory.SqlSyntax, uow.Database))
+                                 uow.Database.Sql()
                                     .Select("id")
                                     .From<NodeDto>()
                                     .Where<NodeDto>(dto => dto.UniqueId == key));
@@ -129,7 +129,7 @@ namespace Umbraco.Core.Services
                         case UmbracoObjectTypes.Member:
                         case UmbracoObjectTypes.DataType:
                             return uow.Database.ExecuteScalar<Guid?>(
-                                 NPoco.Sql.BuilderFor(new SqlContext(RepositoryFactory.SqlSyntax, uow.Database))
+                                 uow.Database.Sql()
                                     .Select("uniqueID")
                                     .From<NodeDto>()
                                     .Where<NodeDto>(dto => dto.NodeId == id));
@@ -495,7 +495,7 @@ namespace Umbraco.Core.Services
         {
             using (var uow = UowProvider.GetUnitOfWork())
             {
-                var sql = NPoco.Sql.BuilderFor(new SqlContext(RepositoryFactory.SqlSyntax, uow.Database))
+                var sql = uow.Database.Sql()
                     .Select("nodeObjectType")
                     .From<NodeDto>()
                     .Where<NodeDto>(x => x.NodeId == id);
@@ -514,7 +514,7 @@ namespace Umbraco.Core.Services
         {
             using (var uow = UowProvider.GetUnitOfWork())
             {
-                var sql = NPoco.Sql.BuilderFor(new SqlContext(RepositoryFactory.SqlSyntax, uow.Database))
+                var sql = uow.Database.Sql()
                     .Select("nodeObjectType")
                     .From<NodeDto>()
                     .Where<NodeDto>(x => x.UniqueId == key);
diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj
index 26137a72bc..5c4591e4df 100644
--- a/src/Umbraco.Core/Umbraco.Core.csproj
+++ b/src/Umbraco.Core/Umbraco.Core.csproj
@@ -48,8 +48,12 @@
     <Reference Include="ICSharpCode.SharpZipLib">
       <HintPath>..\packages\SharpZipLib.0.86.0\lib\20\ICSharpCode.SharpZipLib.dll</HintPath>
     </Reference>
-    <Reference Include="LightInject, Version=4.0.8.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\LightInject.4.0.8\lib\net46\LightInject.dll</HintPath>
+    <Reference Include="LightInject, Version=4.0.9.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\LightInject.4.0.9\lib\net46\LightInject.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="LightInject.Annotation, Version=1.0.0.4, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\LightInject.Annotation.1.0.0.4\lib\net45\LightInject.Annotation.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="log4net, Version=1.2.15.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a, processorArchitecture=MSIL">
@@ -373,12 +377,15 @@
     <Compile Include="Models\PublishedContent\PublishedContentWithKeyWrapped.cs" />
     <Compile Include="Models\Rdbms\AccessDto.cs" />
     <Compile Include="ObjectResolution\ContainerSingleObjectResolver.cs" />
+    <Compile Include="Persistence\Constants-DbProviderNames.cs" />
     <Compile Include="Persistence\FaultHandling\RetryDbConnection.cs">
       <SubType>Component</SubType>
     </Compile>
+    <Compile Include="Persistence\IUmbracoDatabaseConfig.cs" />
     <Compile Include="Persistence\Mappers\AuditItemMapper.cs" />
     <Compile Include="Persistence\Mappers\IMappingResolver.cs" />
     <Compile Include="Persistence\Migrations\IMigrationResolver.cs" />
+    <Compile Include="Persistence\NPocoDatabaseTypeExtensions.cs" />
     <Compile Include="Persistence\Querying\QueryFactory.cs" />
     <Compile Include="Media\Exif\BitConverterEx.cs" />
     <Compile Include="Media\Exif\ExifBitConverter.cs" />
@@ -474,7 +481,7 @@
     <Compile Include="Persistence\Repositories\TaskTypeRepository.cs" />
     <Compile Include="Persistence\Repositories\TupleExtensions.cs" />
     <Compile Include="Persistence\SqlContext.cs" />
-    <Compile Include="Persistence\UmbracoSqlExtensions.cs" />
+    <Compile Include="Persistence\NPocoSqlExtensions.cs" />
     <Compile Include="PropertyEditors\DecimalValidator.cs" />
     <Compile Include="PropertyEditors\ValueConverters\GridValueConverter.cs" />
     <Compile Include="PropertyEditors\ValueConverters\DecimalValueConverter.cs" />
@@ -800,7 +807,6 @@
     <Compile Include="Persistence\DatabaseModelDefinitions\ModificationType.cs" />
     <Compile Include="Persistence\DatabaseModelDefinitions\SystemMethods.cs" />
     <Compile Include="Persistence\DatabaseModelDefinitions\TableDefinition.cs" />
-    <Compile Include="Persistence\DatabaseProviders.cs" />
     <Compile Include="Persistence\DefaultDatabaseFactory.cs" />
     <Compile Include="Persistence\Factories\ContentFactory.cs" />
     <Compile Include="Persistence\Factories\ContentTypeFactory.cs" />
diff --git a/src/Umbraco.Core/UmbracoApplicationBase.cs b/src/Umbraco.Core/UmbracoApplicationBase.cs
index 37941a5ff6..974c5c718b 100644
--- a/src/Umbraco.Core/UmbracoApplicationBase.cs
+++ b/src/Umbraco.Core/UmbracoApplicationBase.cs
@@ -36,8 +36,9 @@ namespace Umbraco.Core
         /// </summary>
         protected UmbracoApplicationBase()
         {
-            //create the container for the application, the boot managers are responsible for registrations
-            Container = new ServiceContainer();         
+            // create the container for the application, the boot managers are responsible for registrations
+            Container = new ServiceContainer();
+            Container.EnableAnnotatedConstructorInjection();
         }
 
         public event EventHandler ApplicationStarting;
diff --git a/src/Umbraco.Core/packages.config b/src/Umbraco.Core/packages.config
index 1cbbee0585..2ce24ebf04 100644
--- a/src/Umbraco.Core/packages.config
+++ b/src/Umbraco.Core/packages.config
@@ -2,7 +2,8 @@
 <packages>
   <package id="AutoMapper" version="4.2.1" targetFramework="net461" />
   <package id="HtmlAgilityPack" version="1.4.9" targetFramework="net45" />
-  <package id="LightInject" version="4.0.8" targetFramework="net461" />
+  <package id="LightInject" version="4.0.9" targetFramework="net461" />
+  <package id="LightInject.Annotation" version="1.0.0.4" targetFramework="net461" />
   <package id="log4net" version="2.0.5" targetFramework="net461" />
   <package id="Microsoft.AspNet.Identity.Core" version="2.2.1" targetFramework="net45" />
   <package id="Microsoft.AspNet.Identity.Owin" version="2.2.1" targetFramework="net45" />
diff --git a/src/Umbraco.Tests/BootManagers/CoreBootManagerTests.cs b/src/Umbraco.Tests/BootManagers/CoreBootManagerTests.cs
index 1a022cff83..731377d778 100644
--- a/src/Umbraco.Tests/BootManagers/CoreBootManagerTests.cs
+++ b/src/Umbraco.Tests/BootManagers/CoreBootManagerTests.cs
@@ -68,8 +68,7 @@ namespace Umbraco.Tests.BootManagers
                 container.Register<IUmbracoSettingsSection>(factory => SettingsForTests.GetDefault());
                 container.Register<DatabaseContext>(factory => new DatabaseContext(
                     factory.GetInstance<IDatabaseFactory>(),
-                    factory.GetInstance<ILogger>(),
-                    factory.GetInstance<SqlSyntaxProviders>()), new PerContainerLifetime());
+                    factory.GetInstance<ILogger>()), new PerContainerLifetime());
             }
         }
         
diff --git a/src/Umbraco.Tests/Cache/DistributedCache/DistributedCacheTests.cs b/src/Umbraco.Tests/Cache/DistributedCache/DistributedCacheTests.cs
index b72b24e501..aa103d7eae 100644
--- a/src/Umbraco.Tests/Cache/DistributedCache/DistributedCacheTests.cs
+++ b/src/Umbraco.Tests/Cache/DistributedCache/DistributedCacheTests.cs
@@ -22,6 +22,7 @@ namespace Umbraco.Tests.Cache.DistributedCache
         public void Setup()
         {
             var container = new ServiceContainer();
+            container.EnableAnnotatedConstructorInjection();
 
             ServerRegistrarResolver.Current = new ServerRegistrarResolver(
                 new TestServerRegistrar());
diff --git a/src/Umbraco.Tests/Cache/PublishedCache/PublishedMediaCacheTests.cs b/src/Umbraco.Tests/Cache/PublishedCache/PublishedMediaCacheTests.cs
index 87aaa3d84a..adac3bea9c 100644
--- a/src/Umbraco.Tests/Cache/PublishedCache/PublishedMediaCacheTests.cs
+++ b/src/Umbraco.Tests/Cache/PublishedCache/PublishedMediaCacheTests.cs
@@ -28,6 +28,8 @@ namespace Umbraco.Tests.Cache.PublishedCache
         protected override void FreezeResolution()
         {
             var container = new ServiceContainer();
+            container.EnableAnnotatedConstructorInjection();
+
             UrlSegmentProviderResolver.Current = new UrlSegmentProviderResolver(container, Mock.Of<ILogger>(), typeof(DefaultUrlSegmentProvider));
             PublishedContentModelFactoryResolver.Current = new PublishedContentModelFactoryResolver();
             base.FreezeResolution();
diff --git a/src/Umbraco.Tests/Migrations/AlterMigrationTests.cs b/src/Umbraco.Tests/Migrations/AlterMigrationTests.cs
index 9168ee6ace..856446f79a 100644
--- a/src/Umbraco.Tests/Migrations/AlterMigrationTests.cs
+++ b/src/Umbraco.Tests/Migrations/AlterMigrationTests.cs
@@ -1,8 +1,10 @@
 using System;
+using System.Data.Common;
 using System.Linq;
 using Moq;
 using NPoco;
 using NUnit.Framework;
+using Umbraco.Core;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Migrations;
@@ -14,15 +16,26 @@ namespace Umbraco.Tests.Migrations
     [TestFixture]
     public class AlterMigrationTests
     {
+        private ILogger _logger;
+        private ISqlSyntaxProvider _sqlSyntax;
+        private UmbracoDatabase _database;
+
+        [SetUp]
+        public void Setup()
+        {
+            _logger = Mock.Of<ILogger>();
+            _sqlSyntax = new SqlCeSyntaxProvider();
+
+            var dbProviderFactory = DbProviderFactories.GetFactory(Constants.DbProviderNames.SqlServer);
+            _database = new UmbracoDatabase("cstr", _sqlSyntax, DatabaseType.SqlServer2008, dbProviderFactory, _logger);
+        }
 
         [Test]
         public void Drop_Foreign_Key()
         {
             // Arrange
-            var sqlSyntax = new SqlCeSyntaxProvider();
-            // fixme Database vs UmbracoDatabase
-            var context = new MigrationContext(DatabaseProviders.SqlServerCE, new Database("test", "System.Data.SqlClient"), Mock.Of<ILogger>(), sqlSyntax);
-            var stub = new DropForeignKeyMigrationStub(sqlSyntax, Mock.Of<ILogger>());
+            var context = new MigrationContext(_database, _logger);
+            var stub = new DropForeignKeyMigrationStub(_logger);
 
             // Act
             stub.GetUpExpressions(context);
@@ -38,9 +51,8 @@ namespace Umbraco.Tests.Migrations
         public void Can_Get_Up_Migration_From_MigrationStub()
         {
             // Arrange
-            var sqlSyntax = new SqlCeSyntaxProvider();
-            var context = new MigrationContext(DatabaseProviders.SqlServerCE, null, Mock.Of<ILogger>(), sqlSyntax);
-            var stub = new AlterUserTableMigrationStub(sqlSyntax, Mock.Of<ILogger>());
+            var context = new MigrationContext(_database, _logger);
+            var stub = new AlterUserTableMigrationStub(_logger);
 
             // Act
             stub.GetUpExpressions(context);
diff --git a/src/Umbraco.Tests/Migrations/FindingMigrationsTest.cs b/src/Umbraco.Tests/Migrations/FindingMigrationsTest.cs
index a5ca3b81bf..c72dab6aec 100644
--- a/src/Umbraco.Tests/Migrations/FindingMigrationsTest.cs
+++ b/src/Umbraco.Tests/Migrations/FindingMigrationsTest.cs
@@ -56,7 +56,7 @@ namespace Umbraco.Tests.Migrations
 
             Assert.That(list.Count, Is.EqualTo(3));
 
-            var context = new MigrationContext(DatabaseProviders.SqlServerCE, DatabaseContext.Database, Logger, SqlSyntax);
+            var context = new MigrationContext(DatabaseContext.Database, Logger);
             foreach (var migration1 in list)
             {
                 var migration = (MigrationBase) migration1;
diff --git a/src/Umbraco.Tests/Migrations/MigrationRunnerTests.cs b/src/Umbraco.Tests/Migrations/MigrationRunnerTests.cs
index 5be8f9bda9..9e425565cb 100644
--- a/src/Umbraco.Tests/Migrations/MigrationRunnerTests.cs
+++ b/src/Umbraco.Tests/Migrations/MigrationRunnerTests.cs
@@ -1,10 +1,11 @@
-using System;
 using System.Collections.Generic;
+using System.Data.Common;
 using System.Linq;
 using Moq;
 using NPoco;
 using NUnit.Framework;
 using Semver;
+using Umbraco.Core;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Migrations;
@@ -17,24 +18,32 @@ namespace Umbraco.Tests.Migrations
     [TestFixture]
     public class MigrationRunnerTests
     {
+        private ILogger _logger;
+        private ISqlSyntaxProvider _sqlSyntax;
+        private UmbracoDatabase _database;
+
+        [SetUp]
+        public void Setup()
+        {
+            _logger = Mock.Of<ILogger>();
+            _sqlSyntax = new SqlCeSyntaxProvider();
+
+            var dbProviderFactory = DbProviderFactories.GetFactory(Constants.DbProviderNames.SqlCe);
+            _database = new UmbracoDatabase("cstr", _sqlSyntax, DatabaseType.SQLCe, dbProviderFactory, _logger);
+        }
+
         [Test]
         public void Executes_Only_One_Migration_For_Spanning_Multiple_Targets()
         {
             var runner = new MigrationRunner(
                 Mock.Of<IMigrationResolver>(),
                 Mock.Of<IMigrationEntryService>(),
-                Mock.Of<ILogger>(), new SemVersion(4, 0, 0), new SemVersion(6, 0, 0), "Test");
+                _logger, new SemVersion(4 /*, 0, 0*/), new SemVersion(6 /*, 0, 0*/), "Test");
 
-            var migrations = runner.OrderedUpgradeMigrations(new List<IMigration> { new MultiMigration(new SqlCeSyntaxProvider(), Mock.Of<ILogger>()) });
+            var migrations = runner.OrderedUpgradeMigrations(new List<IMigration> { new MultiMigration(_logger) });
+            var context = runner.InitializeMigrations(migrations.ToList(), _database /*, true*/);
 
-            var ctx = runner.InitializeMigrations(
-                //new List<IMigration> {new DoRunMigration(), new DoNotRunMigration()},
-                migrations.ToList(),
-                // fixme Database vs UmbracoDatabase
-                new Database("umbracoDbDSN")
-                , DatabaseProviders.SqlServerCE, Mock.Of<ISqlSyntaxProvider>(), true);
-
-            Assert.AreEqual(1, ctx.Expressions.Count);
+            Assert.AreEqual(1, context.Expressions.Count);
         }
 
         [Test]
@@ -43,18 +52,12 @@ namespace Umbraco.Tests.Migrations
             var runner = new MigrationRunner(
                 Mock.Of<IMigrationResolver>(),
                 Mock.Of<IMigrationEntryService>(),
-                Mock.Of<ILogger>(), new SemVersion(4, 0, 0), new SemVersion(5, 0, 0), "Test");
+                _logger, new SemVersion(4 /*, 0, 0*/), new SemVersion(5 /*, 0, 0*/), "Test");
 
-            var migrations = runner.OrderedUpgradeMigrations(new List<IMigration> { new MultiMigration(new SqlCeSyntaxProvider(), Mock.Of<ILogger>()) });
+            var migrations = runner.OrderedUpgradeMigrations(new List<IMigration> { new MultiMigration(_logger) });
+            var context = runner.InitializeMigrations(migrations.ToList(), _database /*, true*/);
 
-            var ctx = runner.InitializeMigrations(
-                //new List<IMigration> {new DoRunMigration(), new DoNotRunMigration()},
-                migrations.ToList(),
-                // fixme Database vs UmbracoDatabase
-                new Database("umbracoDbDSN")
-                , DatabaseProviders.SqlServerCE, Mock.Of<ISqlSyntaxProvider>(), true);
-
-            Assert.AreEqual(1, ctx.Expressions.Count);
+            Assert.AreEqual(1, context.Expressions.Count);
         }
 
         [Test]
@@ -63,36 +66,30 @@ namespace Umbraco.Tests.Migrations
             var runner = new MigrationRunner(
                 Mock.Of<IMigrationResolver>(),
                 Mock.Of<IMigrationEntryService>(),
-                Mock.Of<ILogger>(), new SemVersion(5, 0, 1), new SemVersion(6, 0, 0), "Test");
+                _logger, new SemVersion(5, 0, 1), new SemVersion(6 /*, 0, 0*/), "Test");
 
-            var migrations = runner.OrderedUpgradeMigrations(new List<IMigration> { new MultiMigration(new SqlCeSyntaxProvider(), Mock.Of<ILogger>()) });
+            var migrations = runner.OrderedUpgradeMigrations(new List<IMigration> { new MultiMigration(_logger) });
+            var context = runner.InitializeMigrations(migrations.ToList(), _database /*, true*/);
 
-            var ctx = runner.InitializeMigrations(
-                //new List<IMigration> {new DoRunMigration(), new DoNotRunMigration()},
-                migrations.ToList(),
-                // fixme Database vs UmbracoDatabase
-                new Database("umbracoDbDSN")
-                , DatabaseProviders.SqlServerCE, Mock.Of<ISqlSyntaxProvider>(), true);
-
-            Assert.AreEqual(1, ctx.Expressions.Count());
+            Assert.AreEqual(1, context.Expressions.Count);
         }
 
         [Migration("6.0.0", 1, "Test")]
         [Migration("5.0.0", 1, "Test")]
         private class MultiMigration : MigrationBase
         {
-            public MultiMigration(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-            {
-            }
+            public MultiMigration(ILogger logger) 
+                : base(logger)
+            { }
 
             public override void Up()
             {
-                Context.Expressions.Add(new AlterColumnExpression(DatabaseProviders.SqlServerCE, new []{DatabaseProviders.SqlServerCE}, SqlSyntax));
+                Context.Expressions.Add(new AlterColumnExpression(Context, new [] { DatabaseType.SQLCe }));
             }
 
             public override void Down()
             {
-                Context.Expressions.Add(new AlterColumnExpression(DatabaseProviders.SqlServerCE, new[] { DatabaseProviders.SqlServerCE }, SqlSyntax));
+                Context.Expressions.Add(new AlterColumnExpression(Context, new[] { DatabaseType.SQLCe }));
             }
         }
     }
diff --git a/src/Umbraco.Tests/Migrations/Stubs/AlterUserTableMigrationStub.cs b/src/Umbraco.Tests/Migrations/Stubs/AlterUserTableMigrationStub.cs
index a7985a1e7a..490ba94677 100644
--- a/src/Umbraco.Tests/Migrations/Stubs/AlterUserTableMigrationStub.cs
+++ b/src/Umbraco.Tests/Migrations/Stubs/AlterUserTableMigrationStub.cs
@@ -7,10 +7,9 @@ namespace Umbraco.Tests.Migrations.Stubs
     [MigrationAttribute("6.0.0", 0, "Test")]
     public class AlterUserTableMigrationStub : MigrationBase
     {
-
-        public AlterUserTableMigrationStub(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public AlterUserTableMigrationStub(ILogger logger) 
+            : base(logger)
+        { }
 
         public override void Up()
         {
@@ -21,7 +20,6 @@ namespace Umbraco.Tests.Migrations.Stubs
         }
 
         public override void Down()
-        {
-        }
+        { }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Tests/Migrations/Stubs/DropForeignKeyMigrationStub.cs b/src/Umbraco.Tests/Migrations/Stubs/DropForeignKeyMigrationStub.cs
index e24ca692e2..b24085f777 100644
--- a/src/Umbraco.Tests/Migrations/Stubs/DropForeignKeyMigrationStub.cs
+++ b/src/Umbraco.Tests/Migrations/Stubs/DropForeignKeyMigrationStub.cs
@@ -7,10 +7,9 @@ namespace Umbraco.Tests.Migrations.Stubs
     [Migration("1.0.0", 0, "Test")]
     public class DropForeignKeyMigrationStub : MigrationBase
     {
-        public DropForeignKeyMigrationStub(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        {
-        }
+        public DropForeignKeyMigrationStub(ILogger logger)
+            : base(logger)
+        { }
 
         public override void Up()
         {
diff --git a/src/Umbraco.Tests/Migrations/Stubs/FiveZeroMigration.cs b/src/Umbraco.Tests/Migrations/Stubs/FiveZeroMigration.cs
index 86a867391c..132cd54792 100644
--- a/src/Umbraco.Tests/Migrations/Stubs/FiveZeroMigration.cs
+++ b/src/Umbraco.Tests/Migrations/Stubs/FiveZeroMigration.cs
@@ -7,9 +7,9 @@ namespace Umbraco.Tests.Migrations.Stubs
     [Migration("5.0.0", 0, "Test")]
     public class FiveZeroMigration : MigrationBase
     {
-        public FiveZeroMigration(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public FiveZeroMigration(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Tests/Migrations/Stubs/FourElevenMigration.cs b/src/Umbraco.Tests/Migrations/Stubs/FourElevenMigration.cs
index b79d0b042b..cd6e908c31 100644
--- a/src/Umbraco.Tests/Migrations/Stubs/FourElevenMigration.cs
+++ b/src/Umbraco.Tests/Migrations/Stubs/FourElevenMigration.cs
@@ -7,9 +7,9 @@ namespace Umbraco.Tests.Migrations.Stubs
     [Migration("4.11.0", 0, "Test")]
     public class FourElevenMigration : MigrationBase
     {
-        public FourElevenMigration(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public FourElevenMigration(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Tests/Migrations/Stubs/SixZeroMigration1.cs b/src/Umbraco.Tests/Migrations/Stubs/SixZeroMigration1.cs
index a8a73b8e19..c12b9fd890 100644
--- a/src/Umbraco.Tests/Migrations/Stubs/SixZeroMigration1.cs
+++ b/src/Umbraco.Tests/Migrations/Stubs/SixZeroMigration1.cs
@@ -7,9 +7,9 @@ namespace Umbraco.Tests.Migrations.Stubs
     [MigrationAttribute("6.0.0", 1, "Test")]
     public class SixZeroMigration1 : MigrationBase
     {
-        public SixZeroMigration1(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public SixZeroMigration1(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
@@ -21,7 +21,5 @@ namespace Umbraco.Tests.Migrations.Stubs
         {
             Alter.Table("umbracoUser").AlterColumn("passwordTip").AsString(100);
         }
-
-        
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Tests/Migrations/Stubs/SixZeroMigration2.cs b/src/Umbraco.Tests/Migrations/Stubs/SixZeroMigration2.cs
index 7773a8ce56..184be71561 100644
--- a/src/Umbraco.Tests/Migrations/Stubs/SixZeroMigration2.cs
+++ b/src/Umbraco.Tests/Migrations/Stubs/SixZeroMigration2.cs
@@ -7,9 +7,9 @@ namespace Umbraco.Tests.Migrations.Stubs
     [Migration("6.0.0", 2, "Test")]
     public class SixZeroMigration2 : MigrationBase
     {
-        public SixZeroMigration2(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
-        {
-        }
+        public SixZeroMigration2(ILogger logger) 
+            : base(logger)
+        { }
 
 
         public override void Up()
diff --git a/src/Umbraco.Tests/Migrations/Upgrades/BaseUpgradeTest.cs b/src/Umbraco.Tests/Migrations/Upgrades/BaseUpgradeTest.cs
index e21ee81e2b..0f11e0b4f5 100644
--- a/src/Umbraco.Tests/Migrations/Upgrades/BaseUpgradeTest.cs
+++ b/src/Umbraco.Tests/Migrations/Upgrades/BaseUpgradeTest.cs
@@ -1,14 +1,11 @@
 using System;
-using System.Collections.Generic;
 using System.Text.RegularExpressions;
 using Moq;
 using NPoco;
 using NUnit.Framework;
 using Semver;
 using Umbraco.Core;
-using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
-using Umbraco.Core.ObjectResolution;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Migrations;
 using Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSix;
@@ -43,23 +40,22 @@ namespace Umbraco.Tests.Migrations.Upgrades
         {
             var configuredVersion = new SemVersion(4, 7, 0);
             var targetVersion = new SemVersion(6, 0, 0);
-            var provider = GetDatabaseProvider();
             var db = GetConfiguredDatabase();
 
             //Create db schema and data from old Total.sql file for Sql Ce
-            string statements = GetDatabaseSpecificSqlScript();
+            var statements = GetDatabaseSpecificSqlScript();
             // replace block comments by whitespace
             statements = FindComments.Replace(statements, " ");
             // execute all non-empty statements
-            foreach (string statement in statements.Split(";".ToCharArray()))
+            foreach (var statement in statements.Split(";".ToCharArray()))
             {
-                string rawStatement = statement.Replace("GO", "").Trim();
+                var rawStatement = statement.Replace("GO", "").Trim();
                 if (rawStatement.Length > 0)
                     db.Execute(new Sql(rawStatement));
             }
 
             var logger = Mock.Of<ILogger>();
-            var sql = GetSyntaxProvider();
+            var sqlSyntax = db.SqlSyntax;
 
             //Setup the MigrationRunner
             var migrationRunner = new MigrationRunner(
@@ -70,28 +66,28 @@ namespace Umbraco.Tests.Migrations.Upgrades
                 targetVersion,
                 GlobalSettings.UmbracoMigrationName,
                 //pass in explicit migrations
-                new Core.Persistence.Migrations.Upgrades.TargetVersionFourNineZero.RemoveUmbracoAppConstraints(sql, logger),
-                new DeleteAppTables(sql, logger),
-                new EnsureAppsTreesUpdated(sql, logger),
-                new MoveMasterContentTypeData(sql, logger),
-                new NewCmsContentType2ContentTypeTable(sql, logger),
-                new RemoveMasterContentTypeColumn(sql, logger),
-                new RenameCmsTabTable(sql, logger),
-                new RenameTabIdColumn(sql, logger),
-                new UpdateCmsContentTypeAllowedContentTypeTable(sql, logger),
-                new UpdateCmsContentTypeTable(sql, logger),
-                new UpdateCmsContentVersionTable(sql, logger),
-                new UpdateCmsPropertyTypeGroupTable(sql, logger));
+                new Core.Persistence.Migrations.Upgrades.TargetVersionFourNineZero.RemoveUmbracoAppConstraints(logger),
+                new DeleteAppTables(logger),
+                new EnsureAppsTreesUpdated(logger),
+                new MoveMasterContentTypeData(logger),
+                new NewCmsContentType2ContentTypeTable(logger),
+                new RemoveMasterContentTypeColumn(logger),
+                new RenameCmsTabTable(logger),
+                new RenameTabIdColumn(logger),
+                new UpdateCmsContentTypeAllowedContentTypeTable(logger),
+                new UpdateCmsContentTypeTable(logger),
+                new UpdateCmsContentVersionTable(logger),
+                new UpdateCmsPropertyTypeGroupTable(logger));
 
-            bool upgraded = migrationRunner.Execute(db, provider, sql, true);
+            var upgraded = migrationRunner.Execute(db /*, true*/);
 
             Assert.That(upgraded, Is.True);
 
-            var schemaHelper = new DatabaseSchemaHelper(db, Mock.Of<ILogger>(), sql);
+            var schemaHelper = new DatabaseSchemaHelper(db, logger);
 
-            bool hasTabTable = schemaHelper.TableExist("cmsTab");
-            bool hasPropertyTypeGroupTable = schemaHelper.TableExist("cmsPropertyTypeGroup");
-            bool hasAppTreeTable = schemaHelper.TableExist("umbracoAppTree");
+            var hasTabTable = schemaHelper.TableExist("cmsTab");
+            var hasPropertyTypeGroupTable = schemaHelper.TableExist("cmsPropertyTypeGroup");
+            var hasAppTreeTable = schemaHelper.TableExist("umbracoAppTree");
 
             Assert.That(hasTabTable, Is.False);
             Assert.That(hasPropertyTypeGroupTable, Is.True);
@@ -114,9 +110,7 @@ namespace Umbraco.Tests.Migrations.Upgrades
         public string Path { get; set; }
         public abstract void DatabaseSpecificSetUp();
         public abstract void DatabaseSpecificTearDown();
-        public abstract ISqlSyntaxProvider GetSyntaxProvider();
         public abstract UmbracoDatabase GetConfiguredDatabase();
-        public abstract DatabaseProviders GetDatabaseProvider();
         public abstract string GetDatabaseSpecificSqlScript();
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Tests/Migrations/Upgrades/MySqlUpgradeTest.cs b/src/Umbraco.Tests/Migrations/Upgrades/MySqlUpgradeTest.cs
index bdcb55a4a7..aceb707c9d 100644
--- a/src/Umbraco.Tests/Migrations/Upgrades/MySqlUpgradeTest.cs
+++ b/src/Umbraco.Tests/Migrations/Upgrades/MySqlUpgradeTest.cs
@@ -1,5 +1,8 @@
-using Moq;
+using System.Data.Common;
+using Moq;
+using NPoco;
 using NUnit.Framework;
+using Umbraco.Core;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.SqlSyntax;
@@ -19,19 +22,12 @@ namespace Umbraco.Tests.Migrations.Upgrades
             //TODO Remove created database here
         }
 
-        public override ISqlSyntaxProvider GetSyntaxProvider()
-        {
-            return new MySqlSyntaxProvider(Mock.Of<ILogger>());
-        }
-
         public override UmbracoDatabase GetConfiguredDatabase()
         {
-            return new UmbracoDatabase("Server = 169.254.120.3; Database = upgradetest; Uid = umbraco; Pwd = umbraco", "MySql.Data.MySqlClient", Mock.Of<ILogger>());
-        }
-
-        public override DatabaseProviders GetDatabaseProvider()
-        {
-            return DatabaseProviders.MySql;
+            var databaseType = DatabaseType.MySQL;
+            var sqlSyntax = new MySqlSyntaxProvider(Mock.Of<ILogger>());
+            var dbProviderFactory = DbProviderFactories.GetFactory(Constants.DbProviderNames.MySql);
+            return new UmbracoDatabase("Server = 169.254.120.3; Database = upgradetest; Uid = umbraco; Pwd = umbraco", sqlSyntax, databaseType, dbProviderFactory, Mock.Of<ILogger>());
         }
 
         public override string GetDatabaseSpecificSqlScript()
diff --git a/src/Umbraco.Tests/Migrations/Upgrades/SqlCeDataUpgradeTest.cs b/src/Umbraco.Tests/Migrations/Upgrades/SqlCeDataUpgradeTest.cs
index d8d4bd5fe2..12ee192a7d 100644
--- a/src/Umbraco.Tests/Migrations/Upgrades/SqlCeDataUpgradeTest.cs
+++ b/src/Umbraco.Tests/Migrations/Upgrades/SqlCeDataUpgradeTest.cs
@@ -1,8 +1,11 @@
 using System;
+using System.Data.Common;
 using Moq;
+using NPoco;
 using NUnit.Framework;
 using Semver;
 using SQLCE4Umbraco;
+using Umbraco.Core;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Migrations;
@@ -20,13 +23,11 @@ namespace Umbraco.Tests.Migrations.Upgrades
         [Test, NUnit.Framework.Ignore]
         public override void Can_Upgrade_From_470_To_600()
         {
-            var sqlSyntax = Mock.Of<ISqlSyntaxProvider>();
             var configuredVersion = new SemVersion(4, 11, 0);
             var targetVersion = new SemVersion(6, 0, 0);
-            var provider = GetDatabaseProvider();
             var db = GetConfiguredDatabase();
 
-            var fix = new PublishAfterUpgradeToVersionSixth(sqlSyntax);
+            var fix = new PublishAfterUpgradeToVersionSixth(db.SqlSyntax);
 
             //Setup the MigrationRunner
             var migrationRunner = new MigrationRunner(
@@ -34,11 +35,11 @@ namespace Umbraco.Tests.Migrations.Upgrades
                 Mock.Of<IMigrationEntryService>(),
                 Mock.Of<ILogger>(), configuredVersion, targetVersion, GlobalSettings.UmbracoMigrationName);
 
-            bool upgraded = migrationRunner.Execute(db, provider, sqlSyntax, true);
+            bool upgraded = migrationRunner.Execute(db /*, true*/);
 
             Assert.That(upgraded, Is.True);
 
-            var schemaHelper = new DatabaseSchemaHelper(db, Mock.Of<ILogger>(), sqlSyntax);
+            var schemaHelper = new DatabaseSchemaHelper(db, Mock.Of<ILogger>());
 
             bool hasTabTable = schemaHelper.TableExist("cmsTab");
             bool hasPropertyTypeGroupTable = schemaHelper.TableExist("cmsPropertyTypeGroup");
@@ -61,19 +62,12 @@ namespace Umbraco.Tests.Migrations.Upgrades
             SqlCeContextGuardian.CloseBackgroundConnection();
         }
 
-        public override ISqlSyntaxProvider GetSyntaxProvider()
-        {
-            return new SqlCeSyntaxProvider();
-        }
-
         public override UmbracoDatabase GetConfiguredDatabase()
         {
-            return new UmbracoDatabase("Datasource=|DataDirectory|UmbracoNPocoTests.sdf;Flush Interval=1;", "System.Data.SqlServerCe.4.0", Mock.Of<ILogger>());
-        }
-
-        public override DatabaseProviders GetDatabaseProvider()
-        {
-            return DatabaseProviders.SqlServerCE;
+            var databaseType = DatabaseType.SQLCe;
+            var sqlSyntax = new SqlCeSyntaxProvider();
+            var dbProviderFactory = DbProviderFactories.GetFactory(Constants.DbProviderNames.SqlCe);
+            return new UmbracoDatabase("Datasource=|DataDirectory|UmbracoNPocoTests.sdf;Flush Interval=1;", sqlSyntax, databaseType, dbProviderFactory, Mock.Of<ILogger>());
         }
 
         public override string GetDatabaseSpecificSqlScript()
diff --git a/src/Umbraco.Tests/Migrations/Upgrades/SqlCeUpgradeTest.cs b/src/Umbraco.Tests/Migrations/Upgrades/SqlCeUpgradeTest.cs
index 6e889313f8..d0fcc3d996 100644
--- a/src/Umbraco.Tests/Migrations/Upgrades/SqlCeUpgradeTest.cs
+++ b/src/Umbraco.Tests/Migrations/Upgrades/SqlCeUpgradeTest.cs
@@ -1,10 +1,13 @@
 using System;
 using System.Configuration;
+using System.Data.Common;
 using System.Data.SqlServerCe;
 using System.IO;
 using Moq;
+using NPoco;
 using NUnit.Framework;
 using SQLCE4Umbraco;
+using Umbraco.Core;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.SqlSyntax;
@@ -58,19 +61,12 @@ namespace Umbraco.Tests.Migrations.Upgrades
             TestHelper.ClearDatabase();
         }
 
-        public override ISqlSyntaxProvider GetSyntaxProvider()
-        {
-            return new SqlCeSyntaxProvider();
-        }
-
         public override UmbracoDatabase GetConfiguredDatabase()
         {
-            return new UmbracoDatabase("Datasource=|DataDirectory|UmbracoNPocoTests.sdf;Flush Interval=1;", "System.Data.SqlServerCe.4.0", Mock.Of<ILogger>());
-        }
-
-        public override DatabaseProviders GetDatabaseProvider()
-        {
-            return DatabaseProviders.SqlServerCE;
+            var databaseType = DatabaseType.SQLCe;
+            var sqlSyntax = new SqlCeSyntaxProvider();
+            var dbProviderFactory = DbProviderFactories.GetFactory(Constants.DbProviderNames.SqlCe);
+            return new UmbracoDatabase("Datasource=|DataDirectory|UmbracoNPocoTests.sdf;Flush Interval=1;", sqlSyntax, databaseType, dbProviderFactory, Mock.Of<ILogger>());
         }
 
         public override string GetDatabaseSpecificSqlScript()
diff --git a/src/Umbraco.Tests/Migrations/Upgrades/SqlServerUpgradeTest.cs b/src/Umbraco.Tests/Migrations/Upgrades/SqlServerUpgradeTest.cs
index 8b5fc13114..7f6e68d597 100644
--- a/src/Umbraco.Tests/Migrations/Upgrades/SqlServerUpgradeTest.cs
+++ b/src/Umbraco.Tests/Migrations/Upgrades/SqlServerUpgradeTest.cs
@@ -1,4 +1,7 @@
-using Moq;
+using System;
+using System.Data.Common;
+using Moq;
+using NPoco;
 using NUnit.Framework;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
@@ -17,19 +20,12 @@ namespace Umbraco.Tests.Migrations.Upgrades
         {
         }
 
-        public override ISqlSyntaxProvider GetSyntaxProvider()
-        {
-            return new SqlServerSyntaxProvider();
-        }
-
         public override UmbracoDatabase GetConfiguredDatabase()
         {
-            return new UmbracoDatabase(@"server=.\SQLEXPRESS;database=EmptyForTest;user id=umbraco;password=umbraco", "System.Data.SqlClient", Mock.Of<ILogger>());
-        }
-
-        public override DatabaseProviders GetDatabaseProvider()
-        {
-            return DatabaseProviders.SqlServer;
+            var databaseType = DatabaseType.SqlServer2008;
+            var sqlSyntax = new SqlServerSyntaxProvider(new Lazy<IDatabaseFactory>(() => null));
+            var dbProviderFactory = DbProviderFactories.GetFactory("System.Data.SqlClient");
+            return new UmbracoDatabase(@"server=.\SQLEXPRESS;database=EmptyForTest;user id=umbraco;password=umbraco", sqlSyntax, databaseType, dbProviderFactory, Mock.Of<ILogger>());
         }
 
         public override string GetDatabaseSpecificSqlScript()
diff --git a/src/Umbraco.Tests/Migrations/Upgrades/ValidateOlderSchemaTest.cs b/src/Umbraco.Tests/Migrations/Upgrades/ValidateOlderSchemaTest.cs
index 0b761d0a67..918bb88bf1 100644
--- a/src/Umbraco.Tests/Migrations/Upgrades/ValidateOlderSchemaTest.cs
+++ b/src/Umbraco.Tests/Migrations/Upgrades/ValidateOlderSchemaTest.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Configuration;
+using System.Data.Common;
 using System.Data.SqlServerCe;
 using System.IO;
 using System.Text.RegularExpressions;
@@ -7,6 +8,7 @@ using Moq;
 using NPoco;
 using NUnit.Framework;
 using SQLCE4Umbraco;
+using Umbraco.Core;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.ObjectResolution;
@@ -28,7 +30,7 @@ namespace Umbraco.Tests.Migrations.Upgrades
         {
             // Arrange
             var db = GetConfiguredDatabase();
-            var schema = new DatabaseSchemaCreation(db, Mock.Of<ILogger>(), new SqlCeSyntaxProvider());
+            var schema = new DatabaseSchemaCreation(db, Mock.Of<ILogger>());
 
             //Create db schema and data from old Total.sql file for Sql Ce
             string statements = GetDatabaseSpecificSqlScript();
@@ -100,7 +102,9 @@ namespace Umbraco.Tests.Migrations.Upgrades
 
         public UmbracoDatabase GetConfiguredDatabase()
         {
-            return new UmbracoDatabase("Datasource=|DataDirectory|UmbracoNPocoTests.sdf;Flush Interval=1;", "System.Data.SqlServerCe.4.0", Mock.Of<ILogger>());
+            var databaseType = DatabaseType.SQLCe;
+            var dbProviderFactory = DbProviderFactories.GetFactory(Constants.DbProviderNames.SqlCe);
+            return new UmbracoDatabase("Datasource=|DataDirectory|UmbracoNPocoTests.sdf;Flush Interval=1;", new SqlCeSyntaxProvider(), databaseType, dbProviderFactory, Mock.Of<ILogger>());
         }
 
         public string GetDatabaseSpecificSqlScript()
diff --git a/src/Umbraco.Tests/Migrations/Upgrades/ValidateV7UpgradeTest.cs b/src/Umbraco.Tests/Migrations/Upgrades/ValidateV7UpgradeTest.cs
index 6822728ad4..c21da772b6 100644
--- a/src/Umbraco.Tests/Migrations/Upgrades/ValidateV7UpgradeTest.cs
+++ b/src/Umbraco.Tests/Migrations/Upgrades/ValidateV7UpgradeTest.cs
@@ -1,7 +1,9 @@
-using System.Linq;
+using System.Data.Common;
+using System.Linq;
 using Moq;
 using NPoco;
 using NUnit.Framework;
+using Umbraco.Core;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Migrations;
@@ -13,16 +15,25 @@ namespace Umbraco.Tests.Migrations.Upgrades
     [TestFixture]
     public class ValidateV7UpgradeTest
     {
-       
+        private ILogger _logger;
+        private ISqlSyntaxProvider _sqlSyntax;
+        private UmbracoDatabase _database;
+
+        [SetUp]
+        public void Setup()
+        {
+            _logger = Mock.Of<ILogger>();
+            _sqlSyntax = new SqlCeSyntaxProvider();
+
+            var dbProviderFactory = DbProviderFactories.GetFactory(Constants.DbProviderNames.SqlCe);
+            _database = new UmbracoDatabase("cstr", _sqlSyntax, DatabaseType.SQLCe, dbProviderFactory, _logger);
+        }
 
         [Test]
         public void Validate_AddIndexToCmsMacroTable()
         {
-            var sqlSyntax = new SqlCeSyntaxProvider();
-            var migration = new AddIndexToCmsMacroTable(true, sqlSyntax, Mock.Of<ILogger>());
-            // fixme Database vs UmbracoDatabase
-            var migrationContext = new MigrationContext(DatabaseProviders.SqlServerCE, new Database("test", "System.Data.SqlClient"), Mock.Of<ILogger>(),
-                sqlSyntax);
+            var migration = new AddIndexToCmsMacroTable(true, _logger);
+            var migrationContext = new MigrationContext(_database, _logger);
             migration.GetUpExpressions(migrationContext);
 
             Assert.AreEqual(1, migrationContext.Expressions.Count);
@@ -35,10 +46,8 @@ namespace Umbraco.Tests.Migrations.Upgrades
         [Test]
         public void Validate_AddIndexToCmsMacroPropertyTable()
         {
-            var sqlSyntax = new SqlCeSyntaxProvider();
-            var migration = new AddIndexToCmsMacroPropertyTable(true, sqlSyntax, Mock.Of<ILogger>());
-            // fixme Database vs UmbracoDatabase
-            var migrationContext = new MigrationContext(DatabaseProviders.SqlServerCE, new Database("test", "System.Data.SqlClient"), Mock.Of<ILogger>(), sqlSyntax);
+            var migration = new AddIndexToCmsMacroTable(true, _logger);
+            var migrationContext = new MigrationContext(_database, _logger);
             migration.GetUpExpressions(migrationContext);
 
             Assert.AreEqual(1, migrationContext.Expressions.Count);
diff --git a/src/Umbraco.Tests/MockTests.cs b/src/Umbraco.Tests/MockTests.cs
index d9a8ef785e..353923ec30 100644
--- a/src/Umbraco.Tests/MockTests.cs
+++ b/src/Umbraco.Tests/MockTests.cs
@@ -46,7 +46,7 @@ namespace Umbraco.Tests
         [Test]
         public void Can_Create_Db_Context()
         {
-            var dbCtx = new DatabaseContext(new Mock<IDatabaseFactory>().Object, Mock.Of<ILogger>(), Mock.Of<ISqlSyntaxProvider>(), "test");
+            var dbCtx = new DatabaseContext(new Mock<IDatabaseFactory>().Object, Mock.Of<ILogger>());
             Assert.Pass();
         }
 
@@ -54,7 +54,7 @@ namespace Umbraco.Tests
         public void Can_Create_App_Context_With_Services()
         {
             var appCtx = new ApplicationContext(
-                new DatabaseContext(new Mock<IDatabaseFactory>().Object, Mock.Of<ILogger>(), Mock.Of<ISqlSyntaxProvider>(), "test"),
+                new DatabaseContext(new Mock<IDatabaseFactory>().Object, Mock.Of<ILogger>()),
                 MockHelper.GetMockedServiceContext(),
                 CacheHelper.CreateDisabledCacheHelper(),
                 new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>()));
diff --git a/src/Umbraco.Tests/Models/Mapping/ContentTypeModelMappingTests.cs b/src/Umbraco.Tests/Models/Mapping/ContentTypeModelMappingTests.cs
index 6fa7499553..6839d6f2c6 100644
--- a/src/Umbraco.Tests/Models/Mapping/ContentTypeModelMappingTests.cs
+++ b/src/Umbraco.Tests/Models/Mapping/ContentTypeModelMappingTests.cs
@@ -45,7 +45,7 @@ namespace Umbraco.Tests.Models.Mapping
 
             //Create an app context using mocks
             var appContext = new ApplicationContext(
-                new DatabaseContext(Mock.Of<IDatabaseFactory>(), logger, Mock.Of<ISqlSyntaxProvider>(), "test"),
+                new DatabaseContext(Mock.Of<IDatabaseFactory>(), logger),
                 
                 //Create service context using mocks
                 new ServiceContext(
diff --git a/src/Umbraco.Tests/Persistence/DatabaseContextTests.cs b/src/Umbraco.Tests/Persistence/DatabaseContextTests.cs
index db6bab1160..40063cdd8b 100644
--- a/src/Umbraco.Tests/Persistence/DatabaseContextTests.cs
+++ b/src/Umbraco.Tests/Persistence/DatabaseContextTests.cs
@@ -3,6 +3,7 @@ using System.Configuration;
 using System.Data.SqlServerCe;
 using System.IO;
 using Moq;
+using NPoco;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Logging;
@@ -19,15 +20,23 @@ namespace Umbraco.Tests.Persistence
     public class DatabaseContextTests
     {
 	    private DatabaseContext _dbContext;
+        private ILogger _logger;
+        private SqlCeSyntaxProvider _sqlCeSyntaxProvider;
+        private ISqlSyntaxProvider[] _sqlSyntaxProviders;
 
 		[SetUp]
 		public void Setup()
 		{
-            _dbContext = new DatabaseContext(
-                new DefaultDatabaseFactory(Core.Configuration.GlobalSettings.UmbracoConnectionName, Mock.Of<ILogger>()),
-                Mock.Of<ILogger>(), new SqlCeSyntaxProvider(), "System.Data.SqlServerCe.4.0");
+            // create the database factory and database context
+            _sqlCeSyntaxProvider = new SqlCeSyntaxProvider();
+            _sqlSyntaxProviders = new[] { (ISqlSyntaxProvider) _sqlCeSyntaxProvider };
+            _logger = Mock.Of<ILogger>();
+            var dbFactory = new DefaultDatabaseFactory(Core.Configuration.GlobalSettings.UmbracoConnectionName, _sqlSyntaxProviders, _logger);
+            _dbContext = new DatabaseContext(dbFactory, _logger);
 
-			//unfortunately we have to set this up because the NPocoExtensions require singleton access
+			// unfortunately we have to set this up because the NPocoExtensions require singleton access
+            // fixme - there is no need for this!
+            /*
 			ApplicationContext.Current = new ApplicationContext(
                 CacheHelper.CreateDisabledCacheHelper(),
                 new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>()))
@@ -35,13 +44,17 @@ namespace Umbraco.Tests.Persistence
 					DatabaseContext = _dbContext,
 					IsReady = true
 				};
+            */
 		}
 
 		[TearDown]
 		public void TearDown()
 		{
 			_dbContext = null;
+            // fixme - no need
+            /*
 			ApplicationContext.Current = null;
+            */
 		}
 
         [Test]
@@ -54,58 +67,51 @@ namespace Umbraco.Tests.Persistence
         }
 
         [Test]
-        public void Can_Assert_DatabaseProvider()
+        public void Can_Assert_DatabaseType()
         {
-			var provider = _dbContext.DatabaseProvider;
+			var databaseType = _dbContext.Database.DatabaseType;
 
-            Assert.AreEqual(DatabaseProviders.SqlServerCE, provider);
+            Assert.AreEqual(DatabaseType.SQLCe, databaseType);
         }
 
         [Test]
         public void Can_Assert_Created_Database()
         {
-            string path = TestHelper.CurrentAssemblyDirectory;
+            var path = TestHelper.CurrentAssemblyDirectory;
             AppDomain.CurrentDomain.SetData("DataDirectory", path);
 
-            //Delete database file before continueing
-            //NOTE: we'll use a custom db file for this test since we're re-using the one created with BaseDatabaseFactoryTest
-            string filePath = string.Concat(path, "\\DatabaseContextTests.sdf");
+            // delete database file
+            // NOTE: using a custom db file for this test since we're re-using the one created with BaseDatabaseFactoryTest
+            var filePath = string.Concat(path, "\\DatabaseContextTests.sdf");
             if (File.Exists(filePath))
-            {
                 File.Delete(filePath);
-            }
 
-            //Get the connectionstring settings from config
+            // get the connectionstring settings from config
             var settings = ConfigurationManager.ConnectionStrings[Core.Configuration.GlobalSettings.UmbracoConnectionName];
 
-            //by default the conn string is: Datasource=|DataDirectory|UmbracoNPocoTests.sdf;Flush Interval=1;
-            //we'll just replace the sdf file with our custom one:
-            //Create the Sql CE database
+            // by default the conn string is: Datasource=|DataDirectory|UmbracoNPocoTests.sdf;Flush Interval=1;
+            // replace the SDF file with our own and create the sql ce database
             var engine = new SqlCeEngine(settings.ConnectionString.Replace("UmbracoNPocoTests", "DatabaseContextTests"));
             engine.CreateDatabase();
 
-            var dbFactory = new DefaultDatabaseFactory(engine.LocalConnectionString, "System.Data.SqlServerCe.4.0", Mock.Of<ILogger>());
-            //re-map the dbcontext to the new conn string
-            _dbContext = new DatabaseContext(
-                dbFactory,
-                Mock.Of<ILogger>(),
-                new SqlCeSyntaxProvider(),
-                dbFactory.ProviderName);
-
-            var schemaHelper = new DatabaseSchemaHelper(_dbContext.Database, Mock.Of<ILogger>(), new SqlCeSyntaxProvider());
+            // re-create the database factory and database context with proper connection string
+            var dbFactory = new DefaultDatabaseFactory(engine.LocalConnectionString, _sqlSyntaxProviders, _logger);
+            _dbContext = new DatabaseContext(dbFactory, _logger);
 
+            // create application context
             var appCtx = new ApplicationContext(
-                new DatabaseContext(Mock.Of<IDatabaseFactory>(), Mock.Of<ILogger>(), Mock.Of<ISqlSyntaxProvider>(), "test"),
+                _dbContext,
                 new ServiceContext(migrationEntryService: Mock.Of<IMigrationEntryService>()),
                 CacheHelper.CreateDisabledCacheHelper(),
                 new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>()));
 
-            //Create the umbraco database
+            // create the umbraco database
+            var schemaHelper = new DatabaseSchemaHelper(_dbContext.Database, _logger);
             schemaHelper.CreateDatabaseSchema(false, appCtx);
 
-            bool umbracoNodeTable = schemaHelper.TableExist("umbracoNode");
-            bool umbracoUserTable = schemaHelper.TableExist("umbracoUser");
-            bool cmsTagsTable = schemaHelper.TableExist("cmsTags");
+            var umbracoNodeTable = schemaHelper.TableExist("umbracoNode");
+            var umbracoUserTable = schemaHelper.TableExist("umbracoUser");
+            var cmsTagsTable = schemaHelper.TableExist("cmsTags");
 
             Assert.That(umbracoNodeTable, Is.True);
             Assert.That(umbracoUserTable, Is.True);
@@ -124,7 +130,7 @@ namespace Umbraco.Tests.Persistence
         [TestCase("tcp:MyServer.database.windows.net,1433", "MyDatabase", "MyUser@MyServer", "MyPassword")]
         public void Build_Azure_Connection_String_Regular(string server, string databaseName, string userName, string password)
         {
-            var connectionString = _dbContext.BuildAzureConnectionString(server, databaseName, userName, password);
+            var connectionString = _dbContext.GetAzureConnectionString(server, databaseName, userName, password);
             Assert.AreEqual(connectionString, "Server=tcp:MyServer.database.windows.net,1433;Database=MyDatabase;User ID=MyUser@MyServer;Password=MyPassword");
         }
 
@@ -134,7 +140,7 @@ namespace Umbraco.Tests.Persistence
         [TestCase("tcp:kzeej5z8ty.ssmsawacluster4.windowsazure.mscds.com", "MyDatabase", "MyUser@kzeej5z8ty", "MyPassword")]
         public void Build_Azure_Connection_String_CustomServer(string server, string databaseName, string userName, string password)
         {
-            var connectionString = _dbContext.BuildAzureConnectionString(server, databaseName, userName, password);
+            var connectionString = _dbContext.GetAzureConnectionString(server, databaseName, userName, password);
             Assert.AreEqual(connectionString, "Server=tcp:kzeej5z8ty.ssmsawacluster4.windowsazure.mscds.com,1433;Database=MyDatabase;User ID=MyUser@kzeej5z8ty;Password=MyPassword");
         }
     }
diff --git a/src/Umbraco.Tests/Persistence/FaultHandling/ConnectionRetryTest.cs b/src/Umbraco.Tests/Persistence/FaultHandling/ConnectionRetryTest.cs
index f97b030dda..1d5127db3d 100644
--- a/src/Umbraco.Tests/Persistence/FaultHandling/ConnectionRetryTest.cs
+++ b/src/Umbraco.Tests/Persistence/FaultHandling/ConnectionRetryTest.cs
@@ -1,8 +1,11 @@
-using System.Data.SqlClient;
+using System;
+using System.Data.SqlClient;
 using Moq;
 using NUnit.Framework;
+using Umbraco.Core;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Tests.Persistence.FaultHandling
 {
@@ -13,10 +16,11 @@ namespace Umbraco.Tests.Persistence.FaultHandling
         public void Cant_Connect_To_SqlDatabase_With_Invalid_User()
         {
             // Arrange
-            const string providerName = "System.Data.SqlClient";
             const string connectionString = @"server=.\SQLEXPRESS;database=EmptyForTest;user id=x;password=umbraco";
-            var factory = new DefaultDatabaseFactory(connectionString, providerName, Mock.Of<ILogger>());
-            var database = factory.CreateDatabase();
+            const string providerName = Constants.DbProviderNames.SqlServer;
+            var sqlSyntax = new[] { new SqlServerSyntaxProvider(new Lazy<IDatabaseFactory>(() => null)) };
+            var factory = new DefaultDatabaseFactory(connectionString, providerName, sqlSyntax, Mock.Of<ILogger>());
+            var database = factory.GetDatabase();
 
             //Act
             Assert.Throws<SqlException>(
@@ -27,10 +31,11 @@ namespace Umbraco.Tests.Persistence.FaultHandling
         public void Cant_Connect_To_SqlDatabase_Because_Of_Network()
         {
             // Arrange
-            const string providerName = "System.Data.SqlClient";
             const string connectionString = @"server=.\SQLEXPRESS;database=EmptyForTest;user id=umbraco;password=umbraco";
-            var factory = new DefaultDatabaseFactory(connectionString, providerName, Mock.Of<ILogger>());
-            var database = factory.CreateDatabase();
+            const string providerName = Constants.DbProviderNames.SqlServer;
+            var sqlSyntax = new[] { new SqlServerSyntaxProvider(new Lazy<IDatabaseFactory>(() => null)) };
+            var factory = new DefaultDatabaseFactory(connectionString, providerName, sqlSyntax, Mock.Of<ILogger>());
+            var database = factory.GetDatabase();
 
             //Act
             Assert.Throws<SqlException>(
diff --git a/src/Umbraco.Tests/Persistence/Migrations/MigrationStartupHandlerTests.cs b/src/Umbraco.Tests/Persistence/Migrations/MigrationStartupHandlerTests.cs
index 3ebd40577b..ed2bbb20d9 100644
--- a/src/Umbraco.Tests/Persistence/Migrations/MigrationStartupHandlerTests.cs
+++ b/src/Umbraco.Tests/Persistence/Migrations/MigrationStartupHandlerTests.cs
@@ -67,13 +67,12 @@ namespace Umbraco.Tests.Persistence.Migrations
             var changed1 = new Args { CountExecuted = 0 };
             var testHandler1 = new TestMigrationHandler(changed1);
             testHandler1.OnApplicationStarting(Mock.Of<UmbracoApplicationBase>(), new ApplicationContext(CacheHelper.CreateDisabledCacheHelper(), new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>())));
-            
-            var conn = new MockConnection();
-            var db = new Mock<Database>(conn);
+
+            var db = new UmbracoDatabase("cstr", new SqlCeSyntaxProvider(), DatabaseType.SQLCe, DbProviderFactories.GetFactory(Constants.DbProviderNames.SqlCe), Mock.Of<ILogger>());
 
             var runner1 = new MigrationRunner(Mock.Of<IMigrationResolver>(), Mock.Of<IMigrationEntryService>(), Mock.Of<ILogger>(), new SemVersion(1), new SemVersion(2), "Test1",
                 new IMigration[] { Mock.Of<IMigration>() });
-            var result1 = runner1.Execute(db.Object, DatabaseProviders.SqlServerCE, new SqlCeSyntaxProvider(), (false));
+            var result1 = runner1.Execute(db /*, false*/);
             Assert.AreEqual(1, changed1.CountExecuted);            
         }
 
@@ -87,18 +86,17 @@ namespace Umbraco.Tests.Persistence.Migrations
             var testHandler2 = new TestMigrationHandler("Test2", changed2);
             testHandler2.OnApplicationStarting(Mock.Of<UmbracoApplicationBase>(), new ApplicationContext(CacheHelper.CreateDisabledCacheHelper(), new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>())));
 
-            var conn = new MockConnection();
-            var db = new Mock<Database>(conn);
+            var db = new UmbracoDatabase("cstr", new SqlCeSyntaxProvider(), DatabaseType.SQLCe, DbProviderFactories.GetFactory(Constants.DbProviderNames.SqlCe), Mock.Of<ILogger>());
 
             var runner1 = new MigrationRunner(Mock.Of<IMigrationResolver>(), Mock.Of<IMigrationEntryService>(), Mock.Of<ILogger>(), new SemVersion(1), new SemVersion(2), "Test1",
                 new IMigration[] { Mock.Of<IMigration>()});
-            var result1 = runner1.Execute(db.Object, DatabaseProviders.SqlServerCE, new SqlCeSyntaxProvider(), false);
+            var result1 = runner1.Execute(db /*, false*/);
             Assert.AreEqual(1, changed1.CountExecuted);
             Assert.AreEqual(0, changed2.CountExecuted);
 
             var runner2 = new MigrationRunner(Mock.Of<IMigrationResolver>(), Mock.Of<IMigrationEntryService>(), Mock.Of<ILogger>(), new SemVersion(1), new SemVersion(2), "Test2",
                 new IMigration[] { Mock.Of<IMigration>() });            
-            var result2 = runner2.Execute(db.Object, DatabaseProviders.SqlServerCE, new SqlCeSyntaxProvider(), false);
+            var result2 = runner2.Execute(db /*, false*/);
             Assert.AreEqual(1, changed1.CountExecuted);
             Assert.AreEqual(1, changed2.CountExecuted);
         }
diff --git a/src/Umbraco.Tests/Persistence/Repositories/AuditRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/AuditRepositoryTest.cs
index 6be6bd5f6e..fa5db89fb3 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/AuditRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/AuditRepositoryTest.cs
@@ -17,7 +17,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repo = new AuditRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new AuditRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 repo.AddOrUpdate(new AuditItem(-1, "This is a System audit trail", AuditType.System, 0));
                 unitOfWork.Commit();
diff --git a/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs
index f118bf1b55..30d99ec9c5 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs
@@ -49,10 +49,10 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository, out TemplateRepository templateRepository)
         {
-            templateRepository = new TemplateRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver);
-            var tagRepository = new TagRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver);
-            contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, templateRepository, MappingResolver);
-            var repository = new ContentRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
+            templateRepository = new TemplateRepository(unitOfWork, CacheHelper, Logger, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver);
+            var tagRepository = new TagRepository(unitOfWork, CacheHelper, Logger, MappingResolver);
+            contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper, Logger, templateRepository, MappingResolver);
+            var repository = new ContentRepository(unitOfWork, CacheHelper, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
             return repository;
         }
 
@@ -545,7 +545,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         [Test]
         public void RegexAliasTest()
         {
-            var regex = VersionableRepositoryBaseAliasRegex.For(new SqlServerSyntaxProvider());
+            var regex = VersionableRepositoryBaseAliasRegex.For(new SqlServerSyntaxProvider(new Lazy<IDatabaseFactory>(() => null)));
             Assert.AreEqual(@"(\[\w+]\.\[\w+])\s+AS\s+(\[\w+])", regex.ToString());
             const string sql = "SELECT [table].[column1] AS [alias1], [table].[column2] AS [alias2] FROM [table];";
             var matches = regex.Matches(sql);
diff --git a/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs
index 1d27925fc5..aa6a861b61 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs
@@ -43,29 +43,29 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository)
         {
-            var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver);
-            var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, MappingResolver);
-            contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, templateRepository, MappingResolver);
-            var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
+            var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver);
+            var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver);
+            contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, templateRepository, MappingResolver);
+            var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
             return repository;
         }
 
         private ContentTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork)
         {
-            var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver);
-            var contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, templateRepository, MappingResolver);
+            var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver);
+            var contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, templateRepository, MappingResolver);
             return contentTypeRepository;
         }
 
         private MediaTypeRepository CreateMediaTypeRepository(IDatabaseUnitOfWork unitOfWork)
         {
-            var contentTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, MappingResolver);
+            var contentTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver);
             return contentTypeRepository;
         }
 
         private EntityContainerRepository CreateContainerRepository(IDatabaseUnitOfWork unitOfWork, Guid containerEntityType)
         {
-            return new EntityContainerRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, MappingResolver, containerEntityType);
+            return new EntityContainerRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver, containerEntityType);
         }
 
         //TODO Add test to verify SetDefaultTemplates updates both AllowedTemplates and DefaultTemplate(id).
@@ -77,7 +77,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var templateRepo = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver))
+            using (var templateRepo = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver))
             using (var repository = CreateRepository(unitOfWork))
             {
                 var templates = new[]
diff --git a/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs
index 075093c92e..8e1450a4cd 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs
@@ -58,7 +58,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private EntityContainerRepository CreateContainerRepository(IDatabaseUnitOfWork unitOfWork)
         {
-            return new EntityContainerRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, MappingResolver, Constants.ObjectTypes.DataTypeContainerGuid);
+            return new EntityContainerRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver, Constants.ObjectTypes.DataTypeContainerGuid);
         }
 
         [TestCase("UmbracoPreVal87-21,3,48", 3, true)]
diff --git a/src/Umbraco.Tests/Persistence/Repositories/DomainRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/DomainRepositoryTest.cs
index c68a1fb76a..c0efdadd16 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/DomainRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/DomainRepositoryTest.cs
@@ -19,12 +19,12 @@ namespace Umbraco.Tests.Persistence.Repositories
     {
         private DomainRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository, out ContentRepository contentRepository, out LanguageRepository languageRepository)
         {
-            var templateRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver);
-            var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver);
-            contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, templateRepository, MappingResolver);
-            contentRepository = new ContentRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
-            languageRepository = new LanguageRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver);
-            var domainRepository = new DomainRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver);
+            var templateRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver);
+            var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver);
+            contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, templateRepository, MappingResolver);
+            contentRepository = new ContentRepository(unitOfWork, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
+            languageRepository = new LanguageRepository(unitOfWork, DisabledCache, Logger, MappingResolver);
+            var domainRepository = new DomainRepository(unitOfWork, DisabledCache, Logger, MappingResolver);
             return domainRepository;
         }
 
diff --git a/src/Umbraco.Tests/Persistence/Repositories/LanguageRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/LanguageRepositoryTest.cs
index 9e30c9e71a..82bb7acf7d 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/LanguageRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/LanguageRepositoryTest.cs
@@ -28,7 +28,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private LanguageRepository CreateRepository(IDatabaseUnitOfWork unitOfWork)
         {
-            return new LanguageRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver);            
+            return new LanguageRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver);            
         }
 
      
diff --git a/src/Umbraco.Tests/Persistence/Repositories/MacroRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MacroRepositoryTest.cs
index 9e4655baa3..0f8d77d27a 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/MacroRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/MacroRepositoryTest.cs
@@ -34,7 +34,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var unitOfWork = provider.GetUnitOfWork();
 
             // Act
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 var macro = new Macro("test1", "Test", "~/usercontrol/blah.ascx", "MyAssembly", "test.xslt", "~/views/macropartials/test.cshtml");
                 repository.AddOrUpdate(macro);
@@ -52,7 +52,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var unitOfWork = provider.GetUnitOfWork();
 
             // Act
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 var macro = repository.Get(1);
                 macro.Alias = "test2";
@@ -70,7 +70,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var unitOfWork = provider.GetUnitOfWork();
 
             // Act
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 // Assert
                 Assert.That(repository, Is.Not.Null);
@@ -83,7 +83,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 // Act
                 var macro = repository.Get(1);
@@ -113,7 +113,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 // Act
                 var macros = repository.GetAll();
@@ -130,7 +130,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 // Act
                 var query = new Query<IMacro>(SqlSyntax, MappingResolver).Where(x => x.Alias.ToUpper() == "TEST1");
@@ -147,7 +147,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 // Act
                 var query = new Query<IMacro>(SqlSyntax, MappingResolver).Where(x => x.Name.StartsWith("Test"));
@@ -164,7 +164,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 // Act
                 var macro = new Macro("test", "Test", "~/usercontrol/blah.ascx", "MyAssembly", "test.xslt", "~/views/macropartials/test.cshtml");
@@ -185,7 +185,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 // Act
                 var macro = repository.Get(2);
@@ -226,7 +226,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 // Act
                 var macro = repository.Get(3);
@@ -247,7 +247,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 // Act
                 var exists = repository.Exists(3);
@@ -265,7 +265,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 var macro = repository.Get(1);
                 macro.Properties.Add(new MacroProperty("new1", "New1", 3, "test"));
@@ -292,7 +292,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 var macro = new Macro("newmacro", "A new macro", "~/usercontrol/test1.ascx", "MyAssembly1", "test1.xslt", "~/views/macropartials/test1.cshtml");
                 macro.Properties.Add(new MacroProperty("blah1", "New1", 4, "test.editor"));
@@ -317,7 +317,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 var macro = new Macro("newmacro", "A new macro", "~/usercontrol/test1.ascx", "MyAssembly1", "test1.xslt", "~/views/macropartials/test1.cshtml");
                 macro.Properties.Add(new MacroProperty("blah1", "New1", 4, "test.editor"));
@@ -342,7 +342,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 var macro = new Macro("newmacro", "A new macro", "~/usercontrol/test1.ascx", "MyAssembly1", "test1.xslt", "~/views/macropartials/test1.cshtml");
                 var prop1 = new MacroProperty("blah1", "New1", 4, "test.editor");
@@ -373,7 +373,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 var macro = repository.Get(1);
                 macro.Properties.Add(new MacroProperty("new1", "New1", 3, "test"));
@@ -401,7 +401,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 var macro = repository.Get(1);
                 macro.Properties.Add(new MacroProperty("new1", "New1", 3, "test"));
@@ -430,7 +430,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             var provider = new NPocoUnitOfWorkProvider(Logger);
             using (var unitOfWork = provider.GetUnitOfWork())
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 repository.AddOrUpdate(new Macro("test1", "Test1", "~/usercontrol/test1.ascx", "MyAssembly1", "test1.xslt", "~/views/macropartials/test1.cshtml"));
                 repository.AddOrUpdate(new Macro("test2", "Test2", "~/usercontrol/test2.ascx", "MyAssembly2", "test2.xslt", "~/views/macropartials/test2.cshtml"));
diff --git a/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs
index 3cbed428f2..0635b29ef3 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs
@@ -35,9 +35,9 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private MediaRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out MediaTypeRepository mediaTypeRepository)
         {
-            mediaTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver);
-            var tagRepository = new TagRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver);
-            var repository = new MediaRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, mediaTypeRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
+            mediaTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper, Logger, MappingResolver);
+            var tagRepository = new TagRepository(unitOfWork, CacheHelper, Logger, MappingResolver);
+            var repository = new MediaRepository(unitOfWork, CacheHelper, Logger, mediaTypeRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
             return repository;
         }
 
diff --git a/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs
index d85ff5a72e..db569700d4 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs
@@ -28,12 +28,12 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private MediaTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork)
         {
-            return new MediaTypeRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver);            
+            return new MediaTypeRepository(unitOfWork, DisabledCache, Logger, MappingResolver);            
         }
 
         private EntityContainerRepository CreateContainerRepository(IDatabaseUnitOfWork unitOfWork)
         {
-            return new EntityContainerRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver, Constants.ObjectTypes.MediaTypeContainerGuid);
+            return new EntityContainerRepository(unitOfWork, DisabledCache, Logger, MappingResolver, Constants.ObjectTypes.MediaTypeContainerGuid);
 
         }
 
diff --git a/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs
index 23796ca3ca..33141ecd77 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs
@@ -37,10 +37,10 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private MemberRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out MemberTypeRepository memberTypeRepository, out MemberGroupRepository memberGroupRepository)
         {
-            memberTypeRepository = new MemberTypeRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver);
-            memberGroupRepository = new MemberGroupRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver);
-            var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver);
-            var repository = new MemberRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, memberTypeRepository, memberGroupRepository, tagRepo, Mock.Of<IContentSection>(), MappingResolver);
+            memberTypeRepository = new MemberTypeRepository(unitOfWork, DisabledCache, Logger, MappingResolver);
+            memberGroupRepository = new MemberGroupRepository(unitOfWork, DisabledCache, Logger, MappingResolver);
+            var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver);
+            var repository = new MemberRepository(unitOfWork, DisabledCache, Logger, memberTypeRepository, memberGroupRepository, tagRepo, Mock.Of<IContentSection>(), MappingResolver);
             return repository;
         }
 
@@ -378,7 +378,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             if (isCount)
             {
-                var sqlCount = NPoco.Sql.BuilderFor(new SqlContext(SqlSyntax, DatabaseContext.Database))
+                var sqlCount = DatabaseContext.Database.Sql()
                     .SelectCount()
                     .From<NodeDto>()
                     .InnerJoin<ContentDto>().On<ContentDto, NodeDto>(left => left.NodeId, right => right.NodeId)
@@ -389,7 +389,7 @@ namespace Umbraco.Tests.Persistence.Repositories
                 return sqlCount;
             }
 
-            var sql = NPoco.Sql.BuilderFor(new SqlContext(SqlSyntax, DatabaseContext.Database));
+            var sql = DatabaseContext.Database.Sql();
             sql.Select("umbracoNode.*", "cmsContent.contentType", "cmsContentType.alias AS ContentTypeAlias", "cmsContentVersion.VersionId",
                 "cmsContentVersion.VersionDate", "cmsMember.Email",
                 "cmsMember.LoginName", "cmsMember.Password", "cmsPropertyData.id AS PropertyDataId", "cmsPropertyData.propertytypeid",
@@ -413,7 +413,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private Sql<SqlContext> GetSubquery()
         {
-            var sql = NPoco.Sql.BuilderFor(new SqlContext(SqlSyntax, DatabaseContext.Database));
+            var sql = DatabaseContext.Database.Sql();
             sql.Select("umbracoNode.id")
                 .From<NodeDto>()
                 .InnerJoin<ContentDto>().On<ContentDto, NodeDto>(left => left.NodeId, right => right.NodeId)
diff --git a/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs
index 9f9ff91842..5f1ceb59b6 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs
@@ -32,7 +32,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private MemberTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork)
         {
-            return new MemberTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver);            
+            return new MemberTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver);            
         }
 
         [Test]
diff --git a/src/Umbraco.Tests/Persistence/Repositories/NotificationsRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/NotificationsRepositoryTest.cs
index 071a419477..45fe3ce793 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/NotificationsRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/NotificationsRepositoryTest.cs
@@ -22,7 +22,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            var repo = new NotificationsRepository(unitOfWork, SqlSyntax);
+            var repo = new NotificationsRepository(unitOfWork);
 
             var node = new NodeDto {CreateDate = DateTime.Now, Level = 1, NodeObjectType = Guid.Parse(Constants.ObjectTypes.ContentItem), ParentId = -1, Path = "-1,123", SortOrder = 1, Text = "hello", Trashed = false, UniqueId = Guid.NewGuid(), UserId = 0};
             var result = unitOfWork.Database.Insert(node);
@@ -42,7 +42,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            var repo = new NotificationsRepository(unitOfWork, SqlSyntax);
+            var repo = new NotificationsRepository(unitOfWork);
 
             var userDto = new UserDto { ContentStartId = -1, Email = "test" , Login = "test" , MediaStartId = -1, Password = "test" , Type = 1, UserName = "test" , UserLanguage = "en" };
             unitOfWork.Database.Insert(userDto);
@@ -68,7 +68,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            var repo = new NotificationsRepository(unitOfWork, SqlSyntax);
+            var repo = new NotificationsRepository(unitOfWork);
             
             var node1 = new NodeDto { CreateDate = DateTime.Now, Level = 1, NodeObjectType = Guid.Parse(Constants.ObjectTypes.ContentItem), ParentId = -1, Path = "-1,1", SortOrder = 1, Text = "hello1", Trashed = false, UniqueId = Guid.NewGuid(), UserId = 0 };
             unitOfWork.Database.Insert(node1);
@@ -95,7 +95,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            var repo = new NotificationsRepository(unitOfWork, SqlSyntax);
+            var repo = new NotificationsRepository(unitOfWork);
 
             var node1 = new NodeDto { CreateDate = DateTime.Now, Level = 1, NodeObjectType = Guid.Parse(Constants.ObjectTypes.ContentItem), ParentId = -1, Path = "-1,1", SortOrder = 1, Text = "hello1", Trashed = false, UniqueId = Guid.NewGuid(), UserId = 0 };
             unitOfWork.Database.Insert(node1);
@@ -122,7 +122,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            var repo = new NotificationsRepository(unitOfWork, SqlSyntax);
+            var repo = new NotificationsRepository(unitOfWork);
 
             var userDto = new UserDto { ContentStartId = -1, Email = "test", Login = "test", MediaStartId = -1, Password = "test", Type = 1, UserName = "test", UserLanguage = "en" };
             unitOfWork.Database.Insert(userDto);
diff --git a/src/Umbraco.Tests/Persistence/Repositories/PublicAccessRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/PublicAccessRepositoryTest.cs
index 1115751688..b3051262d8 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/PublicAccessRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/PublicAccessRepositoryTest.cs
@@ -27,7 +27,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
 
                 var entry = new PublicAccessEntry(content[0], content[1], content[2], new[]
@@ -57,7 +57,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
             unitOfWork.Database.EnableSqlTrace = true;
-            using (var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 var entry = new PublicAccessEntry(content[0], content[1], content[2], new[]
                 {
@@ -96,7 +96,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
             unitOfWork.Database.EnableSqlTrace = true;
-            using (var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 var entry = new PublicAccessEntry(content[0], content[1], content[2], new[]
                 {
@@ -140,7 +140,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 var entry = new PublicAccessEntry(content[0], content[1], content[2], new[]
                 {
@@ -177,7 +177,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 var entry = new PublicAccessEntry(content[0], content[1], content[2], new[]
                 {
@@ -204,7 +204,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {                
                 var entry1 = new PublicAccessEntry(content[0], content[1], content[2], new[]
                 {
@@ -241,7 +241,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new PublicAccessRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 var entry1 = new PublicAccessEntry(content[0], content[1], content[2], new[]
                 {
@@ -273,10 +273,10 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository)
         {
-            var templateRepository = new TemplateRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver);
-            var tagRepository = new TagRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver);
-            contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, templateRepository, MappingResolver);
-            var repository = new ContentRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
+            var templateRepository = new TemplateRepository(unitOfWork, CacheHelper, Logger, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver);
+            var tagRepository = new TagRepository(unitOfWork, CacheHelper, Logger, MappingResolver);
+            contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper, Logger, templateRepository, MappingResolver);
+            var repository = new ContentRepository(unitOfWork, CacheHelper, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
             return repository;
         }
 
diff --git a/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs
index 6ed8062a33..a30d1b3688 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs
@@ -30,8 +30,8 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private RelationRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out RelationTypeRepository relationTypeRepository)
         {
-            relationTypeRepository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver);
-            var repository = new RelationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, relationTypeRepository, MappingResolver);
+            relationTypeRepository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver);
+            var repository = new RelationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), relationTypeRepository, MappingResolver);
             return repository;
         }
 
@@ -265,8 +265,8 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            var relationTypeRepository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver);
-            var relationRepository = new RelationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, relationTypeRepository, MappingResolver);
+            var relationTypeRepository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver);
+            var relationRepository = new RelationRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), relationTypeRepository, MappingResolver);
 
             relationTypeRepository.AddOrUpdate(relateContent);
             relationTypeRepository.AddOrUpdate(relateContentType);
diff --git a/src/Umbraco.Tests/Persistence/Repositories/RelationTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/RelationTypeRepositoryTest.cs
index 34817131f1..8b0fdd5a39 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/RelationTypeRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/RelationTypeRepositoryTest.cs
@@ -29,7 +29,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private RelationTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork)
         {
-            return new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver);
+            return new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver);
         }
 
 
@@ -235,7 +235,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            var repository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver);
+            var repository = new RelationTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver);
 
             repository.AddOrUpdate(relateContent);//Id 2
             repository.AddOrUpdate(relateContentType);//Id 3
diff --git a/src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs
index 8ddb8d45f1..a47bddcedb 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs
@@ -19,20 +19,20 @@ namespace Umbraco.Tests.Persistence.Repositories
     [TestFixture]
     public class ServerRegistrationRepositoryTest : BaseDatabaseFactoryTest
     {
-        private ICacheProvider _staticCache;
+        private CacheHelper _cacheHelper;
 
         [SetUp]
         public override void Initialize()
         {
             base.Initialize();
 
-            _staticCache = new StaticCacheProvider();
+            _cacheHelper = new CacheHelper();
             CreateTestData();
         }
 
         private ServerRegistrationRepository CreateRepository(IDatabaseUnitOfWork unitOfWork)
         {
-            return new ServerRegistrationRepository(unitOfWork, _staticCache, Logger, SqlSyntax, MappingResolver);
+            return new ServerRegistrationRepository(unitOfWork, _cacheHelper, Logger, MappingResolver);
         }
 
         [Test]
diff --git a/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs
index 011bf49a21..77f1d7399d 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs
@@ -35,7 +35,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private TagRepository CreateRepository(IDatabaseUnitOfWork unitOfWork)
         {
-            var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver);
+            var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver);
             return tagRepository;
         }
 
@@ -1034,18 +1034,18 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private ContentRepository CreateContentRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository)
         {
-            var templateRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver);
-            var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver);
-            contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, templateRepository, MappingResolver);
-            var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
+            var templateRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver);
+            var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver);
+            contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, templateRepository, MappingResolver);
+            var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
             return repository;
         }
 
         private MediaRepository CreateMediaRepository(IDatabaseUnitOfWork unitOfWork, out MediaTypeRepository mediaTypeRepository)
         {
-            var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver);
-            mediaTypeRepository = new MediaTypeRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver);
-            var repository = new MediaRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, mediaTypeRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
+            var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver);
+            mediaTypeRepository = new MediaTypeRepository(unitOfWork, DisabledCache, Logger, MappingResolver);
+            var repository = new MediaRepository(unitOfWork, DisabledCache, Logger, mediaTypeRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
             return repository;
         }
     }
diff --git a/src/Umbraco.Tests/Persistence/Repositories/TaskRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/TaskRepositoryTest.cs
index 33c961fcab..2a6f58fb6b 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/TaskRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/TaskRepositoryTest.cs
@@ -18,7 +18,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
              var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 var created = DateTime.Now;
                 var task = new Task(new TaskType("asdfasdf"))
@@ -45,7 +45,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 var created = DateTime.Now;
                 repo.AddOrUpdate(new Task(new TaskType("asdfasdf"))
@@ -77,7 +77,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 var task = new Task(new TaskType("asdfasdf"))
                 {
@@ -113,7 +113,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 var task = new Task(new TaskType("asdfasdf"))
                 {
@@ -141,7 +141,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 var found = repo.GetAll().ToArray();
                 Assert.AreEqual(20, found.Count());
@@ -156,7 +156,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 var found = repo.GetTasks(includeClosed: true).ToArray();
                 Assert.AreEqual(15, found.Count());
@@ -171,7 +171,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 var found = repo.GetTasks(itemId:-20).ToArray();
                 Assert.AreEqual(10, found.Count());
@@ -186,7 +186,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 var found = repo.GetTasks(includeClosed: false);
                 Assert.AreEqual(10, found.Count());
@@ -197,7 +197,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 for (int i = 0; i < count; i++)
                 {
diff --git a/src/Umbraco.Tests/Persistence/Repositories/TaskTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/TaskTypeRepositoryTest.cs
index 23f2957f16..15f2fec903 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/TaskTypeRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/TaskTypeRepositoryTest.cs
@@ -18,8 +18,8 @@ namespace Umbraco.Tests.Persistence.Repositories
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
             var taskType = new TaskType("asdfasdf");
-            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
-            using (var taskTypeRepo = new TaskTypeRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, MappingResolver))
+            using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
+            using (var taskTypeRepo = new TaskTypeRepository(unitOfWork, CacheHelper, Logger, MappingResolver))
             {
                 var created = DateTime.Now;
                 var task = new Task(taskType)
diff --git a/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs
index 9b726e2184..ab2556ed07 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs
@@ -30,7 +30,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private ITemplateRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, ITemplatesSection templatesSection = null)
         {
-            return new TemplateRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, _masterPageFileSystem, _viewsFileSystem,
+            return new TemplateRepository(unitOfWork, DisabledCache, Logger, _masterPageFileSystem, _viewsFileSystem,
                 templatesSection ?? Mock.Of<ITemplatesSection>(t => t.DefaultRenderingEngine == RenderingEngine.Mvc), MappingResolver);
         }
 
@@ -403,9 +403,9 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             using (var templateRepository = CreateRepository(unitOfWork))
             {
-                var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver);
-                var contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, templateRepository, MappingResolver);
-                var contentRepo = new ContentRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
+                var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver);
+                var contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, templateRepository, MappingResolver);
+                var contentRepo = new ContentRepository(unitOfWork, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
 
                 using (contentRepo)
                 {
diff --git a/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs
index 8d0bbdff77..db1e308adb 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs
@@ -34,8 +34,8 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private UserRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out UserTypeRepository userTypeRepository)
         {
-            userTypeRepository = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver);
-            var repository = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, userTypeRepository, MappingResolver);
+            userTypeRepository = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver);
+            var repository = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), userTypeRepository, MappingResolver);
             return repository;
         }
 
@@ -175,8 +175,8 @@ namespace Umbraco.Tests.Persistence.Repositories
                 unitOfWork.Commit();
                 var id = user.Id;
 
-                using (var utRepo = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, MappingResolver))
-                using (var repository2 = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, utRepo, MappingResolver))
+                using (var utRepo = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver))
+                using (var repository2 = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, utRepo, MappingResolver))
                 {
                     repository2.Delete(user);
                     unitOfWork.Commit();
@@ -483,8 +483,8 @@ namespace Umbraco.Tests.Persistence.Repositories
             // Arrange
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var utRepo = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, MappingResolver))
-            using (var repository = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, utRepo, MappingResolver))
+            using (var utRepo = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver))
+            using (var repository = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, utRepo, MappingResolver))
             {
 
                 // Act
@@ -534,7 +534,7 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var repository = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, MappingResolver))
+            using (var repository = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver))
             {
                 var userType = MockedUserType.CreateUserType();
                 repository.AddOrUpdate(userType);
diff --git a/src/Umbraco.Tests/Persistence/Repositories/UserTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/UserTypeRepositoryTest.cs
index 012d5c4f0b..b975775a9e 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/UserTypeRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/UserTypeRepositoryTest.cs
@@ -32,7 +32,7 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private UserTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork)
         {
-            return new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver);            
+            return new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver);            
         }
 
         [Test]
@@ -143,7 +143,7 @@ namespace Umbraco.Tests.Persistence.Repositories
                 unitOfWork.Commit();
                 var id = userType.Id;
 
-                using (var repository2 = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, MappingResolver))
+                using (var repository2 = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, MappingResolver))
                 {
                     repository2.Delete(userType);
                     unitOfWork.Commit();
diff --git a/src/Umbraco.Tests/Persistence/SchemaValidationTest.cs b/src/Umbraco.Tests/Persistence/SchemaValidationTest.cs
index 26b5b49efb..23d1e70354 100644
--- a/src/Umbraco.Tests/Persistence/SchemaValidationTest.cs
+++ b/src/Umbraco.Tests/Persistence/SchemaValidationTest.cs
@@ -29,7 +29,7 @@ namespace Umbraco.Tests.Persistence
         {
             // Arrange
             var db = DatabaseContext.Database;
-            var schema = new DatabaseSchemaCreation(db, Logger, new SqlCeSyntaxProvider());
+            var schema = new DatabaseSchemaCreation(db, Logger);
 
             // Act
             var result = schema.ValidateSchema();
diff --git a/src/Umbraco.Tests/Persistence/SqlCeTableByTableTest.cs b/src/Umbraco.Tests/Persistence/SqlCeTableByTableTest.cs
index 7b9a67a607..cb6bac7571 100644
--- a/src/Umbraco.Tests/Persistence/SqlCeTableByTableTest.cs
+++ b/src/Umbraco.Tests/Persistence/SqlCeTableByTableTest.cs
@@ -32,7 +32,7 @@ namespace Umbraco.Tests.Persistence
         
         protected DatabaseSchemaHelper DatabaseSchemaHelper
         {
-            get { return _schemaHelper ?? (_schemaHelper = new DatabaseSchemaHelper(DatabaseContext.Database, Logger, SqlSyntax)); }
+            get { return _schemaHelper ?? (_schemaHelper = new DatabaseSchemaHelper(DatabaseContext.Database, Logger)); }
         }
 
         [SetUp]
diff --git a/src/Umbraco.Tests/Persistence/SyntaxProvider/SqlCeSyntaxProviderTests.cs b/src/Umbraco.Tests/Persistence/SyntaxProvider/SqlCeSyntaxProviderTests.cs
index 7951df2dc6..ed06a5e003 100644
--- a/src/Umbraco.Tests/Persistence/SyntaxProvider/SqlCeSyntaxProviderTests.cs
+++ b/src/Umbraco.Tests/Persistence/SyntaxProvider/SqlCeSyntaxProviderTests.cs
@@ -1,12 +1,16 @@
 using System;
 using System.Collections.Generic;
+using System.Data.Common;
+using Moq;
 using NPoco;
 using NUnit.Framework;
 using Umbraco.Core;
+using Umbraco.Core.Logging;
 using Umbraco.Core.Models.Rdbms;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.DatabaseAnnotations;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
+using Umbraco.Core.Persistence.Migrations;
 using Umbraco.Core.Persistence.Migrations.Syntax.Create.Index;
 using Umbraco.Core.Persistence.Migrations.Syntax.Expressions;
 using Umbraco.Core.Persistence.SqlSyntax;
@@ -70,7 +74,7 @@ WHERE (([umbracoNode].[nodeObjectType] = @0))) x)".Replace(Environment.NewLine,
         [Test]
         public void Format_SqlServer_NonClusteredIndexDefinition_AddsNonClusteredDirective()
         {
-            var sqlSyntax = new SqlServerSyntaxProvider();
+            var sqlSyntax = new SqlServerSyntaxProvider(new Lazy<IDatabaseFactory>(() => null));
             
             var indexDefinition = CreateIndexDefinition();
             indexDefinition.IndexType = IndexTypes.NonClustered;
@@ -82,7 +86,7 @@ WHERE (([umbracoNode].[nodeObjectType] = @0))) x)".Replace(Environment.NewLine,
         [Test]
         public void Format_SqlServer_NonClusteredIndexDefinition_UsingIsClusteredFalse_AddsClusteredDirective()
         {
-            var sqlSyntax = new SqlServerSyntaxProvider();
+            var sqlSyntax = new SqlServerSyntaxProvider(new Lazy<IDatabaseFactory>(() => null));
 
             var indexDefinition = CreateIndexDefinition();
             indexDefinition.IsClustered = false;
@@ -94,8 +98,11 @@ WHERE (([umbracoNode].[nodeObjectType] = @0))) x)".Replace(Environment.NewLine,
         [Test]
         public void CreateIndexBuilder_SqlServer_NonClustered_CreatesNonClusteredIndex()
         {
-            var sqlSyntax = new SqlServerSyntaxProvider();
-            var createExpression = new CreateIndexExpression(DatabaseProviders.SqlServer, new []{DatabaseProviders.SqlServer}, sqlSyntax)
+            var sqlSyntax = new SqlServerSyntaxProvider(new Lazy<IDatabaseFactory>(() => null));
+            var logger = Mock.Of<ILogger>();
+            var db = new UmbracoDatabase("cstr", sqlSyntax, DatabaseType.SqlServer2005, DbProviderFactories.GetFactory(Constants.DbProviderNames.SqlServer), logger);
+            var context = new MigrationContext(db, logger);
+            var createExpression = new CreateIndexExpression(context, new []{ DatabaseType.SqlServer2005 })
             {
                 Index = { Name = "IX_A" }
             };
@@ -107,8 +114,11 @@ WHERE (([umbracoNode].[nodeObjectType] = @0))) x)".Replace(Environment.NewLine,
         [Test]
         public void CreateIndexBuilder_SqlServer_Unique_CreatesUniqueNonClusteredIndex()
         {
-            var sqlSyntax = new SqlServerSyntaxProvider();
-            var createExpression = new CreateIndexExpression(DatabaseProviders.SqlServer, new[] { DatabaseProviders.SqlServer }, sqlSyntax)
+            var sqlSyntax = new SqlServerSyntaxProvider(new Lazy<IDatabaseFactory>(() => null));
+            var logger = Mock.Of<ILogger>();
+            var db = new UmbracoDatabase("cstr", sqlSyntax, DatabaseType.SqlServer2005, DbProviderFactories.GetFactory(Constants.DbProviderNames.SqlServer), logger);
+            var context = new MigrationContext(db, logger);
+            var createExpression = new CreateIndexExpression(context, new[] { DatabaseType.SqlServer2005 })
             {
                 Index = { Name = "IX_A" }
             };
@@ -120,8 +130,11 @@ WHERE (([umbracoNode].[nodeObjectType] = @0))) x)".Replace(Environment.NewLine,
         [Test]
         public void CreateIndexBuilder_SqlServer_Clustered_CreatesClusteredIndex()
         {
-            var sqlSyntax = new SqlServerSyntaxProvider();
-            var createExpression = new CreateIndexExpression(DatabaseProviders.SqlServer, new[] { DatabaseProviders.SqlServer }, sqlSyntax)
+            var sqlSyntax = new SqlServerSyntaxProvider(new Lazy<IDatabaseFactory>(() => null));
+            var logger = Mock.Of<ILogger>();
+            var db = new UmbracoDatabase("cstr", sqlSyntax, DatabaseType.SqlServer2005, DbProviderFactories.GetFactory(Constants.DbProviderNames.SqlServer), logger);
+            var context = new MigrationContext(db, logger);
+            var createExpression = new CreateIndexExpression(context, new[] { DatabaseType.SqlServer2005 })
             {
                 Index = { Name = "IX_A" }
             };
diff --git a/src/Umbraco.Tests/PublishedContent/PublishedMediaTests.cs b/src/Umbraco.Tests/PublishedContent/PublishedMediaTests.cs
index ff59bac94a..d8fb20426e 100644
--- a/src/Umbraco.Tests/PublishedContent/PublishedMediaTests.cs
+++ b/src/Umbraco.Tests/PublishedContent/PublishedMediaTests.cs
@@ -61,6 +61,8 @@ namespace Umbraco.Tests.PublishedContent
         protected override void FreezeResolution()
         {
             var container = new ServiceContainer();
+            container.EnableAnnotatedConstructorInjection();
+
             UrlSegmentProviderResolver.Current = new UrlSegmentProviderResolver(container, Mock.Of<ILogger>(), typeof(DefaultUrlSegmentProvider));
 
             base.FreezeResolution();
diff --git a/src/Umbraco.Tests/Routing/UrlRoutingTestBase.cs b/src/Umbraco.Tests/Routing/UrlRoutingTestBase.cs
index 475909318a..18d4e1c080 100644
--- a/src/Umbraco.Tests/Routing/UrlRoutingTestBase.cs
+++ b/src/Umbraco.Tests/Routing/UrlRoutingTestBase.cs
@@ -61,7 +61,7 @@ namespace Umbraco.Tests.Routing
         {
             var settings = SettingsForTests.GetDefault();
             ApplicationContext.Current = new ApplicationContext(
-                new DatabaseContext(Mock.Of<IDatabaseFactory>(), Logger, Mock.Of<ISqlSyntaxProvider>(), "test"),
+                new DatabaseContext(Mock.Of<IDatabaseFactory>(), Logger),
                 GetServiceContext(settings, Logger),
                 CacheHelper,
                 ProfilingLogger)
diff --git a/src/Umbraco.Tests/Services/ContentServicePerformanceTest.cs b/src/Umbraco.Tests/Services/ContentServicePerformanceTest.cs
index 19b52c55a8..990bbfe121 100644
--- a/src/Umbraco.Tests/Services/ContentServicePerformanceTest.cs
+++ b/src/Umbraco.Tests/Services/ContentServicePerformanceTest.cs
@@ -148,10 +148,10 @@ namespace Umbraco.Tests.Services
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
 
-            using (var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver))
-            using (var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver))
-            using (var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, tRepository, MappingResolver))
-            using (var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, ctRepository, tRepository, tagRepo, Mock.Of<IContentSection>(), MappingResolver))
+            using (var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver))
+            using (var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver))
+            using (var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, tRepository, MappingResolver))
+            using (var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, ctRepository, tRepository, tagRepo, Mock.Of<IContentSection>(), MappingResolver))
             {
                 // Act
                 Stopwatch watch = Stopwatch.StartNew();
@@ -179,10 +179,10 @@ namespace Umbraco.Tests.Services
 
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver))
-            using (var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver))
-            using (var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, tRepository, MappingResolver))
-            using (var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, ctRepository, tRepository, tagRepo, Mock.Of<IContentSection>(), MappingResolver))
+            using (var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver))
+            using (var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver))
+            using (var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, tRepository, MappingResolver))
+            using (var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, ctRepository, tRepository, tagRepo, Mock.Of<IContentSection>(), MappingResolver))
             {
                 // Act
                 Stopwatch watch = Stopwatch.StartNew();
@@ -209,10 +209,10 @@ namespace Umbraco.Tests.Services
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
 
-            using (var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver))
-            using (var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver))
-            using (var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, tRepository, MappingResolver))
-            using (var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, ctRepository, tRepository, tagRepo, Mock.Of<IContentSection>(), MappingResolver))
+            using (var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver))
+            using (var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver))
+            using (var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, tRepository, MappingResolver))
+            using (var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, ctRepository, tRepository, tagRepo, Mock.Of<IContentSection>(), MappingResolver))
             {
 
                 // Act
@@ -242,10 +242,10 @@ namespace Umbraco.Tests.Services
 
             var provider = new NPocoUnitOfWorkProvider(Logger);
             var unitOfWork = provider.GetUnitOfWork();
-            using (var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver))
-            using (var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver))
-            using (var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, tRepository, MappingResolver))
-            using (var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, ctRepository, tRepository, tagRepo, Mock.Of<IContentSection>(), MappingResolver))
+            using (var tRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver))
+            using (var tagRepo = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver))
+            using (var ctRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, tRepository, MappingResolver))
+            using (var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, ctRepository, tRepository, tagRepo, Mock.Of<IContentSection>(), MappingResolver))
             {
 
                 // Act
diff --git a/src/Umbraco.Tests/Services/ContentServiceTests.cs b/src/Umbraco.Tests/Services/ContentServiceTests.cs
index 5dea7521c0..274b644738 100644
--- a/src/Umbraco.Tests/Services/ContentServiceTests.cs
+++ b/src/Umbraco.Tests/Services/ContentServiceTests.cs
@@ -13,6 +13,7 @@ using Umbraco.Core.Models.Membership;
 using Umbraco.Core.Models.Rdbms;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Repositories;
+using Umbraco.Core.Persistence.SqlSyntax;
 using Umbraco.Core.Persistence.UnitOfWork;
 using Umbraco.Core.Services;
 using Umbraco.Tests.TestHelpers;
@@ -1332,7 +1333,7 @@ namespace Umbraco.Tests.Services
         [Test]
         public void Can_Save_Lazy_Content()
         {
-            var databaseFactory = new DefaultDatabaseFactory(Umbraco.Core.Configuration.GlobalSettings.UmbracoConnectionName, Logger);
+            var databaseFactory = new DefaultDatabaseFactory(Umbraco.Core.Configuration.GlobalSettings.UmbracoConnectionName, SqlSyntaxProviders.GetDefaultProviders(Logger), Logger);
             var provider = new NPocoUnitOfWorkProvider(databaseFactory);
             var unitOfWork = provider.GetUnitOfWork();
             var contentType = ServiceContext.ContentTypeService.GetContentType("umbTextpage");
@@ -1610,10 +1611,10 @@ namespace Umbraco.Tests.Services
 
         private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository)
         {
-            var templateRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver);
-            var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, MappingResolver);
-            contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, templateRepository, MappingResolver);
-            var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
+            var templateRepository = new TemplateRepository(unitOfWork, DisabledCache, Logger, Mock.Of<IFileSystem>(), Mock.Of<IFileSystem>(), Mock.Of<ITemplatesSection>(), MappingResolver);
+            var tagRepository = new TagRepository(unitOfWork, DisabledCache, Logger, MappingResolver);
+            contentTypeRepository = new ContentTypeRepository(unitOfWork, DisabledCache, Logger, templateRepository, MappingResolver);
+            var repository = new ContentRepository(unitOfWork, DisabledCache, Logger, contentTypeRepository, templateRepository, tagRepository, Mock.Of<IContentSection>(), MappingResolver);
             return repository;
         }
     }
diff --git a/src/Umbraco.Tests/Services/MacroServiceTests.cs b/src/Umbraco.Tests/Services/MacroServiceTests.cs
index 7a6f68ff40..f73e9cdd17 100644
--- a/src/Umbraco.Tests/Services/MacroServiceTests.cs
+++ b/src/Umbraco.Tests/Services/MacroServiceTests.cs
@@ -27,7 +27,7 @@ namespace Umbraco.Tests.Services
 
             var provider = new NPocoUnitOfWorkProvider(Logger);
             using (var unitOfWork = provider.GetUnitOfWork())
-            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), SqlSyntax, MappingResolver))
+            using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of<ILogger>(), MappingResolver))
             {
                 repository.AddOrUpdate(new Macro("test1", "Test1", "~/usercontrol/test1.ascx", "MyAssembly1", "test1.xslt", "~/views/macropartials/test1.cshtml"));
                 repository.AddOrUpdate(new Macro("test2", "Test2", "~/usercontrol/test2.ascx", "MyAssembly2", "test2.xslt", "~/views/macropartials/test2.cshtml"));
diff --git a/src/Umbraco.Tests/Services/MemberServiceTests.cs b/src/Umbraco.Tests/Services/MemberServiceTests.cs
index 3e7a59a228..51b9896070 100644
--- a/src/Umbraco.Tests/Services/MemberServiceTests.cs
+++ b/src/Umbraco.Tests/Services/MemberServiceTests.cs
@@ -1018,7 +1018,7 @@ namespace Umbraco.Tests.Services
                 result.LastLoginDate.TruncateTo(DateTimeExtensions.DateTruncate.Second));
 
             //now ensure the col is correct
-            var sql = NPoco.Sql.BuilderFor(new SqlContext(SqlSyntax, DatabaseContext.Database)).Select("cmsPropertyData.*")
+            var sql = DatabaseContext.Database.Sql().Select("cmsPropertyData.*")
                 .From<PropertyDataDto>()
                 .InnerJoin<PropertyTypeDto>()
                 .On<PropertyDataDto, PropertyTypeDto>(dto => dto.PropertyTypeId, dto => dto.Id)
diff --git a/src/Umbraco.Tests/Services/PerformanceTests.cs b/src/Umbraco.Tests/Services/PerformanceTests.cs
index b362ff3597..f187d421f4 100644
--- a/src/Umbraco.Tests/Services/PerformanceTests.cs
+++ b/src/Umbraco.Tests/Services/PerformanceTests.cs
@@ -45,7 +45,7 @@ namespace Umbraco.Tests.Services
 
         protected override string GetDbProviderName()
         {
-            return "System.Data.SqlClient";
+            return Constants.DbProviderNames.SqlServer;
         }
 
 
@@ -287,7 +287,7 @@ namespace Umbraco.Tests.Services
             DatabaseContext.Database.BulkInsertRecords(SqlSyntax, nodes);
 
             //re-get the nodes with ids
-            var sql = NPoco.Sql.BuilderFor(new SqlContext(SqlSyntax, DatabaseContext.Database));
+            var sql = DatabaseContext.Database.Sql();
             sql.SelectAll().From<NodeDto>().Where<NodeDto>(x => x.NodeObjectType == customObjectType);
             nodes = DatabaseContext.Database.Fetch<NodeDto>(sql);
 
diff --git a/src/Umbraco.Tests/Services/ThreadSafetyServiceTest.cs b/src/Umbraco.Tests/Services/ThreadSafetyServiceTest.cs
index b4560b072b..1b7037a601 100644
--- a/src/Umbraco.Tests/Services/ThreadSafetyServiceTest.cs
+++ b/src/Umbraco.Tests/Services/ThreadSafetyServiceTest.cs
@@ -1,9 +1,11 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Data.Common;
 using System.Diagnostics;
 using System.Linq;
 using System.Threading;
+using NPoco;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Logging;
@@ -24,37 +26,40 @@ namespace Umbraco.Tests.Services
 	[TestFixture, RequiresSTA]
 	public class ThreadSafetyServiceTest : BaseDatabaseFactoryTest
 	{
-		private PerThreadNPocoUnitOfWorkProvider _uowProvider;
-		private PerThreadDatabaseFactory _dbFactory;
+		private IDatabaseUnitOfWorkProvider _uowProvider;
+		private PerThreadSqlCeDatabaseFactory _dbFactory;
 
 		[SetUp]
 		public override void Initialize()
-		{            
+		{
 			base.Initialize();
-			
-			//we need to use our own custom IDatabaseFactory for the DatabaseContext because we MUST ensure that 
-			//a Database instance is created per thread, whereas the default implementation which will work in an HttpContext
-			//threading environment, or a single apartment threading environment will not work for this test because 
-			//it is multi-threaded.
-			_dbFactory = new PerThreadDatabaseFactory(Logger);
-			//overwrite the local object
-            ApplicationContext.DatabaseContext = new DatabaseContext(_dbFactory, Logger, new SqlCeSyntaxProvider(), "System.Data.SqlServerCe.4.0");
+
+		    var sqlSyntax = new SqlCeSyntaxProvider();
+
+            //we need to use our own custom IDatabaseFactory for the DatabaseContext because we MUST ensure that
+            //a Database instance is created per thread, whereas the default implementation which will work in an HttpContext
+            //threading environment, or a single apartment threading environment will not work for this test because
+            //it is multi-threaded.
+            _dbFactory = new PerThreadSqlCeDatabaseFactory(Logger);
+            _uowProvider = new NPocoUnitOfWorkProvider(_dbFactory);
+
+            // overwrite the local object
+            ApplicationContext.DatabaseContext = new DatabaseContext(_dbFactory, Logger);
 
             //disable cache
 		    var cacheHelper = CacheHelper.CreateDisabledCacheHelper();
 
-			//here we are going to override the ServiceContext because normally with our test cases we use a 
+			//here we are going to override the ServiceContext because normally with our test cases we use a
 			//global Database object but this is NOT how it should work in the web world or in any multi threaded scenario.
 			//we need a new Database object for each thread.
-            var repositoryFactory = new RepositoryFactory(SqlSyntax, Container);
-			_uowProvider = new PerThreadNPocoUnitOfWorkProvider(_dbFactory);
+            var repositoryFactory = new RepositoryFactory(Container);
 		    var evtMsgs = new TransientMessagesFactory();
 		    ApplicationContext.Services = new ServiceContext(
                 repositoryFactory,
-                _uowProvider, 
-                new FileUnitOfWorkProvider(), 
-                new PublishingStrategy(evtMsgs, Logger), 
-                cacheHelper, 
+                _uowProvider,
+                new FileUnitOfWorkProvider(),
+                new PublishingStrategy(evtMsgs, Logger),
+                cacheHelper,
                 Logger,
                 evtMsgs,
                 Enumerable.Empty<IUrlSegmentProvider>());
@@ -75,9 +80,8 @@ namespace Umbraco.Tests.Services
 		{
 			_error = null;
 
-			//dispose!
+			// dispose!
 			_dbFactory.Dispose();
-			_uowProvider.Dispose();
 
 			base.TearDown();
 		}
@@ -94,9 +98,9 @@ namespace Umbraco.Tests.Services
 		{
 			//we will mimick the ServiceContext in that each repository in a service (i.e. ContentService) is a singleton
 			var contentService = (ContentService)ServiceContext.ContentService;
-			
+
 			var threads = new List<Thread>();
-			
+
 			Debug.WriteLine("Starting test...");
 
 			for (var i = 0; i < MaxThreadCount; i++)
@@ -105,13 +109,13 @@ namespace Umbraco.Tests.Services
 					{
 						try
 						{
-							Debug.WriteLine("Created content on thread: " + Thread.CurrentThread.ManagedThreadId);							
-							
+							Debug.WriteLine("Created content on thread: " + Thread.CurrentThread.ManagedThreadId);
+
 							//create 2 content items
 
                             string name1 = "test" + Guid.NewGuid();
 							var content1 = contentService.CreateContent(name1, -1, "umbTextpage", 0);
-							
+
 							Debug.WriteLine("Saving content1 on thread: " + Thread.CurrentThread.ManagedThreadId);
 							contentService.Save(content1);
 
@@ -120,12 +124,12 @@ namespace Umbraco.Tests.Services
                             string name2 = "test" + Guid.NewGuid();
 							var content2 = contentService.CreateContent(name2, -1, "umbTextpage", 0);
 							Debug.WriteLine("Saving content2 on thread: " + Thread.CurrentThread.ManagedThreadId);
-							contentService.Save(content2);	
+							contentService.Save(content2);
 						}
 						catch(Exception e)
-						{														
+						{
 							_error = e;
-						}						
+						}
 					});
 				threads.Add(t);
 			}
@@ -149,7 +153,7 @@ namespace Umbraco.Tests.Services
 			{
 			    throw new Exception("Error!", _error);
 			}
-			
+
 		}
 
 		[Test]
@@ -213,69 +217,64 @@ namespace Umbraco.Tests.Services
 			}
 
 		}
-		
+
 		public void CreateTestData()
 		{
 			//Create and Save ContentType "umbTextpage" -> 1045
 			ContentType contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage", "Textpage");
 			contentType.Key = new Guid("1D3A8E6E-2EA9-4CC1-B229-1AEE19821522");
-			ServiceContext.ContentTypeService.Save(contentType);			
+			ServiceContext.ContentTypeService.Save(contentType);
 		}
 
 		/// <summary>
-		/// Creates a Database object per thread, this mimics the web context which is per HttpContext and is required for the multi-threaded test
+		/// A special implementation of <see cref="IDatabaseFactory"/> that mimics the DefaultDatabaseFactory
+		/// (one db per HttpContext) by providing one db per thread, as required for multi-threaded
+		/// tests.
 		/// </summary>
-		internal class PerThreadDatabaseFactory : DisposableObject, IDatabaseFactory
+		internal class PerThreadSqlCeDatabaseFactory : DisposableObject, IDatabaseFactory
 		{
+            // the DefaultDatabaseFactory uses thread-static databases where there is no http context,
+            // so it would need to be disposed in each thread in order for each database to be disposed,
+            // instead we use this factory which also maintains one database per thread but can dispose
+            // them all in one call
+
 		    private readonly ILogger _logger;
 
-		    public PerThreadDatabaseFactory(ILogger logger)
+		    private readonly DbProviderFactory _dbProviderFactory =
+		        DbProviderFactories.GetFactory(Constants.DbProviderNames.SqlCe);
+
+		    public bool Configured => true;
+            public bool CanConnect => true;
+
+            public void Configure(string connectionString, string providerName)
 		    {
-		        _logger = logger;
+		        throw new NotImplementedException();
 		    }
 
-		    private readonly ConcurrentDictionary<int, UmbracoDatabase> _databases = new ConcurrentDictionary<int, UmbracoDatabase>(); 
+		    public ISqlSyntaxProvider SqlSyntax { get; } = new SqlCeSyntaxProvider();
 
-			public UmbracoDatabase CreateDatabase()
+		    public DatabaseType DatabaseType => DatabaseType.SQLCe;
+
+            public PerThreadSqlCeDatabaseFactory(ILogger logger)
+		    {
+                _logger = logger;
+		    }
+
+		    private readonly ConcurrentDictionary<int, UmbracoDatabase> _databases = new ConcurrentDictionary<int, UmbracoDatabase>();
+
+			public UmbracoDatabase GetDatabase()
 			{
-				var db = _databases.GetOrAdd(
+                return _databases.GetOrAdd(
                     Thread.CurrentThread.ManagedThreadId,
-                    i => new UmbracoDatabase(Umbraco.Core.Configuration.GlobalSettings.UmbracoConnectionName, _logger));
-				return db;
+                    i => new UmbracoDatabase(Core.Configuration.GlobalSettings.UmbracoConnectionName, SqlSyntax, DatabaseType, _dbProviderFactory, _logger));
 			}
 
 			protected override void DisposeResources()
 			{
-				//dispose the databases
-				_databases.ForEach(x => x.Value.Dispose());
+				// dispose the databases
+			    foreach (var database in _databases.Values) database.Dispose();
+			    _databases.Clear();
 			}
 		}
-
-		/// <summary>
-		/// Creates a UOW with a Database object per thread
-		/// </summary>
-		internal class PerThreadNPocoUnitOfWorkProvider : DisposableObject, IDatabaseUnitOfWorkProvider
-		{
-			private readonly PerThreadDatabaseFactory _dbFactory;
-
-			public PerThreadNPocoUnitOfWorkProvider(PerThreadDatabaseFactory dbFactory)
-			{
-				_dbFactory = dbFactory;
-			}
-
-			public IDatabaseUnitOfWork GetUnitOfWork()
-			{
-				//Create or get a database instance for this thread.
-				var db = _dbFactory.CreateDatabase();
-				return new NPocoUnitOfWork(db);
-			}
-
-			protected override void DisposeResources()
-			{
-				//dispose the databases
-				_dbFactory.Dispose();
-			}
-		}
-
 	}
 }
\ No newline at end of file
diff --git a/src/Umbraco.Tests/Templates/TemplateRepositoryTests.cs b/src/Umbraco.Tests/Templates/TemplateRepositoryTests.cs
index 9aef933a2c..ece4a1a0fd 100644
--- a/src/Umbraco.Tests/Templates/TemplateRepositoryTests.cs
+++ b/src/Umbraco.Tests/Templates/TemplateRepositoryTests.cs
@@ -2,14 +2,17 @@
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
+using System.Data.Common;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using NPoco;
 using Umbraco.Core;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
+using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Mappers;
 using Umbraco.Core.Persistence.Repositories;
 using Umbraco.Core.Persistence.SqlSyntax;
@@ -30,9 +33,13 @@ namespace Umbraco.Tests.Templates
         [SetUp]
         public void Setup()
         {
+            var uowMock = new Mock<IDatabaseUnitOfWork>();
+            var db = new UmbracoDatabase("cstr", new SqlCeSyntaxProvider(), DatabaseType.SQLCe, DbProviderFactories.GetFactory(Constants.DbProviderNames.SqlCe), Mock.Of<ILogger>());
+            uowMock.Setup(x => x.Database).Returns(db);
+
             var loggerMock = new Mock<ILogger>();
-            var sqlSyntaxMock = new Mock<ISqlSyntaxProvider>();
-            _templateRepository = new TemplateRepository(_unitOfWorkMock.Object, _cacheMock.Object, loggerMock.Object, sqlSyntaxMock.Object, _masterpageFileSystemMock.Object, _viewFileSystemMock.Object, _templateConfigMock.Object, Mock.Of<IMappingResolver>());
+
+            _templateRepository = new TemplateRepository(_unitOfWorkMock.Object, _cacheMock.Object, loggerMock.Object, _masterpageFileSystemMock.Object, _viewFileSystemMock.Object, _templateConfigMock.Object, Mock.Of<IMappingResolver>());
 
         }
 
diff --git a/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs b/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs
index abc3c0ee40..b2b3b7f47a 100644
--- a/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs
+++ b/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs
@@ -87,15 +87,18 @@ namespace Umbraco.Tests.TestHelpers
 
         protected override void SetupApplicationContext()
         {
+            var sqlSyntaxProviders = new[] { new SqlCeSyntaxProvider() };
+
             var dbFactory = new DefaultDatabaseFactory(
                 GetDbConnectionString(),
                 GetDbProviderName(),
+                sqlSyntaxProviders,
                 Logger);
 
             var evtMsgs = new TransientMessagesFactory();
             _appContext = new ApplicationContext(
                 //assign the db context
-                new DatabaseContext(dbFactory, Logger, SqlSyntax, "System.Data.SqlServerCe.4.0"),
+                new DatabaseContext(dbFactory, Logger),
                 //assign the service context
                 new ServiceContext(
                         Container.GetInstance<RepositoryFactory>(),
@@ -118,7 +121,6 @@ namespace Umbraco.Tests.TestHelpers
             {
                 //TODO: Somehow make this faster - takes 5s +
 
-                _appContext.DatabaseContext.Initialize(dbFactory.ProviderName, dbFactory.ConnectionString);
                 CreateSqlCeDatabase();
                 InitializeDatabase();
 
@@ -141,7 +143,7 @@ namespace Umbraco.Tests.TestHelpers
 
         protected virtual string GetDbProviderName()
         {
-            return "System.Data.SqlServerCe.4.0";
+            return Constants.DbProviderNames.SqlCe;
         }
 
         /// <summary>
@@ -252,7 +254,7 @@ namespace Umbraco.Tests.TestHelpers
                 || (_isFirstTestInFixture && DatabaseTestBehavior == DatabaseBehavior.NewDbFileAndSchemaPerFixture)))
             {
 
-                var schemaHelper = new DatabaseSchemaHelper(DatabaseContext.Database, Logger, SqlSyntax);
+                var schemaHelper = new DatabaseSchemaHelper(DatabaseContext.Database, Logger);
                 //Create the umbraco database and its base data
                 schemaHelper.CreateDatabaseSchema(_appContext);
 
@@ -391,7 +393,7 @@ namespace Umbraco.Tests.TestHelpers
             var factory = routeData != null
                             ? new FakeHttpContextFactory(url, routeData)
                             : new FakeHttpContextFactory(url);
-            
+
             return factory;
         }
 
diff --git a/src/Umbraco.Tests/TestHelpers/BaseUmbracoApplicationTest.cs b/src/Umbraco.Tests/TestHelpers/BaseUmbracoApplicationTest.cs
index 24a5c5f34d..f95c0acd70 100644
--- a/src/Umbraco.Tests/TestHelpers/BaseUmbracoApplicationTest.cs
+++ b/src/Umbraco.Tests/TestHelpers/BaseUmbracoApplicationTest.cs
@@ -56,7 +56,9 @@ namespace Umbraco.Tests.TestHelpers
         {
             base.Initialize();
 
-            Container = new ServiceContainer();
+            var container = new ServiceContainer();
+            container.EnableAnnotatedConstructorInjection();
+            Container = container;
 
             TestHelper.InitializeContentDirectories();
 
@@ -211,8 +213,7 @@ namespace Umbraco.Tests.TestHelpers
             var evtMsgs = new TransientMessagesFactory();
             ApplicationContext.Current = new ApplicationContext(
                 //assign the db context
-                new DatabaseContext(new DefaultDatabaseFactory(Core.Configuration.GlobalSettings.UmbracoConnectionName, Logger),
-                    Logger, SqlSyntax, "System.Data.SqlServerCe.4.0"),
+                new DatabaseContext(new DefaultDatabaseFactory(Core.Configuration.GlobalSettings.UmbracoConnectionName, SqlSyntaxProviders.GetDefaultProviders(Logger), Logger), Logger),
                 //assign the service context
                 new ServiceContext(
                     Container.GetInstance<RepositoryFactory>(), 
diff --git a/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs b/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs
index c88df8ba4f..80b39e51eb 100644
--- a/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs
+++ b/src/Umbraco.Tests/TestHelpers/BaseUsingSqlCeSyntax.cs
@@ -34,7 +34,8 @@ namespace Umbraco.Tests.TestHelpers
             var sqlSyntax = new SqlCeSyntaxProvider();
 
             var container = new ServiceContainer();
-            container.RegisterSingleton<ISqlSyntaxProvider>(factory => sqlSyntax);
+            container.EnableAnnotatedConstructorInjection();
+
             container.RegisterSingleton<ILogger>(factory => Mock.Of<ILogger>());
             container.RegisterSingleton<IProfiler>(factory => Mock.Of<IProfiler>());
 
diff --git a/src/Umbraco.Tests/Umbraco.Tests.csproj b/src/Umbraco.Tests/Umbraco.Tests.csproj
index fb3e318538..64e1911d32 100644
--- a/src/Umbraco.Tests/Umbraco.Tests.csproj
+++ b/src/Umbraco.Tests/Umbraco.Tests.csproj
@@ -63,8 +63,12 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\SharpZipLib.0.86.0\lib\20\ICSharpCode.SharpZipLib.dll</HintPath>
     </Reference>
-    <Reference Include="LightInject, Version=4.0.8.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\LightInject.4.0.8\lib\net46\LightInject.dll</HintPath>
+    <Reference Include="LightInject, Version=4.0.9.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\LightInject.4.0.9\lib\net46\LightInject.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="LightInject.Annotation, Version=1.0.0.4, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\LightInject.Annotation.1.0.0.4\lib\net45\LightInject.Annotation.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="log4net, Version=1.2.15.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a, processorArchitecture=MSIL">
diff --git a/src/Umbraco.Tests/Web/Mvc/SurfaceControllerTests.cs b/src/Umbraco.Tests/Web/Mvc/SurfaceControllerTests.cs
index 7c5921c67a..357b601e41 100644
--- a/src/Umbraco.Tests/Web/Mvc/SurfaceControllerTests.cs
+++ b/src/Umbraco.Tests/Web/Mvc/SurfaceControllerTests.cs
@@ -74,7 +74,7 @@ namespace Umbraco.Tests.Web.Mvc
         public void Umbraco_Helper_Not_Null()
         {
             var appCtx = new ApplicationContext(
-                new DatabaseContext(new Mock<IDatabaseFactory>().Object, Mock.Of<ILogger>(), Mock.Of<ISqlSyntaxProvider>(), "test"),
+                new DatabaseContext(new Mock<IDatabaseFactory>().Object, Mock.Of<ILogger>()),
                 MockHelper.GetMockedServiceContext(),
                 CacheHelper.CreateDisabledCacheHelper(),
                 new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>()));
diff --git a/src/Umbraco.Tests/Web/Mvc/UmbracoViewPageTests.cs b/src/Umbraco.Tests/Web/Mvc/UmbracoViewPageTests.cs
index 756309871f..d9b66a2d2a 100644
--- a/src/Umbraco.Tests/Web/Mvc/UmbracoViewPageTests.cs
+++ b/src/Umbraco.Tests/Web/Mvc/UmbracoViewPageTests.cs
@@ -428,7 +428,7 @@ namespace Umbraco.Tests.Web.Mvc
             var svcCtx = GetServiceContext();
 
             var appCtx = new ApplicationContext(
-                new DatabaseContext(Mock.Of<IDatabaseFactory>(), logger, Mock.Of<ISqlSyntaxProvider>(), "test"),
+                new DatabaseContext(Mock.Of<IDatabaseFactory>(), logger),
                 svcCtx,
                 CacheHelper.CreateDisabledCacheHelper(),
                 new ProfilingLogger(logger, Mock.Of<IProfiler>())) { IsReady = true };
diff --git a/src/Umbraco.Tests/packages.config b/src/Umbraco.Tests/packages.config
index 3c4ac7ecb4..5f9bc7c883 100644
--- a/src/Umbraco.Tests/packages.config
+++ b/src/Umbraco.Tests/packages.config
@@ -3,7 +3,8 @@
   <package id="AspNetWebApi.SelfHost" version="4.0.20710.0" targetFramework="net45" />
   <package id="AutoMapper" version="4.2.1" targetFramework="net461" />
   <package id="Examine" version="0.1.68.0" targetFramework="net45" />
-  <package id="LightInject" version="4.0.8" targetFramework="net461" />
+  <package id="LightInject" version="4.0.9" targetFramework="net461" />
+  <package id="LightInject.Annotation" version="1.0.0.4" targetFramework="net461" />
   <package id="log4net" version="2.0.5" targetFramework="net461" />
   <package id="Lucene.Net" version="2.9.4.1" targetFramework="net45" />
   <package id="Microsoft.AspNet.Mvc" version="5.2.3" targetFramework="net45" />
diff --git a/src/Umbraco.Web/Install/Controllers/InstallApiController.cs b/src/Umbraco.Web/Install/Controllers/InstallApiController.cs
index 0063f66714..1f0c371d43 100644
--- a/src/Umbraco.Web/Install/Controllers/InstallApiController.cs
+++ b/src/Umbraco.Web/Install/Controllers/InstallApiController.cs
@@ -52,7 +52,7 @@ namespace Umbraco.Web.Install.Controllers
         public bool PostValidateDatabaseConnection(DatabaseModel model)
         {
             var dbHelper = new DatabaseHelper();
-            var canConnect = dbHelper.CheckConnection(model, ApplicationContext);
+            var canConnect = dbHelper.CheckConnection(ApplicationContext.DatabaseContext, model);
             return canConnect;
         }
 
diff --git a/src/Umbraco.Web/Install/DatabaseHelper.cs b/src/Umbraco.Web/Install/DatabaseHelper.cs
index cb2263628b..84535675a3 100644
--- a/src/Umbraco.Web/Install/DatabaseHelper.cs
+++ b/src/Umbraco.Web/Install/DatabaseHelper.cs
@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Umbraco.Core;
+using Umbraco.Core;
 using Umbraco.Core.Persistence;
 using Umbraco.Web.Install.Models;
 
@@ -11,41 +6,34 @@ namespace Umbraco.Web.Install
 {
     internal class DatabaseHelper
     {
-        internal bool CheckConnection(DatabaseModel database, ApplicationContext applicationContext)
+        internal bool CheckConnection(DatabaseContext context, DatabaseModel model)
         {
-            string connectionString;
-            DatabaseProviders provider;
-            var dbContext = applicationContext.DatabaseContext;
-
-            if (database.ConnectionString.IsNullOrWhiteSpace() == false)
-            {
-                connectionString = database.ConnectionString;
-                provider = DbConnectionExtensions.DetectProviderFromConnectionString(connectionString);
-            }
-            else if (database.DatabaseType == DatabaseType.SqlCe)
-            {
-                //we do not test this connection
+            // we do not test SqlCE connection
+            if (model.DatabaseType == DatabaseType.SqlCe)
                 return true;
-                //connectionString = dbContext.GetEmbeddedDatabaseConnectionString();
-            }
-            else if (database.IntegratedAuth)
+
+            string providerName;
+            string connectionString;
+
+            if (string.IsNullOrWhiteSpace(model.ConnectionString) == false)
             {
-                connectionString = dbContext.GetIntegratedSecurityDatabaseConnectionString(
-                    database.Server, database.DatabaseName);
-                provider = DatabaseProviders.SqlServer;;
+                providerName = DbConnectionExtensions.DetectProviderNameFromConnectionString(model.ConnectionString);
+                connectionString = model.ConnectionString;
+            }
+            else if (model.IntegratedAuth)
+            {
+                // has to be Sql Server
+                providerName = Constants.DbProviderNames.SqlServer;
+                connectionString = context.GetIntegratedSecurityDatabaseConnectionString(model.Server, model.DatabaseName);
             }
             else
             {
-                string providerName;
-                connectionString = dbContext.GetDatabaseConnectionString(
-                    database.Server, database.DatabaseName, database.Login, database.Password,
-                    database.DatabaseType.ToString(),
-                    out providerName);
-
-                provider = database.DatabaseType == DatabaseType.MySql ? DatabaseProviders.MySql : DatabaseProviders.SqlServer;
+                connectionString = context.GetDatabaseConnectionString(
+                    model.Server, model.DatabaseName, model.Login, model.Password,
+                    model.DatabaseType.ToString(), out providerName);
             }
 
-            return DbConnectionExtensions.IsConnectionAvailable(connectionString, provider);
+            return DbConnectionExtensions.IsConnectionAvailable(connectionString, providerName);
         }
     }
 }
diff --git a/src/Umbraco.Web/Install/InstallHelper.cs b/src/Umbraco.Web/Install/InstallHelper.cs
index ae0606d729..7d663bbc03 100644
--- a/src/Umbraco.Web/Install/InstallHelper.cs
+++ b/src/Umbraco.Web/Install/InstallHelper.cs
@@ -14,6 +14,7 @@ using Umbraco.Core.Configuration;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.SqlSyntax;
 using Umbraco.Web.Install.InstallSteps;
 using Umbraco.Web.Install.Models;
 using Umbraco.Web;
@@ -120,7 +121,11 @@ namespace Umbraco.Web.Install
                 
                 string dbProvider = string.Empty;
                 if (IsBrandNewInstall == false)
-                    dbProvider = ApplicationContext.Current.DatabaseContext.DatabaseProvider.ToString();
+                {
+                    // we don't have DatabaseProvider anymore... doing it differently
+                    //dbProvider = ApplicationContext.Current.DatabaseContext.DatabaseProvider.ToString();
+                    dbProvider = GetDbProviderString(ApplicationContext.Current.DatabaseContext);
+                }
 
                 org.umbraco.update.CheckForUpgrade check = new org.umbraco.update.CheckForUpgrade();
                 check.Install(installId,
@@ -141,6 +146,25 @@ namespace Umbraco.Web.Install
             }
         }
 
+        internal static string GetDbProviderString(DatabaseContext context)
+        {
+            var dbProvider = string.Empty;
+
+            // we don't have DatabaseProvider anymore...
+            //dbProvider = ApplicationContext.Current.DatabaseContext.DatabaseProvider.ToString();
+            //
+            // doing it differently
+            var syntax = context.Database.SqlSyntax;
+            if (syntax is SqlCeSyntaxProvider)
+                dbProvider = "SqlServerCE";
+            else if (syntax is MySqlSyntaxProvider)
+                dbProvider = "MySql";
+            else if (syntax is SqlServerSyntaxProvider)
+                dbProvider = (syntax as SqlServerSyntaxProvider).ServerVersion.IsAzure ? "SqlAzure" : "SqlServer";
+
+            return dbProvider;
+        }
+
         /// <summary>
         /// Checks if this is a brand new install meaning that there is no configured version and there is no configured database connection
         /// </summary>
diff --git a/src/Umbraco.Web/Install/InstallSteps/DatabaseConfigureStep.cs b/src/Umbraco.Web/Install/InstallSteps/DatabaseConfigureStep.cs
index f9ba3fd69b..d2aa040f03 100644
--- a/src/Umbraco.Web/Install/InstallSteps/DatabaseConfigureStep.cs
+++ b/src/Umbraco.Web/Install/InstallSteps/DatabaseConfigureStep.cs
@@ -35,7 +35,7 @@ namespace Umbraco.Web.Install.InstallSteps
 
             var dbHelper = new DatabaseHelper();
 
-            if (dbHelper.CheckConnection(database, _applicationContext) == false)
+            if (dbHelper.CheckConnection(_applicationContext.DatabaseContext, database) == false)
             {
                 throw new InstallException("Could not connect to the database");
             }
diff --git a/src/Umbraco.Web/Install/InstallSteps/DatabaseInstallStep.cs b/src/Umbraco.Web/Install/InstallSteps/DatabaseInstallStep.cs
index 5508197860..f89dc39367 100644
--- a/src/Umbraco.Web/Install/InstallSteps/DatabaseInstallStep.cs
+++ b/src/Umbraco.Web/Install/InstallSteps/DatabaseInstallStep.cs
@@ -30,22 +30,18 @@ namespace Umbraco.Web.Install.InstallSteps
             {
                 throw new InstallException("The database failed to install. ERROR: " + result.Message);
             }
-            
+
             if (result.RequiresUpgrade == false)
             {
                 HandleConnectionStrings();
                 return null;
             }
-            else
-            {
-                //upgrade is required so set the flag for the next step
 
-                return new InstallSetupResult(new Dictionary<string, object>
-                {
-                    {"upgrade", true}
-                });
-            }
-            
+            //upgrade is required so set the flag for the next step
+            return new InstallSetupResult(new Dictionary<string, object>
+            {
+                {"upgrade", true}
+            });
         }
 
         internal static void HandleConnectionStrings()
diff --git a/src/Umbraco.Web/Strategies/Migrations/PublishAfterUpgradeToVersionSixth.cs b/src/Umbraco.Web/Strategies/Migrations/PublishAfterUpgradeToVersionSixth.cs
index 66958a2c9d..70de7c0227 100644
--- a/src/Umbraco.Web/Strategies/Migrations/PublishAfterUpgradeToVersionSixth.cs
+++ b/src/Umbraco.Web/Strategies/Migrations/PublishAfterUpgradeToVersionSixth.cs
@@ -33,7 +33,7 @@ namespace Umbraco.Web.Strategies.Migrations
             var target = new Version(6, 0, 0);
             if (e.ConfiguredVersion < target)
             {
-                var sql = Sql.BuilderFor(new SqlContext(_sqlSyntax, e.MigrationContext.Database))
+                var sql = e.MigrationContext.Database.Sql()
                     .SelectAll()
                     .From<DocumentDto>()
                     .InnerJoin<ContentVersionDto>()
diff --git a/src/Umbraco.Web/Umbraco.Web.csproj b/src/Umbraco.Web/Umbraco.Web.csproj
index 91de7f69bf..e0400c5f4f 100644
--- a/src/Umbraco.Web/Umbraco.Web.csproj
+++ b/src/Umbraco.Web/Umbraco.Web.csproj
@@ -126,8 +126,12 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\SharpZipLib.0.86.0\lib\20\ICSharpCode.SharpZipLib.dll</HintPath>
     </Reference>
-    <Reference Include="LightInject, Version=4.0.8.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\LightInject.4.0.8\lib\net46\LightInject.dll</HintPath>
+    <Reference Include="LightInject, Version=4.0.9.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\LightInject.4.0.9\lib\net46\LightInject.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="LightInject.Annotation, Version=1.0.0.4, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\LightInject.Annotation.1.0.0.4\lib\net45\LightInject.Annotation.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="LightInject.Mvc, Version=1.0.0.4, Culture=neutral, processorArchitecture=MSIL">
diff --git a/src/Umbraco.Web/packages.config b/src/Umbraco.Web/packages.config
index 97242e1500..c72af8d9e8 100644
--- a/src/Umbraco.Web/packages.config
+++ b/src/Umbraco.Web/packages.config
@@ -5,7 +5,8 @@
   <package id="dotless" version="1.4.1.0" targetFramework="net45" />
   <package id="Examine" version="0.1.68.0" targetFramework="net45" />
   <package id="HtmlAgilityPack" version="1.4.9" targetFramework="net45" />
-  <package id="LightInject" version="4.0.8" targetFramework="net461" />
+  <package id="LightInject" version="4.0.9" targetFramework="net461" />
+  <package id="LightInject.Annotation" version="1.0.0.4" targetFramework="net461" />
   <package id="LightInject.Mvc" version="1.0.0.4" targetFramework="net45" />
   <package id="LightInject.Web" version="1.0.0.7" targetFramework="net461" />
   <package id="LightInject.WebApi" version="1.0.0.4" targetFramework="net45" />
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/webservices/CheckForUpgrade.asmx.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/webservices/CheckForUpgrade.asmx.cs
index 1dae965735..08613a4de8 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/webservices/CheckForUpgrade.asmx.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/webservices/CheckForUpgrade.asmx.cs
@@ -7,6 +7,7 @@ using Umbraco.Core;
 using Umbraco.Web.WebServices;
 using Umbraco.Core.Configuration;
 using Umbraco.Web;
+using Umbraco.Web.Install;
 
 
 namespace umbraco.presentation.webservices
@@ -72,7 +73,7 @@ namespace umbraco.presentation.webservices
 
             string dbProvider = string.Empty;
             if (string.IsNullOrEmpty(global::Umbraco.Core.Configuration.GlobalSettings.ConfigurationStatus) == false)
-            dbProvider = ApplicationContext.Current.DatabaseContext.DatabaseProvider.ToString();
+            dbProvider = InstallHelper.GetDbProviderString(ApplicationContext.Current.DatabaseContext);
 
             var check = new global::Umbraco.Web.org.umbraco.update.CheckForUpgrade();
             check.Install(installId,
diff --git a/src/UmbracoExamine/app.config b/src/UmbracoExamine/app.config
index 65f505d522..1075ce62d2 100644
--- a/src/UmbracoExamine/app.config
+++ b/src/UmbracoExamine/app.config
@@ -12,7 +12,7 @@
       </dependentAssembly>
       <dependentAssembly>
         <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-8.0.0.0" newVersion="8.0.0.0" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
       </dependentAssembly>
       <dependentAssembly>
         <assemblyIdentity name="Microsoft.Owin" publicKeyToken="31bf3856ad364e35" culture="neutral" />