diff --git a/src/Umbraco.Core/Persistence/Migrations/MigrationBase.cs b/src/Umbraco.Core/Persistence/Migrations/MigrationBase.cs
index dc10ba1177..a19aaa24ad 100644
--- a/src/Umbraco.Core/Persistence/Migrations/MigrationBase.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/MigrationBase.cs
@@ -42,7 +42,7 @@ namespace Umbraco.Core.Persistence.Migrations
 
         public IAlterSyntaxBuilder Alter
         {
-            get { return new AlterSyntaxBuilder(Context); }
+            get { return new AlterSyntaxBuilder(Context, SqlSyntax); }
         }
 
         public ICreateBuilder Create
@@ -57,22 +57,22 @@ namespace Umbraco.Core.Persistence.Migrations
 
         public IExecuteBuilder Execute
         {
-            get { return new ExecuteBuilder(Context); }
+            get { return new ExecuteBuilder(Context, SqlSyntax); }
         }
 
         public IInsertBuilder Insert
         {
-            get { return new InsertBuilder(Context); }
+            get { return new InsertBuilder(Context, SqlSyntax); }
         }
 
         public IRenameBuilder Rename
         {
-            get { return new RenameBuilder(Context); }
+            get { return new RenameBuilder(Context, SqlSyntax); }
         }
 
         public IUpdateBuilder Update
         {
-            get { return new UpdateBuilder(Context); }
+            get { return new UpdateBuilder(Context, SqlSyntax); }
         }
 
         public IIfDatabaseBuilder IfDatabase(params DatabaseProviders[] databaseProviders)
diff --git a/src/Umbraco.Core/Persistence/Migrations/MigrationExpressionBase.cs b/src/Umbraco.Core/Persistence/Migrations/MigrationExpressionBase.cs
index 655f2c7673..35d199d5f0 100644
--- a/src/Umbraco.Core/Persistence/Migrations/MigrationExpressionBase.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/MigrationExpressionBase.cs
@@ -7,22 +7,22 @@ namespace Umbraco.Core.Persistence.Migrations
 {
     public abstract class MigrationExpressionBase : IMigrationExpression
     {
-        [Obsolete("Use the other constructors specifying an ISqlSyntaxProvider instead")]
-        protected MigrationExpressionBase()
-            : this(SqlSyntaxContext.SqlSyntaxProvider)
-        {
-        }
+        //[Obsolete("Use the other constructors specifying an ISqlSyntaxProvider instead")]
+        //protected MigrationExpressionBase()
+        //    : this(SqlSyntaxContext.SqlSyntaxProvider)
+        //{
+        //}
 
-        [Obsolete("Use the other constructors specifying an ISqlSyntaxProvider instead")]
-        protected MigrationExpressionBase(DatabaseProviders current, DatabaseProviders[] databaseProviders)
-            : this(current, databaseProviders, SqlSyntaxContext.SqlSyntaxProvider)
-        {
-        }
+        //[Obsolete("Use the other constructors specifying an ISqlSyntaxProvider instead")]
+        //protected MigrationExpressionBase(DatabaseProviders current, DatabaseProviders[] databaseProviders)
+        //    : this(current, databaseProviders, SqlSyntaxContext.SqlSyntaxProvider)
+        //{
+        //}
 
-        protected MigrationExpressionBase(ISqlSyntaxProvider sqlSyntax)
-        {
-            SqlSyntax = sqlSyntax;
-        }
+        //protected MigrationExpressionBase(ISqlSyntaxProvider sqlSyntax)
+        //{
+        //    SqlSyntax = sqlSyntax;
+        //}
 
         protected MigrationExpressionBase(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/AlterSyntaxBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/AlterSyntaxBuilder.cs
index 299550d83e..e253f8e607 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/AlterSyntaxBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/AlterSyntaxBuilder.cs
@@ -1,30 +1,35 @@
 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;
 
-        public AlterSyntaxBuilder(IMigrationContext context)
+        public AlterSyntaxBuilder(IMigrationContext context, ISqlSyntaxProvider sqlSyntax, params DatabaseProviders[] databaseProviders)
         {
             _context = context;
+            _sqlSyntax = sqlSyntax;
+            _databaseProviders = databaseProviders;
         }
 
         public IAlterTableSyntax Table(string tableName)
         {
-            var expression = new AlterTableExpression { TableName = tableName };
+            var expression = new AlterTableExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { TableName = tableName };
             //_context.Expressions.Add(expression);
-            return new AlterTableBuilder(expression, _context);
+            return new AlterTableBuilder(_context, _databaseProviders, expression);
         }
 
         public IAlterColumnSyntax Column(string columnName)
         {
-            var expression = new AlterColumnExpression { Column = { Name = columnName } };
+            var expression = new AlterColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) {Column = {Name = columnName}};
             //_context.Expressions.Add(expression);
-            return new AlterColumnBuilder(expression, _context);
+            return new AlterColumnBuilder(_context, _databaseProviders, 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 3b77743b0d..a7077f2d35 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Column/AlterColumnBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Column/AlterColumnBuilder.cs
@@ -2,6 +2,7 @@
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Expressions;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column
 {
@@ -11,11 +12,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column
                                             IAlterColumnOptionForeignKeyCascadeSyntax
     {
         private readonly IMigrationContext _context;
+        private readonly DatabaseProviders[] _databaseProviders;
 
-        public AlterColumnBuilder(AlterColumnExpression expression, IMigrationContext context)
+        public AlterColumnBuilder(IMigrationContext context, DatabaseProviders[] databaseProviders, AlterColumnExpression expression)
             : base(expression)
         {
             _context = context;
+            _databaseProviders = databaseProviders;
         }
 
         public ForeignKeyDefinition CurrentForeignKey { get; set; }
@@ -33,7 +36,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column
 
         public IAlterColumnOptionSyntax WithDefault(SystemMethods method)
         {
-            var dc = new AlterDefaultConstraintExpression
+            var dc = new AlterDefaultConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax)
                          {
                              TableName = Expression.TableName,
                              SchemaName = Expression.SchemaName,
@@ -51,7 +54,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column
 
         public IAlterColumnOptionSyntax WithDefaultValue(object value)
         {
-            var dc = new AlterDefaultConstraintExpression
+            var dc = new AlterDefaultConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax)
                          {
                              TableName = Expression.TableName,
                              SchemaName = Expression.SchemaName,
@@ -81,15 +84,12 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column
         {
             Expression.Column.IsIndexed = true;
 
-            var index = new CreateIndexExpression
-                            {
-                                Index = new IndexDefinition
-                                            {
-                                                Name = indexName,
-                                                SchemaName = Expression.SchemaName,
-                                                TableName = Expression.TableName
-                                            }
-                            };
+            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            {
+                Name = indexName,
+                SchemaName = Expression.SchemaName,
+                TableName = Expression.TableName
+            });
 
             index.Index.Columns.Add(new IndexColumnDefinition
                                         {
@@ -135,16 +135,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column
         {
             Expression.Column.IsUnique = true;
 
-            var index = new CreateIndexExpression
-                            {
-                                Index = new IndexDefinition
-                                            {
-                                                Name = indexName,
-                                                SchemaName = Expression.SchemaName,
-                                                TableName = Expression.TableName,
-                                                IsUnique = true
-                                            }
-                            };
+            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            {
+                Name = indexName,
+                SchemaName = Expression.SchemaName,
+                TableName = Expression.TableName,
+                IsUnique = true
+            });
 
             index.Index.Columns.Add(new IndexColumnDefinition
                                         {
@@ -172,17 +169,14 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column
         {
             Expression.Column.IsForeignKey = true;
 
-            var fk = new CreateForeignKeyExpression
-                         {
-                             ForeignKey = new ForeignKeyDefinition
-                                              {
-                                                  Name = foreignKeyName,
-                                                  PrimaryTable = primaryTableName,
-                                                  PrimaryTableSchema = primaryTableSchema,
-                                                  ForeignTable = Expression.TableName,
-                                                  ForeignTableSchema = Expression.SchemaName
-                                              }
-                         };
+            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            {
+                Name = foreignKeyName,
+                PrimaryTable = primaryTableName,
+                PrimaryTableSchema = primaryTableSchema,
+                ForeignTable = Expression.TableName,
+                ForeignTableSchema = Expression.SchemaName
+            });
 
             fk.ForeignKey.PrimaryColumns.Add(primaryColumnName);
             fk.ForeignKey.ForeignColumns.Add(Expression.Column.Name);
@@ -212,17 +206,14 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column
         public IAlterColumnOptionForeignKeyCascadeSyntax ReferencedBy(string foreignKeyName, string foreignTableSchema,
                                                                       string foreignTableName, string foreignColumnName)
         {
-            var fk = new CreateForeignKeyExpression
-                         {
-                             ForeignKey = new ForeignKeyDefinition
-                                              {
-                                                  Name = foreignKeyName,
-                                                  PrimaryTable = Expression.TableName,
-                                                  PrimaryTableSchema = Expression.SchemaName,
-                                                  ForeignTable = foreignTableName,
-                                                  ForeignTableSchema = foreignTableSchema
-                                              }
-                         };
+            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            {
+                Name = foreignKeyName,
+                PrimaryTable = Expression.TableName,
+                PrimaryTableSchema = Expression.SchemaName,
+                ForeignTable = foreignTableName,
+                ForeignTableSchema = foreignTableSchema
+            });
 
             fk.ForeignKey.PrimaryColumns.Add(Expression.Column.Name);
             fk.ForeignKey.ForeignColumns.Add(foreignColumnName);
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 43be956440..a40e7be320 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterColumnExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterColumnExpression.cs
@@ -6,11 +6,11 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions
 {
     public class AlterColumnExpression : MigrationExpressionBase
     {
-        public AlterColumnExpression(ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax)
-        {
-            Column = new ColumnDefinition() { ModificationType = ModificationType.Alter };
-        }
+        //public AlterColumnExpression(ISqlSyntaxProvider sqlSyntax)
+        //    : base(sqlSyntax)
+        //{
+        //    Column = new ColumnDefinition() { ModificationType = ModificationType.Alter };
+        //}
 
         public AlterColumnExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
             : base(current, databaseProviders, sqlSyntax)
@@ -18,17 +18,17 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions
             Column = new ColumnDefinition() { ModificationType = ModificationType.Alter };
         }
 
-        [Obsolete("Use the constructor specifying an ISqlSyntaxProvider instead")]
-        public AlterColumnExpression()
-            : this(SqlSyntaxContext.SqlSyntaxProvider)
-        {
-        }
+        //[Obsolete("Use the constructor specifying an ISqlSyntaxProvider instead")]
+        //public AlterColumnExpression()
+        //    : this(SqlSyntaxContext.SqlSyntaxProvider)
+        //{
+        //}
 
-        [Obsolete("Use the constructor specifying an ISqlSyntaxProvider instead")]
-        public AlterColumnExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders)
-            : this(current, databaseProviders, SqlSyntaxContext.SqlSyntaxProvider)
-        {
-        }
+        //[Obsolete("Use the constructor specifying an ISqlSyntaxProvider instead")]
+        //public AlterColumnExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders)
+        //    : this(current, databaseProviders, SqlSyntaxContext.SqlSyntaxProvider)
+        //{
+        //}
 
         
 
@@ -42,9 +42,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions
             //    SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(Column.Name),
             //    SqlSyntaxContext.SqlSyntaxProvider.Format(Column));
 
-            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.AlterColumn,
-                                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(TableName),
-                                SqlSyntaxContext.SqlSyntaxProvider.Format(Column));
+            return string.Format(SqlSyntax.AlterColumn,
+                                SqlSyntax.GetQuotedTableName(TableName),
+                                SqlSyntax.Format(Column));
 
             //return string.Format(SqlSyntaxContext.SqlSyntaxProvider.AlterColumn,
             //                     SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(TableName),
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 cd99b6754f..cd83f55a35 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterDefaultConstraintExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterDefaultConstraintExpression.cs
@@ -4,11 +4,8 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions
 {
     public class AlterDefaultConstraintExpression : MigrationExpressionBase
     {
-        public AlterDefaultConstraintExpression()
-        {
-        }
-
-        public AlterDefaultConstraintExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders) : base(current, databaseProviders)
+        public AlterDefaultConstraintExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax) 
+            : base(current, databaseProviders, sqlSyntax)
         {
         }
 
@@ -22,9 +19,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions
         {
             //NOTE Should probably investigate if Deleting a Default Constraint is different from deleting a 'regular' constraint
 
-            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteConstraint,
-                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(TableName),
-                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedName(ConstraintName));
+            return string.Format(SqlSyntax.DeleteConstraint,
+                                 SqlSyntax.GetQuotedTableName(TableName),
+                                 SqlSyntax.GetQuotedName(ConstraintName));
         }
     }
 }
\ No newline at end of file
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 360b699cd8..b5906ed324 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterTableExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterTableExpression.cs
@@ -1,12 +1,12 @@
-namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions
 {
     public class AlterTableExpression : MigrationExpressionBase
     {
-        public AlterTableExpression()
-        {
-        }
 
-        public AlterTableExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders) : base(current, databaseProviders)
+        public AlterTableExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax) 
+            : base(current, databaseProviders, sqlSyntax)
         {
         }
 
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 a50e393e96..7a6ab8d47a 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Table/AlterTableBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Table/AlterTableBuilder.cs
@@ -2,6 +2,7 @@
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Expressions;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table
 {
@@ -10,11 +11,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table
                                                IAlterTableColumnOptionForeignKeyCascadeSyntax
     {
         private readonly IMigrationContext _context;
+        private readonly DatabaseProviders[] _databaseProviders;
 
-        public AlterTableBuilder(AlterTableExpression expression, IMigrationContext context)
+        public AlterTableBuilder(IMigrationContext context, DatabaseProviders[] databaseProviders, AlterTableExpression expression)
             : base(expression)
         {
             _context = context;
+            _databaseProviders = databaseProviders;
         }
 
         public ColumnDefinition CurrentColumn { get; set; }
@@ -36,7 +39,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table
         {
             if (CurrentColumn.ModificationType == ModificationType.Alter)
             {
-                var dc = new AlterDefaultConstraintExpression
+                var dc = new AlterDefaultConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax)
                              {
                                  TableName = Expression.TableName,
                                  SchemaName = Expression.SchemaName,
@@ -66,15 +69,12 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table
         {
             CurrentColumn.IsIndexed = true;
 
-            var index = new CreateIndexExpression
-                            {
-                                Index = new IndexDefinition
-                                            {
-                                                Name = indexName,
-                                                SchemaName = Expression.SchemaName,
-                                                TableName = Expression.TableName
-                                            }
-                            };
+            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            {
+                Name = indexName,
+                SchemaName = Expression.SchemaName,
+                TableName = Expression.TableName
+            });
 
             index.Index.Columns.Add(new IndexColumnDefinition
                                         {
@@ -120,16 +120,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table
         {
             CurrentColumn.IsUnique = true;
 
-            var index = new CreateIndexExpression
-                            {
-                                Index = new IndexDefinition
-                                            {
-                                                Name = indexName,
-                                                SchemaName = Expression.SchemaName,
-                                                TableName = Expression.TableName,
-                                                IsUnique = true
-                                            }
-                            };
+            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            {
+                Name = indexName,
+                SchemaName = Expression.SchemaName,
+                TableName = Expression.TableName,
+                IsUnique = true
+            });
 
             index.Index.Columns.Add(new IndexColumnDefinition
                                         {
@@ -157,17 +154,14 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table
         {
             CurrentColumn.IsForeignKey = true;
 
-            var fk = new CreateForeignKeyExpression
-                         {
-                             ForeignKey = new ForeignKeyDefinition
-                                              {
-                                                  Name = foreignKeyName,
-                                                  PrimaryTable = primaryTableName,
-                                                  PrimaryTableSchema = primaryTableSchema,
-                                                  ForeignTable = Expression.TableName,
-                                                  ForeignTableSchema = Expression.SchemaName
-                                              }
-                         };
+            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            {
+                Name = foreignKeyName,
+                PrimaryTable = primaryTableName,
+                PrimaryTableSchema = primaryTableSchema,
+                ForeignTable = Expression.TableName,
+                ForeignTableSchema = Expression.SchemaName
+            });
 
             fk.ForeignKey.PrimaryColumns.Add(primaryColumnName);
             fk.ForeignKey.ForeignColumns.Add(CurrentColumn.Name);
@@ -197,17 +191,14 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table
         public IAlterTableColumnOptionForeignKeyCascadeSyntax ReferencedBy(string foreignKeyName, string foreignTableSchema,
                                                                            string foreignTableName, string foreignColumnName)
         {
-            var fk = new CreateForeignKeyExpression
-                         {
-                             ForeignKey = new ForeignKeyDefinition
-                                              {
-                                                  Name = foreignKeyName,
-                                                  PrimaryTable = Expression.TableName,
-                                                  PrimaryTableSchema = Expression.SchemaName,
-                                                  ForeignTable = foreignTableName,
-                                                  ForeignTableSchema = foreignTableSchema
-                                              }
-                         };
+            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            {
+                Name = foreignKeyName,
+                PrimaryTable = Expression.TableName,
+                PrimaryTableSchema = Expression.SchemaName,
+                ForeignTable = foreignTableName,
+                ForeignTableSchema = foreignTableSchema
+            });
 
             fk.ForeignKey.PrimaryColumns.Add(CurrentColumn.Name);
             fk.ForeignKey.ForeignColumns.Add(foreignColumnName);
@@ -220,7 +211,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
+            var createColumn = new CreateColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax)
                                    {
                                        Column = column,
                                        SchemaName = Expression.SchemaName,
@@ -236,12 +227,12 @@ 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
-                                  {
-                                      Column = column,
-                                      SchemaName = Expression.SchemaName,
-                                      TableName = Expression.TableName
-                                  };
+            var alterColumn = new AlterColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax)
+            {
+                Column = column,
+                SchemaName = Expression.SchemaName,
+                TableName = Expression.TableName
+            };
 
             CurrentColumn = column;
 
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 439733bc46..d004cd1176 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Column/CreateColumnBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Column/CreateColumnBuilder.cs
@@ -1,6 +1,7 @@
 using System.Data;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Expressions;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Column
 {
@@ -10,11 +11,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Column
                                              ICreateColumnOptionForeignKeyCascadeSyntax
     {
         private readonly IMigrationContext _context;
+        private readonly DatabaseProviders[] _databaseProviders;
 
-        public CreateColumnBuilder(CreateColumnExpression expression, IMigrationContext context)
+        public CreateColumnBuilder(IMigrationContext context, DatabaseProviders[] databaseProviders, CreateColumnExpression expression)
             : base(expression)
         {
             _context = context;
+            _databaseProviders = databaseProviders;
         }
 
         public ForeignKeyDefinition CurrentForeignKey { get; set; }
@@ -56,15 +59,12 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Column
         {
             Expression.Column.IsIndexed = true;
 
-            var index = new CreateIndexExpression
-                            {
-                                Index = new IndexDefinition
-                                            {
-                                                Name = indexName,
-                                                SchemaName = Expression.SchemaName,
-                                                TableName = Expression.TableName
-                                            }
-                            };
+            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            {
+                Name = indexName,
+                SchemaName = Expression.SchemaName,
+                TableName = Expression.TableName
+            });
 
             index.Index.Columns.Add(new IndexColumnDefinition
                                         {
@@ -110,16 +110,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Column
         {
             Expression.Column.IsUnique = true;
 
-            var index = new CreateIndexExpression
-                            {
-                                Index = new IndexDefinition
-                                            {
-                                                Name = indexName,
-                                                SchemaName = Expression.SchemaName,
-                                                TableName = Expression.TableName,
-                                                IsUnique = true
-                                            }
-                            };
+            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            {
+                Name = indexName,
+                SchemaName = Expression.SchemaName,
+                TableName = Expression.TableName,
+                IsUnique = true
+            });
 
             index.Index.Columns.Add(new IndexColumnDefinition
                                         {
@@ -147,17 +144,14 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Column
         {
             Expression.Column.IsForeignKey = true;
 
-            var fk = new CreateForeignKeyExpression
-                         {
-                             ForeignKey = new ForeignKeyDefinition
-                                              {
-                                                  Name = foreignKeyName,
-                                                  PrimaryTable = primaryTableName,
-                                                  PrimaryTableSchema = primaryTableSchema,
-                                                  ForeignTable = Expression.TableName,
-                                                  ForeignTableSchema = Expression.SchemaName
-                                              }
-                         };
+            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            {
+                Name = foreignKeyName,
+                PrimaryTable = primaryTableName,
+                PrimaryTableSchema = primaryTableSchema,
+                ForeignTable = Expression.TableName,
+                ForeignTableSchema = Expression.SchemaName
+            });
 
             fk.ForeignKey.PrimaryColumns.Add(primaryColumnName);
             fk.ForeignKey.ForeignColumns.Add(Expression.Column.Name);
@@ -187,17 +181,14 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Column
         public ICreateColumnOptionForeignKeyCascadeSyntax ReferencedBy(string foreignKeyName, string foreignTableSchema,
                                                                        string foreignTableName, string foreignColumnName)
         {
-            var fk = new CreateForeignKeyExpression
-                         {
-                             ForeignKey = new ForeignKeyDefinition
-                                              {
-                                                  Name = foreignKeyName,
-                                                  PrimaryTable = Expression.TableName,
-                                                  PrimaryTableSchema = Expression.SchemaName,
-                                                  ForeignTable = foreignTableName,
-                                                  ForeignTableSchema = foreignTableSchema
-                                              }
-                         };
+            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            {
+                Name = foreignKeyName,
+                PrimaryTable = Expression.TableName,
+                PrimaryTableSchema = Expression.SchemaName,
+                ForeignTable = foreignTableName,
+                ForeignTableSchema = foreignTableSchema
+            });
 
             fk.ForeignKey.PrimaryColumns.Add(Expression.Column.Name);
             fk.ForeignKey.ForeignColumns.Add(foreignColumnName);
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/CreateBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/CreateBuilder.cs
index 66d50d28fc..e3ad6f972d 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/CreateBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/CreateBuilder.cs
@@ -19,6 +19,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create
 
         public CreateBuilder(IMigrationContext context, ISqlSyntaxProvider sqlSyntax, params DatabaseProviders[] databaseProviders)
         {
+            if (context == null) throw new ArgumentNullException("context");
+            if (sqlSyntax == null) throw new ArgumentNullException("sqlSyntax");
+
             _context = context;
             _sqlSyntax = sqlSyntax;
             _databaseProviders = databaseProviders;
@@ -26,62 +29,56 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create
 
         public ICreateTableWithColumnSyntax Table(string tableName)
         {
-            var expression = new CreateTableExpression { TableName = tableName };
+            var expression = new CreateTableExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { TableName = tableName };
             _context.Expressions.Add(expression);
-            return new CreateTableBuilder(expression, _context);
+            return new CreateTableBuilder(_context, _databaseProviders, expression);
         }
 
         public ICreateColumnOnTableSyntax Column(string columnName)
         {
-            var expression = _databaseProviders == null 
-                ? new CreateColumnExpression { Column = { Name = columnName } }
-                : new CreateColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders) { Column = { Name = columnName } };
+            var expression = new CreateColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { Column = { Name = columnName } };
             _context.Expressions.Add(expression);
-            return new CreateColumnBuilder(expression, _context);
+            return new CreateColumnBuilder(_context, _databaseProviders, expression);
         }
 
         public ICreateForeignKeyFromTableSyntax ForeignKey()
         {
-            var expression = _databaseProviders == null 
-                ? new CreateForeignKeyExpression()
-                : new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders);
+            var expression = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax);
             _context.Expressions.Add(expression);
             return new CreateForeignKeyBuilder(expression);
         }
 
         public ICreateForeignKeyFromTableSyntax ForeignKey(string foreignKeyName)
         {
-            var expression = _databaseProviders == null 
-                ? new CreateForeignKeyExpression { ForeignKey = { Name = foreignKeyName } }
-                : new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders) { ForeignKey = { Name = foreignKeyName } };
+            var expression = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { ForeignKey = { Name = foreignKeyName } };
             _context.Expressions.Add(expression);
             return new CreateForeignKeyBuilder(expression);
         }
 
         public ICreateIndexForTableSyntax Index()
         {
-            var expression = new CreateIndexExpression(_sqlSyntax);
+            var expression = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax);
             _context.Expressions.Add(expression);
             return new CreateIndexBuilder(expression);
         }
 
         public ICreateIndexForTableSyntax Index(string indexName)
         {
-            var expression = new CreateIndexExpression(_sqlSyntax) { Index = { Name = indexName } };
+            var expression = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { Index = { Name = indexName } };
             _context.Expressions.Add(expression);
             return new CreateIndexBuilder(expression);
         }
 
         public ICreateConstraintOnTableSyntax PrimaryKey()
         {
-            var expression = new CreateConstraintExpression(ConstraintType.PrimaryKey);
+            var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax, ConstraintType.PrimaryKey);
             _context.Expressions.Add(expression);
             return new CreateConstraintBuilder(expression);
         }
 
         public ICreateConstraintOnTableSyntax PrimaryKey(string primaryKeyName)
         {
-            var expression = new CreateConstraintExpression(ConstraintType.PrimaryKey);
+            var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax, ConstraintType.PrimaryKey);
             expression.Constraint.ConstraintName = primaryKeyName;
             _context.Expressions.Add(expression);
             return new CreateConstraintBuilder(expression);
@@ -89,14 +86,14 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create
 
         public ICreateConstraintOnTableSyntax UniqueConstraint()
         {
-            var expression = new CreateConstraintExpression(ConstraintType.Unique);
+            var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax, ConstraintType.Unique);
             _context.Expressions.Add(expression);
             return new CreateConstraintBuilder(expression);
         }
 
         public ICreateConstraintOnTableSyntax UniqueConstraint(string constraintName)
         {
-            var expression = new CreateConstraintExpression(ConstraintType.Unique);
+            var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax, ConstraintType.Unique);
             expression.Constraint.ConstraintName = constraintName;
             _context.Expressions.Add(expression);
             return new CreateConstraintBuilder(expression);
@@ -104,7 +101,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create
 
         public ICreateConstraintOnTableSyntax Constraint(string constraintName)
         {
-            var expression = new CreateConstraintExpression(ConstraintType.NonUnique);
+            var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax, 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 3a94cb368a..a06775929b 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Expressions/CreateConstraintExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Expressions/CreateConstraintExpression.cs
@@ -6,10 +6,12 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Expressions
 {
     public class CreateConstraintExpression : MigrationExpressionBase
     {
-        public CreateConstraintExpression(ConstraintType type)
+        public CreateConstraintExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax, ConstraintType constraint) 
+            : base(current, databaseProviders, sqlSyntax)
         {
-            Constraint = new ConstraintDefinition(type);
+            Constraint = new ConstraintDefinition(constraint);
         }
+        
 
         public ConstraintDefinition Constraint { get; private set; }
 
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 c048bda198..8cf37e74d2 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Expressions/CreateTableExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Expressions/CreateTableExpression.cs
@@ -7,24 +7,24 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Expressions
 {
     public class CreateTableExpression : MigrationExpressionBase
     {
-        [Obsolete("Use the other constructors specifying an ISqlSyntaxProvider instead")]
-        public CreateTableExpression()
-        {
-            Columns = new List<ColumnDefinition>();
-        }
+        //[Obsolete("Use the other constructors specifying an ISqlSyntaxProvider instead")]
+        //public CreateTableExpression()
+        //{
+        //    Columns = new List<ColumnDefinition>();
+        //}
 
-        [Obsolete("Use the other constructors specifying an ISqlSyntaxProvider instead")]
-        public CreateTableExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders)
-            : base(current, databaseProviders)
-        {
-            Columns = new List<ColumnDefinition>();
-        }
+        //[Obsolete("Use the other constructors specifying an ISqlSyntaxProvider instead")]
+        //public CreateTableExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders)
+        //    : base(current, databaseProviders)
+        //{
+        //    Columns = new List<ColumnDefinition>();
+        //}
 
-        public CreateTableExpression(ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax)
-        {
-            Columns = new List<ColumnDefinition>();
-        }
+        //public CreateTableExpression(ISqlSyntaxProvider sqlSyntax)
+        //    : base(sqlSyntax)
+        //{
+        //    Columns = new List<ColumnDefinition>();
+        //}
 
         public CreateTableExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
             : base(current, databaseProviders, sqlSyntax)
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 b41caee9a3..86760b71bc 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Table/CreateTableBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Table/CreateTableBuilder.cs
@@ -12,11 +12,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Table
                                                 ICreateTableColumnOptionForeignKeyCascadeSyntax
     {
         private readonly IMigrationContext _context;
+        private readonly DatabaseProviders[] _databaseProviders;
 
-        public CreateTableBuilder(CreateTableExpression expression, IMigrationContext context)
+        public CreateTableBuilder(IMigrationContext context, DatabaseProviders[] databaseProviders, CreateTableExpression expression)
             : base(expression)
-        {            
+        {
             _context = context;
+            _databaseProviders = databaseProviders;
         }
 
         public ColumnDefinition CurrentColumn { get; set; }
@@ -63,15 +65,12 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Table
         {
             CurrentColumn.IsIndexed = true;
 
-            var index = new CreateIndexExpression(Expression.SqlSyntax)
-                            {
-                                Index = new IndexDefinition
-                                            {
-                                                Name = indexName,
-                                                SchemaName = Expression.SchemaName,
-                                                TableName = Expression.TableName
-                                            }
-                            };
+            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            {
+                Name = indexName,
+                SchemaName = Expression.SchemaName,
+                TableName = Expression.TableName
+            });
 
             index.Index.Columns.Add(new IndexColumnDefinition
                                         {
@@ -96,7 +95,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Table
             // it.  For now, this is what I'm doing
             if (Expression.CurrentDatabaseProvider != DatabaseProviders.MySql)
             {
-                var expression = new CreateConstraintExpression(ConstraintType.PrimaryKey)
+                var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, ConstraintType.PrimaryKey)
                 {
                     Constraint =
                 {
@@ -125,7 +124,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Table
 
             if (Expression.CurrentDatabaseProvider != DatabaseProviders.MySql)
             {
-                var expression = new CreateConstraintExpression(ConstraintType.PrimaryKey)
+                var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, ConstraintType.PrimaryKey)
                 {
                     Constraint =
                 {
@@ -161,16 +160,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Table
         {
             CurrentColumn.IsUnique = true;
 
-            var index = new CreateIndexExpression(Expression.SqlSyntax)
-                            {
-                                Index = new IndexDefinition
-                                            {
-                                                Name = indexName,
-                                                SchemaName = Expression.SchemaName,
-                                                TableName = Expression.TableName,
-                                                IsUnique = true
-                                            }
-                            };
+            var index = new CreateIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new IndexDefinition
+            {
+                Name = indexName,
+                SchemaName = Expression.SchemaName,
+                TableName = Expression.TableName,
+                IsUnique = true
+            });
 
             index.Index.Columns.Add(new IndexColumnDefinition
                                         {
@@ -198,17 +194,14 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Table
         {
             CurrentColumn.IsForeignKey = true;
 
-            var fk = new CreateForeignKeyExpression
-                         {
-                             ForeignKey = new ForeignKeyDefinition
-                                              {
-                                                  Name = foreignKeyName,
-                                                  PrimaryTable = primaryTableName,
-                                                  PrimaryTableSchema = primaryTableSchema,
-                                                  ForeignTable = Expression.TableName,
-                                                  ForeignTableSchema = Expression.SchemaName
-                                              }
-                         };
+            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            {
+                Name = foreignKeyName,
+                PrimaryTable = primaryTableName,
+                PrimaryTableSchema = primaryTableSchema,
+                ForeignTable = Expression.TableName,
+                ForeignTableSchema = Expression.SchemaName
+            });
 
             fk.ForeignKey.PrimaryColumns.Add(primaryColumnName);
             fk.ForeignKey.ForeignColumns.Add(CurrentColumn.Name);
@@ -238,17 +231,14 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Table
         public ICreateTableColumnOptionForeignKeyCascadeSyntax ReferencedBy(string foreignKeyName, string foreignTableSchema,
                                                                             string foreignTableName, string foreignColumnName)
         {
-            var fk = new CreateForeignKeyExpression
-                         {
-                             ForeignKey = new ForeignKeyDefinition
-                                              {
-                                                  Name = foreignKeyName,
-                                                  PrimaryTable = Expression.TableName,
-                                                  PrimaryTableSchema = Expression.SchemaName,
-                                                  ForeignTable = foreignTableName,
-                                                  ForeignTableSchema = foreignTableSchema
-                                              }
-                         };
+            var fk = new CreateForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, new ForeignKeyDefinition
+            {
+                Name = foreignKeyName,
+                PrimaryTable = Expression.TableName,
+                PrimaryTableSchema = Expression.SchemaName,
+                ForeignTable = foreignTableName,
+                ForeignTableSchema = foreignTableSchema
+            });
 
             fk.ForeignKey.PrimaryColumns.Add(CurrentColumn.Name);
             fk.ForeignKey.ForeignColumns.Add(foreignColumnName);
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/DeleteBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/DeleteBuilder.cs
index d7fb9bdad3..18ea700ed2 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/DeleteBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/DeleteBuilder.cs
@@ -25,61 +25,55 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete
 
         public void Table(string tableName)
         {
-            var expression = new DeleteTableExpression { TableName = tableName };
+            var expression = new DeleteTableExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { TableName = tableName };
             _context.Expressions.Add(expression);
         }
 
         public IDeleteColumnFromTableSyntax Column(string columnName)
         {
-            var expression = _databaseProviders == null
-                ? new DeleteColumnExpression { ColumnNames = { columnName } }
-                : new DeleteColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders) { ColumnNames = { columnName } };
+            var expression = new DeleteColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) {ColumnNames = {columnName}};
             _context.Expressions.Add(expression);
             return new DeleteColumnBuilder(expression);
         }
 
         public IDeleteForeignKeyFromTableSyntax ForeignKey()
         {
-            var expression = _databaseProviders == null
-                ? new DeleteForeignKeyExpression(_sqlSyntax)
-                : new DeleteForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax);
+            var expression = new DeleteForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax);
             _context.Expressions.Add(expression);
             return new DeleteForeignKeyBuilder(expression);
         }
 
         public IDeleteForeignKeyOnTableSyntax ForeignKey(string foreignKeyName)
         {
-            var expression = _databaseProviders == null
-                ? new DeleteForeignKeyExpression(_sqlSyntax) { ForeignKey = { Name = foreignKeyName } }
-                : new DeleteForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { ForeignKey = { Name = foreignKeyName } };
+            var expression = new DeleteForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) {ForeignKey = {Name = foreignKeyName}};
             _context.Expressions.Add(expression);
             return new DeleteForeignKeyBuilder(expression);
         }
 
         public IDeleteDataSyntax FromTable(string tableName)
         {
-            var expression = new DeleteDataExpression { TableName = tableName };
+            var expression = new DeleteDataExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { TableName = tableName };
             _context.Expressions.Add(expression);
             return new DeleteDataBuilder(expression);
         }
 
         public IDeleteIndexForTableSyntax Index()
         {
-            var expression = new DeleteIndexExpression();
+            var expression = new DeleteIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax);
             _context.Expressions.Add(expression);
             return new DeleteIndexBuilder(expression);
         }
 
         public IDeleteIndexForTableSyntax Index(string indexName)
         {
-            var expression = new DeleteIndexExpression { Index = { Name = indexName } };
+            var expression = new DeleteIndexExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { Index = { Name = indexName } };
             _context.Expressions.Add(expression);
             return new DeleteIndexBuilder(expression);
         }
 
         public IDeleteConstraintOnTableSyntax PrimaryKey(string primaryKeyName)
         {
-            var expression = new DeleteConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, ConstraintType.PrimaryKey)
+            var expression = new DeleteConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax, ConstraintType.PrimaryKey)
             {
                 Constraint = { ConstraintName = primaryKeyName }
             };
@@ -89,7 +83,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete
 
         public IDeleteConstraintOnTableSyntax UniqueConstraint(string constraintName)
         {
-            var expression = new DeleteConstraintExpression(ConstraintType.Unique)
+            var expression = new DeleteConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax, ConstraintType.Unique)
             {
                 Constraint = { ConstraintName = constraintName }
             };
@@ -99,9 +93,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete
 
         public IDeleteDefaultConstraintOnTableSyntax DefaultConstraint()
         {
-            var expression = _databaseProviders == null
-                ? new DeleteDefaultConstraintExpression()
-                : new DeleteDefaultConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders);
+            var expression = new DeleteDefaultConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax);
             _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 c9f8c8d04d..b02bca6f12 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteColumnExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteColumnExpression.cs
@@ -7,13 +7,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 {
     public class DeleteColumnExpression : MigrationExpressionBase
     {
-        public DeleteColumnExpression()
-        {
-            ColumnNames = new List<string>();
-        }
+        //public DeleteColumnExpression()
+        //{
+        //    ColumnNames = new List<string>();
+        //}
 
-        public DeleteColumnExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders)
-            : base(current, databaseProviders)
+        public DeleteColumnExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
+            : base(current, databaseProviders, sqlSyntax)
         {
             ColumnNames = new List<string>();
         }
@@ -31,9 +31,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
             foreach (string columnName in ColumnNames)
             {
                 if (ColumnNames.First() != columnName) sb.AppendLine(";");
-                sb.AppendFormat(SqlSyntaxContext.SqlSyntaxProvider.DropColumn,
-                                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(TableName),
-                                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(columnName));
+                sb.AppendFormat(SqlSyntax.DropColumn,
+                                SqlSyntax.GetQuotedTableName(TableName),
+                                SqlSyntax.GetQuotedColumnName(columnName));
             }
 
             return sb.ToString();
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 39f250532d..21ef6bb517 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteConstraintExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteConstraintExpression.cs
@@ -5,13 +5,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 {
     public class DeleteConstraintExpression : MigrationExpressionBase
     {
-        public DeleteConstraintExpression(ConstraintType type)
-        {
-            Constraint = new ConstraintDefinition(type);
-        }
-
-        public DeleteConstraintExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ConstraintType type)
-            : base(current, databaseProviders)
+        
+        public DeleteConstraintExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax, ConstraintType type)
+            : base(current, databaseProviders, sqlSyntax)
         {
             Constraint = new ConstraintDefinition(type);
         }
@@ -25,24 +21,24 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
             {
                 if (Constraint.IsPrimaryKeyConstraint)
                 {
-                    return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteConstraint,
-                                     SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(Constraint.TableName),
+                    return string.Format(SqlSyntax.DeleteConstraint,
+                                     SqlSyntax.GetQuotedTableName(Constraint.TableName),
                                      "PRIMARY KEY",
                                      "");
                 }
                 else
                 {
-                    return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteConstraint,
-                                     SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(Constraint.TableName),
+                    return string.Format(SqlSyntax.DeleteConstraint,
+                                     SqlSyntax.GetQuotedTableName(Constraint.TableName),
                                      "FOREIGN KEY",
                                      "");
                 }
             }
             else
             {
-                return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteConstraint,
-                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(Constraint.TableName),
-                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedName(Constraint.ConstraintName));
+                return string.Format(SqlSyntax.DeleteConstraint,
+                                 SqlSyntax.GetQuotedTableName(Constraint.TableName),
+                                 SqlSyntax.GetQuotedName(Constraint.ConstraintName));
             }
         }
     }
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 73966f6e93..97c601a2a1 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDataExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDataExpression.cs
@@ -8,12 +8,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
     public class DeleteDataExpression : MigrationExpressionBase
     {
         private readonly List<DeletionDataDefinition> _rows = new List<DeletionDataDefinition>();
-
-        public DeleteDataExpression()
-        {
-        }
-
-        public DeleteDataExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders) : base(current, databaseProviders)
+        
+        public DeleteDataExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax) 
+            : base(current, databaseProviders, sqlSyntax)
         {
         }
 
@@ -32,7 +29,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 
             if (IsAllRows)
             {
-                deleteItems.Add(string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteData, SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(TableName), "1 = 1"));
+                deleteItems.Add(string.Format(SqlSyntax.DeleteData, SqlSyntax.GetQuotedTableName(TableName), "1 = 1"));
             }
             else
             {
@@ -42,13 +39,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
                     foreach (KeyValuePair<string, object> item in row)
                     {
                         whereClauses.Add(string.Format("{0} {1} {2}",
-                                                       SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(item.Key),
+                                                       SqlSyntax.GetQuotedColumnName(item.Key),
                                                        item.Value == null ? "IS" : "=",
                                                        GetQuotedValue(item.Value)));
                     }
 
-                    deleteItems.Add(string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteData,
-                                                  SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(TableName),
+                    deleteItems.Add(string.Format(SqlSyntax.DeleteData,
+                                                  SqlSyntax.GetQuotedTableName(TableName),
                                                   String.Join(" AND ", whereClauses.ToArray())));
                 }
             }
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 43677d23e3..70a74da28e 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDefaultConstraintExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDefaultConstraintExpression.cs
@@ -4,12 +4,8 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 {
     public class DeleteDefaultConstraintExpression : MigrationExpressionBase
     {
-        public DeleteDefaultConstraintExpression()
-        {
-        }
-
-        public DeleteDefaultConstraintExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders)
-            : base(current, databaseProviders)
+        public DeleteDefaultConstraintExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
+            : base(current, databaseProviders, sqlSyntax)
         {
         }
 
@@ -22,7 +18,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
             if (IsExpressionSupported() == false)
                 return string.Empty;
 
-            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteDefaultConstraint,
+            return string.Format(SqlSyntax.DeleteDefaultConstraint,
                                  TableName,
                                  ColumnName);
         }
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 a8c4c7de21..e0fef06f3f 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteForeignKeyExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteForeignKeyExpression.cs
@@ -8,11 +8,11 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 {
     public class DeleteForeignKeyExpression : MigrationExpressionBase
     {
-        public DeleteForeignKeyExpression(ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax)
-        {
-            ForeignKey = new ForeignKeyDefinition();
-        }
+        //public DeleteForeignKeyExpression(ISqlSyntaxProvider sqlSyntax)
+        //    : base(sqlSyntax)
+        //{
+        //    ForeignKey = new ForeignKeyDefinition();
+        //}
 
         public DeleteForeignKeyExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
             : base(current, databaseProviders, sqlSyntax)
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 3e1a959925..e504223669 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteIndexExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteIndexExpression.cs
@@ -5,23 +5,26 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 {
     public class DeleteIndexExpression : MigrationExpressionBase
     {
-        public DeleteIndexExpression()
+
+        public DeleteIndexExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
+            : base(current, databaseProviders, sqlSyntax)
         {
             Index = new IndexDefinition();
         }
 
-        public DeleteIndexExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders) : base(current, databaseProviders)
+        public DeleteIndexExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax, IndexDefinition index) 
+            : base(current, databaseProviders, sqlSyntax)
         {
-            Index = new IndexDefinition();
+            Index = index;
         }
 
-        public virtual IndexDefinition Index { get; set; }
+        public IndexDefinition Index { get; private set; }
 
         public override string ToString()
         {
-            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DropIndex,
-                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedName(Index.Name),
-                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(Index.TableName));
+            return string.Format(SqlSyntax.DropIndex,
+                                 SqlSyntax.GetQuotedName(Index.Name),
+                                 SqlSyntax.GetQuotedTableName(Index.TableName));
         }
     }
 }
\ No newline at end of file
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 2fff4e75e0..0456091a4b 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteTableExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteTableExpression.cs
@@ -4,11 +4,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 {
     public class DeleteTableExpression : MigrationExpressionBase
     {
-        public DeleteTableExpression()
-        {
-        }
-
-        public DeleteTableExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders) : base(current, databaseProviders)
+        
+        public DeleteTableExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax) 
+            : base(current, databaseProviders, sqlSyntax)
         {
         }
 
@@ -17,8 +15,8 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 
         public override string ToString()
         {
-            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DropTable,
-                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(TableName));
+            return string.Format(SqlSyntax.DropTable,
+                                 SqlSyntax.GetQuotedTableName(TableName));
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/ExecuteBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/ExecuteBuilder.cs
index e537253664..549a4a0c66 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/ExecuteBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/ExecuteBuilder.cs
@@ -1,34 +1,31 @@
 using System;
 using Umbraco.Core.Persistence.Migrations.Syntax.Execute.Expressions;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Execute
 {
     public class ExecuteBuilder : IExecuteBuilder
     {
         private readonly IMigrationContext _context;
+        private readonly ISqlSyntaxProvider _sqlSyntax;
         private readonly DatabaseProviders[] _databaseProviders;
 
-        public ExecuteBuilder(IMigrationContext context, params DatabaseProviders[] databaseProviders)
+        public ExecuteBuilder(IMigrationContext context, ISqlSyntaxProvider sqlSyntax, params DatabaseProviders[] databaseProviders)
         {
             _context = context;
+            _sqlSyntax = sqlSyntax;
             _databaseProviders = databaseProviders;
         }
 
         public void Sql(string sqlStatement)
         {
-            var expression = _databaseProviders == null
-                                 ? new ExecuteSqlStatementExpression {SqlStatement = sqlStatement}
-                                 : new ExecuteSqlStatementExpression(_context.CurrentDatabaseProvider,
-                                                                     _databaseProviders) {SqlStatement = sqlStatement};
+            var expression = new ExecuteSqlStatementExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) {SqlStatement = sqlStatement};
             _context.Expressions.Add(expression);
         }
 
         public void Code(Func<Database, string> codeStatement)
         {
-            var expression = _databaseProviders == null
-                                 ? new ExecuteCodeStatementExpression { CodeStatement = codeStatement }
-                                 : new ExecuteCodeStatementExpression(_context.CurrentDatabaseProvider,
-                                                                     _databaseProviders) { CodeStatement = codeStatement };
+            var expression = new ExecuteCodeStatementExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { 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 0f88fe2ee6..e5f487d15d 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,12 @@
 using System;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Execute.Expressions
 {
     public class ExecuteCodeStatementExpression : MigrationExpressionBase
     {
-        public ExecuteCodeStatementExpression()
-        {
-        }
-
-        public ExecuteCodeStatementExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders)
-            : base(current, databaseProviders)
+        public ExecuteCodeStatementExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
+            : base(current, databaseProviders, sqlSyntax)
         {
         }
 
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 308a7719dd..1164ba7caa 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/Expressions/ExecuteSqlStatementExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/Expressions/ExecuteSqlStatementExpression.cs
@@ -1,12 +1,12 @@
-namespace Umbraco.Core.Persistence.Migrations.Syntax.Execute.Expressions
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Syntax.Execute.Expressions
 {
     public class ExecuteSqlStatementExpression : MigrationExpressionBase
     {
-        public ExecuteSqlStatementExpression()
-        {
-        }
 
-        public ExecuteSqlStatementExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders) : base(current, databaseProviders)
+        public ExecuteSqlStatementExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
+            : base(current, databaseProviders, sqlSyntax)
         {
         }
 
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateColumnExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateColumnExpression.cs
index 5c7bf3c0b7..ad16da5286 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateColumnExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateColumnExpression.cs
@@ -5,20 +5,16 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Expressions
 {
     public class CreateColumnExpression : MigrationExpressionBase
     {
-        public CreateColumnExpression()
+
+        public CreateColumnExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
+            : base(current, databaseProviders, sqlSyntax)
         {
             Column = new ColumnDefinition { ModificationType = ModificationType.Create };
         }
 
-        public CreateColumnExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders)
-            : base(current, databaseProviders)
-        {
-            Column = new ColumnDefinition { ModificationType = ModificationType.Create };
-        }
-
-        public virtual string SchemaName { get; set; }
-        public virtual string TableName { get; set; }
-        public virtual ColumnDefinition Column { get; set; }
+        public string SchemaName { get; set; }
+        public string TableName { get; set; }
+        public ColumnDefinition Column { get; set; }
 
         public override string ToString()
         {
@@ -28,9 +24,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Expressions
             if (string.IsNullOrEmpty(Column.TableName))
                 Column.TableName = TableName;
 
-            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.AddColumn,
-                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(Column.TableName),
-                                 SqlSyntaxContext.SqlSyntaxProvider.Format(Column));
+            return string.Format(SqlSyntax.AddColumn,
+                                 SqlSyntax.GetQuotedTableName(Column.TableName),
+                                 SqlSyntax.Format(Column));
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateForeignKeyExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateForeignKeyExpression.cs
index c6c0c437ef..45e40e961f 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateForeignKeyExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateForeignKeyExpression.cs
@@ -5,25 +5,26 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Expressions
 {
     public class CreateForeignKeyExpression : MigrationExpressionBase
     {
-        public CreateForeignKeyExpression()
+        public CreateForeignKeyExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax, ForeignKeyDefinition fkDef)
+            : base(current, databaseProviders, sqlSyntax)
+        {
+            ForeignKey = fkDef;
+        }
+
+        public CreateForeignKeyExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
+            : base(current, databaseProviders, sqlSyntax)
         {
             ForeignKey = new ForeignKeyDefinition();
         }
 
-        public CreateForeignKeyExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders)
-            : base(current, databaseProviders)
-        {
-            ForeignKey = new ForeignKeyDefinition();
-        }
-
-        public virtual ForeignKeyDefinition ForeignKey { get; set; }
+        public ForeignKeyDefinition ForeignKey { get; set; }
 
         public override string ToString()
         {
             if (IsExpressionSupported() == false)
                 return string.Empty;
 
-            return SqlSyntaxContext.SqlSyntaxProvider.Format(ForeignKey);
+            return SqlSyntax.Format(ForeignKey);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateIndexExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateIndexExpression.cs
index eadb30cd9e..7fa38cd3ae 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateIndexExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateIndexExpression.cs
@@ -6,32 +6,20 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Expressions
 {
     public class CreateIndexExpression : MigrationExpressionBase
     {
-        public CreateIndexExpression(ISqlSyntaxProvider sqlSyntax)
-            : base(sqlSyntax)
+
+        public CreateIndexExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax, IndexDefinition index)
+            : base(current, databaseProviders, sqlSyntax)
         {
-            Index = new IndexDefinition();
+            Index = index;
         }
-        
+
         public CreateIndexExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
             : base(current, databaseProviders, sqlSyntax)
         {
             Index = new IndexDefinition();
         }
-
-        [Obsolete("Use alternate ctor specifying ISqlSyntaxProvider instead")]
-        public CreateIndexExpression()
-            : this(SqlSyntaxContext.SqlSyntaxProvider)
-        {
-
-        }
-
-        [Obsolete("Use alternate ctor specifying ISqlSyntaxProvider instead")]
-        public CreateIndexExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders)
-            : this(current, databaseProviders, SqlSyntaxContext.SqlSyntaxProvider)
-        {
-        }
-
-        public virtual IndexDefinition Index { get; set; }
+        
+        public IndexDefinition Index { get; set; }
 
         public override string ToString()
         {
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/IfDatabase/IfDatabaseBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/IfDatabase/IfDatabaseBuilder.cs
index 247a2c34af..e0d20c4875 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/IfDatabase/IfDatabaseBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/IfDatabase/IfDatabaseBuilder.cs
@@ -27,7 +27,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.IfDatabase
 
         public IExecuteBuilder Execute
         {
-            get { return new ExecuteBuilder(_context, _databaseProviders); }
+            get { return new ExecuteBuilder(_context, _sqlSyntax, _databaseProviders); }
         }
 
         public IDeleteBuilder Delete
@@ -37,12 +37,12 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.IfDatabase
 
         public IRenameBuilder Rename
         {
-            get { return new RenameBuilder(_context, _databaseProviders); }
+            get { return new RenameBuilder(_context, _sqlSyntax, _databaseProviders); }
         }
 
         public IUpdateBuilder Update
         {
-            get { return new UpdateBuilder(_context, _databaseProviders); }
+            get { return new UpdateBuilder(_context, _sqlSyntax, _databaseProviders); }
         }
     }
 }
\ 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 e80f336892..28b8c71d39 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/Expressions/InsertDataExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/Expressions/InsertDataExpression.cs
@@ -9,22 +9,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Insert.Expressions
     public class InsertDataExpression : MigrationExpressionBase
     {
         private readonly List<InsertionDataDefinition> _rows = new List<InsertionDataDefinition>();
-
-        [Obsolete("Use the other constructors specifying an ISqlSyntaxProvider instead")]
-        public InsertDataExpression()
-        {
-        }
-
-        [Obsolete("Use the other constructors specifying an ISqlSyntaxProvider instead")]
-        public InsertDataExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders) : base(current, databaseProviders)
-        {
-        }
-
-        public InsertDataExpression(ISqlSyntaxProvider sqlSyntax) : base(sqlSyntax)
-        {
-        }
-
-        public InsertDataExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax) : base(current, databaseProviders, sqlSyntax)
+        
+        public InsertDataExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax) 
+            : base(current, databaseProviders, sqlSyntax)
         {
         }
 
@@ -47,7 +34,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 (SqlSyntax.GetType() != typeof (MySqlSyntaxProvider))
+                if (CurrentDatabaseProvider == DatabaseProviders.SqlServer || CurrentDatabaseProvider == DatabaseProviders.SqlServerCE)
                 {
                     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 889c3e4008..2d3ce9c64d 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/InsertBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/InsertBuilder.cs
@@ -1,19 +1,24 @@
 using Umbraco.Core.Persistence.Migrations.Syntax.Insert.Expressions;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Insert
 {
     public class InsertBuilder : IInsertBuilder
     {
         private readonly IMigrationContext _context;
+        private readonly ISqlSyntaxProvider _sqlSyntax;
+        private readonly DatabaseProviders[] _databaseProviders;
 
-        public InsertBuilder(IMigrationContext context)
+        public InsertBuilder(IMigrationContext context, ISqlSyntaxProvider sqlSyntax, params DatabaseProviders[] databaseProviders)
         {
             _context = context;
+            _sqlSyntax = sqlSyntax;
+            _databaseProviders = databaseProviders;
         }
 
         public IInsertDataSyntax IntoTable(string tableName)
         {
-            var expression = new InsertDataExpression { TableName = tableName };
+            var expression = new InsertDataExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { 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 4f626e2117..1f84401923 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/Expressions/RenameColumnExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/Expressions/RenameColumnExpression.cs
@@ -3,13 +3,9 @@
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Rename.Expressions
 {
     public class RenameColumnExpression : MigrationExpressionBase
-    {
-        public RenameColumnExpression()
-        {
-        }
-
-        public RenameColumnExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders)
-            : base(current, databaseProviders)
+    {        
+        public RenameColumnExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
+            : base(current, databaseProviders, sqlSyntax)
         {
         }
 
@@ -52,7 +48,7 @@ SELECT CONCAT(
             if (IsExpressionSupported() == false)
                 return string.Empty;
 
-            return SqlSyntaxContext.SqlSyntaxProvider.FormatColumnRename(TableName, OldName, NewName);
+            return SqlSyntax.FormatColumnRename(TableName, OldName, NewName);
         }
     }
 }
\ No newline at end of file
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 956cc32bfc..ec60117d7e 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/Expressions/RenameTableExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/Expressions/RenameTableExpression.cs
@@ -4,12 +4,8 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Rename.Expressions
 {
     public class RenameTableExpression : MigrationExpressionBase
     {
-        public RenameTableExpression()
-        {
-        }
-
-        public RenameTableExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders)
-            : base(current, databaseProviders)
+        public RenameTableExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax)
+            : base(current, databaseProviders, sqlSyntax)
         {
         }
 
@@ -22,7 +18,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Rename.Expressions
             if (IsExpressionSupported() == false)
                 return string.Empty;
             
-            return SqlSyntaxContext.SqlSyntaxProvider.FormatTableRename(OldName, NewName);
+            return SqlSyntax.FormatTableRename(OldName, NewName);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/RenameBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/RenameBuilder.cs
index 7116935d77..ebfb08b862 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/RenameBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/RenameBuilder.cs
@@ -1,34 +1,33 @@
 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;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Rename
 {
     public class RenameBuilder : IRenameBuilder
     {
         private readonly IMigrationContext _context;
+        private readonly ISqlSyntaxProvider _sqlSyntax;
         private readonly DatabaseProviders[] _databaseProviders;
 
-        public RenameBuilder(IMigrationContext context, params DatabaseProviders[] databaseProviders)
+        public RenameBuilder(IMigrationContext context, ISqlSyntaxProvider sqlSyntax, params DatabaseProviders[] databaseProviders)
         {
             _context = context;
+            _sqlSyntax = sqlSyntax;
             _databaseProviders = databaseProviders;
         }
 
         public IRenameTableSyntax Table(string oldName)
         {
-            var expression = _databaseProviders == null
-                                 ? new RenameTableExpression {OldName = oldName}
-                                 : new RenameTableExpression(_context.CurrentDatabaseProvider, _databaseProviders) { OldName = oldName };
+            var expression = new RenameTableExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { OldName = oldName };
             _context.Expressions.Add(expression);
             return new RenameTableBuilder(expression);
         }
 
         public IRenameColumnTableSyntax Column(string oldName)
         {
-            var expression = _databaseProviders == null
-                                 ? new RenameColumnExpression {OldName = oldName}
-                                 : new RenameColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders) { OldName = oldName };
+            var expression = new RenameColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { 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 fd470dd7f2..18bec8b938 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/Expressions/UpdateDataExpression.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/Expressions/UpdateDataExpression.cs
@@ -5,11 +5,8 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Update.Expressions
 {
     public class UpdateDataExpression : MigrationExpressionBase
     {
-        public UpdateDataExpression()
-        {
-        }
-
-        public UpdateDataExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders) : base(current, databaseProviders)
+        public UpdateDataExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ISqlSyntaxProvider sqlSyntax) 
+            : base(current, databaseProviders, sqlSyntax)
         {
         }
 
@@ -31,7 +28,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Update.Expressions
             foreach (var item in Set)
             {
                 updateItems.Add(string.Format("{0} = {1}",
-                                              SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(item.Key),
+                                              SqlSyntax.GetQuotedColumnName(item.Key),
                                               GetQuotedValue(item.Value)));
             }
 
@@ -44,13 +41,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Update.Expressions
                 foreach (var item in Where)
                 {
                     whereClauses.Add(string.Format("{0} {1} {2}",
-                                                   SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(item.Key),
+                                                   SqlSyntax.GetQuotedColumnName(item.Key),
                                                    item.Value == null ? "IS" : "=",
                                                    GetQuotedValue(item.Value)));
                 }
             }
-            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.UpdateData,
-                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(TableName),
+            return string.Format(SqlSyntax.UpdateData,
+                                 SqlSyntax.GetQuotedTableName(TableName),
                                  string.Join(", ", updateItems.ToArray()), 
                                  string.Join(" AND ", whereClauses.ToArray()));
         }
diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/UpdateBuilder.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/UpdateBuilder.cs
index e2e118c05f..3816e65132 100644
--- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/UpdateBuilder.cs
+++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/UpdateBuilder.cs
@@ -1,23 +1,24 @@
 using Umbraco.Core.Persistence.Migrations.Syntax.Update.Expressions;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Update
 {
     public class UpdateBuilder : IUpdateBuilder
     {
         private readonly IMigrationContext _context;
+        private readonly ISqlSyntaxProvider _sqlSyntax;
         private readonly DatabaseProviders[] _databaseProviders;
 
-        public UpdateBuilder(IMigrationContext context, params DatabaseProviders[] databaseProviders)
+        public UpdateBuilder(IMigrationContext context, ISqlSyntaxProvider sqlSyntax, params DatabaseProviders[] databaseProviders)
         {
             _context = context;
+            _sqlSyntax = sqlSyntax;
             _databaseProviders = databaseProviders;
         }
 
         public IUpdateSetSyntax Table(string tableName)
         {
-            var expression = _databaseProviders == null 
-                ? new UpdateDataExpression { TableName = tableName }
-                : new UpdateDataExpression(_context.CurrentDatabaseProvider, _databaseProviders) { TableName = tableName };
+            var expression = new UpdateDataExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) { TableName = tableName };
             _context.Expressions.Add(expression);
             return new UpdateDataBuilder(expression, _context);
         }
diff --git a/src/Umbraco.Tests/Migrations/MigrationRunnerTests.cs b/src/Umbraco.Tests/Migrations/MigrationRunnerTests.cs
index 4cc50a671a..f1ac4feb7f 100644
--- a/src/Umbraco.Tests/Migrations/MigrationRunnerTests.cs
+++ b/src/Umbraco.Tests/Migrations/MigrationRunnerTests.cs
@@ -80,12 +80,12 @@ namespace Umbraco.Tests.Migrations
 
             public override void Up()
             {
-                Context.Expressions.Add(new AlterColumnExpression(SqlSyntax));
+                Context.Expressions.Add(new AlterColumnExpression(DatabaseProviders.SqlServerCE, new []{DatabaseProviders.SqlServerCE}, SqlSyntax));
             }
 
             public override void Down()
             {
-                Context.Expressions.Add(new AlterColumnExpression(SqlSyntax));
+                Context.Expressions.Add(new AlterColumnExpression(DatabaseProviders.SqlServerCE, new[] { DatabaseProviders.SqlServerCE }, SqlSyntax));
             }
         }
     }
diff --git a/src/Umbraco.Tests/Persistence/SyntaxProvider/SqlCeSyntaxProviderTests.cs b/src/Umbraco.Tests/Persistence/SyntaxProvider/SqlCeSyntaxProviderTests.cs
index b574cb81bd..39b2e9e506 100644
--- a/src/Umbraco.Tests/Persistence/SyntaxProvider/SqlCeSyntaxProviderTests.cs
+++ b/src/Umbraco.Tests/Persistence/SyntaxProvider/SqlCeSyntaxProviderTests.cs
@@ -15,47 +15,46 @@ namespace Umbraco.Tests.Persistence.SyntaxProvider
     [TestFixture]
     public class SqlCeSyntaxProviderTests
     {
-        [SetUp]
-        public void SetUp()
-        {
-            SqlSyntaxContext.SqlSyntaxProvider = new SqlCeSyntaxProvider();
-        }
 
         [Test]
         public void Can_Generate_Delete_SubQuery_Statement()
         {
+            var sqlSyntax = new SqlCeSyntaxProvider();
+
             var mediaObjectType = Guid.Parse(Constants.ObjectTypes.Media);
             var subQuery = new Sql()
                             .Select("DISTINCT cmsContentXml.nodeId")
-                            .From<ContentXmlDto>()
-                            .InnerJoin<NodeDto>()
-                            .On<ContentXmlDto, NodeDto>(left => left.NodeId, right => right.NodeId)
+                            .From<ContentXmlDto>(sqlSyntax)
+                            .InnerJoin<NodeDto>(sqlSyntax)
+                            .On<ContentXmlDto, NodeDto>(sqlSyntax, left => left.NodeId, right => right.NodeId)
                             .Where<NodeDto>(dto => dto.NodeObjectType == mediaObjectType);
             
-            var sql = SqlSyntaxContext.SqlSyntaxProvider.GetDeleteSubquery("cmsContentXml", "nodeId", subQuery);
+            var sqlOutput = sqlSyntax.GetDeleteSubquery("cmsContentXml", "nodeId", subQuery);
 
             Assert.AreEqual(@"DELETE FROM [cmsContentXml] WHERE [nodeId] IN (SELECT [nodeId] FROM (SELECT DISTINCT cmsContentXml.nodeId
 FROM [cmsContentXml]
 INNER JOIN [umbracoNode]
 ON [cmsContentXml].[nodeId] = [umbracoNode].[id]
-WHERE ([umbracoNode].[nodeObjectType] = @0)) x)".Replace(Environment.NewLine, " ").Replace("\n", " ").Replace("\r", " "), 
-                                                sql.SQL.Replace(Environment.NewLine, " ").Replace("\n", " ").Replace("\r", " "));
+WHERE ([umbracoNode].[nodeObjectType] = @0)) x)".Replace(Environment.NewLine, " ").Replace("\n", " ").Replace("\r", " "),
+                                                sqlOutput.SQL.Replace(Environment.NewLine, " ").Replace("\n", " ").Replace("\r", " "));
 
-            Assert.AreEqual(1, sql.Arguments.Length);
-            Assert.AreEqual(mediaObjectType, sql.Arguments[0]);
+            Assert.AreEqual(1, sqlOutput.Arguments.Length);
+            Assert.AreEqual(mediaObjectType, sqlOutput.Arguments[0]);
         }
 
         [NUnit.Framework.Ignore("This doesn't actually test anything")]
         [Test]
         public void Can_Generate_Create_Table_Statement()
         {
+            var sqlSyntax = new SqlCeSyntaxProvider();
+
             var type = typeof (NodeDto);
             var definition = DefinitionFactory.GetTableDefinition(type);
 
-            string create = SqlSyntaxContext.SqlSyntaxProvider.Format(definition);
-            string primaryKey = SqlSyntaxContext.SqlSyntaxProvider.FormatPrimaryKey(definition);
-            var indexes = SqlSyntaxContext.SqlSyntaxProvider.Format(definition.Indexes);
-            var keys = SqlSyntaxContext.SqlSyntaxProvider.Format(definition.ForeignKeys);
+            string create = sqlSyntax.Format(definition);
+            string primaryKey = sqlSyntax.FormatPrimaryKey(definition);
+            var indexes = sqlSyntax.Format(definition.Indexes);
+            var keys = sqlSyntax.Format(definition.ForeignKeys);
 
             Console.WriteLine(create);
             Console.WriteLine(primaryKey);
@@ -73,32 +72,35 @@ WHERE ([umbracoNode].[nodeObjectType] = @0)) x)".Replace(Environment.NewLine, "
         [Test]
         public void Format_SqlServer_NonClusteredIndexDefinition_AddsNonClusteredDirective()
         {
-            SqlSyntaxContext.SqlSyntaxProvider = new SqlServerSyntaxProvider();
-
+            var sqlSyntax = new SqlServerSyntaxProvider();
+            
             var indexDefinition = CreateIndexDefinition();
             indexDefinition.IndexType = IndexTypes.NonClustered;
 
-            var actual = SqlSyntaxContext.SqlSyntaxProvider.Format(indexDefinition);
+            var actual = sqlSyntax.Format(indexDefinition);
             Assert.AreEqual("CREATE NONCLUSTERED INDEX [IX_A] ON [TheTable] ([A])", actual);
         }
 
         [Test]
         public void Format_SqlServer_NonClusteredIndexDefinition_UsingIsClusteredFalse_AddsClusteredDirective()
         {
-            SqlSyntaxContext.SqlSyntaxProvider = new SqlServerSyntaxProvider();
+            var sqlSyntax = new SqlServerSyntaxProvider();
 
             var indexDefinition = CreateIndexDefinition();
             indexDefinition.IsClustered = false;
 
-            var actual = SqlSyntaxContext.SqlSyntaxProvider.Format(indexDefinition);
+            var actual = sqlSyntax.Format(indexDefinition);
             Assert.AreEqual("CREATE CLUSTERED INDEX [IX_A] ON [TheTable] ([A])", actual);
         }
 
         [Test]
         public void CreateIndexBuilder_SqlServer_NonClustered_CreatesNonClusteredIndex()
         {
-            SqlSyntaxContext.SqlSyntaxProvider = new SqlServerSyntaxProvider();
-            var createExpression = new CreateIndexExpression { Index = { Name = "IX_A" } };
+            var sqlSyntax = new SqlServerSyntaxProvider();
+            var createExpression = new CreateIndexExpression(DatabaseProviders.SqlServer, new []{DatabaseProviders.SqlServer}, sqlSyntax)
+            {
+                Index = { Name = "IX_A" }
+            };
             var builder = new CreateIndexBuilder(createExpression);
             builder.OnTable("TheTable").OnColumn("A").Ascending().WithOptions().NonClustered();
             Assert.AreEqual("CREATE NONCLUSTERED INDEX [IX_A] ON [TheTable] ([A])", createExpression.ToString());
@@ -107,8 +109,11 @@ WHERE ([umbracoNode].[nodeObjectType] = @0)) x)".Replace(Environment.NewLine, "
         [Test]
         public void CreateIndexBuilder_SqlServer_Unique_CreatesUniqueNonClusteredIndex()
         {
-            SqlSyntaxContext.SqlSyntaxProvider = new SqlServerSyntaxProvider();
-            var createExpression = new CreateIndexExpression { Index = { Name = "IX_A" } };
+            var sqlSyntax = new SqlServerSyntaxProvider();
+            var createExpression = new CreateIndexExpression(DatabaseProviders.SqlServer, new[] { DatabaseProviders.SqlServer }, sqlSyntax)
+            {
+                Index = { Name = "IX_A" }
+            };
             var builder = new CreateIndexBuilder(createExpression);
             builder.OnTable("TheTable").OnColumn("A").Ascending().WithOptions().Unique();
             Assert.AreEqual("CREATE UNIQUE NONCLUSTERED INDEX [IX_A] ON [TheTable] ([A])", createExpression.ToString());
@@ -117,8 +122,11 @@ WHERE ([umbracoNode].[nodeObjectType] = @0)) x)".Replace(Environment.NewLine, "
         [Test]
         public void CreateIndexBuilder_SqlServer_Clustered_CreatesClusteredIndex()
         {
-            SqlSyntaxContext.SqlSyntaxProvider = new SqlServerSyntaxProvider();
-            var createExpression = new CreateIndexExpression { Index = { Name = "IX_A" } };
+            var sqlSyntax = new SqlServerSyntaxProvider();
+            var createExpression = new CreateIndexExpression(DatabaseProviders.SqlServer, new[] { DatabaseProviders.SqlServer }, sqlSyntax)
+            {
+                Index = { Name = "IX_A" }
+            };
             var builder = new CreateIndexBuilder(createExpression);
             builder.OnTable("TheTable").OnColumn("A").Ascending().WithOptions().Clustered();
             Assert.AreEqual("CREATE CLUSTERED INDEX [IX_A] ON [TheTable] ([A])", createExpression.ToString());
@@ -134,11 +142,6 @@ WHERE ([umbracoNode].[nodeObjectType] = @0)) x)".Replace(Environment.NewLine, "
                 SchemaName = "dbo"
             };
         }
-
-        [TearDown]
-        public void TearDown()
-        {
-            SqlSyntaxContext.SqlSyntaxProvider = null;
-        }
+        
     }
 }
\ No newline at end of file