internal override void RevertMigration( string migrationId, DbMigration migration, XDocument targetModel) { IEnumerable <MigrationOperation> systemOperations = Enumerable.Empty <MigrationOperation>(); string defaultSchema = DbMigrator.GetDefaultSchema(migration); XDocument historyModel1 = this.GetHistoryModel(defaultSchema); if (object.ReferenceEquals((object)targetModel, (object)this._emptyModel.Value) && !this._historyRepository.IsShared()) { systemOperations = (IEnumerable <MigrationOperation>) this._modelDiffer.Diff(historyModel1, this._emptyModel.Value, (Lazy <ModificationCommandTreeGenerator>)null, (MigrationSqlGenerator)null, (string)null, (string)null); } else { string lastDefaultSchema = this.GetLastDefaultSchema(migrationId); if (!string.Equals(lastDefaultSchema, defaultSchema, StringComparison.Ordinal)) { XDocument historyModel2 = this.GetHistoryModel(lastDefaultSchema); systemOperations = (IEnumerable <MigrationOperation>) this._modelDiffer.Diff(historyModel1, historyModel2, (Lazy <ModificationCommandTreeGenerator>)null, (MigrationSqlGenerator)null, (string)null, (string)null); } } migration.Down(); this.ExecuteOperations(migrationId, new VersionedModel(targetModel, (string)null), migration.Operations, systemOperations, true, false); }
internal override void ApplyMigration(DbMigration migration, DbMigration lastMigration) { IMigrationMetadata migrationMetadata = (IMigrationMetadata)migration; VersionedModel sourceModel1 = this.GetLastModel(lastMigration, migrationMetadata.Id); VersionedModel sourceModel2 = migration.GetSourceModel(); VersionedModel targetModel = migration.GetTargetModel(); if (sourceModel2 != null && this.IsModelOutOfDate(sourceModel2.Model, lastMigration)) { base.AutoMigrate(migrationMetadata.Id.ToAutomaticMigrationId(), sourceModel1, sourceModel2, false); sourceModel1 = sourceModel2; } string defaultSchema = DbMigrator.GetDefaultSchema(migration); XDocument historyModel = this.GetHistoryModel(defaultSchema); IEnumerable <MigrationOperation> systemOperations = Enumerable.Empty <MigrationOperation>(); if (object.ReferenceEquals((object)sourceModel1.Model, (object)this._emptyModel.Value) && !base.HistoryExists()) { systemOperations = (IEnumerable <MigrationOperation>) this._modelDiffer.Diff(this._emptyModel.Value, historyModel, (Lazy <ModificationCommandTreeGenerator>)null, (MigrationSqlGenerator)null, (string)null, (string)null); } else { string lastDefaultSchema = this.GetLastDefaultSchema(migrationMetadata.Id); if (!string.Equals(lastDefaultSchema, defaultSchema, StringComparison.Ordinal)) { systemOperations = (IEnumerable <MigrationOperation>) this._modelDiffer.Diff(this.GetHistoryModel(lastDefaultSchema), historyModel, (Lazy <ModificationCommandTreeGenerator>)null, (MigrationSqlGenerator)null, (string)null, (string)null); } } migration.Up(); this.ExecuteOperations(migrationMetadata.Id, targetModel, migration.Operations, systemOperations, false, false); }
public DbMigrator CreateMigrator <TContext>( DbMigration migration, IEnumerable <Tuple <string, MigrationSqlGenerator> > sqlGenerators = null, bool automaticDataLossEnabled = false) where TContext : DbContext { using (var context = CreateContext <TContext>()) { var operations = migration.GetOperations(); var generatedMigration = CodeGenerator .Generate( GenerateUniqueMigrationName(migration.GetType().Name), operations, Convert.ToBase64String(CompressModel(GetModel(context))), Convert.ToBase64String(CompressModel(GetModel(context))), "System.Data.Entity.Migrations", migration.GetType().Name); return(new DbMigrator(CreateMigrationsConfiguration <TContext>( scaffoldedMigrations: generatedMigration, sqlGenerators: sqlGenerators, automaticDataLossEnabled: automaticDataLossEnabled))); } }
internal override void RevertMigration( string migrationId, DbMigration migration, XDocument targetModel) { var systemOperations = Enumerable.Empty <MigrationOperation>(); var migrationSchema = GetDefaultSchema(migration); var historyModel = GetHistoryModel(migrationSchema); if (ReferenceEquals(targetModel, _emptyModel.Value) && !_historyRepository.IsShared()) { systemOperations = _modelDiffer.Diff(historyModel, targetModel); } else { var lastMigrationSchema = GetLastDefaultSchema(migrationId); if (!string.Equals(lastMigrationSchema, migrationSchema, StringComparison.Ordinal)) { var lastHistoryModel = GetHistoryModel(lastMigrationSchema); systemOperations = _modelDiffer.Diff(historyModel, lastHistoryModel); } } migration.Down(); ExecuteOperations(migrationId, targetModel, migration.Operations, systemOperations, downgrading: true); }
private bool IsModelOutOfDate(XDocument model, DbMigration lastMigration) { DebugCheck.NotNull(model); var sourceModel = GetLastModel(lastMigration); return(_modelDiffer.Diff(sourceModel, model).Any()); }
public static IList <MigrationOperation> GetOperations(this DbMigration migration) { var migrationOperations = (IList <MigrationOperation>)_operationsProperty.GetValue(migration, null); if (!migrationOperations.Any()) { migration.Up(); } return(migrationOperations); }
internal override void Upgrade( IEnumerable <string> pendingMigrations, string targetMigrationId, string lastMigrationId) { DbMigration lastMigration = null; if (lastMigrationId != null) { lastMigration = _migrationAssembly.GetMigration(lastMigrationId); } foreach (var pendingMigration in pendingMigrations) { var migration = _migrationAssembly.GetMigration(pendingMigration); base.ApplyMigration(migration, lastMigration); lastMigration = migration; _emptyMigrationNeeded = false; if (pendingMigration.EqualsIgnoreCase(targetMigrationId)) { break; } } if (string.IsNullOrWhiteSpace(targetMigrationId) && ((_emptyMigrationNeeded && _configuration.AutomaticMigrationsEnabled) || IsModelOutOfDate(_currentModel, lastMigration))) { if (!_configuration.AutomaticMigrationsEnabled) { throw Error.AutomaticDisabledException(); } base.AutoMigrate( MigrationAssembly.CreateMigrationId( _calledByCreateDatabase ? Strings.InitialCreate : Strings.AutomaticMigration), _calledByCreateDatabase ? _emptyModel.Value : GetLastModel(lastMigration), _currentModel, false); } // Context may not be constructable when Migrations is being called by DbContext CreateDatabase // and the config cannot have Seed data anyway, so avoid doing model diff and creating the context to seed. if (!_calledByCreateDatabase && !IsModelOutOfDate(_currentModel, lastMigration)) { base.SeedDatabase(); } }
internal override void ApplyMigration(DbMigration migration, DbMigration lastMigration) { DebugCheck.NotNull(migration); var migrationMetadata = (IMigrationMetadata)migration; var compressor = new ModelCompressor(); var lastModel = GetLastModel(lastMigration, migrationMetadata.Id); var targetModel = compressor.Decompress(Convert.FromBase64String(migrationMetadata.Target)); if (migrationMetadata.Source != null) { var sourceModel = compressor.Decompress(Convert.FromBase64String(migrationMetadata.Source)); if (IsModelOutOfDate(sourceModel, lastMigration)) { base.AutoMigrate( migrationMetadata.Id.ToAutomaticMigrationId(), lastModel, sourceModel, downgrading: false); lastModel = sourceModel; } } var migrationSchema = GetDefaultSchema(migration); var historyModel = GetHistoryModel(migrationSchema); var systemOperations = Enumerable.Empty <MigrationOperation>(); if (ReferenceEquals(lastModel, _emptyModel.Value) && !base.HistoryExists()) { systemOperations = _modelDiffer.Diff(lastModel, historyModel); } else { var lastMigrationSchema = GetLastDefaultSchema(migrationMetadata.Id); if (!string.Equals(lastMigrationSchema, migrationSchema, StringComparison.Ordinal)) { var lastHistoryModel = GetHistoryModel(lastMigrationSchema); systemOperations = _modelDiffer.Diff(lastHistoryModel, historyModel); } } migration.Up(); ExecuteOperations(migrationMetadata.Id, targetModel, migration.Operations, systemOperations, false); }
private static string GetDefaultSchema(DbMigration migration) { try { string str = new ResourceManager(migration.GetType()).GetString("DefaultSchema"); return(!string.IsNullOrWhiteSpace(str) ? str : "dbo"); } catch (MissingManifestResourceException ex) { return("dbo"); } }
internal override void Upgrade( IEnumerable <string> pendingMigrations, string targetMigrationId, string lastMigrationId) { DbMigration lastMigration = null; if (lastMigrationId != null) { lastMigration = _migrationAssembly.GetMigration(lastMigrationId); } foreach (var pendingMigration in pendingMigrations) { var migration = _migrationAssembly.GetMigration(pendingMigration); base.ApplyMigration(migration, lastMigration); lastMigration = migration; _emptyMigrationNeeded = false; if (pendingMigration.EqualsIgnoreCase(targetMigrationId)) { break; } } if (string.IsNullOrWhiteSpace(targetMigrationId) && ((_emptyMigrationNeeded && _configuration.AutomaticMigrationsEnabled) || IsModelOutOfDate(_currentModel, lastMigration))) { if (!_configuration.AutomaticMigrationsEnabled) { throw Error.AutomaticDisabledException(); } base.AutoMigrate( MigrationAssembly.CreateMigrationId( _calledByCreateDatabase ? Strings.InitialCreate : Strings.AutomaticMigration), _calledByCreateDatabase ? _emptyModel.Value : GetLastModel(lastMigration), _currentModel, false); } if (!IsModelOutOfDate(_currentModel, lastMigration)) { base.SeedDatabase(); } }
public static void CreateFullTextIndex( this DbMigration migration, string table, string index, string[] columns) { var op = new CreateFullTextIndexOperation { Table = table, Index = index, Columns = columns }; ((IDbMigration)migration).AddOperation(op); }
private static string GetDefaultSchema(DbMigration migration) { DebugCheck.NotNull(migration); try { var defaultSchema = new ResourceManager(migration.GetType()).GetString(DefaultSchemaResourceKey); return(!string.IsNullOrWhiteSpace(defaultSchema) ? defaultSchema : EdmModelExtensions.DefaultSchema); } catch (MissingManifestResourceException) { // Upgrade scenario, no default schema resource found return(EdmModelExtensions.DefaultSchema); } }
internal override void ApplyMigration(DbMigration migration, DbMigration lastMigration) { var migrationMetadata = (IMigrationMetadata)migration; var compressor = new ModelCompressor(); var lastModel = GetLastModel(lastMigration, migrationMetadata.Id); var targetModel = compressor.Decompress(Convert.FromBase64String(migrationMetadata.Target)); if (migrationMetadata.Source != null) { var sourceModel = compressor.Decompress(Convert.FromBase64String(migrationMetadata.Source)); if (IsModelOutOfDate(sourceModel, lastMigration)) { base.AutoMigrate( migrationMetadata.Id.ToAutomaticMigrationId(), lastModel, sourceModel, downgrading: false); lastModel = sourceModel; } } bool?includeSystemOps = null; var isFirstMigration = ReferenceEquals(lastModel, _emptyModel.Value); if (isFirstMigration && !_historyRepository.IsShared()) { includeSystemOps = true; if (!targetModel.HasSystemOperations()) { // upgrade scenario, inject the history model AttachHistoryModel(targetModel); } } var systemOperations = _modelDiffer.Diff(lastModel, targetModel, includeSystemOps) .Where(o => o.IsSystem); migration.Up(); ExecuteOperations(migrationMetadata.Id, targetModel, migration.Operations.Concat(systemOperations), false); }
public DbMigrator CreateMigrator <TContext>(DbMigration migration) where TContext : DbContext { var modelCompressor = new ModelCompressor(); var generatedMigration = CodeGenerator .Generate( UtcNowGenerator.UtcNowAsMigrationIdTimestamp() + "_" + migration.GetType().Name, migration.GetOperations(), Convert.ToBase64String(modelCompressor.Compress(CreateContext <TContext>().GetModel())), Convert.ToBase64String(modelCompressor.Compress(CreateContext <TContext>().GetModel())), "System.Data.Entity.Migrations", migration.GetType().Name); return(new DbMigrator(CreateMigrationsConfiguration <TContext>(scaffoldedMigrations: generatedMigration))); }
public DbMigrator CreateMigrator <TContext>(DbMigration migration) where TContext : DbContext { using (var context = CreateContext <TContext>()) { var generatedMigration = CodeGenerator .Generate( GenerateUniqueMigrationName(migration.GetType().Name), migration.GetOperations(), Convert.ToBase64String(CompressModel(GetModel(context))), Convert.ToBase64String(CompressModel(GetModel(context))), "System.Data.Entity.Migrations", migration.GetType().Name); return(new DbMigrator(CreateMigrationsConfiguration <TContext>(scaffoldedMigrations: generatedMigration))); } }
private VersionedModel GetLastModel( DbMigration lastMigration, string currentMigrationId = null) { if (lastMigration != null) { return(lastMigration.GetTargetModel()); } string migrationId; string productVersion; XDocument lastModel = this._historyRepository.GetLastModel(out migrationId, out productVersion, (string)null); if (lastModel != null && (currentMigrationId == null || string.CompareOrdinal(migrationId, currentMigrationId) < 0)) { return(new VersionedModel(lastModel, productVersion)); } return(new VersionedModel(this._emptyModel.Value, (string)null)); }
private XDocument GetLastModel(DbMigration lastMigration, string currentMigrationId = null) { if (lastMigration != null) { var migrationMetadata = (IMigrationMetadata)lastMigration; return(new ModelCompressor().Decompress(Convert.FromBase64String(migrationMetadata.Target))); } string migrationId; var lastModel = _historyRepository.GetLastModel(out migrationId); if (lastModel != null && (currentMigrationId == null || string.CompareOrdinal(migrationId, currentMigrationId) < 0)) { return(lastModel); } return(_emptyModel.Value); }
internal override void Downgrade(IEnumerable <string> pendingMigrations) { for (int index = 0; index < pendingMigrations.Count <string>() - 1; ++index) { string migrationId1 = pendingMigrations.ElementAt <string>(index); DbMigration migration = this._migrationAssembly.GetMigration(migrationId1); string migrationId2 = pendingMigrations.ElementAt <string>(index + 1); string productVersion1 = (string)null; XDocument xdocument = migrationId2 != "0" ? this._historyRepository.GetModel(migrationId2, out productVersion1) : this._emptyModel.Value; string productVersion2; XDocument model = this._historyRepository.GetModel(migrationId1, out productVersion2); if (migration == null) { base.AutoMigrate(migrationId1, new VersionedModel(model, (string)null), new VersionedModel(xdocument, productVersion1), true); } else { base.RevertMigration(migrationId1, migration, xdocument); } } }
internal override void RevertMigration(string migrationId, DbMigration migration, XDocument sourceModel, XDocument targetModel) { bool?includeSystemOps = null; if (ReferenceEquals(targetModel, _emptyModel.Value) && !_historyRepository.IsShared()) { includeSystemOps = true; if (!sourceModel.HasSystemOperations()) { // upgrade scenario, inject the history model AttachHistoryModel(sourceModel); } } var systemOperations = _modelDiffer.Diff(sourceModel, targetModel, includeSystemOps) .Where(o => o.IsSystem); migration.Down(); ExecuteOperations(migrationId, targetModel, migration.Operations.Concat(systemOperations), downgrading: true); }
internal override void Upgrade( IEnumerable <string> pendingMigrations, string targetMigrationId, string lastMigrationId) { DbMigration lastMigration = (DbMigration)null; if (lastMigrationId != null) { lastMigration = this._migrationAssembly.GetMigration(lastMigrationId); } foreach (string pendingMigration in pendingMigrations) { DbMigration migration = this._migrationAssembly.GetMigration(pendingMigration); base.ApplyMigration(migration, lastMigration); lastMigration = migration; this._emptyMigrationNeeded = false; if (pendingMigration.EqualsIgnoreCase(targetMigrationId)) { break; } } if (string.IsNullOrWhiteSpace(targetMigrationId) && (this._emptyMigrationNeeded && this._configuration.AutomaticMigrationsEnabled || this.IsModelOutOfDate(this._currentModel, lastMigration))) { if (!this._configuration.AutomaticMigrationsEnabled) { throw Error.AutomaticDisabledException(); } base.AutoMigrate(MigrationAssembly.CreateMigrationId(this._calledByCreateDatabase ? Strings.InitialCreate : Strings.AutomaticMigration), this._calledByCreateDatabase ? new VersionedModel(this._emptyModel.Value, (string)null) : this.GetLastModel(lastMigration, (string)null), new VersionedModel(this._currentModel, (string)null), false); } if (this._calledByCreateDatabase || this.IsModelOutOfDate(this._currentModel, lastMigration)) { return; } base.SeedDatabase(); }
/// <summary> /// Create a new computed column /// </summary> /// <param name="migration">The DBMigration</param> /// <param name="tableName">The name of table for create computed column</param> /// <param name="columnName">The name of computed column to drop</param> public static void DropComputedColumn(this DbMigration migration, string tableName, string columnName) { ((IDbMigration)migration) .AddOperation(new DropComputedColumnOperation(tableName, columnName)); }
/// <summary> /// Remove table permission to specified user /// </summary> /// <param name="migration">The DbMigration</param> /// <param name="table">The table you remove the permission</param> /// <param name="user">The user you remove the permission</param> /// <param name="permission">The permission to revoke</param> public static void RevokeTablePermission(this DbMigration migration, string table, string user, TablePermission permission) { ((IDbMigration)migration) .AddOperation(new RevokeTablePermissionOperation(table, user, permission)); }
/// <summary> /// Change the collation to specified database /// </summary> /// <param name="migration">The DbMigration</param> /// <param name="databaseName">The name of database you change the collation.</param> /// <param name="collation">The collation to set.</param> public static void SetDatabaseCollation(this DbMigration migration, string databaseName, string collation) { ((IDbMigration)migration) .AddOperation(new DatabaseCollationOperation(databaseName, collation)); }
internal virtual bool IsModelOutOfDate(XDocument model, DbMigration lastMigration) { VersionedModel lastModel = this.GetLastModel(lastMigration, (string)null); return(this._modelDiffer.Diff(lastModel.Model, model, (Lazy <ModificationCommandTreeGenerator>)null, (MigrationSqlGenerator)null, lastModel.Version, (string)null).Any <MigrationOperation>()); }
/// <summary> /// Create a new view /// </summary> /// <param name="migration">The DBMigration</param> /// <param name="viewName">The name of view to create</param> /// <param name="bodySql">The sql body of view to create</param> public static void CreateView(this DbMigration migration, string viewName, string bodySql) { ((IDbMigration)migration) .AddOperation(new CreateViewOperation(viewName, bodySql)); }
/// <summary> /// Drop existing view /// </summary> /// <param name="migration">the DBMigration</param> /// <param name="viewName">the name of view to drop</param> public static void DropView(this DbMigration migration, string viewName) { ((IDbMigration)migration) .AddOperation(new DropViewOperation(viewName)); }
/// <summary> /// Add a new computed column /// </summary> /// <param name="migration">The DBMigration</param> /// <param name="columnName">The name of computed column to create</param> /// <param name="bodySql">The sql body of view to create</param> /// <param name="tableName">The name of table for create computed column</param> public static void AddComputedColumn(this DbMigration migration, string tableName, string columnName, string bodySql) { ((IDbMigration)migration) .AddOperation(new AddComputedColumnOperation(tableName, columnName, bodySql)); }
/// <summary> /// Execute sql scripts from existing sql file. /// </summary> /// <param name="migration">the DBMigration.</param> /// <param name="sqlFilePath">The sql file path with scripts to be executed.</param> public static void SqlFile(this DbMigration migration, string sqlFilePath) { ((IDbMigration)migration) .AddOperation(new SqlFileOperation(sqlFilePath)); }
/// <summary> /// Execute sql scripts from existing stream. /// </summary> /// <param name="migration">The DBMigration</param> /// <param name="sqlFileStream">The stream with sql scripts to be executed.</param> public static void SqlFile(this DbMigration migration, Stream sqlFileStream) { ((IDbMigration)migration) .AddOperation(new SqlFileOperation(sqlFileStream)); }
/// <summary> /// Execute sql scripts from existing resource. /// </summary> /// <param name="migration">The DbMigration</param> /// <param name="assembly">The assembly that contain the resource.</param> /// <param name="resourceName">The resource name.</param> public static void SqlResource(this DbMigration migration, Assembly assembly, string resourceName) { ((IDbMigration)migration) .AddOperation(new SqlResourceOperation(assembly, resourceName)); }