public void AddQueue(string sql, SugarParameter parsmeter)
{
this.Context.AddQueue(sql, parsmeter);
}
private void PreToSql()
{
UpdateBuilder.PrimaryKeys = GetPrimaryKeys();
if (this.IsWhereColumns)
{
foreach (var pkName in UpdateBuilder.PrimaryKeys)
{
if (WhereColumnList != null && WhereColumnList.Count() > 0)
{
continue;
}
var isContains = this.UpdateBuilder.DbColumnInfoList.Select(it => it.DbColumnName.ToLower()).Contains(pkName.ToLower());
Check.Exception(isContains == false, "Use UpdateColumns().WhereColumn() ,UpdateColumns need {0}", pkName);
}
}
#region IgnoreColumns
if (this.Context.IgnoreColumns != null && this.Context.IgnoreColumns.Any())
{
var currentIgnoreColumns = this.Context.IgnoreColumns.Where(it => it.EntityName == this.EntityInfo.EntityName).ToList();
this.UpdateBuilder.DbColumnInfoList = this.UpdateBuilder.DbColumnInfoList.Where(it =>
{
return(!currentIgnoreColumns.Any(i => it.PropertyName.Equals(i.PropertyName, StringComparison.CurrentCulture)));
}).ToList();
}
#endregion
if (this.IsSingle)
{
foreach (var item in this.UpdateBuilder.DbColumnInfoList)
{
if (this.UpdateBuilder.Parameters == null)
{
this.UpdateBuilder.Parameters = new List <SugarParameter>();
}
if (this.UpdateBuilder.SetValues.Any(it => this.SqlBuilder.GetNoTranslationColumnName(it.Key) == item.PropertyName))
{
continue;
}
var parameter = new SugarParameter(this.SqlBuilder.SqlParameterKeyWord + item.DbColumnName, item.Value, item.PropertyType);
if (item.IsJson)
{
parameter.IsJson = true;
}
if (item.IsArray)
{
parameter.IsArray = true;
}
this.UpdateBuilder.Parameters.Add(parameter);
}
}
#region Identities
List <string> identities = GetIdentityKeys();
if (identities != null && identities.Any())
{
this.UpdateBuilder.DbColumnInfoList.ForEach(it =>
{
var mappingInfo = identities.SingleOrDefault(i => it.DbColumnName.Equals(i, StringComparison.CurrentCultureIgnoreCase));
if (mappingInfo != null && mappingInfo.Any())
{
it.IsIdentity = true;
}
});
}
#endregion
List <string> primaryKey = GetPrimaryKeys();
if (primaryKey != null && primaryKey.Count > 0)
{
this.UpdateBuilder.DbColumnInfoList.ForEach(it =>
{
var mappingInfo = primaryKey.SingleOrDefault(i => it.DbColumnName.Equals(i, StringComparison.CurrentCultureIgnoreCase));
if (mappingInfo != null && mappingInfo.Any())
{
it.IsPrimarykey = true;
}
});
}
if (this.UpdateBuilder.Parameters.HasValue() && this.UpdateBuilder.SetValues.IsValuable())
{
this.UpdateBuilder.Parameters.RemoveAll(it => this.UpdateBuilder.SetValues.Any(v => (SqlBuilder.SqlParameterKeyWord + SqlBuilder.GetNoTranslationColumnName(v.Key)) == it.ParameterName));
}
}
public IDeleteable <T> Where(string whereString, SugarParameter parameter)
{
DeleteBuilder.Parameters.Add(parameter);
return(this);
}
private void Update(MemberInitExpression expression, ExpressionParameter parameter)
{
int i = 0;
foreach (MemberBinding binding in expression.Bindings)
{
++i;
if (binding.BindingType != MemberBindingType.Assignment)
{
throw new NotSupportedException();
}
MemberAssignment memberAssignment = (MemberAssignment)binding;
var type = expression.Type;
var memberName = this.Context.GetDbColumnName(type.Name, memberAssignment.Member.Name);
var item = memberAssignment.Expression;
//Column IsJson Handler
if (memberAssignment.Member.CustomAttributes != null)
{
var customAttribute = memberAssignment.Member.GetCustomAttribute <SugarColumn>();
if (customAttribute?.IsJson ?? false)
{
var paramterValue = ExpressionTool.DynamicInvoke(item);
var parameterName = AppendParameter(new SerializeService().SerializeObject(paramterValue));
this.Context.Result.Append(base.Context.GetEqString(memberName, parameterName));
continue;
}
}
if ((item is MemberExpression) && ((MemberExpression)item).Expression == null)
{
var paramterValue = ExpressionTool.DynamicInvoke(item);
string parameterName = AppendParameter(paramterValue);
this.Context.Result.Append(base.Context.GetEqString(memberName, parameterName));
}
else if (IsNotMember(item))
{
if (base.Context.Result.IsLockCurrentParameter == false)
{
base.Context.Result.CurrentParameter = parameter;
base.Context.Result.IsLockCurrentParameter = true;
parameter.IsAppendTempDate();
base.Expression = item;
base.Expression = (item as UnaryExpression).Operand;
base.Start();
parameter.IsAppendResult();
var result = this.Context.DbMehtods.IIF(new MethodCallExpressionModel()
{
Args = new List <MethodCallExpressionArgs>()
{
new MethodCallExpressionArgs()
{
IsMember = true, MemberName = parameter.CommonTempData.ObjToString() + "=1"
},
new MethodCallExpressionArgs()
{
IsMember = true, MemberName = AppendParameter(0)
},
new MethodCallExpressionArgs()
{
IsMember = true, MemberName = AppendParameter(1)
}
}
});
parameter.Context.Result.Append(base.Context.GetEqString(memberName, result));
base.Context.Result.CurrentParameter = null;
}
}
else if (IsNotParameter(item))
{
try
{
parameter.Context.Result.Append(base.Context.GetEqString(memberName, AppendParameter(ExpressionTool.DynamicInvoke(item).ObjToBool())));
}
catch
{
throw new NotSupportedException(item.ToString());
}
}
else if (IsMethod(item))
{
if (item is UnaryExpression)
{
item = (item as UnaryExpression).Operand;
}
var callMethod = item as MethodCallExpression;
if (MethodTimeMapping.Any(it => it.Key == callMethod.Method.Name) || MethodMapping.Any(it => it.Key == callMethod.Method.Name) || IsExtMethod(callMethod.Method.Name) || IsSubMethod(callMethod) || callMethod.Method.DeclaringType.FullName.StartsWith(UtilConstants.AssemblyName + UtilConstants.Dot))
{
MethodCall(parameter, memberName, item);
}
else
{
var paramterValue = ExpressionTool.DynamicInvoke(item);
string parameterName = AppendParameter(paramterValue);
this.Context.Result.Append(base.Context.GetEqString(memberName, parameterName));
}
}
else if (IsConst(item) && IsConvert(item) && UtilMethods.IsNullable(item.Type) && UtilMethods.GetUnderType(item.Type) == UtilConstants.BoolType)
{
item = (item as UnaryExpression).Operand;
parameter.Context.Result.Append(base.Context.GetEqString(memberName, GetNewExpressionValue(item)));
}
else if (IsConst(item))
{
base.Expression = item;
base.Start();
string parameterName = this.Context.SqlParameterKeyWord + ExpressionConst.Const + this.Context.ParameterIndex;
parameter.Context.Result.Append(base.Context.GetEqString(memberName, parameterName));
var addItem = new SugarParameter(parameterName, parameter.CommonTempData);
var dataType = UtilMethods.GetUnderType(item.Type);
if (addItem.Value == null && dataType == UtilConstants.DateType)
{
addItem.DbType = System.Data.DbType.Date;
}
if (addItem.Value == null && dataType.IsIn(UtilConstants.FloatType, UtilConstants.IntType, UtilConstants.LongType, UtilConstants.DecType, UtilConstants.DobType))
{
addItem.DbType = System.Data.DbType.Int32;
}
if (addItem.Value == null && dataType == UtilConstants.BoolType)
{
addItem.DbType = System.Data.DbType.Boolean;
}
this.Context.Parameters.Add(addItem);
this.Context.ParameterIndex++;
}
else if (item is MemberExpression)
{
if (base.Context.Result.IsLockCurrentParameter == false)
{
base.Context.Result.CurrentParameter = parameter;
base.Context.Result.IsLockCurrentParameter = true;
parameter.IsAppendTempDate();
base.Expression = item;
base.Start();
parameter.IsAppendResult();
parameter.Context.Result.Append(base.Context.GetEqString(memberName, parameter.CommonTempData.ObjToString()));
base.Context.Result.CurrentParameter = null;
}
}
else if (item is BinaryExpression)
{
var result = GetNewExpressionValue(item);
if (result.HasValue())
{
result = result.Replace(",", UtilConstants.ReplaceCommaKey);
}
this.Context.Result.Append(base.Context.GetEqString(memberName, result));
}
else if (item is MemberInitExpression)
{
try
{
var value = ExpressionTool.DynamicInvoke(item);
var parameterName = AppendParameter(value);
parameter.Context.Result.Append(base.Context.GetEqString(memberName, parameterName));
}
catch (Exception ex)
{
throw new NotSupportedException("Not Supported " + item.ToString() + " " + ex.Message);
}
}
else if (item is NewExpression)
{
try
{
var value = ExpressionTool.DynamicInvoke(item);
var parameterName = AppendParameter(value);
parameter.Context.Result.Append(base.Context.GetEqString(memberName, parameterName));
}
catch (Exception ex)
{
throw new NotSupportedException("Not Supported " + item.ToString() + " " + ex.Message);
}
}
else if (item is ConditionalExpression)
{
var result = GetNewExpressionValue(item);
this.Context.Result.Append(base.Context.GetEqString(memberName, result));
}
}
}
