public override void InitializeDatabase(MsSqlModelContext context)
{
var migrator = new DbMigrator(new Configuration());
var pendingMigrations = migrator.GetPendingMigrations();
var lastMigration = pendingMigrations.LastOrDefault();
if (lastMigration != null)
{
try
{
migrator.Update(lastMigration);
}
catch (DbUpdateException ex)
{
// Retrieve the error messages as a list of strings.
var errorMessages = ex.Entries;
// Join the list to a single string.
var fullErrorMessage = string.Join("; ", errorMessages);
// Combine the original exception message with the new one.
var exceptionMessage = string.Concat(ex.Message, " The validation errors are: ", fullErrorMessage);
// Throw a new DbEntityValidationException with the improved exception message.
throw new DbEntityValidationException(exceptionMessage, ex);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="connectionString"></param>
/// <param name="providerInvariantName"></param>
/// <returns>whether migrations were applied</returns>
public static bool ApplyPendingMigrations <T>(string connectionString, string providerInvariantName, bool createIfNotExists = false)
where T : DbMigrationsConfiguration, new()
{
bool returnVar = false;
if (!createIfNotExists || !CreateDatabaseIfRequired(connectionString))
{
returnVar = MoveFromAutoToExplicitMigrations(typeof(T), connectionString);
}
var configuration = new T()
{
TargetDatabase = new DbConnectionInfo(connectionString, providerInvariantName)
};
var migrator = new DbMigrator(configuration);
if (migrator.GetPendingMigrations().Any())
{
try
{
migrator.Update();
}
catch (Exception e)
{
LogManager.GetLogger("BlowTrial.Migrations.CodeBasedMigrations").Error("Migration failed", e);
}
returnVar = true;
}
return(returnVar);
}
void IDatabaseInitializer <TContext> .InitializeDatabase(TContext context)
{
var doseed = !context.Database.Exists();
// && new DatabaseTableChecker().AnyModelTableExists(context);
// check to see if to seed - we 'lack' the 'AnyModelTableExists'
// ...could be copied/done otherwise if needed...
var migrator = new DbMigrator(_configuration);
// if (doseed || !context.Database.CompatibleWithModel(false))
if (migrator.GetPendingMigrations().Any())
{
migrator.Update();
}
// move on with the 'CreateDatabaseIfNotExists' for the 'Seed'
base.InitializeDatabase(context);
if (doseed)
{
try
{
Seed(context);
}
catch (Exception ex)
{
LogHelper.Error(ex);
}
context.SaveChanges();
}
}
/// <summary>
/// Получить список столбцов которые будут удалены
/// </summary>
/// <param name="configuration">Конфигурация миграций</param>
/// <returns>Список столбцов которые будут удалены</returns>
private IEnumerable <ColumnInfo> GetDroppingColumnFromMigrationsConfiguration(DbMigrationsConfiguration configuration)
{
var droppingColumn = new List <ColumnInfo>();
if (configuration != null)
{
var migrator = new DbMigrator(configuration);
var pendingMigrations = migrator.GetPendingMigrations();
if (pendingMigrations.Any())
{
var targetMigration = pendingMigrations.Last();
var scriptor = new MigratorScriptingDecorator(migrator);
string script = scriptor.ScriptUpdate(sourceMigration: null, targetMigration: targetMigration);
var parts = script.Split(new[] { "\r\n\r\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries).ToList(); //разбиваем скрипт по миграциям
parts.RemoveAll(p => p.StartsWith("INSERT [dbo].[__MigrationHistory]") || p.StartsWith("VALUES")); //удаляем вставки в MigrationHistory
var dropColumnParts = parts.Where(p => p.Contains("DROP COLUMN")); //находим DROP COLUMN
foreach (var dropColumnPart in dropColumnParts)
{
Regex regex = new Regex("ALTER TABLE (?<schemaWithTable>.*) DROP COLUMN (?<column>.*)");
Match match = regex.Match(dropColumnPart);
string[] schemaWithTable = match.Groups["schemaWithTable"].Value.Split(new[] { '.', '[', ']' }, StringSplitOptions.RemoveEmptyEntries);
string schema = schemaWithTable.First();
string table = schemaWithTable.Last();
string column = match.Groups["column"].Value.Trim(new[] { '[', ']' });
droppingColumn.Add(new ColumnInfo(new TableInfo(schema, table), column));
}
}
}
return(droppingColumn);
}
void IDatabaseInitializer <TContext> .InitializeDatabase(TContext context)
{
Contract.Requires(context != null, "context");
var doseed = !context.Database.Exists();
// && new DatabaseTableChecker().AnyModelTableExists(context);
// check to see if to seed - we 'lack' the 'AnyModelTableExists' - could be copied/done otherwise if needed...
var migrator = new DbMigrator(_configuration);
// if (doseed || !context.Database.CompatibleWithModel(throwIfNoMetadata: false))
if (migrator.GetPendingMigrations().Any())
{
migrator.Update();
}
//var scriptor = new MigratorScriptingDecorator(migrator);
//string script = scriptor.ScriptUpdate(sourceMigration: null, targetMigration: null);
// move on with the 'CreateDatabaseIfNotExists' for the 'Seed'
base.InitializeDatabase(context);
if (doseed)
{
//Seed(context);
context.SaveChanges();
}
}
public void InitializeDatabase(HelpContext context)
{
if (!context.Database.Exists())
{
// if database did not exist before - create it
context.Database.Create();
}
else
{
// query to check if MigrationHistory table is present in the database
var migrationHistoryTableExists = ((IObjectContextAdapter)context).ObjectContext.ExecuteStoreQuery <int>(
string.Format(
"SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = '{0}' AND table_name = '__MigrationHistory'",
ConfigurationManager.AppSettings["dbname"]));
// if MigrationHistory table is not there (which is the case first time we run) - create it
if (migrationHistoryTableExists.FirstOrDefault() == 0)
{
context.Database.Delete();
context.Database.Create();
}
var config = new Configuration();
var migratror = new DbMigrator(config);
var pending = migratror.GetPendingMigrations();
Console.WriteLine(pending.Count());
migratror.Update();
}
}
protected void Application_Start()
{
Database.SetInitializer <MsSqlDbContext>(null);
using (var db = new MsSqlDbContext())
{
db.Database.Initialize(false);
}
var migrator = new DbMigrator(new Configuration());
if (migrator.GetPendingMigrations().Any())
{
migrator.Update();
}
Database.SetInitializer(new MigrateDatabaseToLatestVersion <MsSqlDbContext, Configuration>());
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var mapper = new AutoMapperConfig();
mapper.Execute(Assembly.GetExecutingAssembly());
}
/// <inheritdoc />
public override void InitializeDatabase([NotNull] TContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
bool exists = context.Database.Exists();
if (exists)
{
DbMigrator migrator = new DbMigrator(_configuration);
if (!context.Database.CompatibleWithModel(false) || migrator.GetPendingMigrations().Any())
{
migrator.Update();
}
}
base.InitializeDatabase(context);
if (!exists)
{
return;
}
Seed(context);
context.SaveChanges();
}
static void Main(string[] args)
{
Log.Logger = StandardLoggerConfigurator.GetEnrichedLogger();
Log.Logger.Information("Starting migration...");
try
{
var settings = new Configuration();
var migrator = new DbMigrator(settings);
Log.Logger.Information("Migrating " + settings.TargetDatabase);
foreach (var pendingMigration in migrator.GetPendingMigrations())
{
Log.Logger.Debug("Pending migration: " + pendingMigration);
}
migrator.Update();
}
catch (Exception e)
{
Log.Logger.Error(e, "Error during migration");
throw;
}
Log.Logger.Information("Migration done without problems...");
}
/// <summary>
/// Initializes the database.
/// </summary>
/// <param name="context">The context.</param>
/// <inheritdoc />
public virtual void InitializeDatabase(TContext context)
{
if (_config == null)
{
_config = new TMigrationsConfiguration
{
TargetDatabase = new DbConnectionInfo(context.Database.Connection.ConnectionString, "System.Data.SqlClient")
};
}
var seed = !context.Database.Exists();
var migrator = new DbMigrator(_config);
if (!seed)
{
var local = migrator.GetLocalMigrations();
var pending = migrator.GetPendingMigrations();
if (local.Count() == pending.Count())
{
seed = true;
}
}
migrator.Update();
InitializeDbSettings(context);
if (seed)
{
Seed(context);
}
}
public static void MigrateDatabase(this IContainer container)
{
var logger = container.Resolve <ILoggerFactory>().CreateLogger("Startup.DatabaseMigrator");
var db = container.Resolve <FunnyQuotesCookieDbContext>();
var migrator = new DbMigrator(new FunnyQuotesCookieDatabase.Migrations.Configuration(), db);
// dynamic databaseCreator = Type.GetType("System.Data.Entity.Migrations.Utilities.DatabaseCreator, EntityFramework");
bool dbExists = db.Database.Exists();
// var pendingMigrations = (dbExists ? migrator.GetPendingMigrations() : migrator.GetLocalMigrations()).ToList();
var pendingMigrations = migrator.GetPendingMigrations().ToList();
// var appliedMigrations = migrator.GetDatabaseMigrations().ToList();
if (!pendingMigrations.Any())
{
logger.LogInformation("Database is up to date");
return;
}
if (!dbExists)
{
logger.LogInformation($"Creating database '{db.Database.Connection.Database}'");
}
logger.LogInformation("Applying the following migrations:");
foreach (var migration in pendingMigrations)
{
logger.LogInformation($"- {migration}");
}
logger.LogInformation("Database successfully migrated");
}
public static Task <bool> InitializeAsync(CancellationToken cancellationToken)
{
return(Task.Run(() =>
{
var factory = new SqlServerConnectionFactory();
try
{
var connection = factory.CreateConnection();
var context = new Context(connection);
context.Database.CreateIfNotExists();
var migrationConfig = new Migrations.Configuration
{
TargetDatabase = new DbConnectionInfo(connection.ConnectionString, "System.Data.SqlClient")
};
var migrator = new DbMigrator(migrationConfig);
var migrations = migrator.GetPendingMigrations();
if (migrations.Any())
{
migrator.Update();
}
connection.Dispose();
context.Dispose();
return true;
}
catch (DbException exc)
{
return false;
}
}, cancellationToken));
}
private bool NeedsMigration(TContext context, out List <string> pendingMigrations)
{
var dbProviderName = GetDbProviderName(context);
this.config.TargetDatabase = new DbConnectionInfo(context.Database.Connection.ConnectionString,
dbProviderName ?? "System.Data.SqlClient");
var migrator = new DbMigrator(this.config);
// lets check if there are pending migrations
pendingMigrations = migrator.GetPendingMigrations().ToList();
// if we don't have any migrations added by Add-Migration ... then tell the developer
if (!pendingMigrations.Any() && !context.Database.Exists())
{
throw new DbMigrationException(
"There are no migrations in this project! Please scaffold migration by executing 'Add-Migration -Verbose Initial' cmdlet in Package Manager Console");
}
if (!pendingMigrations.Any())
{
this.logger.Debug(() => "No pending migrations, so go out here");
return(false);
}
return(true);
}
public Configuration()
{
AutomaticMigrationsEnabled = false;
ContextKey = "CloudPlus.Authentication.Database.CloudPlusAuthDbContext";
var dbMigrator = new DbMigrator(this);
var pendingMigrations = dbMigrator.GetPendingMigrations().ToArray();
if (pendingMigrations.Any())
{
dbMigrator.Update();
}
foreach (var pendingMigration in pendingMigrations)
{
var migrationName = pendingMigration.Substring(pendingMigration.IndexOf('_') + 1).Replace("-", "");
var dbMigration = typeof(Configuration).Assembly.GetType(
typeof(Configuration).Namespace + "." + migrationName);
if (!dbMigration.GetInterfaces().Any(x =>
x.IsGenericType &&
x.GetGenericTypeDefinition() == typeof(IMigrationSeed <>)))
{
continue;
}
var context = new CloudPlusAuthDbContext();
var seedMigration = (IMigrationSeed <CloudPlusAuthDbContext>)Activator.CreateInstance(dbMigration);
seedMigration.Seed(context);
context.SaveChanges();
}
}
public static void Migrate(string target, bool isDowngrade)
{
try
{
var migrator = new DbMigrator(new Migrations.Configuration());
if (!string.IsNullOrEmpty(target))
{
migrator.Update(target);
IoC.Current.Get <IPredefinedDataManager>().Run(target);
}
else
{
if (isDowngrade)
{
migrator.Update("0");
}
else
{
var pendings = migrator.GetPendingMigrations();
foreach (var migrName in pendings)
{
migrator.Update(migrName);
IoC.Current.Get <IPredefinedDataManager>().Run(migrName);
}
}
}
}
catch (MigrationsException ex)
{
throw new DataAccessException("Migration failed", ex);
}
}
public void Initialize()
{
try
{
Catfish.Tests.Migrations.Configuration config = new Catfish.Tests.Migrations.Configuration();
var migrator = new DbMigrator(config);
foreach (string migName in migrator.GetPendingMigrations())
{
Type migration = config.MigrationsAssembly.GetType(string.Format("{0}.{1}", config.MigrationsNamespace, migName.Substring(16)));
DbMigration m = (DbMigration)Activator.CreateInstance(migration);
m.Up();
var prop = m.GetType().GetProperty("Operations", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
if (prop != null)
{
IEnumerable <MigrationOperation> operations = prop.GetValue(m) as IEnumerable <MigrationOperation>;
var generator = config.GetSqlGenerator("System.Data.SQLite");
var statements = generator.Generate(operations, "2008");
foreach (MigrationStatement item in statements)
{
Db.Database.ExecuteSqlCommand(item.Sql);
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public Configuration()
{
AutomaticMigrationsEnabled = false;
//TODO: We don't need this if we are going to recreate initial migration everytime. Later on this needs to be implemented
var dbMigrator = new DbMigrator(this);
var pendingMigrations = dbMigrator.GetPendingMigrations().ToArray();
if (pendingMigrations.Any())
{
dbMigrator.Update();
}
foreach (var pendingMigration in pendingMigrations)
{
var migrationName = pendingMigration.Substring(pendingMigration.IndexOf('_') + 1).Replace("-", "");
var dbMigration = typeof(Configuration).Assembly.GetType(
typeof(Configuration).Namespace + "." + migrationName);
if (!dbMigration.GetInterfaces()
.Any(x =>
x.IsGenericType &&
x.GetGenericTypeDefinition() == typeof(IMigrationSeed <>)))
{
continue;
}
var context = new CldpDbContext();
var seedMigration = (IMigrationSeed <CldpDbContext>)Activator.CreateInstance(dbMigration);
seedMigration.Seed(context);
context.SaveChanges();
}
}
void IDatabaseInitializer <TContext> .InitializeDatabase(TContext context)
{
var doseed = !context.Database.Exists();
// && new DatabaseTableChecker().AnyModelTableExists(context);
// check to see if to seed - we 'lack' the 'AnyModelTableExists' - could be copied/done otherwise if needed...
var migrator = new DbMigrator(_configuration);
var _pendingMigrations = migrator.GetPendingMigrations().Any();
var _historyRepository = migrator.GetType().GetField("_historyRepository", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(migrator);
var _existingConnection = _historyRepository.GetType().BaseType.GetField("_existingConnection", BindingFlags.Instance | BindingFlags.NonPublic);
_existingConnection.SetValue(_historyRepository, null);
// if (doseed || !context.Database.CompatibleWithModel(throwIfNoMetadata: false))
if (_pendingMigrations)
{
migrator.Update();
}
// move on with the 'CreateDatabaseIfNotExists' for the 'Seed'
base.InitializeDatabase(context);
if (doseed)
{
Seed(context);
context.SaveChanges();
}
}
public void Configuration(IAppBuilder app)
{
// If we are using the Azure Storage Emulator we need to make sure it is installed and started.
if (ConfigurationManager.AppSettings["BlobStorageConnectionString"] == "UseDevelopmentStorage=true" ||
ConfigurationManager.AppSettings["BlobStorageConnectionString"] == "DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://localhost:10000/devstoreaccount1;TableEndpoint=http://localhost:10002/devstoreaccount1;QueueEndpoint=http://localhost:10001/devstoreaccount1;")
{
//AzureStorageEmulatorManager.Start(); // We start Azure Storage Emulator manually instead.
}
// Should we check for pending database migrations and apply them?
if (bool.Parse(ConfigurationManager.AppSettings["checkForPendingDatabaseMigrations"]))
{
var configuration = new Migrations.Configuration();
var migrator = new DbMigrator(configuration);
if (migrator.GetPendingMigrations().Count() > 0)
{
migrator.Update();
}
}
Bootstrapper.Initialise();
// Any connection or hub wire up and configuration should go here
app.MapSignalR();
}
void IDatabaseInitializer <TContext> .InitializeDatabase(TContext context)
{
var doseed = context.Database.Exists();
//&& new DatabaseTableChecker().AnyModelTableExists(context);
// check to see if to seed - we 'lack' the 'AnyModelTableExists'
// ...could be copied/done otherwise if needed...
var migrator = new DbMigrator(_configuration);
//if (!doseed || !context.Database.CompatibleWithModel(false))
//获取已在程序集中定义但尚未应用于目标数据库的所有迁移
if (migrator.GetPendingMigrations().Any())
{
migrator.Update();
}
// move on with the 'CreateDatabaseIfNotExists' for the 'Seed'
if (!doseed)
{
base.InitializeDatabase(context);
}
//如果数据库不存在
if (!doseed)
{
Seed(context);
context.SaveChanges();
}
}
public void InitializeDatabase(TContext context)
{
Console.WriteLine($"Initializing database using {InitializerName}");
if (!context.Database.Exists())
{
throw new InvalidOperationException("The database does not exist");
}
if (!IsDatabaseCompatibleWithModel(context))
{
throw new InvalidOperationException("The database is not compatible with the entity model");
}
var migrator = new DbMigrator(_config);
var migrations = migrator
.GetPendingMigrations()
.ToList();
if (!migrations.Any())
{
Console.WriteLine($"Seeding database from {InitializerName}");
_seeder?.SeedData(context);
return;
}
var message = $"There are pending migrations {string.Join("\r\n", migrations)} that must be applied before starting application";
throw new MigrationsPendingException(message);
}
public Configuration()
{
AutomaticMigrationsEnabled = false;
var migrator = new DbMigrator(this);
_pendingMigrations = migrator.GetPendingMigrations().Any();
}
static UnitOfWorkFactory()
{
try
{
var context = new AppDBContext();
bool dbExists = context.Database.Exists();
if (!dbExists || !context.Database.CompatibleWithModel(false))
{
var configuration = new CottonDBMS.Data.EF.Migrations.Configuration();
var migrator = new DbMigrator(configuration);
migrator.Configuration.TargetDatabase = new DbConnectionInfo(context.Database.Connection.ConnectionString, "System.Data.SqlClient");
var migrations = migrator.GetPendingMigrations();
if (migrations.Any())
{
migrator.Update();
}
}
if (!dbExists)
{
context.ApplySeeds();
}
}
catch (Exception exc)
{
var msg = exc.Message;
}
CottonDBMS.EF.Tasks.GinSyncWithCloudTask.Init();
}
public void CreateOrUpdateDatabase(TContext context, string queryFolder, string connectionString)
{
var migrator = new DbMigrator(_configuration);
_pendingMigrations = migrator.GetPendingMigrations();
if (context.Database.Exists())
{
if (!context.Database.CompatibleWithModel(throwIfNoMetadata: false) || _pendingMigrations.Any())
{
foreach (var pmigration in _pendingMigrations)
{
migrator.Update(pmigration);
CustomCommandInMigrationUp(pmigration, queryFolder, connectionString);
}
}
}
else
{
foreach (var pmigration in _pendingMigrations)
{
migrator.Update(pmigration);
CustomCommandInMigrationUp(pmigration, queryFolder, connectionString);
}
//context.Database.Create();
//Seed(context);
//context.SaveChanges();
}
}
public GTDoroConfiguration()
{
AutomaticMigrationsEnabled = false;
ContextKey = "GTDoro.Core.DAL.GTDoroContext";
var migrator = new DbMigrator(this);
_pendingMigrations = migrator.GetPendingMigrations().Any();
}
public void InitializeDatabase(DbContext2Database context)
{
Contract.Requires(context != null, "context");
var configuration = new DbContext2MigrationsConfiguration()
{
TargetDatabase = new DbConnectionInfo(_connection)
};
if (!context.Database.Exists() || !context.Database.CompatibleWithModel(throwIfNoMetadata: false))
{
var migrator = new DbMigrator(configuration);
string[] pastMigrations = migrator.GetDatabaseMigrations().OrderBy(s => s).ToArray();
string[] knownMigrations = migrator.GetLocalMigrations().OrderBy(s => s).ToArray();
string[] pendingMigrations = migrator.GetPendingMigrations().OrderBy(s => s).ToArray();
Console.Out.WriteLine("Known migrations:");
foreach (var m in knownMigrations)
{
Console.Out.WriteLine(m);
}
Console.Out.WriteLine("Past migrations:");
foreach (var m in pastMigrations)
{
Console.Out.WriteLine(m);
}
Console.Out.WriteLine("Pending migrations:");
foreach (var m in pendingMigrations)
{
Console.Out.WriteLine(m);
}
if (!pendingMigrations.Any())
{
Console.Out.WriteLine($"Database mismatch: exists={context.Database.Exists()} and compatibility={context.Database.CompatibleWithModel(throwIfNoMetadata: false)} but there are no migrations pending.");
}
foreach (string s in migrator.GetPendingMigrations())
{
Console.Out.WriteLine($"Applying database migration {s}.");
migrator.Update(s);
}
}
context.SaveChanges();
}
public static void UpgradeDatabase()
{
var dbMigrator = new DbMigrator(new Migrations.Configuration());
if (dbMigrator.GetPendingMigrations().Any())
{
dbMigrator.Update();
}
}
public DbMigratorEventArgs(DbMigrationsConfiguration migrationConfiguration)
{
this.MigrationConfiguration = migrationConfiguration;
DbMigrator migrator = new DbMigrator(migrationConfiguration);
this.PendingMigrations = migrator.GetPendingMigrations();
this.CompletedMigrations = migrator.GetDatabaseMigrations();
}
/// <summary>
/// Metoda sprawdza czy istnieją jakieś migracje aktualizujące bazę danych
/// </summary>
/// <returns></returns>
internal static List <string> GetPendingMigrations()
{
var configuration = new Configuration();
configuration.TargetDatabase = new DbConnectionInfo(System.Configuration.ConfigurationManager.ConnectionStrings["GasCalculatorContext"].ConnectionString, "System.Data.SqlServerCE.4.0");
var dbMigrator = new DbMigrator(configuration);
return(dbMigrator.GetPendingMigrations().ToList());
}
public void InitializeDatabase(CommandSchedulerDbContext context)
{
var dbMigrator = new DbMigrator(new CommandSchedulerMigrationConfiguration());
if (dbMigrator.GetPendingMigrations().Any())
{
dbMigrator.Update("201407120005564_v0_8_2");
}
}