/// <summary>
/// 获取对象数据
/// </summary>
/// <param name="domainModel">领域模型</param>
/// <param name="domainObject">领域对象</param>
/// <param name="dataId">数据唯一标识</param>
/// <param name="shardingValue">分库分表键值对</param>
/// <returns>对象数据</returns>
public List <DataTable> GetData(string domainModelID, string domainObjectID, string dataId, ShardingValue shardingValue = null)
{
if (string.IsNullOrWhiteSpace(domainModelID))
{
throw new ArgumentNullException("DataAccessService.GetData.domainModelID");
}
if (string.IsNullOrWhiteSpace(domainObjectID))
{
throw new ArgumentNullException("DataAccessService.GetData.domainObjectID");
}
if (string.IsNullOrWhiteSpace(dataId))
{
throw new ArgumentNullException("DataAccessService.GetData.dataId");
}
try
{
var domainModel = DomainModelManageService.GetInstance().GetDomainModel(domainModelID);
if (domainModel == null)
{
throw new Exception("Dae-0001: Cannot find DomainModel: " + domainModelID);
}
var domainObject = domainModel.DomainObjects.FirstOrDefault(i => i.ID == domainObjectID);
if (domainObject == null)
{
throw new Exception("Dae-0001: Cannot find DomainObject: " + domainObjectID);
}
return(DataAccessEngine.GetInstance().GetDataQueryService().GetData(domainModel, domainObject, dataId, shardingValue));
}
catch (Exception e)
{
throw new Exception("Dae-Query-001: 数据查询失败!", e);
}
}
/// <summary>
/// 删除数据
/// </summary>
/// <param name="domainModelID">领域模型ID</param>
/// <param name="domainObjectID">领域对象ID</param>
/// <param name="dataIds">数据唯一标识集合</param>
/// <param name="shardingValue">分库分表键值对</param>
public void Delete(string domainModelID, string domainObjectID, IList <string> dataIds, ShardingValue shardingValue = null)
{
if (string.IsNullOrWhiteSpace(domainModelID))
{
throw new ArgumentNullException("DataAccessService.Delete.domainModelID");
}
if (string.IsNullOrWhiteSpace(domainObjectID))
{
throw new ArgumentNullException("DataAccessService.Delete.domainObjectID");
}
if (dataIds == null || dataIds.Count == 0)
{
throw new ArgumentNullException("DataAccessService.Delete.dataIds");
}
try
{
var domainModel = DomainModelManageService.GetInstance().GetDomainModel(domainModelID);
if (domainModel == null)
{
throw new Exception("Dae-0001: Cannot find DomainModel: " + domainModelID);
}
var domainObject = domainModel.DomainObjects.FirstOrDefault(i => i.ID == domainObjectID);
if (domainObject == null)
{
throw new Exception("Dae-0001: Cannot find DomainObject: " + domainObjectID);
}
DataAccessEngine.GetInstance().GetDataDeleteService().DeleteByIDs(domainModel, domainObject, dataIds, shardingValue);
}
catch (Exception e)
{
throw new Exception("Dae-Delete-002: 数据批量删除失败!", e);
}
}
/// <summary>
/// 保存指定对象的数据
/// </summary>
/// <param name="domainModelID">领域模型ID</param>
/// <param name="domainObjectID">领域对象ID</param>
/// <param name="instances">对象实例</param>
public void Save(string domainModelID, string domainObjectID, List <object> instances, ShardingValue shardingValue = null)
{
if (string.IsNullOrWhiteSpace(domainModelID))
{
throw new ArgumentNullException("DataAccessService.Save.domainModelID");
}
if (string.IsNullOrWhiteSpace(domainObjectID))
{
throw new ArgumentNullException("DataAccessService.Save.domainObjectID");
}
if (instances == null)
{
throw new ArgumentNullException("DataAccessService.Save.instances");
}
try
{
var domainModel = DomainModelManageService.GetInstance().GetDomainModel(domainModelID);
if (domainModel == null)
{
throw new Exception("Dae-0001: Cannot find DomainModel: " + domainModelID);
}
var domainObject = domainModel.DomainObjects.FirstOrDefault(i => i.ID == domainObjectID);
if (domainObject == null)
{
throw new Exception("Dae-0001: Cannot find DomainObject: " + domainObjectID);
}
var shardings = new List <ShardingValue>();
if (shardingValue != null)
{
instances.ForEach(i => shardings.Add(shardingValue));
}
DataAccessEngine.GetInstance().GetDataSaveService().SaveBatch(domainModel, domainObject, instances, shardings);
}
catch (Exception e)
{
throw new Exception("Dae-Save-001: 数据保存失败!", e);
}
}
/// <summary>
/// 更新指定对象的数据
/// </summary>
/// <param name="domainModelID">领域模型ID</param>
/// <param name="domainObjectID">领域对象ID</param>
/// <param name="instance">对象实例</param>
public void Update(string domainModelID, string domainObjectID, object instance, ShardingValue shardingValue = null)
{
if (string.IsNullOrWhiteSpace(domainModelID))
{
throw new ArgumentNullException("DataAccessService.Update.domainModelID");
}
if (string.IsNullOrWhiteSpace(domainObjectID))
{
throw new ArgumentNullException("DataAccessService.Update.domainObjectID");
}
if (instance == null)
{
throw new ArgumentNullException("DataAccessService.Update.instance");
}
try
{
var domainModel = DomainModelManageService.GetInstance().GetDomainModel(domainModelID);
if (domainModel == null)
{
throw new Exception("Dae-0001: Cannot find DomainModel: " + domainModelID);
}
var domainObject = domainModel.DomainObjects.FirstOrDefault(i => i.ID == domainObjectID);
if (domainObject == null)
{
throw new Exception("Dae-0001: Cannot find DomainObject: " + domainObjectID);
}
DataAccessEngine.GetInstance().GetDataUpdateService().Update(domainModel, domainObject, instance, shardingValue);
}
catch (Exception e)
{
throw new Exception("Dae-Update-001: 数据保存失败!", e);
}
}
/// <summary>
/// 解析Sharding规则
/// </summary>
/// <param name="dataObject">数据对象</param>
/// <param name="value">值</param>
/// <returns>连接</returns>
public IList <ShardingTarget> Parse(DataObject dataObject, ShardingValue value)
{
var dbNames = new List <string>();
if (dataObject.IsDatabaseSharding && dataObject.DatabaseShardingStrategy != null)
{
var databaseStragety = dataObject.DatabaseShardingStrategy;
var dblinks = dataObject.DataSource.DbLinks.Select(i => i.Name).ToList();
var calc = ShardingStrategyFactory.GetSingKeyShardingAlgorithm(databaseStragety);
switch (value.ShardingValueType)
{
case ShardingValueType.SINGLE:
dbNames.Add(calc.DoEqualSharding(dblinks, value));
break;
case ShardingValueType.LIST:
dbNames.AddRange(calc.DoInSharding(dblinks, value).Distinct());
break;
case ShardingValueType.RANGE:
dbNames.AddRange(calc.DoBetweenSharding(dblinks, value).Distinct());
break;
default: break;
}
}
else
{
dbNames.Add(dataObject.DataSource.DefaultDbLink.Name);
}
var tableList = new List <string>();
if (dataObject.IsTableSharding && dataObject.TableShardingStrategy != null)
{
var tableNames = dataObject.ActualTableNames.Split(',').ToList();
var calc = ShardingStrategyFactory.GetSingKeyShardingAlgorithm(dataObject.TableShardingStrategy);
switch (value.ShardingValueType)
{
case ShardingValueType.SINGLE:
tableList.Add(calc.DoEqualSharding(tableNames, value));
break;
case ShardingValueType.LIST:
tableList.AddRange(calc.DoInSharding(tableNames, value).Distinct());
break;
case ShardingValueType.RANGE:
tableList.AddRange(calc.DoBetweenSharding(tableNames, value).Distinct());
break;
default: break;
}
}
else
{
tableList.Add(dataObject.LogicTableName);
}
var result = new List <ShardingTarget>();
foreach (var tableName in tableList)
{
var dbName = dataObject.DataSource.DbLinks.FirstOrDefault(i => i.Tables.FirstOrDefault(t => t.Name == tableName) != null);
if (dbNames.Contains(dbName.Name))
{
result.Add(new ShardingTarget()
{
DataSource = dbName.Name, TableName = tableName
});
}
}
return(result);
}
