public static void GenerateDb()
{
if (ConfigurationHelper.GetAppSettingOrDefault("单元测试-生成数据库", false))
{
if (ClearDb && ConfigurationHelper.GetAppSettingOrDefault("单元测试-生成数据库-先清空数据库", false))
{
//不想手工去删除数据库，可以使用下面这个方法来在程序中删除所有的表。
DropAllTables();
ClearDb = false;
}
using (var c = new RafyDbMigrationContext(DbSettingNames.DbMigrationHistory))
{
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
using (var c = new RafyDbMigrationContext(DbSettingNames.RafyPlugins))
{
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
using (var c = new RafyDbMigrationContext(UnitTestEntityRepositoryDataProvider.DbSettingName))
{
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
UnitTestPlugin.InitailizeSequences();
using (RdbDataProvider.RedirectDbSetting(
UnitTestEntityRepositoryDataProvider.DbSettingName,
UnitTestEntityRepositoryDataProvider.DbSettingName_Duplicate
))
{
using (var c = new RafyDbMigrationContext(UnitTestEntityRepositoryDataProvider.DbSettingName_Duplicate))
{
c.ClassMetaReader.EntityDbSettingName = UnitTestEntityRepositoryDataProvider.DbSettingName;
c.ClassMetaReader.IsGeneratingForeignKey = false;
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
UnitTestPlugin.InitailizeSequences();
}
using (var c = new RafyDbMigrationContext(UnitTest2EntityRepositoryDataProvider.DbSettingName))
{
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
using (var c = new RafyDbMigrationContext(StringTestEntityDataProvider.DbSettingName))
{
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
}
}
/// <summary>
/// 构造一个实体的数据源节点。
/// </summary>
/// <param name="repository">本实体数据源来自于这个实体仓库。</param>
/// <param name="alias">同一个实体仓库可以表示多个不同的数据源。这时，需要这些不同的数据源指定不同的别名。</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">entityRepository</exception>
public ITableSource Table(IRepository repository, string alias = null)
{
if (repository == null)
{
throw new ArgumentNullException("entityRepository");
}
var tableInfo = RdbDataProvider.Get(repository).DbTable.Info;
if (tableInfo == null)
{
ORMHelper.ThrowBasePropertyNotMappedException(repository.EntityType);
}
//构造一个 EntitySource 对象。
//在构造 TableSource 时，不必立刻为所有属性生成相应的列。必须使用懒加载。
var table = new TableSource();
table._tableInfo = tableInfo;
var res = table as ITableSource;
res.EntityRepository = repository;
table.TableName = tableInfo.Name;
table.Alias = alias;
return(table);
}
public void UtilsTest_Logger_ThreadDbAccessed()
{
var repo = RF.Concrete <TestUserRepository>();
using (RF.TransactionScope(repo))
{
int count = 0;
EventHandler <Logger.DbAccessedEventArgs> handler = (o, e) =>
{
if (e.ConnectionSchema == RdbDataProvider.Get(repo).DbSetting)
{
count++;
}
};
Logger.ThreadDbAccessed += handler;
repo.Save(new TestUser());
Logger.ThreadDbAccessed -= handler;
var p = DbSetting.FindOrCreate(UnitTestEntityRepositoryDataProvider.DbSettingName).ProviderName;
if (p == DbSetting.Provider_SqlClient)
{
Assert.IsTrue(count == 1);//sqlServer= 1
}
else
{
Assert.IsTrue(count == 2);//sqlce oracle=2
}
}
}
private List <EntityMeta> GetMappingEntityTypes()
{
var tableEntityTypes = new List <EntityMeta>();
//程序集列表，生成数据库会反射找到程序集内的实体类型进行数据库映射
foreach (var assembly in RafyEnvironment.AllPlugins)
{
foreach (var type in assembly.Assembly.GetTypes())
{
if (!type.IsAbstract)
{
//判断实体类型是否映射了某一个数据库
var em = CommonModel.Entities.Find(type);
if (em != null && em.TableMeta != null)
{
var entityDb = RdbDataProvider.Get(RF.Find(type)).ConnectionStringSettingName;
if (entityDb == this._dbSetting.Name)
{
tableEntityTypes.Add(em);
}
}
}
}
}
return(tableEntityTypes);
}
public static void DropAllTables()
{
using (var c = new RafyDbMigrationContext(DbSettingNames.DbMigrationHistory))
{
DropTables(c);
}
using (var c = new RafyDbMigrationContext(DbSettingNames.RafyPlugins))
{
DropTables(c);
}
using (var c = new RafyDbMigrationContext(UnitTestEntityRepositoryDataProvider.DbSettingName))
{
DropTables(c);
}
using (RdbDataProvider.RedirectDbSetting(
UnitTestEntityRepositoryDataProvider.DbSettingName,
UnitTestEntityRepositoryDataProvider.DbSettingName_Duplicate
))
{
using (var c = new RafyDbMigrationContext(UnitTestEntityRepositoryDataProvider.DbSettingName_Duplicate))
{
c.ClassMetaReader.EntityDbSettingName = UnitTestEntityRepositoryDataProvider.DbSettingName;
c.ClassMetaReader.IsGeneratingForeignKey = false;
DropTables(c);
}
}
using (var c = new RafyDbMigrationContext(UnitTest2EntityRepositoryDataProvider.DbSettingName))
{
DropTables(c);
}
using (var c = new RafyDbMigrationContext(StringTestEntityDataProvider.DbSettingName))
{
DropTables(c);
}
}
public void DPT_EntityList_Migration()
{
//聚合实体
var repo = RF.ResolveInstance <InvoiceRepository>();
using (RF.TransactionScope(DataTableMigrationPlugin.BackUpDbSettingName))
{
using (RF.TransactionScope(DataTableMigrationPlugin.DbSettingName))
{
var invoiceList = new InvoiceList
{
new Invoice()
{
InvoiceItemList =
{
new InvoiceItem(),
new InvoiceItem(),
}
},
new Invoice()
{
InvoiceItemList =
{
new InvoiceItem(),
new InvoiceItem(),
}
},
new Invoice(),
new Invoice()
};
RF.Save(invoiceList);
Assert.AreEqual(repo.GetAll().Count, 4, "新增 Invoice 数目为4");
var context = new DataTableMigrationContext(
2,
DateTime.Now.AddMinutes(2),
new List <Type>()
{
typeof(Invoice)
}
);
var dataTableMigrationService = new DataTableMigrationService(context);
dataTableMigrationService.ExecuteArchivingData();
Assert.AreEqual(repo.GetAll().Count, 0, "执行数据归档后 Invoice 数目为 0");
using (RdbDataProvider.RedirectDbSetting(
DataTableMigrationPlugin.DbSettingName,
DataTableMigrationPlugin.BackUpDbSettingName
))
{
Assert.AreEqual(repo.GetAll().Count, 4, "数据归档数据库 Invoice 数目为 4");
}
}
}
}
/// <summary>
/// 保存实体归档
/// </summary>
/// <param name="repository">实体仓储</param>
/// <param name="component">实体集合</param>
/// <param name="isSupportTree">是否是树形实体</param>
public void SaveToHistory(IRepository repository, EntityList component, bool isSupportTree)
{
if (isSupportTree)
{
var treeEntityList = TreeHelper.ConvertToList <Entity>(component);
ChangeEntityPersistenceStatus(treeEntityList, PersistenceStatus.New);
using (
RdbDataProvider.RedirectDbSetting(DataTableMigrationPlugin.DbSettingName,
DataTableMigrationPlugin.BackUpDbSettingName))
{
foreach (var treeEntity in treeEntityList)
{
repository.Save(treeEntity);
}
}
}
else
{
ChangeEntityPersistenceStatus(component, PersistenceStatus.New);
using (
RdbDataProvider.RedirectDbSetting(DataTableMigrationPlugin.DbSettingName,
DataTableMigrationPlugin.BackUpDbSettingName))
{
repository.Save(component);
}
}
}
public static void GenerateDb()
{
if (ConfigurationHelper.GetAppSettingOrDefault("单元测试-生成数据库", false))
{
using (var c = new RafyDbMigrationContext(DbSettingNames.DbMigrationHistory))
{
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
using (var c = new RafyDbMigrationContext(DbSettingNames.RafyPlugins))
{
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
using (var c = new RafyDbMigrationContext(UnitTestEntityRepositoryDataProvider.DbSettingName))
{
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
using (RdbDataProvider.RedirectDbSetting(UnitTestEntityRepositoryDataProvider.DbSettingName,
UnitTestEntityRepositoryDataProvider.DbSettingName_Duplicate))
{
using (var c = new RafyDbMigrationContext(UnitTestEntityRepositoryDataProvider.DbSettingName_Duplicate))
{
c.ClassMetaReader.EntityDbSettingName = UnitTestEntityRepositoryDataProvider.DbSettingName;
c.ClassMetaReader.IsGeneratingForeignKey = false;
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
}
using (var c = new RafyDbMigrationContext(UnitTest2EntityRepositoryDataProvider.DbSettingName))
{
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
using (var c = new RafyDbMigrationContext(StringTestEntityDataProvider.DbSettingName))
{
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
//启用批量更新
var dbSetting = DbSetting.FindOrCreate(UnitTestEntityRepositoryDataProvider.DbSettingName);
if (DbSetting.IsOracleProvider(dbSetting))
{
OracleBatchImporter.EnableBatchSequence(RF.ResolveInstance <BookRepository>());
OracleBatchImporter.EnableBatchSequence(RF.ResolveInstance <InvoiceRepository>());
}
}
}
public void DAT_EntityList_Migration()
{
//聚合实体
var repo = RF.ResolveInstance <InvoiceRepository>();
using (RF.TransactionScope(BackUpDbSettingName))
using (RF.TransactionScope(DbSettingName))
{
var invoiceList = new InvoiceList
{
new Invoice()
{
InvoiceItemList =
{
new InvoiceItem(),
new InvoiceItem(),
}
},
new Invoice()
{
InvoiceItemList =
{
new InvoiceItem(),
new InvoiceItem(),
}
},
new Invoice(),
new Invoice()
};
RF.Save(invoiceList);
Assert.AreEqual(repo.GetAll().Count, 4, "新增 Invoice 数目为4");
var context = new AggregationArchiveContext
{
OrignalDataDbSettingName = DbSettingName,
BackUpDbSettingName = BackUpDbSettingName,
BatchSize = 2,
DateOfArchiving = DateTime.Now.AddMinutes(2),
AggregationsToArchive = new List <Type> {
typeof(Invoice)
}
};
var migrationSvc = new AggregationArchiver();
migrationSvc.Archive(context);
Assert.AreEqual(repo.GetAll().Count, 0, "执行数据归档后 Invoice 数目为 0");
using (RdbDataProvider.RedirectDbSetting(DbSettingName, BackUpDbSettingName))
{
Assert.AreEqual(repo.GetAll().Count, 4, "数据归档数据库 Invoice 数目为 4");
}
}
}
/// <summary>
/// 保存实体归档
/// </summary>
/// <param name="repository">实体仓储</param>
/// <param name="entitiesToMigrate">实体集合</param>
private void BackupToHistory(IRepository repository, EntityList entitiesToMigrate)
{
var newList = repository.NewList();
newList.Clone(entitiesToMigrate, CloneOptions.NewComposition());
using (RdbDataProvider.RedirectDbSetting(_orignalDataDbSettingName, _backUpDbSettingName))
{
this.SaveList(repository, newList);
}
}
private static void AssertAllDataMigrated(EntityList rawList, IRepository repository)
{
Assert.AreEqual(0, repository.CountAll(), "执行数据归档后聚合根的数目为 0");
EntityList migratedList = null;
using (RdbDataProvider.RedirectDbSetting(DbSettingName, BackUpDbSettingName))
{
migratedList = repository.GetAll();
}
AssertAggtEqual(rawList, migratedList, repository);
}
public void UtilsTest_DBA_QueryValue_DateTime()
{
var repo = RF.ResolveInstance <BookRepository>();
var dp = RdbDataProvider.Get(repo);
if (dp.DbSetting.ProviderName == DbSetting.Provider_SqlClient)
{
using (var dba = dp.CreateDbAccesser())
{
var time = dba.QueryValue(@"SELECT GETDATE()");
Assert.IsInstanceOfType(time, typeof(DateTime));
}
}
}
public void DPT_TreeEntity_Migration()
{
//树形实体带聚合子
var repo = RF.ResolveInstance <FolderRepository>();
using (RF.TransactionScope(DataTableMigrationPlugin.BackUpDbSettingName))
{
using (RF.TransactionScope(DataTableMigrationPlugin.DbSettingName))
{
RF.Save(new Folder
{
Name = "001.",
FileList = { new File(), new File() },
TreeChildren =
{
new Folder
{
TreeChildren ={ new Folder() }
}
}
});
Assert.AreEqual(repo.GetAll().Count, 1, "树形实体只查根实体 Folder 数目为1");
var context = new DataTableMigrationContext(
2,
DateTime.Now.AddMinutes(2),
new List <Type>()
{
typeof(Folder)
}
);
var dataTableMigrationService = new DataTableMigrationService(context);
dataTableMigrationService.ExecuteArchivingData();
Assert.AreEqual(repo.GetAll().Count, 0, "执行数据归档后 Folder 数目为 0");
using (
RdbDataProvider.RedirectDbSetting(DataTableMigrationPlugin.DbSettingName,
DataTableMigrationPlugin.BackUpDbSettingName))
{
Assert.AreEqual(repo.GetAll().Count, 1, "归档数据库 Folder 数目为 3");
Assert.AreEqual(repo.GetAll()[0].FileList.Count, 2, "归档数据库聚合子 File 数目为 2");
}
}
}
}
public static void GenerateDb()
{
if (ConfigurationHelper.GetAppSettingOrDefault("单元测试-生成数据库", false))
{
using (var c = new RafyDbMigrationContext(DbSettingNames.DbMigrationHistory))
{
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
using (var c = new RafyDbMigrationContext(DbSettingNames.RafyPlugins))
{
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
using (var c = new RafyDbMigrationContext(UnitTestEntityRepositoryDataProvider.DbSettingName))
{
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
using (RdbDataProvider.RedirectDbSetting(
UnitTestEntityRepositoryDataProvider.DbSettingName,
UnitTestEntityRepositoryDataProvider.DbSettingName_Duplicate
))
{
using (var c = new RafyDbMigrationContext(UnitTestEntityRepositoryDataProvider.DbSettingName_Duplicate))
{
c.ClassMetaReader.EntityDbSettingName = UnitTestEntityRepositoryDataProvider.DbSettingName;
c.ClassMetaReader.IsGeneratingForeignKey = false;
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
}
using (var c = new RafyDbMigrationContext(UnitTest2EntityRepositoryDataProvider.DbSettingName))
{
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
using (var c = new RafyDbMigrationContext(StringTestEntityDataProvider.DbSettingName))
{
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
}
}
public void DMT_AutoMigrate_ChangeDbSetting()
{
using (RdbDataProvider.RedirectDbSetting(UnitTestEntityRepositoryDataProvider.DbSettingName,
UnitTestEntityRepositoryDataProvider.DbSettingName_Duplicate))
{
using (var c = new RafyDbMigrationContext(UnitTestEntityRepositoryDataProvider.DbSettingName_Duplicate))
{
/// 实体元数据默认设置的连接字符串
/// 如果切换新的数据库需要设置，否则不用设置
c.ClassMetaReader.EntityDbSettingName = UnitTestEntityRepositoryDataProvider.DbSettingName;
c.HistoryRepository = new DbHistoryRepository();
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
}
}
/// <summary>
/// 保存实体归档
/// </summary>
/// <param name="repository">实体仓储</param>
/// <param name="entitiesToMigrate">实体集合</param>
private void BackupToHistory(IRepository repository, EntityList entitiesToMigrate)
{
var options = CloneOptions.NewComposition();
options.Actions |= CloneActions.IdProperty;//Id 也需要拷贝。
options.Method = CloneValueMethod.LoadProperty;
var newList = repository.NewList();
newList.Clone(entitiesToMigrate, options);
using (RdbDataProvider.RedirectDbSetting(_orignalDataDbSettingName, _backUpDbSettingName))
{
this.SaveList(repository, newList);
}
}
/// <summary>
/// 为指定的聚合启用批量插入。
/// 此方法会更改整个聚合中所有实体对应的序列的每次递增数为 sequenceStep。
/// 调用时机：在数据库生成完成后调用。
/// 原因：在 ORACLE 中，如果要批量插入实体，则需要先把实体对应的 Sequence 变为以 sequenceStep 为每次递增。
/// 副作用：这会导致不使用批量插入功能时，实体的 Id 号变为 100000,200000,300000 这样的形式递增。
/// </summary>
/// <param name="aggtRepo">The aggt repo.</param>
/// <param name="sequenceStep">The sequence step.</param>
public static void EnableBatchSequence(IRepository aggtRepo, int sequenceStep = 100000)
{
if (sequenceStep < 100)
{
throw new ArgumentOutOfRangeException("sequenceStep");
}
using (var dba = RdbDataProvider.Get(aggtRepo).CreateDbAccesser())
{
foreach (var repo in DomainHelper.EnumerateAllTypesInAggregation(aggtRepo))
{
var table = RdbDataProvider.Get(repo).DbTable;
var seqName = OracleMigrationProvider.SequenceName(table.Name, table.IdentityColumn.Name);
dba.ExecuteText(string.Format("ALTER SEQUENCE {0} INCREMENT BY {1} NOCACHE", seqName, sequenceStep));
}
}
}
public void DAT_TreeEntity_Migration()
{
//树形实体带聚合子
var repo = RF.ResolveInstance <FolderRepository>();
using (RF.TransactionScope(BackUpDbSettingName))
using (RF.TransactionScope(DbSettingName))
{
RF.Save(new Folder
{
Name = "001.",
FileList = { new File(), new File() },
TreeChildren =
{
new Folder
{
TreeChildren ={ new Folder() }
}
}
});
Assert.AreEqual(repo.GetAll().Count, 1, "树形实体只查根实体 Folder 数目为1");
var context = new AggregationArchiveContext
{
OrignalDataDbSettingName = DbSettingName,
BackUpDbSettingName = BackUpDbSettingName,
BatchSize = 2,
DateOfArchiving = DateTime.Now.AddMinutes(2),
AggregationsToArchive = new List <Type> {
typeof(Folder)
}
};
var migrationSvc = new AggregationArchiver();
migrationSvc.Archive(context);
Assert.AreEqual(repo.GetAll().Count, 0, "执行数据归档后 Folder 数目为 0");
using (RdbDataProvider.RedirectDbSetting(DbSettingName, BackUpDbSettingName))
{
Assert.AreEqual(repo.GetAll().Count, 1, "归档数据库 Folder 数目为 3");
Assert.AreEqual(repo.GetAll()[0].FileList.Count, 2, "归档数据库聚合子 File 数目为 2");
}
}
}
/// <summary>
/// 批量插入大量实体
/// </summary>
/// <param name="repository">The repository.</param>
/// <param name="entityList">The entity list.</param>
/// <exception cref="System.ArgumentOutOfRangeException"></exception>
/// <exception cref="System.ArgumentNullException">只支持 SqlServer</exception>
private static void AddBatch(IRepositoryInternal repository, IList <Entity> entityList)
{
if (entityList.Count < 1)
{
throw new ArgumentOutOfRangeException();
}
var dp = RdbDataProvider.Get(repository);
var connection = dp.CreateDbAccesser().Connection;
var tableInfo = dp.DbTable;
var sqlCon = connection as SqlConnection;
if (sqlCon == null)
{
throw new ArgumentNullException("只支持 SqlServer");
}
new BatchInsert(entityList, sqlCon, tableInfo).Execute();
}
public void DAT_Cut()
{
if (IsTestDbSQLite())
{
return;
}
using (RF.TransactionScope(BackUpDbSettingName))
using (RF.TransactionScope(DbSettingName))
{
var rawList = new BookCategoryList
{
new BookCategory
{
Name = "bc1"
}
};
var repo = RF.ResolveInstance <BookCategoryRepository>();
repo.Save(rawList);
Assert.AreEqual(1, repo.CountAll(), "新增数目为 1");
rawList = repo.GetAll();//由于数据库中存储的值可能与内存中的值有一定的差异，所以这里需要把这些数据重新读取出来再进行对比。
Archive(new List <ArchiveItem>
{
new ArchiveItem
{
AggregationRoot = typeof(BookCategory),
ArchiveType = ArchiveType.Cut
},
});
Assert.AreEqual(0, repo.CountAll(), "执行数据归档后数目为 0");
using (RdbDataProvider.RedirectDbSetting(DbSettingName, BackUpDbSettingName))
{
Assert.AreEqual(1, repo.CountAll(), "数据归档数据库数目为 1");
}
AssertAllDataMigrated(rawList, repo);
}
}
public void UtilsTest_Logger_ThreadDbAccessed()
{
var repo = RF.Concrete <TestUserRepository>();
using (RF.TransactionScope(repo))
{
int count = 0;
EventHandler <Logger.DbAccessedEventArgs> handler = (o, e) =>
{
if (e.ConnectionSchema == RdbDataProvider.Get(repo).DbSetting)
{
count++;
}
};
Logger.ThreadDbAccessed += handler;
repo.Save(new TestUser());
Logger.ThreadDbAccessed -= handler;
Assert.IsTrue(count == 2);
}
}
/// <summary>
/// 通过数据库配置名的代理：实体仓库，构造一个 单连接事务块。
/// </summary>
/// <param name="dbDelegate"></param>
/// <returns></returns>
public static SingleConnectionTransactionScope TransactionScope(IRepository dbDelegate)
{
return(new SingleConnectionTransactionScope(RdbDataProvider.Get(dbDelegate).DbSetting));
}
public static void GenerateDb()
{
if (ConfigurationHelper.GetAppSettingOrDefault("Test_GenerateDb", false))
{
//生成数据库时，为简单起见，需要先加载所有的插件。
//注意，此行代码会导致按需加载的单元测试全部通过。
//所以平时应该通过配置文件来关闭数据库生成功能。
RafyEnvironment.EnsureAllPluginsLoaded();
ForceAllPluginsLoaded = true;
if (ClearDb && ConfigurationHelper.GetAppSettingOrDefault("Test_GenerateDb_Clear", false))
{
//不想手工去删除数据库，可以使用下面这个方法来在程序中删除所有的表。
DropAllTables();
ClearDb = false;
}
using (var c = new RafyDbMigrationContext(DbSettingNames.DbMigrationHistory))
{
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
using (var c = new RafyDbMigrationContext(DbSettingNames.RafyPlugins))
{
if (c.DbSetting.ProviderName != DbSetting.Provider_SQLite)
{
c.HistoryRepository = new DbHistoryRepository();
}
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
using (var c = new RafyDbMigrationContext(UnitTestEntityRepositoryDataProvider.DbSettingName))
{
if (c.DbSetting.ProviderName != DbSetting.Provider_SQLite)
{
c.HistoryRepository = new DbHistoryRepository();
}
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
UnitTestPlugin.InitailizeSequences();
using (RdbDataProvider.RedirectDbSetting(
UnitTestEntityRepositoryDataProvider.DbSettingName,
UnitTestEntityRepositoryDataProvider.DbSettingName_Duplicate
))
{
using (var c = new RafyDbMigrationContext(UnitTestEntityRepositoryDataProvider.DbSettingName_Duplicate))
{
c.ClassMetaReader.EntityDbSettingName = UnitTestEntityRepositoryDataProvider.DbSettingName;
c.ClassMetaReader.IsGeneratingForeignKey = false;
if (c.DbSetting.ProviderName != DbSetting.Provider_SQLite)
{
c.HistoryRepository = new DbHistoryRepository();
}
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
UnitTestPlugin.InitailizeSequences();
}
using (var c = new RafyDbMigrationContext(UnitTest2EntityRepositoryDataProvider.DbSettingName))
{
if (c.DbSetting.ProviderName != DbSetting.Provider_SQLite)
{
c.HistoryRepository = new DbHistoryRepository();
}
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
using (var c = new RafyDbMigrationContext(StringTestEntityDataProvider.DbSettingName))
{
if (c.DbSetting.ProviderName != DbSetting.Provider_SQLite)
{
c.HistoryRepository = new DbHistoryRepository();
}
c.RunDataLossOperation = DataLossOperation.All;
c.AutoMigrate();
}
}
}
/// <summary>
/// 为指定的仓库创建批量导入器。
/// </summary>
/// <param name="repository">The repository.</param>
/// <returns></returns>
public static IBatchImporter CreateImporter(this IRepository repository)
{
var rdp = RdbDataProvider.Get(repository);
return(CreateImporter(rdp.DbSetting));
}
