private IReadOnlyCollection <string> GetMigrations()
{
var config = FindDbMigrationsConfiguration();
var migrator = new DbMigrator(config);
return(migrator.GetDatabaseMigrations().ToList().AsReadOnly());
}
private void PrepareDatabaseMigrations(DbMigrator migrator, EFMigrationDetails migrationDetails)
{
var databaseMigrations = migrator.GetDatabaseMigrations().Select(v => new SelectListItem
{
Text = EFMigrationDetails.GetDisplayName(v),
Value = v
}).ToList();
SelectListItem disabledItem = new SelectListItem
{
Text = "--------------------------------------",
Value = "",
Disabled = true,
};
if (databaseMigrations.Any())
{
databaseMigrations = databaseMigrations.Skip(1).ToList();
if (databaseMigrations.Any())
{
databaseMigrations.Add(disabledItem);
}
databaseMigrations.Add(new SelectListItem
{
Text = "<<Remove All Migrations>>",
Value = "0"
});
}
migrationDetails.Migrations = new SelectList(databaseMigrations, "Value", "Text", databaseMigrations.FirstOrDefault(m => !m.Disabled), new List <string> {
disabledItem.Value
});
migrationDetails.TargetMigration = databaseMigrations.Where(m => !m.Disabled).Select(si => si.Value).FirstOrDefault();
}
public void Migrations_work_with_wrapping_provider_setup_by_replacing_ADO_NET_provider()
{
RegisterAdoNetProvider(typeof(WrappingAdoNetProvider <SqlClientFactory>));
MutableResolver.AddResolver <DbProviderServices>(k => WrappingEfProvider <SqlClientFactory, SqlProviderServices> .Instance);
MutableResolver.AddResolver <Func <MigrationSqlGenerator> >(WrappingEfProvider <SqlClientFactory, SqlProviderServices> .Instance);
var log = WrappingAdoNetProvider <SqlClientFactory> .Instance.Log;
log.Clear();
using (var context = new MigrationsBlogContext())
{
context.Database.Delete();
}
using (var context = new MigrationsBlogContext())
{
Assert.False(context.Database.Exists());
}
var migrator = new DbMigrator(new MigrateInitializerConfiguration());
var appliedMigrations = migrator.GetDatabaseMigrations();
Assert.Equal(2, appliedMigrations.Count());
// Sanity check that the wrapping provider really did get used
var methods = log.Select(i => i.Method).ToList();
Assert.Contains("ExecuteReader", methods);
Assert.Contains("Open", methods);
Assert.Contains("Close", methods);
}
/// <summary>
/// 数据库初始化配置构造方法。
/// </summary>
public GenericConfiguration()
{
this.AutomaticMigrationsEnabled = true;
this.AutomaticMigrationDataLossAllowed = true;
var migrator = new DbMigrator(this);
this.isDatabaseMigration = migrator.GetDatabaseMigrations().Any();
}
public DataDbConfiguration()
{
AutomaticMigrationsEnabled = true;
AutomaticMigrationDataLossAllowed = true;
var migrator = new DbMigrator(this);
_isInitialized = migrator.GetDatabaseMigrations().Any();
}
public DbMigratorEventArgs(DbMigrationsConfiguration migrationConfiguration)
{
this.MigrationConfiguration = migrationConfiguration;
DbMigrator migrator = new DbMigrator(migrationConfiguration);
this.PendingMigrations = migrator.GetPendingMigrations();
this.CompletedMigrations = migrator.GetDatabaseMigrations();
}
/// <summary>
/// Проверяет установлена ли последняя миграция
/// </summary>
/// <returns>Результат проверки миграций</returns>
public string CheckLastMigration()
{
var migrator = new DbMigrator(_configuration);
var targetMigration = migrator.GetLocalMigrations().ToList();
var targetMigrationDb = migrator.GetDatabaseMigrations(null, false).ToList();
return(migrator.CheckMigrations(targetMigration.LastOrDefault(), targetMigrationDb.LastOrDefault(), false));
}
public void ListMigrations()
{
var config = FindDbMigrationsConfiguration();
var migrator = new DbMigrator(config);
foreach (var migration in migrator.GetDatabaseMigrations())
{
Console.WriteLine(migration);
}
}
public void RollbackSingleDataMigration()
{
var configuration = new Rock.Migrations.Configuration();
var migrator = new DbMigrator(configuration);
// Get the second-last migration to be applied.
// Migrations are returned in order of last-applied first.
var targetMigrationName = migrator.GetDatabaseMigrations().Skip(1).Take(1).FirstOrDefault();
Debug.Print($"Rolling back to target migration \"{ targetMigrationName }\"...");
// Update to the second-last migration.
migrator.Update(targetMigrationName);
var newLastMigrationName = migrator.GetDatabaseMigrations().FirstOrDefault();
Assert.AreEqual(targetMigrationName, newLastMigrationName);
}
private static void ShowAll(DbManagerOptions options)
{
var migrator = new DbMigrator(new TMigrationConfig());
Logger.Info("Возможный следующие миграции:");
migrator.GetLocalMigrations().ForEach(m => Logger.Info(m));
Logger.Info("Миграции примененные к базе данных:");
migrator.GetDatabaseMigrations().ForEach(m => Logger.Info(m));
}
public ActionResult Migrations(string errorMsg)
{
var configuration = new Configuration();
var migrator = new DbMigrator(configuration);
ViewBag.AppliedMigrations = migrator.GetDatabaseMigrations();
ViewBag.PendingMigrations = migrator.GetPendingMigrations();
ViewBag.ErrorMessage = errorMsg;
return(View());
}
private static void PrintMigrationStatus(DbMigrator migrator)
{
foreach (var applied in migrator.GetDatabaseMigrations())
{
Console.WriteLine("\tApplied: {0}", applied);
}
foreach (var pending in migrator.GetPendingMigrations())
{
Console.WriteLine("\tPending: {0}", pending);
}
Console.WriteLine();
}
/// <summary>
/// Opens a database connection and checks the currently installed migrations
/// </summary>
private IEnumerable <string> GetInstalledMigrations(IDatabaseConfig config)
{
DbMigrator dbMigrator = null;
if (TestDatabaseConnection(config))
{
dbMigrator = CreateDbMigrator(config);
}
return(dbMigrator != null
? dbMigrator.GetDatabaseMigrations()
: Enumerable.Empty <string>());
}
public static void UpdateDatabase(string connectionString)
{
var configuration = new Configuration
{
TargetDatabase = new DbConnectionInfo(connectionString, "System.Data.SqlClient")
};
var migrator = new DbMigrator(configuration);
var pending = migrator.GetPendingMigrations().ToArray();
var local = migrator.GetLocalMigrations().ToArray();
var db = migrator.GetDatabaseMigrations().ToArray();
migrator.Update();
}
public void CanGetDatabaseMigrations()
{
// given
SpikesMigrationsDb db = CreateDbContext();
var initializer = SpikesMultiMigrateDbToLastestVersion.UsingAutoMigrations();
initializer.InitializeDatabase(db);
// when, then
var migrator = new DbMigrator(new AutoConfiguration());
IEnumerable <string> migrations = migrator.GetDatabaseMigrations();
Assert.That(migrations, Is.Not.Empty);
}
internal static Tuple <IEnumerable <string>, IEnumerable <string>, IEnumerable <string> > GetMigrationsInfo()
{
try
{
var migrator = new DbMigrator(new Migrations.Configuration());
return(Tuple.Create(migrator.GetDatabaseMigrations(),
migrator.GetLocalMigrations(), migrator.GetPendingMigrations()));
}
catch (MigrationsException ex)
{
throw new DataAccessException("Failed to retreive migrations information", ex);
}
}
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 ZsValidateItem Validate()
{
var result = new ZsValidateItem()
{
Title = _label
};
try
{
_migrationsConfiguration.TargetDatabase = new DbConnectionInfo(_connectionName);
var migrator = new DbMigrator(_migrationsConfiguration);
if (migrator.GetPendingMigrations().Any())
{
result.State = ZsValidateState.Fail;
result.Description = "<b>Pending Migrations Found</b><br/>";
result.Description += "<ul>";
foreach (var migration in migrator.GetPendingMigrations().OrderBy(b => b))
{
result.Description += "<li>" + migration + "</li>";
}
result.Description += "</ul>";
}
else
{
result.State = ZsValidateState.Ok;
result.Description = "<b>Migrations Up to Date</b><br/>";
result.Description += "<ul>";
foreach (var migration in migrator.GetDatabaseMigrations().OrderBy(b => b))
{
result.Description += "<li>" + migration + "</li>";
}
result.Description += "</ul>";
}
}
catch (Exception ex)
{
result.State = ZsValidateState.Fail;
result.Description = "Exception occurred: " + ex.Message;
}
return(result);
}
public virtual IEnumerable <MigrationInfo> GetMigrations(String contextTypeName)
{
var contextType = GetContextType(contextTypeName);
var configurationType = GetConfigurationType(contextType);
var configuration = CreateConfiguration(configurationType);
var migrator = new DbMigrator(configuration);
var migrations = new Dictionary <String, MigrationInfo>();
Func <String, MigrationInfo> getInfo = migrationId =>
{
MigrationInfo info;
if (!migrations.TryGetValue(migrationId, out info))
{
info = new MigrationInfo {
Id = migrationId
};
migrations.Add(migrationId, info);
}
return(info);
};
foreach (var migrationId in migrator.GetDatabaseMigrations())
{
var info = getInfo.Invoke(migrationId);
info.InDatabase = true;
}
foreach (var migrationId in migrator.GetLocalMigrations())
{
var info = getInfo.Invoke(migrationId);
info.InProject = true;
}
return(migrations.Values.OrderBy(i => i.Id));
}
private static void Main(string[] args)
{
_logger = LogManager.GetCurrentClassLogger();
_logger.Log(LogLevel.Info, "Версия: {0}", Assembly.GetEntryAssembly().GetName().Version);
try
{
IndexUpdater indexUpdater = new IndexUpdater();
indexUpdater.DeleteIndexForDroppingColumns(typeof(BloggingContext));
using (BloggingContext context = new BloggingContext())
{
if (context.Database.CompatibleWithModel(false))
{
_logger.Log(LogLevel.Info, "База данных успешно обновлена");
}
else
{
_logger.Log(LogLevel.Error, "Ошибка обновления базы данных: модель данных не соответствует базе данных");
}
indexUpdater.UpdateIndexes(context);
}
var dbMigrator = new DbMigrator(new MigrationsConfiguration());
var databaseMigrations = dbMigrator.GetDatabaseMigrations().Reverse().ToList();
if (databaseMigrations.Any())
{
_logger.Log(LogLevel.Info, "Миграции в базе данных:");
foreach (var databaseMigration in databaseMigrations)
{
_logger.Log(LogLevel.Info, databaseMigration);
}
}
}
catch (Exception ex)
{
_logger.Log(LogLevel.Fatal, ex);
}
Console.ReadLine();
}
public static void EFMigration(string connectionName)
{
var dbConnectionInfo = new DbConnectionInfo(connectionName);
DbMigrator migrator = new DbMigrator(new Configuration()
{
TargetDatabase = dbConnectionInfo
});
foreach (var migration in migrator.GetDatabaseMigrations())
{
Console.WriteLine($"Previous Migration: {migration}");
}
foreach (var migration in migrator.GetPendingMigrations())
{
Console.WriteLine($"Pending migration: {migration}");
migrator.Update(migration);
Console.WriteLine("Migration {0} complete.", migration);
Console.WriteLine();
}
}
/// <summary>
/// Проверяет наличие миграции в БД по ее версии
/// </summary>
/// <param name="version">Версия миграции</param>
/// <returns>Результат проверки миграций</returns>
public string CheckByVersion(string version)
{
var migrator = new DbMigrator(_configuration);
var targetMigration =
migrator.GetLocalMigrations()
.Where(s => s.ToLowerInvariant().StartsWith(version.ToLowerInvariant()))
.ToList();
if (targetMigration.Count == 0)
{
throw new MigrationsException(string.Format(Constants.MigrationNotFound, version));
}
var targetMigrationDb = migrator.GetDatabaseMigrations(version, true).ToList();
if (targetMigrationDb.Count == 0)
{
throw new MigrationsException(string.Format(Constants.MigrationNotFound, version));
}
return(migrator.CheckMigrations(targetMigration.Last(), targetMigrationDb.Last(), true));
}
/// <summary>
/// Ищет конкретную миграцию в БД по имени миграции
/// </summary>
/// <param name="migration">Название миграции</param>
/// <returns>Результат проверки миграций</returns>
public string CheckByMigrationName(string migration)
{
var migrator = new DbMigrator(_configuration);
var targetMigration =
migrator.GetLocalMigrations()
.Where(s => s.ToLowerInvariant().Contains(migration.ToLowerInvariant()))
.ToList();
if (targetMigration.Count > 1)
{
throw new MigrationsException(string.Format(Constants.NotUniqMigration,
Environment.NewLine,
targetMigration.Join(separator: Environment.NewLine)));
}
if (targetMigration.Count == 0)
{
throw new MigrationsException(string.Format(Constants.MigrationNotFound, migration));
}
var targetMigrationDb = migrator.GetDatabaseMigrations(migration, false).ToList();
if (targetMigrationDb.Count > 1)
{
throw new MigrationsException(string.Format(Constants.NotUniqMigration,
Environment.NewLine,
targetMigrationDb.Join(separator: Environment.NewLine)));
}
if (targetMigrationDb.Count == 0)
{
throw new MigrationsException(string.Format(Constants.MigrationNotFound, migration));
}
return(migrator.CheckMigrations(targetMigration.First(), targetMigrationDb.First(), false));
}
public void MigrateDatabase()
{
//Arrange
Animals.Migrations.Configuration config = new Configuration();
DbMigrator migrator = new DbMigrator(config);
Console.WriteLine("Past migrations:");
foreach (string s in migrator.GetDatabaseMigrations())
{
Console.WriteLine(s);
}
Console.WriteLine("Local migrations:");
foreach (string s in migrator.GetLocalMigrations())
{
Console.WriteLine(s);
}
Console.WriteLine("Pending migrations:");
foreach (string s in migrator.GetPendingMigrations())
{
Console.WriteLine(s);
}
Console.WriteLine("Migrating...");
foreach (string s in migrator.GetPendingMigrations())
{
//Act
Console.WriteLine("Applying migration {0}", s);
Action act = () => migrator.Update(s);
//Assert
act.ShouldNotThrow();
}
}
/// <summary>
/// Gets all migrations that have been applied to the target database
/// </summary>
/// <returns>Array of database migration names</returns>
public string[] GetDatabaseMigrations()
{
return(_migrator.GetDatabaseMigrations().ToArray());
}
/// <summary>
/// Gets all migrations that have been applied to the target database.
/// </summary>
/// <returns>List of migrations</returns>
public IEnumerable <string> GetRemoteMigrations()
{
AssertForReady();
return(_dbMigrator.GetDatabaseMigrations());
}
int IDbVersionProvider.GetVersion()
{
var migrator = new DbMigrator(new Configuration());
return(migrator.GetDatabaseMigrations().Count());
}
public static void MigrateDatabase(Tenant tenant) //string DBName/*VentasDBContext ctx*/)
{
//context.Database.Create();
//var datab = context.Database;
//Tenant tenant = new Tenant();
using (var context = new TenantsDBContext())
{
//tenant.BaseDeDatos = DBName;
tenant.ConnectionString = "data source=DESKTOP-JSIT42C\\SQLEXPRESS; MultipleActiveResultSets=true ;initial catalog=" + tenant.BaseDeDatos + "; integrated security=SSPI";
tenant.Host = (System.Environment.MachineName == "DESKTOP-JSIT42C") ? "DESKTOP-JSIT42C\\SQLEXPRESS" : "localhost";
tenant.Nombre = tenant.BaseDeDatos;
context.Tenants.Add(tenant);
context.SaveChanges();
}
Common.TenantData.tenant = tenant;
//using (var context = new VentasDBContext(tenant.ConnectionString))
//{
// UltimoDiario u = new UltimoDiario();
// u.UltimaFechaImpresion = tenant.FechaImpresionUltimoDiario;
// u.UltimoNumeroAsiento = 1;
// u.UltimoNumeroFolio = 1;
// u.UltimoNumeroRenglon = 1;
// u.UltimoNumeroTransporte = 1;
// context.UltimoDiario.Add(u);
// context.SaveChanges();
//}
var newDbConnString = "data source=DESKTOP-JSIT42C\\SQLEXPRESS; MultipleActiveResultSets=true ;initial catalog=" + tenant.BaseDeDatos + "; integrated security=SSPI"; //context.Database.Connection.ConnectionString;
var connStringBuilder = new SqlConnectionStringBuilder(newDbConnString);
connStringBuilder.InitialCatalog = tenant.BaseDeDatos;
ConfigurationVentas config = new ConfigurationVentas();
DbMigrator migrator = new DbMigrator(config);
VentasDBContext ctx = new VentasDBContext(newDbConnString);
ctx.Database.Create();
Console.WriteLine("Past migrations:");
foreach (string s in migrator.GetDatabaseMigrations())
{
Console.WriteLine(s);
}
Console.WriteLine("Local migrations:");
foreach (string s in migrator.GetLocalMigrations())
{
Console.WriteLine(s);
}
Console.WriteLine("Pending migrations:");
foreach (string s in migrator.GetPendingMigrations())
{
Console.WriteLine(s);
}
Console.WriteLine("Migrating...");
foreach (string s in migrator.GetLocalMigrations()) //GetPendingMigrations())
{
//Act
Console.WriteLine("Applying migration {0}", s);
Action act = () => migrator.Update(s);
//Assert
//act.ShouldNotThrow();
}
}
/// <summary>
/// The entry point of the program, where the program control starts and ends.
/// </summary>
public static void Main()
{
// USER INPUT /////////////////////////////////////////////////////////////////////////////////
// Always first create a new database migration with DatabaseStep.ADD_MIGRATION,
// and include the created files in the project and set resource file to EmbeddedResource.
// After creating a migration run UPDATE_DATABASE to update the database.
const DatabaseStep step = DatabaseStep.UPDATE_DATABASE;
// Specify the name of the database migration in case of ADD-MIGRATION.
// Note: Make sure to create a new name for each new migration.
// After creating migration include the files in the folder by right clicking on
// Zk.Migrations and selecting "Add files from folder". Then add the .cs, .resx and
// .Designer.cs files with the name specified below.
// Last but not least set the .resx file's build action to EmbeddedResource by right
// clicking on it.
// Make sure that the Setup.postgresql script has run manually to create the database user.
const string MIGRATION_NAME = "CalendarAndUser";
// END USER INPUT /////////////////////////////////////////////////////////////////////////////
// Get executing path from which the location of the Update_Scripts and new Migrations can be determined.
var executingPath = AppDomain.CurrentDomain.BaseDirectory;
// Add a new migration (PowerShell: Add-Migration)
if (step == DatabaseStep.ADD_MIGRATION)
{
// Initialize the wrapper classes around the Entity Framework PowerShell API.
var config = new Configuration();
var scaffolder = new MigrationScaffolder(config);
var migration = scaffolder.Scaffold(MIGRATION_NAME);
// Place migration code in main project "Migrations" folder and migration scripts in "App_Data"
var migrationsPath = Regex.Replace(executingPath, "bin/.*", "");
// Write migrations
File.WriteAllText(migrationsPath + MIGRATION_NAME + ".cs", migration.UserCode);
File.WriteAllText(migrationsPath + MIGRATION_NAME + ".Designer.cs", migration.DesignerCode);
using (var writer = new ResXResourceWriter(migrationsPath + MIGRATION_NAME + ".resx"))
{
foreach (var resource in migration.Resources)
{
writer.AddResource(resource.Key, resource.Value);
}
}
Console.WriteLine("EF code migration {0} written to Migrations folder...\n\n" +
"Next step is to include the .cs, .resx and .Designer.cs file in the project" +
"by right clicking on the project and selecting " +
"\"Add files from folder.\"\n" +
"Then right click on {0}.resx and set build action to \"EmbeddedResource\""
, migration.MigrationId);
}
else if (step == DatabaseStep.CREATE_SCRIPT)
{
var config = new Configuration();
var migrator = new DbMigrator(config);
var scriptor = new MigratorScriptingDecorator(migrator);
// Determine name of the previous run migration if exists.
string lastMigration = migrator.GetDatabaseMigrations().LastOrDefault();
// Get the script
string script = scriptor.ScriptUpdate(sourceMigration: lastMigration, targetMigration: MIGRATION_NAME);
// Create the PostgreSQL update script based on last migration on database and
// current migration.
string formattedScript = string.Format
("/* * * * * * * * * * * * * * * * * * * * * * *\n" +
" *\n" +
" * Migration:\t\t{0}\n *\n" +
" * Date and time:\t{1}\n" +
" *\n" +
" * * * * * * * * * * * * * * * * * * * * * * */\n\n" +
"{2}",
MIGRATION_NAME,
DateTime.Now,
script);
// Write string to file in Migrations folder of main project
var updateScriptPath = Regex.Replace(executingPath, "Zk.Migrations/.*", "Zk/App_Data/Migrations/");
File.WriteAllText(updateScriptPath + MIGRATION_NAME + ".postgresql", formattedScript);
Console.WriteLine("Update script {0}.postgresql written to Zk/App_Data/Migrations folder.\n" +
"Please include the script by right clicking on the folder and selecting " +
"\"Add files to folder\"," +
"\nIt is recommended to prefix the filename with the current datetime.",
MIGRATION_NAME);
}
// If a new migration is created the database can be updated. (PowerShell: Update-Database)
else if (step == DatabaseStep.UPDATE_DATABASE)
{
var config = new Configuration();
var migrator = new DbMigrator(config);
// Write to database
migrator.Update();
// Show which migrations were applied.
var migrationNames = string.Join(", ", migrator.GetDatabaseMigrations().ToArray().First());
Console.WriteLine("Applied migration {0} to database.", migrationNames);
}
}