/// <summary>
/// 构造数据上下文
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <param name="model">领域模型</param>
/// <param name="opType">数据访问类型</param>
/// <param name="data">数据</param>
/// <returns>数据上下文</returns>
public static DataContext CreateDataContext <T>(DomainModel.Spi.DomainModel model, DomainModel.Spi.DomainObject domainObject, DataAccessOpType opType, T data)
{
DataContext dataContext = null;
switch (opType)
{
case DataAccessOpType.I:
dataContext = CreateSaveContext(model, domainObject, data);
break;
case DataAccessOpType.Q:
dataContext = CreateQueryContext(model, domainObject, data as IDictionary <string, object>);
break;
case DataAccessOpType.U:
dataContext = CreateUpdateContext(model, domainObject, data);
break;
case DataAccessOpType.D:
dataContext = CreateDeleteContext(model, domainObject, data as IDictionary <string, object>);
break;
default:
break;
}
return(dataContext);
}
/// <summary>
/// 批量删除
/// </summary>
/// <remarks>按主键数据作为查询依据</remarks>
/// <param name="domainModel">领域模型</param>
/// <param name="domainObject">领域对象</param>
/// <param name="dataID">主键数据</param>
/// <param name="shardingKeyValue">分库分表键值对</param>
/// <returns>删除SQL</returns>
public void DeleteByIDs(DomainModel.Spi.DomainModel domainModel, DomainModel.Spi.DomainObject domainObject, IEnumerable <string> dataIDs, ShardingValue shardingKeyValue = null)
{
if (domainModel == null)
{
throw new ArgumentNullException("DataDeleteService.DeleteByID.domainModel");
}
if (domainObject == null)
{
throw new ArgumentNullException("DataDeleteService.DeleteByID.domainObject");
}
if (dataIDs == null || dataIDs.Count() == 0)
{
throw new ArgumentNullException("DataDeleteService.DeleteByID.dataIDs");
}
var sqlList = new SqlStatementCollection();
foreach (var dataID in dataIDs)
{
var sqls = SQLBuilderFactory.CreateSQLBuilder().ParseDeleteSqlByID(domainModel, domainObject, dataID, shardingKeyValue);
sqlList.AddRange(sqls);
}
var db = DatabaseFactory.CreateDefaultDatabase();
db.ExecuteSQLWithTransaction(sqlList);
}
/// <summary>
/// 构造函数(Default\Insert\Delete场景)
/// </summary>
/// <param name="domainModel">领域模型</param>
/// <param name="domainObject">领域对象</param>
/// <param name="dbType">数据库类型</param>
public SqlBuildingContext(DomainModel.Spi.DomainModel domainModel, DomainObject domainObject, DbType dbType)
{
this.DbType = dbType;
this.Node = domainObject;
this.DataObject = domainObject.DataObject;
this.CommonObject = domainModel;
}
/// <summary>
/// 构造函数(Default\Insert\Delete场景)
/// </summary>
/// <param name="domainModel">通用中领域模型间对象</param>
/// <param name="domainObject">领域对象</param>
/// <param name="dbType">数据库类型</param>
/// <param name="dataContext">数据上下文</param>
public SqlBuildingContext(DomainModel.Spi.DomainModel domainModel, DomainObject domainObject, DbType dbType, DataContext dataContext)
: this(domainModel, domainObject, dbType)
{
this.DataContext = dataContext;
this.QueryFilter = dataContext.QueryFilter;
this.DbType = domainObject.DataObject.DataSource.DbType;
}
/// <summary>
/// 解析生成删除SQL
/// </summary>
/// <remarks>按主键数据作为查询依据</remarks>
/// <param name="domainModel">领域模型</param>
/// <param name="domainObject">领域对象</param>
/// <param name="dataID">主键数据</param>
/// <param name="shardingKeyValue">分库分表键值对</param>
/// <returns>删除SQL</returns>
public SqlStatementCollection ParseDeleteSqlByID(DomainModel.Spi.DomainModel domainModel, DomainModel.Spi.DomainObject domainObject, string dataID, ShardingValue shardingKeyValue = null)
{
var sqls = new SqlStatementCollection();
var sqlSchema = new SqlStatementCollection();
var routeInfo = routeService.RouteByDataID(domainModel, dataID, shardingKeyValue);
var dataIDDic = CreatePkDataDictionary(domainModel, domainModel.RootDomainObject, dataID);
var dataContext = DataContextBuilder.CreateDataContext<IDictionary<string, object>>(domainModel, domainObject, DataAccessOpType.D, dataIDDic);
//解析SQL语句主干接口
ParseDeleteSqlSchema(sqlSchema, domainModel, domainObject, routeInfo, dataContext);
//在SqlSchema上逐表添加数据
ParseDeleteSqlDetail(sqlSchema, sqls, domainModel, domainObject, dataContext, routeInfo);
var result = new SqlStatementCollection();
foreach (var tempDomainObject in domainModel.ReverseDomainObjects)
{
var sql = sqls.FirstOrDefault(i => i.NodeID == tempDomainObject.ID);
if (sql != null)
{
result.Add(sql);
}
}
return result;
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="domainModel">领域模型</param>
/// <param name="domainObject">领域对象</param>
/// <param name="dbType">数据库类型</param>
/// <param name="filterCondition">过滤条件</param>
/// <param name="orderByCondition">排序条件</param>
public SqlBuildingContext(DomainModel.Spi.DomainModel domainModel, DomainObject domainObject, DbType dbType, string filterCondition = "", string orderByCondition = "")
: this(domainModel, domainObject, dbType)
{
FilterCondition = filterCondition;
OrderByCondition = orderByCondition;
this.DbType = domainObject.DataObject.DataSource.DbType;
}
private static void BuildDomainObjects(System.Type t, DomainModel.Spi.DomainModel domainModel,
DomainObjectAttribute rootDomainObjectAttr, DbTableAttribute rootDbTableAttr)
{
var rootDomainObject = new DomainObject
{
ID = Guid.NewGuid().ToString(),
Name = rootDomainObjectAttr.Name,
ClazzReflectType = t.FullName,
DomainModel = domainModel,
IsLazyLoad = rootDomainObjectAttr.IsLazyload,
};
var dataObject = new Sharding.Database.DataObject()
{
Name = rootDbTableAttr.Name,
IsView = rootDbTableAttr.IsView,
ID = Guid.NewGuid().ToString(),
TableShardingStrategyID = rootDbTableAttr.TableShardingStrategyID,
DatabaseShardingStrategyID = rootDbTableAttr.DBShardingStrategyID,
LogicTableName = rootDbTableAttr.Name,
DataSourceName = rootDbTableAttr.DataSourceName
};
if (string.IsNullOrEmpty(rootDbTableAttr.ID) != false)
{
dataObject = new Sharding.Database.DataObject()
{
ID = rootDbTableAttr.ID
};
}
rootDomainObject.DataObject = dataObject;
domainModel.RootDomainObject = rootDomainObject;
}
/// <summary>
/// 保存领域模型数据
/// </summary>
/// <param name="domainModel">领域模型</param>
/// <param name="instanceList">对象实例集合</param>
/// <param name="shardingValueList">分区分表键值对集合</param>
public void SaveBatch(DomainModel.Spi.DomainModel domainModel, List <object> instanceList, List <ShardingValue> shardingValueList = null)
{
if (domainModel == null)
{
throw new ArgumentNullException("SaveService.Save.domainModel");
}
if (instanceList == null)
{
throw new ArgumentNullException("SaveService.Save.instanceList");
}
var sqls = new SqlStatementCollection();
for (int i = 0; i < instanceList.Count; i++)
{
var currentObj = instanceList[i];
ShardingValue shardingValue = null;
if (shardingValueList != null)
{
shardingValue = shardingValueList[i];
}
var sqlstatements = SQLBuilderFactory.CreateSQLBuilder().ParseInsertSql(domainModel, currentObj, shardingValue);
sqls.AddRange(sqlstatements);
}
var db = DatabaseFactory.CreateDefaultDatabase();
db.ExecuteSQLWithTransaction(sqls);
}
/// <summary>
/// 构造ShardingValue
/// </summary>
/// <param name="domainModel">领域模型</param>
/// <param name="instance">数据</param>
/// <returns>ShardingValue</returns>
private ShardingValue CreateShardingValue(DomainModel.Spi.DomainModel domainModel, DomainModel.Spi.DomainObject domainObject, object instance)
{
ShardingValue shardingValue = null;
var shardingColumn = domainObject.DataObject.Columns.FirstOrDefault(i => i.IsShardingColumn);
if (shardingColumn == null)
{
throw new Exception("DataObject unset sharding column:" + domainObject.DataObjectID);
}
var shardingElement = domainObject.Elements.FirstOrDefault(i => i.DataColumnID == shardingColumn.ID);
var propValue = ObjectPropertyValueUtils.GetPropValue(shardingElement.PropertyName, instance);
switch (shardingElement.DataType)
{
case ElementDataType.DateTime:
case ElementDataType.Date:
shardingValue = new ShardingValue(domainModel.Name, shardingElement.ID, Convert.ToDateTime(propValue));
break;
case ElementDataType.Integer:
shardingValue = new ShardingValue(domainModel.Name, shardingElement.ID, Convert.ToInt64(propValue));
break;
case ElementDataType.String:
default:
shardingValue = new ShardingValue(domainModel.Name, shardingElement.ID, Convert.ToString(propValue));
break;
}
return(shardingValue);
}
/// <summary>
/// 构造ShardingValue
/// </summary>
/// <param name="domainModel">领域模型</param>
/// <param name="instance">数据</param>
/// <returns>ShardingValue</returns>
private ShardingValue CreateShardingValueByDataID(DomainModel.Spi.DomainModel domainModel, DomainObject domainObject, string dataID)
{
ShardingValue shardingValue = null;
var shardingColumn = domainObject.DataObject.Columns.FirstOrDefault(i => i.IsShardingColumn);
if (shardingColumn == null)
{
return(shardingValue);
}
var shardingElement = domainObject.Elements.FirstOrDefault(i => i.DataColumnID == shardingColumn.ID);
switch (shardingElement.DataType)
{
case ElementDataType.DateTime:
case ElementDataType.Date:
shardingValue = new ShardingValue(domainModel.Name, shardingElement.ID, Convert.ToDateTime(dataID));
break;
case ElementDataType.Integer:
shardingValue = new ShardingValue(domainModel.Name, shardingElement.ID, Convert.ToInt64(dataID));
break;
case ElementDataType.String:
default:
shardingValue = new ShardingValue(domainModel.Name, shardingElement.ID, Convert.ToString(dataID));
break;
}
return(shardingValue);
}
/// <summary>
/// 初始化SQL构造中间变量
/// </summary>
/// <param name="commonObject">通用中间对象</param>
/// <param name="coNode">节点</param>
/// <param name="dataObject">数据对象</param>
/// <param name="currentDbTable">当前操作对应的数据库表</param>
/// <returns>SQL构造中间变量</returns>
protected SqlBuildingInfo InitSqlBuildingInfo(DomainModel.Spi.DomainModel commonObject, DomainObject coNode, DataObject dataObject, string tableName, string dataSourceName)
{
//构造SqlBuildingInfo
var sqlInfo = new SqlBuildingInfo();
sqlInfo.CommonObject = commonObject;
sqlInfo.RootNode = commonObject.RootDomainObject;
sqlInfo.CurrentNode = coNode;
sqlInfo.CurrentDataObject = dataObject;
sqlInfo.TableName = tableName;
sqlInfo.DataSource = dataSourceName;
sqlInfo.CurrentSqlTable = new SqlTable(sqlInfo.TableName, sqlInfo.TableName, sqlInfo.TableName);
//SqlTable注册处理
RegistSqlTable(sqlInfo.CurrentSqlTable.TableName, sqlInfo.CurrentSqlTable, sqlInfo);
//如果当前节点是根节点:
if (sqlInfo.RootNode.ID == sqlInfo.CurrentNode.ID)
{
sqlInfo.RootDataObject = dataObject;
sqlInfo.RootSqlTable = sqlInfo.CurrentSqlTable;
}
else
{
sqlInfo.RootDataObject = commonObject.RootDomainObject.DataObject;
//sqlInfo.RootSqlTable = GetSubQuerySql(commonObject, commonObject.RootNode);
}
//SqlTable再次注册处理
RegistSqlTable(sqlInfo.CurrentSqlTable.TableName, sqlInfo.CurrentSqlTable, sqlInfo);
return(sqlInfo);
}
/// <summary>
/// 初始化SQL构造中间变量
/// </summary>
/// <param name="commonObject">通用中间对象</param>
/// <param name="coNode">节点</param>
/// <param name="dataObject">数据对象</param>
/// <param name="currentDbTable">当前操作对应的数据库表</param>
/// <returns>SQL构造中间变量</returns>
protected SqlBuildingInfo InitSqlBuildingInfoForSelect(DomainModel.Spi.DomainModel commonObject, DomainObject coNode, DataObject dataObject, string tableName)
{
var sqlInfo = new SqlBuildingInfo()
{
CommonObject = commonObject,
RootNode = commonObject.RootDomainObject,
CurrentNode = coNode,
CurrentDataObject = dataObject,
TableName = tableName
};
sqlInfo.CurrentSqlTable = new SqlTable(sqlInfo.TableName, sqlInfo.TableName, sqlInfo.TableName);
//如果当前节点是根节点:
if (sqlInfo.CurrentNode.IsRootObject || sqlInfo.RootNode.ID == sqlInfo.CurrentNode.ID)
{
sqlInfo.RootDataObject = dataObject;
sqlInfo.RootSqlTable = sqlInfo.CurrentSqlTable;
}
else
{
sqlInfo.RootDataObject = commonObject.RootDomainObject.DataObject;
//sqlInfo.RootSqlTable = CoHelper.GetRootSQLDomTable(commonObject);
}
RegistSqlTable(sqlInfo.CurrentDataObject.ID, sqlInfo.CurrentSqlTable, sqlInfo);
return(sqlInfo);
}
/// <summary>
/// 数据领域对象
/// </summary>
/// <param name="dataObject">领域对象</param>
public void SaveDomainModel(DomainModel.Spi.DomainModel domainModel)
{
if (domainModel == null)
{
throw new ArgumentNullException("DomainModelManager.SaveDomainModel.domainModel");
}
var asso = domainModel.DomainObjects.SelectMany(i => i.Associations).ToList();
var assoItems = asso.SelectMany(i => i.Items).ToList();
using (var tran = new TransactionScope(TransactionScopeOption.Required))
{
DacServiceManager.GetDomainModelDao().SaveDomainModel(domainModel);
foreach (var domainObject in domainModel.DomainObjects)
{
DacServiceManager.GetDomainModelDao().SaveDomainObjectElements(domainObject.Elements);
}
if (asso.Count > 0)
{
DacServiceManager.GetDomainModelDao().SaveDomainAssociation(asso);
}
if (assoItems.Count > 0)
{
DacServiceManager.GetDomainModelDao().SaveDomainAssociationItem(assoItems);
}
tran.Complete();
}
}
/// <summary>
/// 构造查询主体部分
/// </summary>
/// <remarks>查询主体是一个子查询，为了支持一个数据对象多个数据库表</remarks>
/// <param name="sql">Select语句</param>
/// <param name="domainModel">通用中间对象</param>
/// <param name="domainObject">当前节点</param>
/// <param name="dataObject">当前节点对应的数据对象</param>
private void BuildMainFrom(SelectSqlStatement sql, DomainModel.Spi.DomainModel domainModel, DomainObject domainObject, DataObject dataObject, string tableName, SqlBuildingContext sqlContext)
{
//初始化主查询SQL语句
var context = sqlContext.DataContext;
sql.NodeID = domainObject.ID;
sql.CommonObjectID = domainModel.ID;
sql.NodeVersion = domainModel.Version.ToString();
sql.CommonObjectVersion = domainModel.Version.ToString();
sql.TableName = tableName;
sql.TableCode = tableName;
sql.SqlBuildingInfo = base.InitSqlBuildingInfo(domainModel, domainObject, dataObject, tableName, sqlContext.DataSource);
if (context.Data.ContainsKey(domainObject.ID))
{
var dataContextItem = context.GetCurrentDataContextItem(domainObject.ID);
foreach (var column in dataObject.PKColumns)
{
var pkField = new SqlPrimaryKeyField(sql.SqlBuildingInfo.CurrentSqlTable, column.ColumnName);
var pkElement = domainObject.Elements.FirstOrDefault(i => i.DataColumnID == column.ID);
pkField.Value.Value = dataContextItem.PrimaryKeyData[pkElement.ID];
sql.PrimaryKeys.ChildCollection.Add(pkField);
}
}
//将子查询加入到当前Select语句中
sql.From.ChildCollection.Add(sql.SqlBuildingInfo.CurrentSqlTable);
}
protected static DataContext CreateUpdateContext(DomainModel.Spi.DomainModel model, DomainModel.Spi.DomainObject domainObject, object data)
{
var context = new DataContext();
var dataContextItem = GetModelObjectPropValue(data, domainObject, DataAccessOpType.U, true);
context.Add(domainObject.ID, new List <DataContextItem>()
{
dataContextItem
});
if (domainObject.ChildDomainObjects.Count > 0)
{
foreach (var childModelObject in domainObject.ChildDomainObjects)
{
var objectList = ObjectPropertyValueUtils.GetCollectionPropValue(childModelObject.PropertyName, data);
var items = new List <DataContextItem>(objectList.Count());
foreach (var obj in objectList)
{
items.Add(GetModelObjectPropValue(obj, childModelObject, DataAccessOpType.U, true));
LoopGetModelObjectPropValue(childModelObject, context, obj, DataAccessOpType.U, true);
}
context.Add(childModelObject.ID, items);
}
}
return(context);
}
/// <summary>
/// 获取领域模型结果集映射
/// </summary>
/// <param name="model">领域模型</param>
/// <returns>领域模型结果集映射</returns>
public ResultMapping GetResultMapping(DomainModel.Spi.DomainModel model)
{
if (model == null)
{
throw new ArgumentNullException("ResultMappingService.GetResultMapping.model");
}
return(ResultMappingFactory.GetInstance().CreateOrGetResultMapping(model));
}
private Dictionary<string, object> CreatePkDataDictionary(DomainModel.Spi.DomainModel domainModel, DomainModel.Spi.DomainObject domainObject, string dataID)
{
var dataIDDic = new Dictionary<string, object>();
foreach (var column in domainObject.DataObject.PKColumns)
{
var pkElement = domainObject.Elements.FirstOrDefault(i => i.DataColumnID == column.ID);
dataIDDic.Add(pkElement.ID, dataID);
break;
}
return dataIDDic;
}
/// <summary>
/// 删除领域对象
/// </summary>
/// <param name="id">领域对象ID</param>
public void DeleteDomainModel(string id)
{
var model = new DomainModel.Spi.DomainModel {
ID = id
};
this.DomainModels.Attach(model);
this.DomainModels.Remove(model);
this.SaveChanges();
}
/// <summary>
/// 解析生成Insert语句。
/// </summary>
/// <param name="domainModel">领域模型。</param>
/// <param name="instance">要插入的数据。</param>
/// <param name="shardingKeyValue">分库分表键值对</param>
/// <returns>Insert语句集合。</returns>
public SqlStatementCollection ParseInsertSql(DomainModel.Spi.DomainModel domainModel, object instance, ShardingValue shardingKeyValue = null)
{
var sqls = new SqlStatementCollection();
var routeInfo = routeService.Route(domainModel, instance, shardingKeyValue);
var dataContext = DataContextBuilder.CreateDataContext<object>(domainModel, domainModel.RootDomainObject, DataAccessOpType.I, instance);
//解析SQL语句主干接口
ParseInsertSqlSchema(sqls, domainModel, domainModel.RootDomainObject, routeInfo);
//在SqlSchema上逐表添加数据
return ParseInsertSqlDetail(sqls, domainModel, dataContext, routeInfo);
}
public static DomainModel.Spi.DomainModel Parse(System.Type t)
{
var domainModel = new DomainModel.Spi.DomainModel();
var attributes = t.GetCustomAttributes(false);
var domainModelAttrObj = attributes.FirstOrDefault(i => i.GetType() == typeof(DomainModelAttribute));
if (domainModelAttrObj == null)
{
throw new Exception($"Type:{t.FullName} does not contain DomainModelAttribute");
}
var domainModelAttr = domainModelAttrObj as DomainModelAttribute;
domainModel.Name = domainModelAttr.Name;
domainModel.ID = Guid.NewGuid().ToString();
var domainModelCacheAttrObj = attributes.FirstOrDefault(i => i.GetType() == typeof(CacheAttribute));
if (domainModelCacheAttrObj != null)
{
var domainModelCacheAttr = domainModelCacheAttrObj as CacheAttribute;
domainModel.IsCache = true;
domainModel.CacheStrategy = domainModelCacheAttr.Scope.ToString();
}
var domainModelLogicDelAttrObj = attributes.FirstOrDefault(i => i.GetType() == typeof(LogicDeleteAttribute));
if (domainModelLogicDelAttrObj != null)
{
domainModel.IsLogicDelete = true;
}
//解析子对象
var rootDomainObjectAttr = attributes.FirstOrDefault(i => i.GetType() == typeof(DomainObjectAttribute)) as DomainObjectAttribute;
if (rootDomainObjectAttr == null)
{
throw new Exception($"Type:{t.FullName} does not contain DomainObjectAttribute");
}
var rootDbTableAttr = attributes.FirstOrDefault(i => i.GetType() == typeof(DbTableAttribute)) as DbTableAttribute;
if (rootDbTableAttr == null)
{
throw new Exception($"Type:{t.FullName} does not contain DbTableAttribute");
}
BuildDomainObjects(t, domainModel, rootDomainObjectAttr, rootDbTableAttr);
return(domainModel);
}
/// <summary>
/// 领域对象校验
/// </summary>
/// <param name="model">领域对象</param>
private void DomainModelValidate(DomainModel.Spi.DomainModel model)
{
foreach (var domainObject in model.DomainObjects)
{
if (string.IsNullOrWhiteSpace(domainObject.DataObjectID))
{
throw new Exception(string.Format("DomainObject:{0}, can not find DataObject.", model.Name));
}
if (domainObject.DataObject == null)
{
domainObject.DataObject = DataObjectManageService.GetInstance().GetDataObject(domainObject.DataObjectID);
}
}
}
protected static DataContext CreateDeleteContext(DomainModel.Spi.DomainModel model, DomainModel.Spi.DomainObject domainObject, IDictionary <string, object> pkData)
{
var context = new DataContext();
var dataContextItem = new DataContextItem()
{
OpType = DataAccessOpType.D
};
dataContextItem.PrimaryKeyData = pkData;
context.Add(domainObject.ID, new List <DataContextItem>()
{
dataContextItem
});
return(context);
}
/// <summary>
/// 获取对象数据
/// </summary>
/// <param name="domainModel">领域模型</param>
/// <param name="dataID">数据唯一标识</param>
/// <param name="shardingValue">分库分表键值对</param>
/// <returns>对象数据</returns>
public List <DataTable> GetData(DomainModel.Spi.DomainModel domainModel, string dataID, ShardingValue shardingValue = null)
{
if (domainModel == null)
{
throw new ArgumentNullException("DataQueryService.GetData.domainModel");
}
if (string.IsNullOrWhiteSpace(dataID))
{
throw new ArgumentNullException("DataQueryService.GetData.dataID");
}
var sqls = SQLBuilderFactory.CreateSQLBuilder().ParseQuerySqlByID(domainModel, dataID, shardingValue);
var db = DatabaseFactory.CreateDefaultDatabase();
return(db.GetDataCollection(sqls));
}
/// <summary>
/// 更新领域模型数据
/// </summary>
/// <param name="domainModel">领域模型</param>
/// <param name="instance">对象实例</param>
/// <param name="shardingValue">分区分表键值对</param>
public void Update(DomainModel.Spi.DomainModel domainModel, object instance, ShardingValue shardingValue = null)
{
if (domainModel == null)
{
throw new ArgumentNullException("DataUpdateService.Update.domainModel");
}
if (instance == null)
{
throw new ArgumentNullException("DataUpdateService.Update.instance");
}
var sqls = SQLBuilderFactory.CreateSQLBuilder().ParseUpdateSql(domainModel, instance, shardingValue);
var db = DatabaseFactory.CreateDefaultDatabase();
db.ExecuteSQLWithTransaction(sqls);
}
public static ISQLBuilder CreateSQLBuilder(DomainModel.Spi.DomainModel domainModel)
{
var mainDbType = domainModel.RootDomainObject.DataObject.DataSource.DbType;
switch (mainDbType)
{
//case DbType.ES:
// return new ESSQLBuilder();
case DbType.SQLServer:
case DbType.MySQL:
case DbType.Oracle:
return(CreateSQLBuilder());
default:
return(CreateSQLBuilder());
}
}
public static IDatabase CreateDatabase(DomainModel.Spi.DomainModel domainModel)
{
var mainDbType = domainModel.RootDomainObject.DataObject.DataSource.DbType;
switch (mainDbType)
{
//case Metadata.Database.DbType.ES:
// return new ESDatabase();
case DbType.SQLServer:
case DbType.MySQL:
case DbType.Oracle:
return(CreateDefaultDatabase());
default:
return(CreateDefaultDatabase());
}
}
/// <summary>
/// 解析生成删除SQL
/// </summary>
/// <remarks>按主键数据作为查询依据</remarks>
/// <param name="domainModel">领域模型</param>
/// <param name="dataID">主键数据</param>
/// <param name="shardingKeyValue">分库分表键值对</param>
/// <returns>删除SQL</returns>
public void DeleteByID(DomainModel.Spi.DomainModel domainModel, string dataID, ShardingValue shardingKeyValue = null)
{
if (domainModel == null)
{
throw new ArgumentNullException("DataDeleteService.DeleteByID.domainModel");
}
if (string.IsNullOrWhiteSpace(dataID))
{
throw new ArgumentNullException("DataDeleteService.DeleteByID.dataID");
}
var sqls = SQLBuilderFactory.CreateSQLBuilder().ParseDeleteSqlByID(domainModel, dataID, shardingKeyValue);
var db = DatabaseFactory.CreateDefaultDatabase();
db.ExecuteSQLWithTransaction(sqls);
}
/// <summary>
/// 解析生成查询SQL
/// </summary>
/// <remarks>按主键数据作为查询依据</remarks>
/// <param name="domainModel">领域模型</param>
/// <param name="domainObject">领域对象</param>
/// <param name="dataID">主键数据</param>
/// <param name="shardingKeyValue">分库分表键值对</param>
/// <returns>查询SQL</returns>
public SqlStatementCollection ParseQuerySqlByID(DomainModel.Spi.DomainModel domainModel, DomainModel.Spi.DomainObject domainObject, string dataID, ShardingValue shardingKeyValue = null)
{
var sqls = new SqlStatementCollection();
var sqlSchema = new SqlStatementCollection();
var routeInfo = routeService.RouteByDataID(domainModel, dataID, shardingKeyValue);
var dataIDDic = CreatePkDataDictionary(domainModel, domainObject, dataID);
var dataContext = DataContextBuilder.CreateDataContext<IDictionary<string, object>>(domainModel, domainObject, DataAccessOpType.Q, dataIDDic);
//解析SQL语句主干接口
ParseQuerySqlSchema(sqlSchema, domainModel, domainObject, routeInfo, dataContext);
//在SqlSchema上逐表添加数据
ParseQuerySqlDetail(sqlSchema, sqls, domainModel, domainObject, dataContext, routeInfo);
return sqlSchema;
}
/// <summary>
/// 构造查询SQL语句的主干结构
/// </summary>
/// <param name="dataObject">数据对象</param>
/// <returns>查询SQL语句的主干结构</returns>
private void ParseDeleteSqlSchema(SqlStatementCollection sqlSchemata, DomainModel.Spi.DomainModel domainModel, DomainModel.Spi.DomainObject domainObject, Dictionary<string, ShardingTarget> routeInfo, DataContext dataContext)
{
var selectStrategy = new DeleteSqlBuildStrategy();
var context = new SqlBuildingContext(domainModel, domainObject, SQLBuilderUtils.GetCurrentDbType(), dataContext);
context.RouteInfo = routeInfo;
var nodeSqlSchemata = selectStrategy.BuildTableSqlSchema(context);
sqlSchemata.AddRange(nodeSqlSchemata);
//递归处理子对象
if (domainObject.ChildDomainObjects.Count == 0) return;
foreach (var childModelObject in domainObject.ChildDomainObjects)
{
ParseDeleteSqlSchema(sqlSchemata, domainModel, childModelObject, routeInfo, dataContext);
}
}
public static void AreEqual(DomainModel.Spi.DomainModel expected, DomainModel.Spi.DomainModel actual)
{
Assert.IsNotNull(expected);
Assert.IsNotNull(actual);
Assert.AreEqual(expected.CacheStrategy, actual.CacheStrategy);
Assert.AreEqual(expected.IsCache, actual.IsCache);
Assert.AreEqual(expected.Name, actual.Name);
Assert.AreEqual(expected.RootDomainObjectID, actual.RootDomainObjectID);
Assert.AreEqual(expected.Version, actual.Version);
Assert.AreEqual(expected.DomainObjects.Count, actual.DomainObjects.Count);
Assert.AreEqual(expected.RootDomainObject.DataObjectID, actual.RootDomainObject.DataObjectID);
Assert.AreEqual(expected.RootDomainObject.DomainModelID, actual.RootDomainObject.DomainModelID);
Assert.AreEqual(expected.RootDomainObject.IsRootObject, actual.RootDomainObject.IsRootObject);
Assert.AreEqual(expected.RootDomainObject.PropertyName, actual.RootDomainObject.PropertyName);
Assert.AreEqual(expected.RootDomainObject.Elements.Count, actual.RootDomainObject.Elements.Count);
}
