protected virtual string PrepareUpdateSql(T obj, ORMappingItemCollection mapping)
{
WhereSqlClauseBuilder primaryKeyBuilder = PrepareWhereSqlBuilder(obj, mapping);
UpdateSqlClauseBuilder updateBuilder = PrepareUpdateSqlBuilder(obj, mapping);
return(string.Format("UPDATE {0} SET {1} WHERE {2}",
GetTableName(obj, mapping),
updateBuilder.ToSqlString(TSqlBuilder.Instance),
primaryKeyBuilder.ToSqlString(TSqlBuilder.Instance)));
}
/// <summary>
/// 添加一行数据，并返回新主键
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public int InsertData(UserOperationLog data)
{
ORMappingItemCollection mappings = ORMapping.GetMappingInfo <UserOperationLog>();
string sql = ORMapping.GetInsertSql(data, mappings, TSqlBuilder.Instance);
decimal result = (decimal)DbHelper.RunSqlReturnScalar(string.Format("{0} \n SELECT @@IDENTITY", sql), this.GetConnectionName());
return(decimal.ToInt32(result));
}
protected override ORMappingItemCollection GetMappingInfo(Dictionary <string, object> context)
{
ORMappingItemCollection result = base.GetMappingInfo(context).Clone();
result["DATA"].BindingFlags = ClauseBindingFlags.All;
result["UPDATE_TAG"].BindingFlags = ClauseBindingFlags.All;
result["CREATE_TIME"].BindingFlags = ClauseBindingFlags.All;
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="dataCollection"></param>
/// <param name="row"></param>
protected virtual void OnDataRowToObject(TCollection dataCollection, DataRow row)
{
T data = new T();
ORMappingItemCollection mapping = GetMappingInfo();
ORMapping.DataRowToObject(row, mapping, data);
dataCollection.Add(data);
}
/// <summary>
/// 在上下文中注册查询返回的结果
/// </summary>
/// <param name="tableName"></param>
/// <param name="mapping"></param>
/// <param name="sql"></param>
/// <param name="action"></param>
protected void RegisterQueryData(string tableName, ORMappingItemCollection mapping, string sql, Action <TCollection> action)
{
VersionedQueryInContextBuilder <T, TCollection> .Instance.RegisterQueryData(
this.GetSqlContext(),
tableName,
mapping,
sql,
action,
(row) => this.CreateNewData(row));
}
public static string GetORMMapinngField(this ORMappingItemCollection coll, string property)
{
var attr = coll.Find(m => m.PropertyName == property);
if (attr == null)
{
return(string.Empty);
}
return(attr.DataFieldName);
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
/// <param name="sqlContext"></param>
/// <param name="context"></param>
/// <returns></returns>
protected virtual string InnerDeleteInContext(T data, SqlContextItem sqlContext, Dictionary <string, object> context)
{
ORMappingItemCollection mappings = GetMappingInfo(context);
string sql = this.GetDeleteSql(data, mappings, context);
sqlContext.AppendSqlWithSperatorInContext(TSqlBuilder.Instance, sql);
return(sql);
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
/// <param name="sqlContext"></param>
/// <param name="context"></param>
/// <param name="ignoreProperties">需要忽略的属性</param>
/// <returns></returns>
protected virtual string InnerInsertInContext(T data, SqlContextItem sqlContext, Dictionary <string, object> context, string [] ignoreProperties)
{
ORMappingItemCollection mappings = GetMappingInfo(context);
string sql = this.GetInsertSql(data, mappings, context, ignoreProperties);
sqlContext.AppendSqlInContext(TSqlBuilder.Instance, sql);
return(sql);
}
/// <summary>
///
/// </summary>
/// <param name="obj"></param>
/// <param name="mapping"></param>
/// <param name="ignoreProperties">需要忽略的参数</param>
/// <returns></returns>
public virtual string PrepareUpdateSql(T obj, ORMappingItemCollection mapping, params string[] ignoreProperties)
{
IConnectiveSqlClause primaryKeyBuilder = this.PrepareWhereSqlBuilder(obj, mapping, ignoreProperties);
UpdateSqlClauseBuilder updateBuilder = this.PrepareUpdateSqlBuilder(obj, mapping, ignoreProperties);
return(string.Format("UPDATE {0} SET {1} WHERE {2}",
GetTableName(obj, mapping),
updateBuilder.ToSqlString(TSqlBuilder.Instance),
primaryKeyBuilder.ToSqlString(TSqlBuilder.Instance)));
}
private static string GetInsertSql(WfPersistQueue pq)
{
ORMappingItemCollection mappingInfo = ORMapping.GetMappingInfo(pq.GetType());
string sql = string.Format("INSERT INTO {0}(PROCESS_ID, UPDATE_TAG, TENANT_CODE) SELECT INSTANCE_ID, UPDATE_TAG, TENANT_CODE FROM WF.PROCESS_INSTANCES WHERE INSTANCE_ID = {1}",
mappingInfo.TableName,
TSqlBuilder.Instance.CheckUnicodeQuotationMark(pq.ProcessID));
return(sql);
}
private static ORMappingItem GetMappingItemFromIDType(UserTaskIDType idType)
{
ORMappingItemCollection mappings = ORMapping.GetMappingInfo <UserTask>();
ORMappingItem keyItem = GetMappingFromPropertyName(idType.ToString(), mappings);
ExceptionHelper.FalseThrow(keyItem != null, "不能找到idType为{0}对应的字段", idType.ToString());
return(keyItem);
}
protected virtual WhereSqlClauseBuilder PrepareWhereSqlBuilder(T obj, ORMappingItemCollection mapping)
{
WhereSqlClauseBuilder primaryKeyBuilder = ORMapping.GetWhereSqlClauseBuilderByPrimaryKey(obj);
//string vsFieldName = GetPropertyFieldName("VersionStartTime", mapping);
//if (primaryKeyBuilder.Exists(item => ((SqlClauseBuilderItemIUW)item).DataField == vsFieldName) == false)
// primaryKeyBuilder.AppendItem(vsFieldName, obj.VersionStartTime);
return(primaryKeyBuilder);
}
private static string GetQueryTableName(ORMappingItemCollection mappings, DateTime timePoint)
{
string result = mappings.GetQueryTableName();
if (timePoint != DateTime.MinValue)
{
result = mappings.TableName;
}
return(result);
}
/// <summary>
/// 准备Where的子句，填写了VersionStartTime。在插入操作时，VST应该是MinValue。否则应该是最后一条记录的时间
/// </summary>
/// <param name="obj"></param>
/// <param name="mapping"></param>
/// <param name="ignoreProperties">忽略的属性</param>
/// <returns></returns>
public virtual WhereSqlClauseBuilder PrepareWhereSqlBuilder(T obj, ORMappingItemCollection mapping, string[] ignoreProperties)
{
obj.NullCheck("obj");
mapping.NullCheck("mapping");
WhereSqlClauseBuilder primaryKeyBuilder = ORMapping.GetWhereSqlClauseBuilderByPrimaryKey(obj);
ModifyTimeFieldsInWhereBuilder(obj, mapping, primaryKeyBuilder);
return(primaryKeyBuilder);
}
protected override string GetInsertSql(WfDelegation data, ORMappingItemCollection mappings, Dictionary <string, object> context, string[] ignoreProperties)
{
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(data, mappings, "ApplicationName", "ProgramName");
builder.AppendItem("APPLICATION_NAME", data.ApplicationName.IsNotEmpty() ? data.ApplicationName : string.Empty);
builder.AppendItem("PROGRAM_NAME", data.ProgramName.IsNotEmpty() ? data.ProgramName : string.Empty);
return(string.Format("INSERT INTO {0} {1}",
mappings.TableName,
builder.ToSqlString(TSqlBuilder.Instance)));
}
protected override string GetTableName(VersionedSchemaObjectBase obj, ORMappingItemCollection mapping)
{
string result = this._TableName;
if (result.IsNullOrEmpty())
{
result = obj.Schema.SnapshotTable;
}
return(result);
}
private static void eventContainer_SetUserTasksAccomplished(UserTaskCollection tasks, Dictionary <object, object> context)
{
ExceptionHelper.FalseThrow <ArgumentNullException>(tasks != null, "tasks");
//需要删除的待办的ID
InSqlClauseBuilder deleteTaskIDs = new InSqlClauseBuilder();
StringBuilder strB = new StringBuilder();
ORMappingItemCollection mapping = ORMapping.GetMappingInfo <UserTask>().Clone();
string userTaskTableName = mapping.TableName;
mapping.TableName = "WF.USER_ACCOMPLISHED_TASK";
foreach (UserTask task in tasks)
{
UserTask clonedUserTask = GetClonedAccomplishedUserTask(task);
if (strB.Length > 0)
{
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
}
WhereSqlClauseBuilder builder = GetDeleteAccomplishedUserTaskWhereBuilder(task);
//删除已办
strB.AppendFormat("DELETE {0} WHERE {1}",
mapping.TableName,
builder.ToSqlString(TSqlBuilder.Instance));
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
strB.Append(GetUserTaskInsertSql(clonedUserTask, mapping, "Category", "TopFlag"));
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
deleteTaskIDs.AppendItem(task.TaskID);
}
if (strB.Length > 0 && deleteTaskIDs.IsEmpty == false)
{
//删除待办
strB.AppendFormat("DELETE {0} WHERE TASK_GUID {1}",
userTaskTableName,
deleteTaskIDs.ToSqlStringWithInOperator(TSqlBuilder.Instance));
}
if (strB.Length > 0)
{
DbHelper.RunSqlWithTransaction(strB.ToString(), GetConnectionName());
}
}
/// <summary>
/// 生成删除数据的SQL（时间封口）
/// </summary>
/// <param name="obj"></param>
/// <param name="mapping"></param>
/// <param name="getDeleteSql"></param>
/// <param name="addCurrentTimeVar"></param>
/// <param name="ignoreProperties"></param>
/// <returns></returns>
public string ToDeleteSql(T obj, ORMappingItemCollection mapping, Func <string> getDeleteSql, bool addCurrentTimeVar = true, params string[] ignoreProperties)
{
obj.NullCheck("obj");
mapping.NullCheck("mapping");
getDeleteSql.NullCheck("getDeleteSql");
return(VersionStrategyUpdateSqlHelper.ConstructUpdateSql(null, (strB, context) =>
{
strB.Append(getDeleteSql());
},
addCurrentTimeVar));
}
protected virtual int InnerUpdate(T data, Dictionary <string, object> context)
{
ORMappingItemCollection mappings = GetMappingInfo(context);
string sql = this.GetUpdateSql(data, mappings, context);
int result = 0;
DbHelper.RunSql(db => result = db.ExecuteNonQuery(CommandType.Text, sql), this.GetConnectionName());
return(result);
}
private static void DefaultDataRowToObject <T, TCollection>(TCollection dataCollection, DataRow row)
where T : new()
where TCollection : EditableDataObjectCollectionBase <T>, new()
{
T data = new T();
ORMappingItemCollection mapping = ORMapping.GetMappingInfo <T>();
ORMapping.DataRowToObject(row, mapping, data);
dataCollection.Add(data);
}
/// <summary>
/// 生成Update和Insert混合的子句。先Update，然后通过RowCount判断是需要Insert。其中Update子句可以自己构造
/// </summary>
/// <param name="obj"></param>
/// <param name="mapping"></param>
/// <param name="getUpdateSql"></param>
/// <param name="getInsertSql"></param>
/// <param name="addCurrentTimeVar">是否添加@currentTime变量</param>
/// <param name="ignoreProperties">需要忽略的属性</param>
/// <returns></returns>
public string ToUpdateSql(T obj, ORMappingItemCollection mapping, Func <string> getUpdateSql, Func <string> getInsertSql, bool addCurrentTimeVar = true, params string[] ignoreProperties)
{
obj.NullCheck("obj");
mapping.NullCheck("mapping");
getUpdateSql.NullCheck("getUpdateSql");
getInsertSql.NullCheck("getInsertSql");
return(VersionStrategyUpdateSqlHelper.ConstructUpdateSql(null, (strB, context) =>
{
this.PrepareSingleObjectUpdateSql(strB, obj, mapping, true, getUpdateSql, getInsertSql, ignoreProperties);
},
addCurrentTimeVar));
}
protected override string GetUpdateSql(WeChatFriend data, ORMappingItemCollection mappings, Dictionary <string, object> context)
{
UpdateSqlClauseBuilder uBuilder = ORMapping.GetUpdateSqlClauseBuilder(data, mappings, "OpenID");
WhereSqlClauseBuilder wBuilder = ORMapping.GetWhereSqlClauseBuilderByPrimaryKey(data, mappings);
string sql = string.Format("UPDATE {0} SET {1} WHERE {2}",
mappings.TableName,
uBuilder.ToSqlString(TSqlBuilder.Instance),
wBuilder.ToSqlString(TSqlBuilder.Instance));
return(sql);
}
protected override string GetInsertSql(AMSEvent data, ORMappingItemCollection mappings, Dictionary <string, object> context)
{
StringBuilder strB = new StringBuilder();
strB.Append(base.GetInsertSql(data, mappings, context));
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
AMSEventChannel eventChannel = AMSEventChannel.FromAMSEvent(data);
strB.Append(ORMapping.GetInsertSql(eventChannel, TSqlBuilder.Instance));
return(strB.ToString());
}
public int AddOperationTasksLogs(UserOperationTasksLogCollection userTaskslogs)
{
StringBuilder sqlStrB = new StringBuilder();
ORMappingItemCollection mappings = ORMapping.GetMappingInfo <UserOperationTasksLog>();
foreach (UserOperationTasksLog data in userTaskslogs)
{
sqlStrB.AppendFormat("{0} ; \n", ORMapping.GetInsertSql(data, mappings, TSqlBuilder.Instance));
}
return(DbHelper.RunSql(sqlStrB.ToString(), this.GetConnectionName()));
}
public override void Delete(WfRelativeProcess data)
{
ORMappingItemCollection mapping = ORMapping.GetMappingInfo <WfRelativeProcess>();
WhereSqlClauseBuilder wBuilder = new WhereSqlClauseBuilder();
wBuilder.AppendItem("PROCESS_ID", data.ProcessID);
wBuilder.AppendTenantCodeSqlClause(typeof(WfProcessCurrentActivity));
string sql = string.Format("DELETE {0} WHERE {1}", mapping.TableName, wBuilder.ToSqlString(TSqlBuilder.Instance));
DbHelper.RunSql(sql, GetConnectionName());
}
public QueryCondition GetQueryConditionByTime(Action <ConnectiveSqlClauseCollection> whereAction, DateTime dateTime)
{
ConnectiveSqlClauseCollection connectiveSqlClauses = new ConnectiveSqlClauseCollection();
ORMappingItemCollection mappings = ORMapping.GetMappingInfo <T>();
connectiveSqlClauses.GetVersionTimeCondion <QueryCondtionEntityBase>(dateTime, mappings.TableName, whereAction);
QueryCondition qc = new QueryCondition
{
FromClause = mappings.TableName,
WhereClause = connectiveSqlClauses.ToSqlString(TSqlBuilder.Instance)
};
return(qc);
}
/// <summary>
/// 更新某一状态下所有时间的完成时间
/// </summary>
/// <param name="endTime"></param>
/// <param name="state"></param>
/// <returns></returns>
public int UpdateEndTime(DateTime endTime, AMSEventState state)
{
SqlClauseBuilderBase wBuilder = new WhereSqlClauseBuilder().AppendItem("State", state.ToString());
SqlClauseBuilderBase uBuilder = new UpdateSqlClauseBuilder().AppendItem("EndTime", endTime);
Dictionary <string, object> context = new Dictionary <string, object>();
ORMappingItemCollection mappings = this.GetMappingInfo(context);
string sql = string.Format("UPDATE {0} SET {1} WHERE {2}",
mappings.TableName, uBuilder.ToSqlString(TSqlBuilder.Instance), wBuilder.ToSqlString(TSqlBuilder.Instance));
return(DbHelper.RunSql(sql, this.GetConnectionName()));
}
private void InnerInsertWithStream(MaterialContent data, Stream stream, Dictionary <string, object> context)
{
ORMappingItemCollection mappings = GetMappingInfo(context);
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(data, "ContentData");
builder.AppendItem("CONTENT_DATA", stream);
string sql = string.Format("INSERT INTO {0}{1} ",
mappings.TableName,
builder.ToSqlString(TSqlBuilder.Instance));
DbHelper.RunSql(sql, GetConnectionName());
}
/// <summary>
/// 创建逻辑删除语句
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="data">传入的对象</param>
/// <returns>逻辑删除语句</returns>
public static string GetLogicDeleteSql <T>(T data)
{
ORMappingItemCollection mappings = ORMapping.GetMappingInfo <T>();
//创建Where子句表达式
WhereSqlClauseBuilder builder = ORMapping.GetWhereSqlClauseBuilderByPrimaryKey(data, mappings);
ExceptionHelper.FalseThrow(builder.Count > 0, "必须为对象{0}指定关键字", typeof(T));
return(String.Format(" UPDATE {0} SET ValidStatus=0 WHERE {1} {2}",
mappings.TableName,
builder.ToSqlString(TSqlBuilder.Instance),
TSqlBuilder.Instance.DBStatementSeperator));
}
/// <summary>
/// 获取
/// </summary>
/// <param name="coll"></param>
/// <param name="property"></param>
/// <param name="alsName">别名</param>
/// <returns></returns>
public static string GetDataField(this ORMappingItemCollection coll, string property, string alsName = null)
{
var attr = coll.Find(m => m.PropertyName == property);
if (attr == null)
{
return(string.Empty);
}
if (string.IsNullOrWhiteSpace(alsName))
{
alsName = coll.TableName;
}
return(string.Format("{0}.{1}", alsName, attr.DataFieldName));
}
private static string GetUserTaskInsertSql(UserTask task, ORMappingItemCollection mapping, params string[] ignoreProperties)
{
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(task, mapping, ignoreProperties);
builder.AppendTenantCode();
return string.Format("INSERT INTO {0} {1}", mapping.TableName, builder.ToSqlString(TSqlBuilder.Instance));
}
private static ORMappingItemCollection LoadMappingFromResource(string path, Type type)
{
ORMappingItemCollection mapping = new ORMappingItemCollection();
Stream stream = null;
try
{
using (XmlReader reader = ResourceHelper.LoadXmlReaderFromResource(Assembly.GetExecutingAssembly(),
path, out stream))
{
mapping.ReadFromXml(reader, type);
}
}
finally
{
if (stream != null)
stream.Dispose();
}
return mapping;
}
private static ORMappingItem GetMappingFromPropertyName(string propertyName, ORMappingItemCollection mappings)
{
ORMappingItem result = null;
foreach (ORMappingItem item in mappings)
{
if (item.PropertyName == propertyName)
{
result = item;
break;
}
}
return result;
}
private static void FillOneUpdateSql(StringBuilder strB, ItemAndContainerSnapshot obj, ORMappingItemCollection mapping)
{
if (obj.VersionStartTime != DateTime.MinValue)
{
WhereSqlClauseBuilder primaryKeyBuilder = ORMapping.GetWhereSqlClauseBuilderByPrimaryKey(obj, mapping);
strB.AppendFormat("UPDATE {0} SET VersionEndTime = @currentTime WHERE {1} AND VersionStartTime = {2}",
mapping.TableName,
primaryKeyBuilder.ToSqlString(TSqlBuilder.Instance),
TSqlBuilder.Instance.FormatDateTime(obj.VersionStartTime));
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
strB.AppendFormat("IF @@ROWCOUNT > 0\n");
strB.AppendFormat("BEGIN\n");
strB.AppendFormat("\t{0}\n", PrepareInsertSql(obj, mapping));
strB.AppendFormat("END\n");
strB.AppendFormat("ELSE\n");
strB.AppendFormat("\tRAISERROR ({0}, 16, 1)",
TSqlBuilder.Instance.CheckUnicodeQuotationMark(string.Format("对象\"{0}\"和\"{1}\"的版本不是最新的，不能更新",
obj.ItemID, obj.ContainerID)));
}
else
{
strB.AppendFormat(PrepareInsertSql(obj, mapping));
}
}
private static string PrepareInsertSql(ItemAndContainerSnapshot obj, ORMappingItemCollection mapping)
{
InsertSqlClauseBuilder builder = ORMapping.GetInsertSqlClauseBuilder(obj);
builder.AppendItem("VersionStartTime", "@currentTime", "=", true);
builder.AppendItem("VersionEndTime", SCConnectionDefine.MaxVersionEndTime);
return string.Format("INSERT INTO {0}{1}", mapping.TableName, builder.ToSqlString(TSqlBuilder.Instance));
}
