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);
}
/// <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
}
}
}
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));
}
}
}
/// <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));
}
}
}
/// <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 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));
}
/// <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));
}