333
This commit is contained in:
454
FrameWork/SqlSugar/ExpressionsToSql/ResolveItems/BaseResolve.cs
Normal file
454
FrameWork/SqlSugar/ExpressionsToSql/ResolveItems/BaseResolve.cs
Normal file
@@ -0,0 +1,454 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Reflection;
|
||||
using System.Text;
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class BaseResolve
|
||||
{
|
||||
protected Expression Expression { get; set; }
|
||||
protected Expression ExactExpression { get; set; }
|
||||
public ExpressionContext Context { get; set; }
|
||||
public bool? IsLeft { get; set; }
|
||||
public int ContentIndex { get { return this.Context.Index; } }
|
||||
public int Index { get; set; }
|
||||
public ExpressionParameter BaseParameter { get; set; }
|
||||
|
||||
private BaseResolve()
|
||||
{
|
||||
|
||||
}
|
||||
public BaseResolve(ExpressionParameter parameter)
|
||||
{
|
||||
this.Expression = parameter.CurrentExpression;
|
||||
this.Context = parameter.Context;
|
||||
this.BaseParameter = parameter;
|
||||
}
|
||||
|
||||
public BaseResolve Start()
|
||||
{
|
||||
Context.Index++;
|
||||
Expression expression = this.Expression;
|
||||
ExpressionParameter parameter = new ExpressionParameter()
|
||||
{
|
||||
Context = this.Context,
|
||||
CurrentExpression = expression,
|
||||
IsLeft = this.IsLeft,
|
||||
BaseExpression = this.ExactExpression,
|
||||
BaseParameter = this.BaseParameter,
|
||||
Index = Context.Index
|
||||
};
|
||||
if (expression is LambdaExpression)
|
||||
{
|
||||
return new LambdaExpressionResolve(parameter);
|
||||
}
|
||||
else if (expression is BinaryExpression)
|
||||
{
|
||||
return new BinaryExpressionResolve(parameter);
|
||||
}
|
||||
else if (expression is BlockExpression)
|
||||
{
|
||||
Check.ThrowNotSupportedException("BlockExpression");
|
||||
}
|
||||
else if (expression is ConditionalExpression)
|
||||
{
|
||||
return new ConditionalExpressionResolve(parameter);
|
||||
}
|
||||
else if (expression is MethodCallExpression)
|
||||
{
|
||||
return new MethodCallExpressionResolve(parameter);
|
||||
}
|
||||
else if (expression is MemberExpression && ((MemberExpression)expression).Expression == null)
|
||||
{
|
||||
return new MemberNoExpressionResolve(parameter);
|
||||
}
|
||||
else if (expression is MemberExpression && ((MemberExpression)expression).Expression.NodeType == ExpressionType.Constant)
|
||||
{
|
||||
return new MemberConstExpressionResolve(parameter);
|
||||
}
|
||||
else if (expression is MemberExpression && ((MemberExpression)expression).Expression.NodeType == ExpressionType.New)
|
||||
{
|
||||
return new MemberNewExpressionResolve(parameter);
|
||||
}
|
||||
else if (expression is ConstantExpression)
|
||||
{
|
||||
return new ConstantExpressionResolve(parameter);
|
||||
}
|
||||
else if (expression is MemberExpression)
|
||||
{
|
||||
return new MemberExpressionResolve(parameter);
|
||||
}
|
||||
else if (expression is UnaryExpression)
|
||||
{
|
||||
return new UnaryExpressionResolve(parameter);
|
||||
}
|
||||
else if (expression is MemberInitExpression)
|
||||
{
|
||||
return new MemberInitExpressionResolve(parameter);
|
||||
}
|
||||
else if (expression is NewExpression)
|
||||
{
|
||||
return new NewExpressionResolve(parameter);
|
||||
}
|
||||
else if (expression is NewArrayExpression)
|
||||
{
|
||||
return new NewArrayExpessionResolve(parameter);
|
||||
}
|
||||
else if (expression is ParameterExpression)
|
||||
{
|
||||
return new TypeParameterExpressionReolve(parameter);
|
||||
}
|
||||
else if (expression != null && expression.NodeType.IsIn(ExpressionType.NewArrayBounds))
|
||||
{
|
||||
Check.ThrowNotSupportedException("ExpressionType.NewArrayBounds");
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
protected void AppendMember(ExpressionParameter parameter, bool? isLeft, object appendValue)
|
||||
{
|
||||
|
||||
Context.ParameterIndex++;
|
||||
if (isLeft == true)
|
||||
{
|
||||
appendValue += ExpressionConst.ExpressionReplace + parameter.BaseParameter.Index;
|
||||
}
|
||||
if (this.Context.Result.Contains(ExpressionConst.FormatSymbol))
|
||||
{
|
||||
this.Context.Result.Replace(ExpressionConst.FormatSymbol, appendValue.ObjToString());
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Context.Result.Append(appendValue);
|
||||
}
|
||||
}
|
||||
protected void AppendValue(ExpressionParameter parameter, bool? isLeft, object value)
|
||||
{
|
||||
if (parameter.BaseExpression is BinaryExpression || parameter.BaseExpression == null)
|
||||
{
|
||||
var oppoSiteExpression = isLeft == true ? parameter.BaseParameter.RightExpression : parameter.BaseParameter.LeftExpression;
|
||||
if (parameter.CurrentExpression is MethodCallExpression)
|
||||
{
|
||||
var appendValue = value;
|
||||
if (this.Context.Result.Contains(ExpressionConst.FormatSymbol))
|
||||
{
|
||||
this.Context.Result.Replace(ExpressionConst.FormatSymbol, appendValue.ObjToString());
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Context.Result.Append(appendValue);
|
||||
}
|
||||
this.AppendOpreator(parameter, isLeft);
|
||||
}
|
||||
else if (oppoSiteExpression is MemberExpression)
|
||||
{
|
||||
string appendValue = Context.SqlParameterKeyWord
|
||||
+ ((MemberExpression)oppoSiteExpression).Member.Name
|
||||
+ Context.ParameterIndex;
|
||||
//update by florent 2019-05-10
|
||||
if (value == null)
|
||||
{
|
||||
appendValue = "null";
|
||||
parameter.BaseParameter.ValueIsNull = true;
|
||||
}
|
||||
else if (value.ObjToString() != "NULL" && !parameter.ValueIsNull)
|
||||
{
|
||||
this.Context.Parameters.Add(new SugarParameter(appendValue, value));
|
||||
}
|
||||
else
|
||||
{
|
||||
appendValue = value.ObjToString();
|
||||
}
|
||||
Context.ParameterIndex++;
|
||||
appendValue = string.Format(" {0} ", appendValue);
|
||||
if (isLeft == true)
|
||||
{
|
||||
appendValue += ExpressionConst.ExpressionReplace + parameter.BaseParameter.Index;
|
||||
}
|
||||
if (this.Context.Result.Contains(ExpressionConst.FormatSymbol))
|
||||
{
|
||||
this.Context.Result.Replace(ExpressionConst.FormatSymbol, appendValue);
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Context.Result.Append(appendValue);
|
||||
}
|
||||
}
|
||||
else if ((oppoSiteExpression is UnaryExpression && (oppoSiteExpression as UnaryExpression).Operand is MemberExpression)) {
|
||||
string appendValue = Context.SqlParameterKeyWord
|
||||
+ ((MemberExpression)(oppoSiteExpression as UnaryExpression).Operand).Member.Name
|
||||
+ Context.ParameterIndex;
|
||||
if (value.ObjToString() != "NULL" && !parameter.ValueIsNull)
|
||||
{
|
||||
this.Context.Parameters.Add(new SugarParameter(appendValue, value));
|
||||
}
|
||||
else
|
||||
{
|
||||
appendValue = value.ObjToString();
|
||||
}
|
||||
Context.ParameterIndex++;
|
||||
appendValue = string.Format(" {0} ", appendValue);
|
||||
if (isLeft == true)
|
||||
{
|
||||
appendValue += ExpressionConst.ExpressionReplace + parameter.BaseParameter.Index;
|
||||
}
|
||||
if (this.Context.Result.Contains(ExpressionConst.FormatSymbol))
|
||||
{
|
||||
this.Context.Result.Replace(ExpressionConst.FormatSymbol, appendValue);
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Context.Result.Append(appendValue);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
var appendValue = this.Context.SqlParameterKeyWord + ExpressionConst.Const + Context.ParameterIndex;
|
||||
Context.ParameterIndex++;
|
||||
if (value != null && value.GetType().IsEnum())
|
||||
{
|
||||
value = Convert.ToInt64(value);
|
||||
}
|
||||
this.Context.Parameters.Add(new SugarParameter(appendValue, value));
|
||||
appendValue = string.Format(" {0} ", appendValue);
|
||||
if (isLeft == true)
|
||||
{
|
||||
appendValue += ExpressionConst.ExpressionReplace + parameter.BaseParameter.Index;
|
||||
}
|
||||
if (this.Context.Result.Contains(ExpressionConst.FormatSymbol))
|
||||
{
|
||||
this.Context.Result.Replace(ExpressionConst.FormatSymbol, appendValue);
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Context.Result.Append(appendValue);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
protected void AppendOpreator(ExpressionParameter parameter, bool? isLeft)
|
||||
{
|
||||
if (isLeft == true)
|
||||
{
|
||||
this.Context.Result.Append(" " + ExpressionConst.ExpressionReplace + parameter.BaseParameter.Index);
|
||||
}
|
||||
}
|
||||
protected string AppendParameter(object paramterValue)
|
||||
{
|
||||
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
|
||||
this.Context.ParameterIndex++; ;
|
||||
this.Context.Parameters.Add(new SugarParameter(parameterName, paramterValue));
|
||||
return parameterName;
|
||||
}
|
||||
protected void AppendNot(object Value)
|
||||
{
|
||||
var isAppend = !this.Context.Result.Contains(ExpressionConst.FormatSymbol);
|
||||
var lastCharIsSpace = this.Context.Result.LastCharIsSpace;
|
||||
if (isAppend)
|
||||
{
|
||||
this.Context.Result.Append(lastCharIsSpace?"NOT":" NOT");
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Context.Result.Replace(ExpressionConst.FormatSymbol, "NOT");
|
||||
}
|
||||
}
|
||||
|
||||
protected MethodCallExpressionArgs GetMethodCallArgs(ExpressionParameter parameter, Expression item)
|
||||
{
|
||||
var newContext = this.Context.GetCopyContext();
|
||||
newContext.MappingColumns = this.Context.MappingColumns;
|
||||
newContext.MappingTables = this.Context.MappingTables;
|
||||
newContext.IgnoreComumnList = this.Context.IgnoreComumnList;
|
||||
newContext.SqlFuncServices = this.Context.SqlFuncServices;
|
||||
newContext.Resolve(item, this.Context.IsJoin ? ResolveExpressType.WhereMultiple : ResolveExpressType.WhereSingle);
|
||||
this.Context.Index = newContext.Index;
|
||||
this.Context.ParameterIndex = newContext.ParameterIndex;
|
||||
if (newContext.Parameters.HasValue())
|
||||
{
|
||||
this.Context.Parameters.AddRange(newContext.Parameters);
|
||||
}
|
||||
if (newContext.SingleTableNameSubqueryShortName.HasValue())
|
||||
{
|
||||
this.Context.SingleTableNameSubqueryShortName = newContext.SingleTableNameSubqueryShortName;
|
||||
}
|
||||
var methodCallExpressionArgs = new MethodCallExpressionArgs()
|
||||
{
|
||||
IsMember = true,
|
||||
MemberName = newContext.Result.GetResultString()
|
||||
};
|
||||
return methodCallExpressionArgs;
|
||||
}
|
||||
|
||||
protected string GetNewExpressionValue(Expression item)
|
||||
{
|
||||
var newContext = this.Context.GetCopyContext();
|
||||
newContext.Resolve(item, this.Context.IsJoin ? ResolveExpressType.WhereMultiple : ResolveExpressType.WhereSingle);
|
||||
this.Context.Index = newContext.Index;
|
||||
this.Context.ParameterIndex = newContext.ParameterIndex;
|
||||
if (newContext.Parameters.HasValue())
|
||||
{
|
||||
this.Context.Parameters.AddRange(newContext.Parameters);
|
||||
}
|
||||
return newContext.Result.GetResultString();
|
||||
}
|
||||
|
||||
protected void ResolveNewExpressions(ExpressionParameter parameter, Expression item, string asName)
|
||||
{
|
||||
if (item is ConstantExpression)
|
||||
{
|
||||
this.Expression = item;
|
||||
this.Start();
|
||||
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
|
||||
this.Context.ParameterIndex++;
|
||||
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
|
||||
this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.CommonTempData));
|
||||
}
|
||||
else if ((item is MemberExpression) && ((MemberExpression)item).Expression == null)
|
||||
{
|
||||
var paramterValue = ExpressionTool.GetPropertyValue(item as MemberExpression);
|
||||
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
|
||||
this.Context.ParameterIndex++;
|
||||
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
|
||||
this.Context.Parameters.Add(new SugarParameter(parameterName, paramterValue));
|
||||
}
|
||||
else if ((item is MemberExpression) && ((MemberExpression)item).Expression.NodeType == ExpressionType.Constant)
|
||||
{
|
||||
this.Expression = item;
|
||||
this.Start();
|
||||
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
|
||||
this.Context.ParameterIndex++;
|
||||
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
|
||||
this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.CommonTempData));
|
||||
}
|
||||
else if (item is MemberExpression)
|
||||
{
|
||||
if (this.Context.Result.IsLockCurrentParameter == false)
|
||||
{
|
||||
this.Context.Result.CurrentParameter = parameter;
|
||||
this.Context.Result.IsLockCurrentParameter = true;
|
||||
parameter.IsAppendTempDate();
|
||||
this.Expression = item;
|
||||
this.Start();
|
||||
parameter.IsAppendResult();
|
||||
this.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
|
||||
this.Context.Result.CurrentParameter = null;
|
||||
}
|
||||
}
|
||||
else if (item is UnaryExpression && ((UnaryExpression)item).Operand is MemberExpression)
|
||||
{
|
||||
if (this.Context.Result.IsLockCurrentParameter == false)
|
||||
{
|
||||
var expression = ((UnaryExpression)item).Operand as MemberExpression;
|
||||
if (expression.Expression == null)
|
||||
{
|
||||
this.Context.Result.CurrentParameter = parameter;
|
||||
this.Context.Result.IsLockCurrentParameter = true;
|
||||
parameter.IsAppendTempDate();
|
||||
this.Expression = item;
|
||||
this.Start();
|
||||
parameter.IsAppendResult();
|
||||
this.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
|
||||
this.Context.Result.CurrentParameter = null;
|
||||
}
|
||||
else if (expression.Expression is ConstantExpression)
|
||||
{
|
||||
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
|
||||
this.Context.ParameterIndex++;
|
||||
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
|
||||
this.Context.Parameters.Add(new SugarParameter(parameterName, ExpressionTool.GetMemberValue(expression.Member, expression)));
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Context.Result.CurrentParameter = parameter;
|
||||
this.Context.Result.IsLockCurrentParameter = true;
|
||||
parameter.IsAppendTempDate();
|
||||
this.Expression = item;
|
||||
this.Start();
|
||||
parameter.IsAppendResult();
|
||||
this.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
|
||||
this.Context.Result.CurrentParameter = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (item is UnaryExpression && ((UnaryExpression)item).Operand is ConstantExpression)
|
||||
{
|
||||
if (this.Context.Result.IsLockCurrentParameter == false)
|
||||
{
|
||||
this.Expression = ((UnaryExpression)item).Operand;
|
||||
this.Start();
|
||||
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
|
||||
this.Context.ParameterIndex++;
|
||||
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
|
||||
this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.CommonTempData));
|
||||
}
|
||||
}
|
||||
else if (item is BinaryExpression)
|
||||
{
|
||||
if (this.Context.Result.IsLockCurrentParameter == false)
|
||||
{
|
||||
var newContext = this.Context.GetCopyContextWithMapping();
|
||||
var resolveExpressType = this.Context.IsSingle ? ResolveExpressType.WhereSingle : ResolveExpressType.WhereMultiple;
|
||||
newContext.Resolve(item, resolveExpressType);
|
||||
this.Context.Index = newContext.Index;
|
||||
this.Context.ParameterIndex = newContext.ParameterIndex;
|
||||
if (newContext.Parameters.HasValue())
|
||||
{
|
||||
this.Context.Parameters.AddRange(newContext.Parameters);
|
||||
}
|
||||
this.Context.Result.Append(this.Context.GetAsString(asName, newContext.Result.GetString()));
|
||||
this.Context.Result.CurrentParameter = null;
|
||||
}
|
||||
}
|
||||
else if (item.Type.IsClass())
|
||||
{
|
||||
this.Expression = item;
|
||||
this.Start();
|
||||
var shortName = parameter.CommonTempData;
|
||||
var listProperties = item.Type.GetProperties().Cast<PropertyInfo>().ToList();
|
||||
foreach (var property in listProperties)
|
||||
{
|
||||
var hasIgnore = this.Context.IgnoreComumnList != null && this.Context.IgnoreComumnList.Any(it => it.EntityName.Equals(item.Type.Name, StringComparison.CurrentCultureIgnoreCase) && it.PropertyName.Equals(property.Name, StringComparison.CurrentCultureIgnoreCase));
|
||||
if (hasIgnore)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if (property.PropertyType.IsClass())
|
||||
{
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
var propertyName = property.Name;
|
||||
var dbColumnName = propertyName;
|
||||
var mappingInfo = this.Context.MappingColumns.FirstOrDefault(it => it.EntityName == item.Type.Name && it.PropertyName.Equals(propertyName, StringComparison.CurrentCultureIgnoreCase));
|
||||
if (mappingInfo.HasValue()) {
|
||||
dbColumnName = mappingInfo.DbColumnName;
|
||||
}
|
||||
asName = this.Context.GetTranslationText(item.Type.Name + "." + propertyName);
|
||||
if (Context.IsJoin)
|
||||
{
|
||||
this.Context.Result.Append(Context.GetAsString(asName, dbColumnName, shortName.ObjToString()));
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Context.Result.Append(Context.GetAsString(asName, dbColumnName));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (item is MethodCallExpression|| item is UnaryExpression)
|
||||
{
|
||||
this.Expression = item;
|
||||
this.Start();
|
||||
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
|
||||
}
|
||||
else
|
||||
{
|
||||
Check.ThrowNotSupportedException(item.GetType().Name);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Text;
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class BinaryExpressionResolve : BaseResolve
|
||||
{
|
||||
public BinaryExpressionResolve(ExpressionParameter parameter) : base(parameter)
|
||||
{
|
||||
var expression = this.Expression as BinaryExpression;
|
||||
var operatorValue = parameter.OperatorValue = ExpressionTool.GetOperator(expression.NodeType);
|
||||
var isEqual = expression.NodeType == ExpressionType.Equal;
|
||||
var isComparisonOperator = ExpressionTool.IsComparisonOperator(expression);
|
||||
base.ExactExpression = expression;
|
||||
var leftExpression = expression.Left;
|
||||
var rightExpression = expression.Right;
|
||||
var leftIsBinary = leftExpression is BinaryExpression;
|
||||
var rightBinary = rightExpression is BinaryExpression;
|
||||
var lbrs = leftIsBinary && !rightBinary;
|
||||
var lsrb = !leftIsBinary && rightBinary;
|
||||
var lbrb = rightBinary && leftIsBinary;
|
||||
var lsbs = !leftIsBinary && !rightBinary;
|
||||
var isAppend = !base.Context.Result.Contains(ExpressionConst.FormatSymbol);
|
||||
if (isAppend)
|
||||
{
|
||||
base.Context.Result.Append(ExpressionConst.LeftParenthesis);
|
||||
base.Context.Result.Append(ExpressionConst.FormatSymbol);
|
||||
}
|
||||
else
|
||||
{
|
||||
base.Context.Result.Replace(ExpressionConst.FormatSymbol, ExpressionConst.LeftParenthesis + ExpressionConst.FormatSymbol);
|
||||
}
|
||||
parameter.LeftExpression = leftExpression;
|
||||
parameter.RightExpression = rightExpression;
|
||||
base.Expression = leftExpression;
|
||||
base.IsLeft = true;
|
||||
base.Start();
|
||||
base.IsLeft = false;
|
||||
base.Expression = rightExpression;
|
||||
base.Start();
|
||||
base.IsLeft = null;
|
||||
if (lsbs && parameter.ValueIsNull)
|
||||
{
|
||||
base.Context.Result.Replace(ExpressionConst.ExpressionReplace + parameter.Index, isEqual ? "IS" : "IS NOT");
|
||||
base.Context.Result.Replace(ExpressionConst.ExpressionReplace + (parameter.Index+1), isEqual ? "IS" : "IS NOT");
|
||||
}
|
||||
else
|
||||
{
|
||||
base.Context.Result.Replace(ExpressionConst.ExpressionReplace + parameter.Index, operatorValue);
|
||||
base.Context.Result.Replace(ExpressionConst.ExpressionReplace + (parameter.Index + 1), operatorValue);
|
||||
}
|
||||
base.Context.Result.Append(ExpressionConst.RightParenthesis);
|
||||
if (parameter.BaseExpression is BinaryExpression && parameter.IsLeft == true)
|
||||
{
|
||||
base.Context.Result.Append(" " + ExpressionConst.ExpressionReplace + parameter.BaseParameter.Index + " ");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Text;
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class BlockExpressionResolve:BaseResolve
|
||||
{
|
||||
public BlockExpressionResolve(ExpressionParameter parameter) : base(parameter)
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Text;
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class ConditionalExpressionResolve:BaseResolve
|
||||
{
|
||||
public ConditionalExpressionResolve(ExpressionParameter parameter) : base(parameter)
|
||||
{
|
||||
var express = base.Expression as ConditionalExpression;
|
||||
var isLeft = parameter.IsLeft;
|
||||
switch (base.Context.ResolveType)
|
||||
{
|
||||
case ResolveExpressType.None:
|
||||
case ResolveExpressType.WhereSingle:
|
||||
case ResolveExpressType.WhereMultiple:
|
||||
case ResolveExpressType.SelectSingle:
|
||||
case ResolveExpressType.SelectMultiple:
|
||||
case ResolveExpressType.FieldSingle:
|
||||
case ResolveExpressType.FieldMultiple:
|
||||
case ResolveExpressType.Join:
|
||||
case ResolveExpressType.ArraySingle:
|
||||
case ResolveExpressType.ArrayMultiple:
|
||||
case ResolveExpressType.Update:
|
||||
default:
|
||||
Check.Exception(true, "Does not support it.xx==value ? true:false , Use SqlFunc.IIF (it.xx==value,true,false)");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Reflection;
|
||||
using System.Text;
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class ConstantExpressionResolve : BaseResolve
|
||||
{
|
||||
public ConstantExpressionResolve(ExpressionParameter parameter) : base(parameter)
|
||||
{
|
||||
var expression = base.Expression as ConstantExpression;
|
||||
var isLeft = parameter.IsLeft;
|
||||
object value = ExpressionTool.GetValue(expression.Value);
|
||||
var baseParameter = parameter.BaseParameter;
|
||||
baseParameter.ChildExpression = expression;
|
||||
var isSetTempData = baseParameter.CommonTempData.HasValue() && baseParameter.CommonTempData.Equals(CommonTempDataType.Result);
|
||||
switch (parameter.Context.ResolveType)
|
||||
{
|
||||
case ResolveExpressType.SelectSingle:
|
||||
case ResolveExpressType.Update:
|
||||
case ResolveExpressType.SelectMultiple:
|
||||
baseParameter.CommonTempData = value;
|
||||
break;
|
||||
case ResolveExpressType.WhereSingle:
|
||||
case ResolveExpressType.WhereMultiple:
|
||||
if (isSetTempData)
|
||||
{
|
||||
baseParameter.CommonTempData = value;
|
||||
}
|
||||
else
|
||||
{
|
||||
var parentIsBinary = parameter.BaseParameter.CurrentExpression is BinaryExpression;
|
||||
var parentIsRoot = parameter.BaseParameter.CurrentExpression is LambdaExpression;
|
||||
var isBool = value != null && value.GetType() == UtilConstants.BoolType;
|
||||
if (parentIsRoot && isBool)
|
||||
{
|
||||
this.Context.Result.Append(value.ObjToBool() ? this.Context.DbMehtods.True() : this.Context.DbMehtods.False());
|
||||
break;
|
||||
}
|
||||
if (parentIsBinary && isBool)
|
||||
{
|
||||
var isLogicOperator =
|
||||
parameter.BaseExpression.NodeType == ExpressionType.And ||
|
||||
parameter.BaseExpression.NodeType == ExpressionType.AndAlso ||
|
||||
parameter.BaseExpression.NodeType == ExpressionType.Or ||
|
||||
parameter.BaseExpression.NodeType == ExpressionType.OrElse;
|
||||
if (isLogicOperator)
|
||||
{
|
||||
AppendMember(parameter, isLeft, (value.ObjToBool() ? this.Context.DbMehtods.True() : this.Context.DbMehtods.False()));
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (value == null && parentIsBinary)
|
||||
{
|
||||
parameter.BaseParameter.ValueIsNull = true;
|
||||
value = this.Context.DbMehtods.Null();
|
||||
}
|
||||
AppendValue(parameter, isLeft, value);
|
||||
}
|
||||
break;
|
||||
case ResolveExpressType.FieldSingle:
|
||||
case ResolveExpressType.FieldMultiple:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Text;
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class LambdaExpressionResolve : BaseResolve
|
||||
{
|
||||
public LambdaExpressionResolve(ExpressionParameter parameter) : base(parameter)
|
||||
{
|
||||
LambdaExpression lambda = base.Expression as LambdaExpression;
|
||||
var expression = lambda.Body;
|
||||
base.Expression = expression;
|
||||
if (parameter.Context.ResolveType.IsIn(ResolveExpressType.FieldMultiple, ResolveExpressType.FieldSingle)) {
|
||||
parameter.CommonTempData = CommonTempDataType.Append;
|
||||
}
|
||||
base.Start();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Reflection;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class MemberConstExpressionResolve : BaseResolve
|
||||
{
|
||||
public MemberConstExpressionResolve(ExpressionParameter parameter) : base(parameter)
|
||||
{
|
||||
var expression = base.Expression as MemberExpression;
|
||||
var isLeft = parameter.IsLeft;
|
||||
object value = ExpressionTool.GetMemberValue(expression.Member, expression);
|
||||
var baseParameter = parameter.BaseParameter;
|
||||
var isSetTempData = baseParameter.CommonTempData.HasValue() && baseParameter.CommonTempData.Equals(CommonTempDataType.Result);
|
||||
switch (parameter.Context.ResolveType)
|
||||
{
|
||||
case ResolveExpressType.Update:
|
||||
case ResolveExpressType.SelectSingle:
|
||||
case ResolveExpressType.SelectMultiple:
|
||||
if (value != null && value.GetType().IsEnum())
|
||||
{
|
||||
value = Convert.ToInt64(value);
|
||||
}
|
||||
parameter.BaseParameter.CommonTempData = value;
|
||||
break;
|
||||
case ResolveExpressType.WhereSingle:
|
||||
case ResolveExpressType.WhereMultiple:
|
||||
if (isSetTempData)
|
||||
{
|
||||
baseParameter.CommonTempData = value;
|
||||
}
|
||||
else
|
||||
{
|
||||
AppendValue(parameter, isLeft, value);
|
||||
}
|
||||
break;
|
||||
case ResolveExpressType.FieldSingle:
|
||||
case ResolveExpressType.FieldMultiple:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,380 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Text;
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class MemberExpressionResolve : BaseResolve
|
||||
{
|
||||
public ExpressionParameter Parameter { get; set; }
|
||||
public MemberExpressionResolve(ExpressionParameter parameter) : base(parameter)
|
||||
{
|
||||
ExpressionParameter baseParameter;
|
||||
MemberExpression expression;
|
||||
bool? isLeft;
|
||||
bool isSetTempData, isValue, isValueBool, isLength, isDateValue, isHasValue, isDateDate, isMemberValue, isSingle, fieldIsBool, isSelectField, isField;
|
||||
SettingParameters(parameter, out baseParameter, out expression, out isLeft, out isSetTempData, out isValue, out isValueBool, out isLength, out isDateValue, out isHasValue, out isDateDate, out isMemberValue, out isSingle, out fieldIsBool, out isSelectField, out isField);
|
||||
baseParameter.ChildExpression = expression;
|
||||
if (isLength)
|
||||
{
|
||||
ResolveLength(parameter, isLeft, expression);
|
||||
}
|
||||
else if (isHasValue)
|
||||
{
|
||||
ResolveHasValue(parameter, expression);
|
||||
}
|
||||
else if (isDateValue)
|
||||
{
|
||||
ResolveDateValue(parameter, isLeft, expression);
|
||||
}
|
||||
else if (isValueBool)
|
||||
{
|
||||
ResolveValueBool(parameter, baseParameter, expression, isLeft, isSingle);
|
||||
}
|
||||
else if (isValue)
|
||||
{
|
||||
ResolveValue(parameter, baseParameter, expression, isLeft, isSetTempData, isSingle);
|
||||
}
|
||||
else if (isDateDate)
|
||||
{
|
||||
ResolveDateDate(parameter, isLeft, expression);
|
||||
}
|
||||
else if (isMemberValue)
|
||||
{
|
||||
ResolveMemberValue(parameter, baseParameter, isLeft, isSetTempData, expression);
|
||||
}
|
||||
else if (fieldIsBool && !isField && !isSelectField)
|
||||
{
|
||||
ResolvefieldIsBool(parameter, baseParameter, isLeft, isSetTempData, expression, isSingle);
|
||||
}
|
||||
else
|
||||
{
|
||||
ResolveDefault(parameter, baseParameter, expression, isLeft, isSetTempData, isSingle);
|
||||
}
|
||||
}
|
||||
|
||||
#region Resolve default
|
||||
private void ResolveDefault(ExpressionParameter parameter, ExpressionParameter baseParameter, MemberExpression expression, bool? isLeft, bool isSetTempData, bool isSingle)
|
||||
{
|
||||
string fieldName = string.Empty;
|
||||
switch (parameter.Context.ResolveType)
|
||||
{
|
||||
case ResolveExpressType.SelectSingle:
|
||||
fieldName = GetSingleName(parameter, expression, isLeft);
|
||||
if (isSetTempData)
|
||||
baseParameter.CommonTempData = fieldName;
|
||||
else
|
||||
base.Context.Result.Append(fieldName);
|
||||
break;
|
||||
case ResolveExpressType.SelectMultiple:
|
||||
fieldName = GetMultipleName(parameter, expression, isLeft);
|
||||
if (isSetTempData)
|
||||
baseParameter.CommonTempData = fieldName;
|
||||
else
|
||||
base.Context.Result.Append(fieldName);
|
||||
break;
|
||||
case ResolveExpressType.WhereSingle:
|
||||
case ResolveExpressType.WhereMultiple:
|
||||
ResolveWhereLogic(parameter, baseParameter, expression, isLeft, isSetTempData, isSingle);
|
||||
break;
|
||||
case ResolveExpressType.FieldSingle:
|
||||
fieldName = GetSingleName(parameter, expression, isLeft);
|
||||
base.Context.Result.Append(fieldName);
|
||||
break;
|
||||
case ResolveExpressType.FieldMultiple:
|
||||
fieldName = GetMultipleName(parameter, expression, isLeft);
|
||||
base.Context.Result.Append(fieldName);
|
||||
break;
|
||||
case ResolveExpressType.ArrayMultiple:
|
||||
case ResolveExpressType.ArraySingle:
|
||||
fieldName = GetName(parameter, expression, isLeft, parameter.Context.ResolveType == ResolveExpressType.ArraySingle);
|
||||
base.Context.Result.Append(fieldName);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Resolve Where
|
||||
private void ResolveWhereLogic(ExpressionParameter parameter, ExpressionParameter baseParameter, MemberExpression expression, bool? isLeft, bool isSetTempData, bool isSingle)
|
||||
{
|
||||
string fieldName = string.Empty;
|
||||
if (isSetTempData)
|
||||
{
|
||||
if (ExpressionTool.IsConstExpression(expression))
|
||||
{
|
||||
var value = ExpressionTool.GetMemberValue(expression.Member, expression);
|
||||
baseParameter.CommonTempData = value;
|
||||
}
|
||||
else
|
||||
{
|
||||
fieldName = GetName(parameter, expression, null, isSingle);
|
||||
baseParameter.CommonTempData = fieldName;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (ExpressionTool.IsConstExpression(expression))
|
||||
{
|
||||
var value = ExpressionTool.GetMemberValue(expression.Member, expression);
|
||||
base.AppendValue(parameter, isLeft, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
fieldName = GetName(parameter, expression, isLeft, isSingle);
|
||||
AppendMember(parameter, isLeft, fieldName);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endregion
|
||||
|
||||
#region Resolve special member
|
||||
private MemberExpression ResolveValue(ExpressionParameter parameter, ExpressionParameter baseParameter, MemberExpression expression, bool? isLeft, bool isSetTempData, bool isSingle)
|
||||
{
|
||||
expression = expression.Expression as MemberExpression;
|
||||
baseParameter.ChildExpression = expression;
|
||||
ResolveWhereLogic(parameter, baseParameter, expression, isLeft, isSetTempData, isSingle);
|
||||
return expression;
|
||||
}
|
||||
|
||||
private void ResolveValueBool(ExpressionParameter parameter, ExpressionParameter baseParameter, MemberExpression expression, bool? isLeft, bool isSingle)
|
||||
{
|
||||
string fieldName = GetName(parameter, expression.Expression as MemberExpression, isLeft, isSingle);
|
||||
if (expression.Type == UtilConstants.BoolType && baseParameter.OperatorValue.IsNullOrEmpty())
|
||||
{
|
||||
fieldName = this.Context.DbMehtods.EqualTrue(fieldName);
|
||||
}
|
||||
AppendMember(parameter, isLeft, fieldName);
|
||||
}
|
||||
|
||||
private void ResolveMemberValue(ExpressionParameter parameter, ExpressionParameter baseParameter, bool? isLeft, bool isSetTempData, MemberExpression expression)
|
||||
{
|
||||
var value = ExpressionTool.GetMemberValue(expression.Member, expression);
|
||||
if (isSetTempData)
|
||||
{
|
||||
baseParameter.CommonTempData = value;
|
||||
}
|
||||
else
|
||||
{
|
||||
AppendValue(parameter, isLeft, value);
|
||||
}
|
||||
}
|
||||
private void ResolvefieldIsBool(ExpressionParameter parameter, ExpressionParameter baseParameter, bool? isLeft, bool isSetTempData, MemberExpression expression, bool isSingle)
|
||||
{
|
||||
var fieldName = GetName(parameter, expression, isLeft, isSingle);
|
||||
if (isSetTempData)
|
||||
{
|
||||
baseParameter.CommonTempData = fieldName;
|
||||
}
|
||||
else
|
||||
{
|
||||
fieldName = this.Context.DbMehtods.EqualTrue(fieldName.ObjToString());
|
||||
AppendMember(parameter, isLeft, fieldName);
|
||||
}
|
||||
}
|
||||
|
||||
private void ResolveDateDate(ExpressionParameter parameter, bool? isLeft, MemberExpression expression)
|
||||
{
|
||||
var name = expression.Member.Name;
|
||||
var oldCommonTempDate = parameter.CommonTempData;
|
||||
parameter.CommonTempData = CommonTempDataType.Result;
|
||||
this.Expression = expression.Expression;
|
||||
this.Start();
|
||||
var isConst = parameter.CommonTempData.GetType() == UtilConstants.DateType;
|
||||
if (isConst)
|
||||
{
|
||||
AppendValue(parameter, isLeft, parameter.CommonTempData.ObjToDate().Date);
|
||||
}
|
||||
else
|
||||
{
|
||||
var GetYear = new MethodCallExpressionModel()
|
||||
{
|
||||
Args = new List<MethodCallExpressionArgs>() {
|
||||
new MethodCallExpressionArgs() { IsMember=true, MemberName=parameter.CommonTempData, MemberValue=parameter.CommonTempData },
|
||||
new MethodCallExpressionArgs() { MemberName=DateType.Year, MemberValue=DateType.Year}
|
||||
}
|
||||
};
|
||||
AppendMember(parameter, isLeft, GetToDate(this.Context.DbMehtods.MergeString(
|
||||
this.GetDateValue(parameter.CommonTempData, DateType.Year),
|
||||
"'-'",
|
||||
this.GetDateValue(parameter.CommonTempData, DateType.Month),
|
||||
"'-'",
|
||||
this.GetDateValue(parameter.CommonTempData, DateType.Day))));
|
||||
}
|
||||
parameter.CommonTempData = oldCommonTempDate;
|
||||
}
|
||||
|
||||
private void ResolveDateValue(ExpressionParameter parameter, bool? isLeft, MemberExpression expression)
|
||||
{
|
||||
var name = expression.Member.Name;
|
||||
var oldCommonTempDate = parameter.CommonTempData;
|
||||
parameter.CommonTempData = CommonTempDataType.Result;
|
||||
this.Expression = expression.Expression;
|
||||
var isConst = this.Expression is ConstantExpression;
|
||||
if (this.Expression.Type == UtilConstants.DateType && this.Expression.ToString() == "DateTime.Now")
|
||||
{
|
||||
this.Expression = expression;
|
||||
var parameterName=base.AppendParameter(ExpressionTool.GetMemberValue(expression.Member, expression));
|
||||
base.AppendMember(parameter, isLeft, parameterName);
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Start();
|
||||
var result = this.Context.DbMehtods.DateValue(new MethodCallExpressionModel()
|
||||
{
|
||||
Args = new List<MethodCallExpressionArgs>() {
|
||||
new MethodCallExpressionArgs() { IsMember = !isConst, MemberName = parameter.CommonTempData, MemberValue = null },
|
||||
new MethodCallExpressionArgs() { IsMember = true, MemberName = name, MemberValue = name }
|
||||
}
|
||||
});
|
||||
base.AppendMember(parameter, isLeft, result);
|
||||
}
|
||||
parameter.CommonTempData = oldCommonTempDate;
|
||||
}
|
||||
|
||||
private void ResolveHasValue(ExpressionParameter parameter, MemberExpression expression)
|
||||
{
|
||||
parameter.CommonTempData = CommonTempDataType.Result;
|
||||
this.Expression = expression.Expression;
|
||||
this.Start();
|
||||
var methodParamter = new MethodCallExpressionArgs() { IsMember = true, MemberName = parameter.CommonTempData, MemberValue = null };
|
||||
var result = this.Context.DbMehtods.HasValue(new MethodCallExpressionModel()
|
||||
{
|
||||
Args = new List<MethodCallExpressionArgs>() {
|
||||
methodParamter
|
||||
}
|
||||
});
|
||||
this.Context.Result.Append(result);
|
||||
parameter.CommonTempData = null;
|
||||
}
|
||||
|
||||
private void ResolveLength(ExpressionParameter parameter, bool? isLeft, MemberExpression expression)
|
||||
{
|
||||
var oldCommonTempDate = parameter.CommonTempData;
|
||||
parameter.CommonTempData = CommonTempDataType.Result;
|
||||
this.Expression = expression.Expression;
|
||||
var isConst = this.Expression is ConstantExpression;
|
||||
this.Start();
|
||||
var methodParamter = new MethodCallExpressionArgs() { IsMember = !isConst, MemberName = parameter.CommonTempData, MemberValue = null };
|
||||
var result = this.Context.DbMehtods.Length(new MethodCallExpressionModel()
|
||||
{
|
||||
Args = new List<MethodCallExpressionArgs>() {
|
||||
methodParamter
|
||||
}
|
||||
});
|
||||
base.AppendMember(parameter, isLeft, result);
|
||||
parameter.CommonTempData = oldCommonTempDate;
|
||||
}
|
||||
#endregion
|
||||
|
||||
#region Helper
|
||||
private string AppendMember(ExpressionParameter parameter, bool? isLeft, string fieldName)
|
||||
{
|
||||
if (parameter.BaseExpression is BinaryExpression || (parameter.BaseParameter.CommonTempData != null && parameter.BaseParameter.CommonTempData.Equals(CommonTempDataType.Append)))
|
||||
{
|
||||
fieldName = string.Format(" {0} ", fieldName);
|
||||
if (isLeft == true)
|
||||
{
|
||||
fieldName += ExpressionConst.ExpressionReplace + parameter.BaseParameter.Index;
|
||||
}
|
||||
if (base.Context.Result.Contains(ExpressionConst.FormatSymbol))
|
||||
{
|
||||
base.Context.Result.Replace(ExpressionConst.FormatSymbol, fieldName);
|
||||
}
|
||||
else
|
||||
{
|
||||
base.Context.Result.Append(fieldName);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
base.Context.Result.Append(fieldName);
|
||||
}
|
||||
|
||||
return fieldName;
|
||||
}
|
||||
|
||||
private string GetName(ExpressionParameter parameter, MemberExpression expression, bool? isLeft, bool isSingle)
|
||||
{
|
||||
if (isSingle)
|
||||
{
|
||||
return GetSingleName(parameter, expression, IsLeft);
|
||||
}
|
||||
else
|
||||
{
|
||||
return GetMultipleName(parameter, expression, IsLeft);
|
||||
}
|
||||
}
|
||||
|
||||
private string GetMultipleName(ExpressionParameter parameter, MemberExpression expression, bool? isLeft)
|
||||
{
|
||||
string shortName = expression.Expression.ToString();
|
||||
string fieldName = expression.Member.Name;
|
||||
fieldName = this.Context.GetDbColumnName(expression.Expression.Type.Name, fieldName);
|
||||
fieldName = Context.GetTranslationColumnName(shortName + UtilConstants.Dot + fieldName);
|
||||
return fieldName;
|
||||
}
|
||||
|
||||
private string GetSingleName(ExpressionParameter parameter, MemberExpression expression, bool? isLeft)
|
||||
{
|
||||
string fieldName = expression.Member.Name;
|
||||
fieldName = this.Context.GetDbColumnName(expression.Expression.Type.Name, fieldName);
|
||||
fieldName = Context.GetTranslationColumnName(fieldName);
|
||||
return fieldName;
|
||||
}
|
||||
|
||||
private string GetDateValue(object value, DateType type)
|
||||
{
|
||||
var pars = new MethodCallExpressionModel()
|
||||
{
|
||||
Args = new List<MethodCallExpressionArgs>() {
|
||||
new MethodCallExpressionArgs() { IsMember=true, MemberName=value, MemberValue=value },
|
||||
new MethodCallExpressionArgs() { MemberName=type, MemberValue=type}
|
||||
}
|
||||
};
|
||||
return this.Context.DbMehtods.DateValue(pars);
|
||||
}
|
||||
|
||||
private string GetToDate(string value)
|
||||
{
|
||||
var pars = new MethodCallExpressionModel()
|
||||
{
|
||||
Args = new List<MethodCallExpressionArgs>() {
|
||||
new MethodCallExpressionArgs() { MemberName=value, MemberValue=value },
|
||||
}
|
||||
};
|
||||
return this.Context.DbMehtods.ToDate(pars);
|
||||
}
|
||||
|
||||
private void SettingParameters(ExpressionParameter parameter, out ExpressionParameter baseParameter, out MemberExpression expression, out bool? isLeft, out bool isSetTempData, out bool isValue, out bool isValueBool, out bool isLength, out bool isDateValue, out bool isHasValue, out bool isDateDate, out bool isMemberValue, out bool isSingle, out bool fieldIsBool, out bool isSelectField, out bool isField)
|
||||
{
|
||||
baseParameter = parameter.BaseParameter;
|
||||
expression = base.Expression as MemberExpression;
|
||||
var childExpression = expression.Expression as MemberExpression;
|
||||
var memberName = expression.Member.Name;
|
||||
var childIsMember = childExpression != null;
|
||||
var isRoot = parameter.BaseExpression == null;
|
||||
isLeft = parameter.IsLeft;
|
||||
isSetTempData = parameter.IsSetTempData;
|
||||
isValue = memberName == "Value" && expression.Member.DeclaringType.Name == "Nullable`1";
|
||||
var isBool = expression.Type == UtilConstants.BoolType;
|
||||
isValueBool = isValue && isBool && isRoot;
|
||||
isLength = memberName == "Length" && childIsMember && childExpression.Type == UtilConstants.StringType;
|
||||
isDateValue = memberName.IsIn(Enum.GetNames(typeof(DateType))) && (childIsMember && childExpression.Type == UtilConstants.DateType);
|
||||
var isLogicOperator = ExpressionTool.IsLogicOperator(baseParameter.OperatorValue) || baseParameter.OperatorValue.IsNullOrEmpty();
|
||||
isHasValue = isLogicOperator && memberName == "HasValue" && expression.Expression != null && expression.NodeType == ExpressionType.MemberAccess;
|
||||
isDateDate = memberName == "Date" && expression.Expression.Type == UtilConstants.DateType;
|
||||
isMemberValue = expression.Expression != null && expression.Expression.NodeType != ExpressionType.Parameter && !isValueBool;
|
||||
isSingle = parameter.Context.ResolveType.IsIn(ResolveExpressType.WhereSingle, ResolveExpressType.SelectSingle, ResolveExpressType.FieldSingle, ResolveExpressType.ArraySingle);
|
||||
fieldIsBool = isBool && isLogicOperator && (parameter.BaseParameter == null || !(parameter.BaseParameter.CurrentExpression is MemberInitExpression || parameter.BaseParameter.CurrentExpression is NewExpression));
|
||||
var isSelect = this.Context.ResolveType.IsIn(ResolveExpressType.SelectSingle, ResolveExpressType.SelectMultiple);
|
||||
isSelectField = isSelect && isRoot;
|
||||
isField = this.Context.ResolveType.IsIn(ResolveExpressType.FieldSingle, ResolveExpressType.FieldMultiple);
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,151 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Reflection;
|
||||
using System.Text;
|
||||
using System.Text.RegularExpressions;
|
||||
using System.Threading.Tasks;
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class MemberInitExpressionResolve : BaseResolve
|
||||
{
|
||||
public MemberInitExpressionResolve(ExpressionParameter parameter) : base(parameter)
|
||||
{
|
||||
var expression = base.Expression as MemberInitExpression;
|
||||
switch (parameter.Context.ResolveType)
|
||||
{
|
||||
case ResolveExpressType.WhereSingle:
|
||||
break;
|
||||
case ResolveExpressType.WhereMultiple:
|
||||
break;
|
||||
case ResolveExpressType.SelectSingle:
|
||||
Select(expression, parameter, true);
|
||||
break;
|
||||
case ResolveExpressType.SelectMultiple:
|
||||
Select(expression, parameter, false);
|
||||
break;
|
||||
case ResolveExpressType.FieldSingle:
|
||||
break;
|
||||
case ResolveExpressType.FieldMultiple:
|
||||
break;
|
||||
case ResolveExpressType.Update:
|
||||
Update(expression, parameter);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
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 = memberAssignment.Member.ReflectedType;
|
||||
var memberName = this.Context.GetDbColumnName(type.Name, memberAssignment.Member.Name);
|
||||
var item = memberAssignment.Expression;
|
||||
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 (IsMethod(item))
|
||||
{
|
||||
if (item is UnaryExpression)
|
||||
item = (item as UnaryExpression).Operand;
|
||||
MethodCall(parameter, memberName, 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));
|
||||
this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.CommonTempData));
|
||||
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);
|
||||
this.Context.Result.Append(base.Context.GetEqString(memberName, result));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static bool IsConst(Expression item)
|
||||
{
|
||||
return item is UnaryExpression || item.NodeType == ExpressionType.Constant || (item is MemberExpression) && ((MemberExpression)item).Expression.NodeType == ExpressionType.Constant;
|
||||
}
|
||||
|
||||
private static bool IsMethod(Expression item)
|
||||
{
|
||||
return item is MethodCallExpression || (item is UnaryExpression && (item as UnaryExpression).Operand is MethodCallExpression);
|
||||
}
|
||||
|
||||
private void MethodCall(ExpressionParameter parameter, string memberName, Expression item)
|
||||
{
|
||||
if (IsSubMethod(item as MethodCallExpression))
|
||||
{
|
||||
UtilMethods.GetOldValue(parameter.CommonTempData, () =>
|
||||
{
|
||||
parameter.CommonTempData = CommonTempDataType.Result;
|
||||
base.Expression = item;
|
||||
base.Start();
|
||||
var subSql = base.Context.GetEqString(memberName, parameter.CommonTempData.ObjToString());
|
||||
if (ResolveExpressType.Update == this.Context.ResolveType) {
|
||||
subSql = Regex.Replace(subSql,@" \[\w+?\]\.",this.Context.GetTranslationTableName(parameter.CurrentExpression.Type.Name,true) +".");
|
||||
}
|
||||
parameter.Context.Result.Append(subSql);
|
||||
});
|
||||
}
|
||||
else
|
||||
{
|
||||
base.Expression = item;
|
||||
base.Start();
|
||||
parameter.Context.Result.Append(base.Context.GetEqString(memberName, parameter.CommonTempData.ObjToString()));
|
||||
}
|
||||
}
|
||||
|
||||
private void Select(MemberInitExpression expression, ExpressionParameter parameter, bool isSingle)
|
||||
{
|
||||
foreach (MemberBinding binding in expression.Bindings)
|
||||
{
|
||||
if (binding.BindingType != MemberBindingType.Assignment)
|
||||
{
|
||||
throw new NotSupportedException();
|
||||
}
|
||||
MemberAssignment memberAssignment = (MemberAssignment)binding;
|
||||
var memberName = memberAssignment.Member.Name;
|
||||
var item = memberAssignment.Expression;
|
||||
ResolveNewExpressions(parameter, item, memberName);
|
||||
}
|
||||
}
|
||||
|
||||
private bool IsSubMethod(MethodCallExpression express)
|
||||
{
|
||||
return SubTools.SubItemsConst.Any(it =>express.Object != null && express.Object.Type.Name == "Subqueryable`1");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class MemberNewExpressionResolve : BaseResolve
|
||||
{
|
||||
public MemberNewExpressionResolve(ExpressionParameter parameter) : base(parameter)
|
||||
{
|
||||
var expression = base.Expression as MemberExpression;
|
||||
var isLeft = parameter.IsLeft;
|
||||
object value = null;
|
||||
value = ExpressionTool.DynamicInvoke(expression);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class MemberNoExpressionResolve : BaseResolve
|
||||
{
|
||||
public MemberNoExpressionResolve(ExpressionParameter parameter) : base(parameter)
|
||||
{
|
||||
var expression = base.Expression as MemberExpression;
|
||||
var isLeft = parameter.IsLeft;
|
||||
object value = null;
|
||||
var isField = expression.Member is System.Reflection.FieldInfo;
|
||||
var isProperty = expression.Member is System.Reflection.PropertyInfo;
|
||||
var baseParameter = parameter.BaseParameter;
|
||||
var isSetTempData = baseParameter.CommonTempData.HasValue() && baseParameter.CommonTempData.Equals(CommonTempDataType.Result);
|
||||
if (isField)
|
||||
{
|
||||
value = ExpressionTool.GetFiledValue(expression);
|
||||
}
|
||||
else if (isProperty)
|
||||
{
|
||||
value = ExpressionTool.GetPropertyValue(expression);
|
||||
}
|
||||
switch (base.Context.ResolveType)
|
||||
{
|
||||
case ResolveExpressType.WhereSingle:
|
||||
case ResolveExpressType.WhereMultiple:
|
||||
case ResolveExpressType.SelectSingle:
|
||||
case ResolveExpressType.SelectMultiple:
|
||||
case ResolveExpressType.Update:
|
||||
if (isSetTempData)
|
||||
{
|
||||
baseParameter.CommonTempData = value;
|
||||
}
|
||||
else
|
||||
{
|
||||
AppendValue(parameter, isLeft, value);
|
||||
}
|
||||
break;
|
||||
case ResolveExpressType.FieldSingle:
|
||||
break;
|
||||
case ResolveExpressType.FieldMultiple:
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,567 @@
|
||||
using SqlSugar;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Collections.ObjectModel;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Text;
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class MethodCallExpressionResolve : BaseResolve
|
||||
{
|
||||
public MethodCallExpressionResolve(ExpressionParameter parameter) : base(parameter)
|
||||
{
|
||||
var express = base.Expression as MethodCallExpression;
|
||||
var isLeft = parameter.IsLeft;
|
||||
string methodName = express.Method.Name;
|
||||
var isValidNativeMethod = IsValidNativeMethod(express, methodName);
|
||||
List<MethodCallExpressionArgs> appendArgs = null;
|
||||
if (MethodTimeMapping.ContainsKey(methodName))
|
||||
{
|
||||
appendArgs = new List<MethodCallExpressionArgs>();
|
||||
var dateType = MethodTimeMapping[methodName];
|
||||
string paramterName = this.Context.SqlParameterKeyWord + ExpressionConst.Const + this.Context.ParameterIndex;
|
||||
appendArgs.Add(new MethodCallExpressionArgs() { IsMember = false, MemberName = paramterName, MemberValue = dateType });
|
||||
this.Context.Parameters.Add(new SugarParameter(paramterName, dateType.ToString()));
|
||||
this.Context.ParameterIndex++;
|
||||
methodName = "DateAdd";
|
||||
isValidNativeMethod = true;
|
||||
}
|
||||
else if (methodName == "get_Item")
|
||||
{
|
||||
string paramterName = this.Context.SqlParameterKeyWord + ExpressionConst.Const + this.Context.ParameterIndex;
|
||||
this.Context.Parameters.Add(new SugarParameter(paramterName, ExpressionTool.DynamicInvoke(express)));
|
||||
this.Context.Result.Append(string.Format(" {0} ", paramterName));
|
||||
this.Context.ParameterIndex++;
|
||||
return;
|
||||
}
|
||||
else if (methodName == "NewGuid")
|
||||
{
|
||||
this.Context.Result.Append(this.Context.DbMehtods.GuidNew());
|
||||
return;
|
||||
}
|
||||
else if (IsSubMethod(express, methodName))
|
||||
{
|
||||
//Check.Exception(!(parameter.BaseExpression is BinaryExpression), "Current expressions are not supported");
|
||||
SubResolve subResolve = new SubResolve(express, this.Context, parameter.OppsiteExpression);
|
||||
var appendSql = subResolve.GetSql();
|
||||
if (this.Context.ResolveType.IsIn(ResolveExpressType.SelectMultiple, ResolveExpressType.SelectSingle)||(parameter.BaseParameter!=null&¶meter.BaseParameter.CommonTempData!=null&¶meter.BaseParameter.CommonTempData.Equals(CommonTempDataType.Result)))
|
||||
{
|
||||
parameter.BaseParameter.CommonTempData = appendSql;
|
||||
}
|
||||
else
|
||||
{
|
||||
base.AppendValue(parameter, isLeft, appendSql);
|
||||
}
|
||||
return;
|
||||
}
|
||||
else if (IsIfElse(express, methodName))
|
||||
{
|
||||
CaseWhenResolve caseResole = new CaseWhenResolve(express, this.Context, parameter.OppsiteExpression);
|
||||
var appendSql = caseResole.GetSql();
|
||||
if (this.Context.ResolveType.IsIn(ResolveExpressType.SelectMultiple, ResolveExpressType.SelectSingle))
|
||||
{
|
||||
parameter.BaseParameter.CommonTempData = appendSql;
|
||||
}
|
||||
else
|
||||
{
|
||||
base.AppendValue(parameter, isLeft, appendSql);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (IsContainsArray(express, methodName, isValidNativeMethod))
|
||||
{
|
||||
methodName = "ContainsArray";
|
||||
isValidNativeMethod = true;
|
||||
}
|
||||
if (isValidNativeMethod)
|
||||
{
|
||||
NativeExtensionMethod(parameter, express, isLeft, MethodMapping[methodName], appendArgs);
|
||||
}
|
||||
else
|
||||
{
|
||||
SqlFuncMethod(parameter, express, isLeft);
|
||||
}
|
||||
}
|
||||
|
||||
private bool IsValidNativeMethod(MethodCallExpression express, string methodName)
|
||||
{
|
||||
return MethodMapping.ContainsKey(methodName) && express.Method.DeclaringType.Namespace == ("System");
|
||||
}
|
||||
|
||||
private bool IsExtMethod(string methodName)
|
||||
{
|
||||
if (this.Context.SqlFuncServices == null) return false;
|
||||
return this.Context.SqlFuncServices.Select(it => it.UniqueMethodName).Contains(methodName);
|
||||
}
|
||||
|
||||
private bool IsIfElse(MethodCallExpression express, string methodName)
|
||||
{
|
||||
if (methodName == "End"&& express.Object.Type==typeof(CaseWhen))
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
private void SqlFuncMethod(ExpressionParameter parameter, MethodCallExpression express, bool? isLeft)
|
||||
{
|
||||
if (!CheckMethod(express))
|
||||
{
|
||||
CusMethod(parameter, express, isLeft);
|
||||
}
|
||||
else
|
||||
{
|
||||
var method = express.Method;
|
||||
string name = method.Name;
|
||||
var args = express.Arguments.Cast<Expression>().ToList();
|
||||
MethodCallExpressionModel model = new MethodCallExpressionModel();
|
||||
model.Args = new List<MethodCallExpressionArgs>();
|
||||
switch (this.Context.ResolveType)
|
||||
{
|
||||
case ResolveExpressType.WhereSingle:
|
||||
case ResolveExpressType.WhereMultiple:
|
||||
Check.Exception(name == "GetSelfAndAutoFill", "SqlFunc.GetSelfAndAutoFill can only be used in Select.");
|
||||
Where(parameter, isLeft, name, args, model);
|
||||
break;
|
||||
case ResolveExpressType.SelectSingle:
|
||||
case ResolveExpressType.SelectMultiple:
|
||||
case ResolveExpressType.Update:
|
||||
Select(parameter, isLeft, name, args, model);
|
||||
break;
|
||||
case ResolveExpressType.FieldSingle:
|
||||
case ResolveExpressType.FieldMultiple:
|
||||
Field(parameter, isLeft, name, args, model);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void CusMethod(ExpressionParameter parameter, MethodCallExpression express, bool? isLeft)
|
||||
{
|
||||
try
|
||||
{
|
||||
var constValue = ExpressionTool.DynamicInvoke(express);
|
||||
parameter.BaseParameter.CommonTempData = constValue;
|
||||
var parameterName = base.AppendParameter(constValue);
|
||||
if (parameter.BaseParameter.CommonTempData != null && parameter.BaseParameter.CommonTempData.Equals(CommonTempDataType.Result))
|
||||
{
|
||||
this.Context.Result.Append(parameterName);
|
||||
}
|
||||
else
|
||||
{
|
||||
base.AppendValue(parameter, isLeft, parameterName);
|
||||
}
|
||||
}
|
||||
catch
|
||||
{
|
||||
Check.Exception(true, string.Format(ErrorMessage.MethodError, express.Method.Name));
|
||||
}
|
||||
}
|
||||
|
||||
private void NativeExtensionMethod(ExpressionParameter parameter, MethodCallExpression express, bool? isLeft, string name, List<MethodCallExpressionArgs> appendArgs = null)
|
||||
{
|
||||
var method = express.Method;
|
||||
var args = express.Arguments.Cast<Expression>().ToList();
|
||||
MethodCallExpressionModel model = new MethodCallExpressionModel();
|
||||
model.Args = new List<MethodCallExpressionArgs>();
|
||||
switch (this.Context.ResolveType)
|
||||
{
|
||||
case ResolveExpressType.WhereSingle:
|
||||
case ResolveExpressType.WhereMultiple:
|
||||
if (express.Object != null)
|
||||
args.Insert(0, express.Object);
|
||||
Where(parameter, isLeft, name, args, model, appendArgs);
|
||||
break;
|
||||
case ResolveExpressType.SelectSingle:
|
||||
case ResolveExpressType.SelectMultiple:
|
||||
case ResolveExpressType.Update:
|
||||
if (express.Object != null)
|
||||
args.Insert(0, express.Object);
|
||||
Select(parameter, isLeft, name, args, model, appendArgs);
|
||||
break;
|
||||
case ResolveExpressType.FieldSingle:
|
||||
case ResolveExpressType.FieldMultiple:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private void Field(ExpressionParameter parameter, bool? isLeft, string name, IEnumerable<Expression> args, MethodCallExpressionModel model, List<MethodCallExpressionArgs> appendArgs = null)
|
||||
{
|
||||
if (this.Context.ResolveType == ResolveExpressType.FieldSingle)
|
||||
{
|
||||
this.Context.ResolveType = ResolveExpressType.WhereSingle;
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Context.ResolveType = ResolveExpressType.WhereMultiple;
|
||||
}
|
||||
Where(parameter, isLeft, name, args, model);
|
||||
}
|
||||
private void Select(ExpressionParameter parameter, bool? isLeft, string name, IEnumerable<Expression> args, MethodCallExpressionModel model, List<MethodCallExpressionArgs> appendArgs = null)
|
||||
{
|
||||
if (name == "GetSelfAndAutoFill")
|
||||
{
|
||||
var memberValue = (args.First() as MemberExpression).Expression.ToString();
|
||||
model.Args.Add(new MethodCallExpressionArgs() { MemberValue = memberValue, IsMember = true, MemberName = memberValue });
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (var item in args)
|
||||
{
|
||||
AppendItem(parameter, name, args, model, item);
|
||||
}
|
||||
if (appendArgs != null)
|
||||
{
|
||||
model.Args.AddRange(appendArgs);
|
||||
}
|
||||
}
|
||||
if (parameter.BaseParameter.BaseParameter.BaseParameter == null)
|
||||
{
|
||||
this.Context.Result.Append(GetMdthodValue(name, model));
|
||||
}
|
||||
else
|
||||
{
|
||||
parameter.BaseParameter.CommonTempData = GetMdthodValue(name, model);
|
||||
}
|
||||
}
|
||||
private void Where(ExpressionParameter parameter, bool? isLeft, string name, IEnumerable<Expression> args, MethodCallExpressionModel model, List<MethodCallExpressionArgs> appendArgs = null)
|
||||
{
|
||||
foreach (var item in args)
|
||||
{
|
||||
var expItem = item;
|
||||
if (item is UnaryExpression) {
|
||||
expItem = (item as UnaryExpression).Operand;
|
||||
}
|
||||
AppendItem(parameter, name, args, model, expItem);
|
||||
}
|
||||
if (appendArgs != null)
|
||||
{
|
||||
model.Args.AddRange(appendArgs);
|
||||
}
|
||||
var methodValue = GetMdthodValue(name, model);
|
||||
if (parameter.BaseExpression is BinaryExpression && parameter.OppsiteExpression.Type == UtilConstants.BoolType&&name=="HasValue"&&!(parameter.OppsiteExpression is BinaryExpression)) {
|
||||
methodValue = this.Context.DbMehtods.CaseWhen(new List<KeyValuePair<string, string>>() {
|
||||
new KeyValuePair<string, string>("IF",methodValue.ObjToString()),
|
||||
new KeyValuePair<string, string>("Return","1"),
|
||||
new KeyValuePair<string, string>("End","0")
|
||||
});
|
||||
}
|
||||
base.AppendValue(parameter, isLeft, methodValue);
|
||||
}
|
||||
|
||||
private void AppendItem(ExpressionParameter parameter, string name, IEnumerable<Expression> args, MethodCallExpressionModel model, Expression item)
|
||||
{
|
||||
var isBinaryExpression = item is BinaryExpression || item is MethodCallExpression;
|
||||
var isConst = item is ConstantExpression;
|
||||
var isIIF = name == "IIF";
|
||||
var isIFFBoolMember = isIIF && (item is MemberExpression) && (item as MemberExpression).Type == UtilConstants.BoolType;
|
||||
var isIFFUnary = isIIF && (item is UnaryExpression) && (item as UnaryExpression).Operand.Type == UtilConstants.BoolType;
|
||||
var isIFFBoolBinary = isIIF && (item is BinaryExpression) && (item as BinaryExpression).Type == UtilConstants.BoolType;
|
||||
var isIFFBoolMethod = isIIF && (item is MethodCallExpression) && (item as MethodCallExpression).Type == UtilConstants.BoolType;
|
||||
var isFirst = item == args.First();
|
||||
if (isFirst && isIIF && isConst)
|
||||
{
|
||||
var value = (item as ConstantExpression).Value.ObjToBool() ? this.Context.DbMehtods.True() : this.Context.DbMehtods.False();
|
||||
var methodCallExpressionArgs = new MethodCallExpressionArgs()
|
||||
{
|
||||
IsMember = true,
|
||||
MemberName = value,
|
||||
MemberValue = value
|
||||
};
|
||||
model.Args.Add(methodCallExpressionArgs);
|
||||
}
|
||||
else if (isIFFUnary && !isFirst)
|
||||
{
|
||||
AppendModelByIIFMember(parameter, model, (item as UnaryExpression).Operand);
|
||||
}
|
||||
else if (isIFFBoolMember && !isFirst)
|
||||
{
|
||||
AppendModelByIIFMember(parameter, model, item);
|
||||
|
||||
}
|
||||
else if (isIFFBoolBinary && !isFirst)
|
||||
{
|
||||
AppendModelByIIFBinary(parameter, model, item);
|
||||
|
||||
}
|
||||
else if (isIFFBoolMethod && !isFirst)
|
||||
{
|
||||
AppendModelByIIFMethod(parameter, model, item);
|
||||
}
|
||||
else if (isBinaryExpression)
|
||||
{
|
||||
model.Args.Add(GetMethodCallArgs(parameter, item));
|
||||
}
|
||||
else
|
||||
{
|
||||
AppendModel(parameter, model, item);
|
||||
}
|
||||
}
|
||||
private void AppendModelByIIFMember(ExpressionParameter parameter, MethodCallExpressionModel model, Expression item)
|
||||
{
|
||||
parameter.CommonTempData = CommonTempDataType.Result;
|
||||
base.Expression = item;
|
||||
base.Start();
|
||||
var methodCallExpressionArgs = new MethodCallExpressionArgs()
|
||||
{
|
||||
IsMember = parameter.ChildExpression is MemberExpression,
|
||||
MemberName = parameter.CommonTempData
|
||||
};
|
||||
if (methodCallExpressionArgs.IsMember && parameter.ChildExpression != null && parameter.ChildExpression.ToString() == "DateTime.Now")
|
||||
{
|
||||
methodCallExpressionArgs.IsMember = false;
|
||||
}
|
||||
var value = methodCallExpressionArgs.MemberName;
|
||||
if (methodCallExpressionArgs.IsMember)
|
||||
{
|
||||
var childExpression = parameter.ChildExpression as MemberExpression;
|
||||
if (childExpression.Expression != null && childExpression.Expression is ConstantExpression)
|
||||
{
|
||||
methodCallExpressionArgs.IsMember = false;
|
||||
}
|
||||
}
|
||||
if (methodCallExpressionArgs.IsMember == false)
|
||||
{
|
||||
var parameterName = this.Context.SqlParameterKeyWord + ExpressionConst.MethodConst + this.Context.ParameterIndex;
|
||||
this.Context.ParameterIndex++;
|
||||
methodCallExpressionArgs.MemberName = parameterName;
|
||||
methodCallExpressionArgs.MemberValue = value;
|
||||
this.Context.Parameters.Add(new SugarParameter(parameterName, value));
|
||||
}
|
||||
model.Args.Add(methodCallExpressionArgs);
|
||||
parameter.ChildExpression = null;
|
||||
}
|
||||
private void AppendModelByIIFBinary(ExpressionParameter parameter, MethodCallExpressionModel model, Expression item)
|
||||
{
|
||||
Check.Exception(true, "The SqlFunc.IIF(arg1,arg2,arg3) , {0} argument do not support ", item.ToString());
|
||||
}
|
||||
private void AppendModelByIIFMethod(ExpressionParameter parameter, MethodCallExpressionModel model, Expression item)
|
||||
{
|
||||
var methodExpression = item as MethodCallExpression;
|
||||
if (methodExpression.Method.Name.IsIn("ToBool", "ToBoolean", "IIF"))
|
||||
{
|
||||
model.Args.Add(base.GetMethodCallArgs(parameter, item));
|
||||
}
|
||||
else
|
||||
{
|
||||
Check.Exception(true, "The SqlFunc.IIF(arg1,arg2,arg3) , {0} argument do not support ", item.ToString());
|
||||
}
|
||||
}
|
||||
private void AppendModel(ExpressionParameter parameter, MethodCallExpressionModel model, Expression item)
|
||||
{
|
||||
parameter.CommonTempData = CommonTempDataType.Result;
|
||||
base.Expression = item;
|
||||
base.Start();
|
||||
var methodCallExpressionArgs = new MethodCallExpressionArgs()
|
||||
{
|
||||
IsMember = parameter.ChildExpression is MemberExpression && !ExpressionTool.IsConstExpression(parameter.ChildExpression as MemberExpression),
|
||||
MemberName = parameter.CommonTempData
|
||||
};
|
||||
if (methodCallExpressionArgs.IsMember && parameter.ChildExpression != null && parameter.ChildExpression.ToString() == "DateTime.Now")
|
||||
{
|
||||
methodCallExpressionArgs.IsMember = false;
|
||||
}
|
||||
var value = methodCallExpressionArgs.MemberName;
|
||||
if (methodCallExpressionArgs.IsMember)
|
||||
{
|
||||
var childExpression = parameter.ChildExpression as MemberExpression;
|
||||
if (childExpression.Expression != null && childExpression.Expression is ConstantExpression)
|
||||
{
|
||||
methodCallExpressionArgs.IsMember = false;
|
||||
}
|
||||
}
|
||||
if (methodCallExpressionArgs.IsMember == false)
|
||||
{
|
||||
var parameterName = this.Context.SqlParameterKeyWord + ExpressionConst.MethodConst + this.Context.ParameterIndex;
|
||||
this.Context.ParameterIndex++;
|
||||
methodCallExpressionArgs.MemberName = parameterName;
|
||||
methodCallExpressionArgs.MemberValue = value;
|
||||
this.Context.Parameters.Add(new SugarParameter(parameterName, value));
|
||||
}
|
||||
model.Args.Add(methodCallExpressionArgs);
|
||||
parameter.ChildExpression = null;
|
||||
}
|
||||
|
||||
private object GetMdthodValue(string name, MethodCallExpressionModel model)
|
||||
{
|
||||
if (IsExtMethod(name))
|
||||
{
|
||||
DbType type = DbType.SqlServer;
|
||||
if (this.Context is SqlServerExpressionContext)
|
||||
type = DbType.SqlServer;
|
||||
else if (this.Context is MySqlExpressionContext)
|
||||
type = DbType.MySql;
|
||||
else if (this.Context is SqliteExpressionContext)
|
||||
type = DbType.Sqlite;
|
||||
else if(this.Context is OracleExpressionContext)
|
||||
type = DbType.Oracle;
|
||||
return this.Context.SqlFuncServices.First(it => it.UniqueMethodName == name).MethodValue(model,type,this.Context);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch (name)
|
||||
{
|
||||
case "IIF":
|
||||
return this.Context.DbMehtods.IIF(model);
|
||||
case "HasNumber":
|
||||
return this.Context.DbMehtods.HasNumber(model);
|
||||
case "HasValue":
|
||||
return this.Context.DbMehtods.HasValue(model);
|
||||
case "IsNullOrEmpty":
|
||||
return this.Context.DbMehtods.IsNullOrEmpty(model);
|
||||
case "ToLower":
|
||||
return this.Context.DbMehtods.ToLower(model);
|
||||
case "ToUpper":
|
||||
return this.Context.DbMehtods.ToUpper(model);
|
||||
case "Trim":
|
||||
return this.Context.DbMehtods.Trim(model);
|
||||
case "Contains":
|
||||
return this.Context.DbMehtods.Contains(model);
|
||||
case "ContainsArray":
|
||||
var caResult = this.Context.DbMehtods.ContainsArray(model);
|
||||
this.Context.Parameters.RemoveAll(it => it.ParameterName == model.Args[0].MemberName.ObjToString());
|
||||
return caResult;
|
||||
case "Equals":
|
||||
return this.Context.DbMehtods.Equals(model);
|
||||
case "DateIsSame":
|
||||
if (model.Args.Count == 2)
|
||||
return this.Context.DbMehtods.DateIsSameDay(model);
|
||||
else
|
||||
{
|
||||
var dsResult = this.Context.DbMehtods.DateIsSameByType(model);
|
||||
this.Context.Parameters.RemoveAll(it => it.ParameterName == model.Args[2].MemberName.ObjToString());
|
||||
return dsResult;
|
||||
}
|
||||
case "DateAdd":
|
||||
if (model.Args.Count == 2)
|
||||
return this.Context.DbMehtods.DateAddDay(model);
|
||||
else
|
||||
{
|
||||
var daResult = this.Context.DbMehtods.DateAddByType(model);
|
||||
this.Context.Parameters.RemoveAll(it => it.ParameterName == model.Args[2].MemberName.ObjToString());
|
||||
return daResult;
|
||||
}
|
||||
case "DateValue":
|
||||
var dvResult = this.Context.DbMehtods.DateValue(model);
|
||||
this.Context.Parameters.RemoveAll(it => it.ParameterName == model.Args[1].MemberName.ObjToString());
|
||||
return dvResult;
|
||||
case "Between":
|
||||
return this.Context.DbMehtods.Between(model);
|
||||
case "StartsWith":
|
||||
return this.Context.DbMehtods.StartsWith(model);
|
||||
case "EndsWith":
|
||||
return this.Context.DbMehtods.EndsWith(model);
|
||||
case "ToInt32":
|
||||
return this.Context.DbMehtods.ToInt32(model);
|
||||
case "ToInt64":
|
||||
return this.Context.DbMehtods.ToInt64(model);
|
||||
case "ToDate":
|
||||
return this.Context.DbMehtods.ToDate(model);
|
||||
case "ToTime":
|
||||
return this.Context.DbMehtods.ToTime(model);
|
||||
case "ToString":
|
||||
Check.Exception(model.Args.Count > 1, "ToString (Format) is not supported, Use ToString().If time formatting can be used it.Date.Year+\"-\"+it.Data.Month+\"-\"+it.Date.Day ");
|
||||
return this.Context.DbMehtods.ToString(model);
|
||||
case "ToDecimal":
|
||||
return this.Context.DbMehtods.ToDecimal(model);
|
||||
case "ToGuid":
|
||||
return this.Context.DbMehtods.ToGuid(model);
|
||||
case "ToDouble":
|
||||
return this.Context.DbMehtods.ToDouble(model);
|
||||
case "ToBool":
|
||||
return this.Context.DbMehtods.ToBool(model);
|
||||
case "Substring":
|
||||
return this.Context.DbMehtods.Substring(model);
|
||||
case "Replace":
|
||||
return this.Context.DbMehtods.Replace(model);
|
||||
case "Length":
|
||||
return this.Context.DbMehtods.Length(model);
|
||||
case "AggregateSum":
|
||||
return this.Context.DbMehtods.AggregateSum(model);
|
||||
case "AggregateAvg":
|
||||
return this.Context.DbMehtods.AggregateAvg(model);
|
||||
case "AggregateMin":
|
||||
return this.Context.DbMehtods.AggregateMin(model);
|
||||
case "AggregateMax":
|
||||
return this.Context.DbMehtods.AggregateMax(model);
|
||||
case "AggregateCount":
|
||||
return this.Context.DbMehtods.AggregateCount(model);
|
||||
case "MappingColumn":
|
||||
var mappingColumnResult = this.Context.DbMehtods.MappingColumn(model);
|
||||
var isValid = model.Args[0].IsMember && model.Args[1].IsMember == false;
|
||||
Check.Exception(!isValid, "SqlFunc.MappingColumn parameters error, The property name on the left, string value on the right");
|
||||
this.Context.Parameters.RemoveAll(it => it.ParameterName == model.Args[1].MemberName.ObjToString());
|
||||
return mappingColumnResult;
|
||||
case "IsNull":
|
||||
return this.Context.DbMehtods.IsNull(model);
|
||||
case "MergeString":
|
||||
return this.Context.DbMehtods.MergeString(model.Args.Select(it => it.MemberName.ObjToString()).ToArray());
|
||||
case "GetSelfAndAutoFill":
|
||||
this.Context.Parameters.RemoveAll(it => it.ParameterName == model.Args[0].MemberName.ObjToString());
|
||||
return this.Context.DbMehtods.GetSelfAndAutoFill(model.Args[0].MemberValue.ObjToString(), this.Context.IsSingle);
|
||||
case "GetDate":
|
||||
return this.Context.DbMehtods.GetDate();
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static Dictionary<string, string> MethodMapping = new Dictionary<string, string>() {
|
||||
{ "ToString","ToString"},
|
||||
{ "ToInt32","ToInt32"},
|
||||
{ "ToInt16","ToInt32"},
|
||||
{ "ToInt64","ToInt64"},
|
||||
{ "ToDecimal","ToDecimal"},
|
||||
{ "ToDateTime","ToDate"},
|
||||
{ "ToBoolean","ToBool"},
|
||||
{ "ToDouble","ToDouble"},
|
||||
{ "Length","Length"},
|
||||
{ "Replace","Replace"},
|
||||
{ "Contains","Contains"},
|
||||
{ "ContainsArray","ContainsArray"},
|
||||
{ "EndsWith","EndsWith"},
|
||||
{ "StartsWith","StartsWith"},
|
||||
{ "HasValue","HasValue"},
|
||||
{ "Trim","Trim"},
|
||||
{ "Equals","Equals"},
|
||||
{ "ToLower","ToLower"},
|
||||
{ "ToUpper","ToUpper"},
|
||||
{ "Substring","Substring"},
|
||||
{ "DateAdd","DateAdd"}
|
||||
};
|
||||
|
||||
private static Dictionary<string, DateType> MethodTimeMapping = new Dictionary<string, DateType>() {
|
||||
{ "AddYears",DateType.Year},
|
||||
{ "AddMonths",DateType.Month},
|
||||
{ "AddDays",DateType.Day},
|
||||
{ "AddHours",DateType.Hour},
|
||||
{ "AddMinutes",DateType.Minute},
|
||||
{ "AddSeconds",DateType.Second},
|
||||
{ "AddMilliseconds",DateType.Millisecond}
|
||||
};
|
||||
|
||||
private bool IsContainsArray(MethodCallExpression express, string methodName, bool isValidNativeMethod)
|
||||
{
|
||||
return !isValidNativeMethod && express.Method.DeclaringType.Namespace.IsIn("System.Linq", "System.Collections.Generic") && methodName == "Contains";
|
||||
}
|
||||
|
||||
private bool IsSubMethod(MethodCallExpression express, string methodName)
|
||||
{
|
||||
return SubTools.SubItemsConst.Any(it => it.Name == methodName) && express.Object != null && express.Object.Type.Name == "Subqueryable`1";
|
||||
}
|
||||
private bool CheckMethod(MethodCallExpression expression)
|
||||
{
|
||||
if (IsExtMethod(expression.Method.Name))
|
||||
return true;
|
||||
if (expression.Method.ReflectedType().FullName != ExpressionConst.SqlFuncFullName)
|
||||
return false;
|
||||
else
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class NewArrayExpessionResolve : BaseResolve
|
||||
{
|
||||
public NewArrayExpessionResolve(ExpressionParameter parameter) : base(parameter)
|
||||
{
|
||||
var expression = (NewArrayExpression)base.Expression;
|
||||
switch (base.Context.ResolveType)
|
||||
{
|
||||
case ResolveExpressType.WhereSingle:
|
||||
case ResolveExpressType.WhereMultiple:
|
||||
case ResolveExpressType.SelectSingle:
|
||||
case ResolveExpressType.SelectMultiple:
|
||||
case ResolveExpressType.FieldSingle:
|
||||
case ResolveExpressType.FieldMultiple:
|
||||
Check.ThrowNotSupportedException("NewArrayExpression");
|
||||
break;
|
||||
case ResolveExpressType.ArraySingle:
|
||||
foreach (var item in expression.Expressions)
|
||||
{
|
||||
base.Expression = item;
|
||||
base.Start();
|
||||
}
|
||||
break;
|
||||
case ResolveExpressType.Join:
|
||||
base.Context.ResolveType = ResolveExpressType.WhereMultiple;
|
||||
int i = 0;
|
||||
foreach (var item in expression.Expressions)
|
||||
{
|
||||
if (item is UnaryExpression)
|
||||
{
|
||||
base.Expression = item;
|
||||
base.Start();
|
||||
if (parameter.CommonTempData is JoinType)
|
||||
{
|
||||
if (i > 0)
|
||||
{
|
||||
base.Context.Result.Append("," + parameter.CommonTempData.ObjToString() + ",");
|
||||
}
|
||||
else
|
||||
{
|
||||
base.Context.Result.Append(parameter.CommonTempData.ObjToString() + ",");
|
||||
}
|
||||
++i;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Reflection;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class NewExpressionResolve : BaseResolve
|
||||
{
|
||||
public NewExpressionResolve(ExpressionParameter parameter) : base(parameter)
|
||||
{
|
||||
var expression = base.Expression as NewExpression;
|
||||
Check.Exception(expression.Type == UtilConstants.GuidType, "Not Support new Guid(), Use Guid.New()");
|
||||
switch (parameter.Context.ResolveType)
|
||||
{
|
||||
case ResolveExpressType.WhereSingle:
|
||||
Check.ThrowNotSupportedException(expression.ToString());
|
||||
break;
|
||||
case ResolveExpressType.WhereMultiple:
|
||||
Check.ThrowNotSupportedException(expression.ToString());
|
||||
break;
|
||||
case ResolveExpressType.SelectSingle:
|
||||
Check.Exception(expression.Type == UtilConstants.DateType, "ThrowNotSupportedException {0} ",expression.ToString());
|
||||
Select(expression, parameter, true);
|
||||
break;
|
||||
case ResolveExpressType.SelectMultiple:
|
||||
Check.Exception(expression.Type == UtilConstants.DateType, "ThrowNotSupportedException {0} ", expression.ToString());
|
||||
Select(expression, parameter, false);
|
||||
break;
|
||||
case ResolveExpressType.FieldSingle:
|
||||
Check.ThrowNotSupportedException(expression.ToString());
|
||||
break;
|
||||
case ResolveExpressType.FieldMultiple:
|
||||
case ResolveExpressType.ArrayMultiple:
|
||||
case ResolveExpressType.ArraySingle:
|
||||
foreach (var item in expression.Arguments)
|
||||
{
|
||||
base.Expression = item;
|
||||
base.Start();
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private void Select(NewExpression expression, ExpressionParameter parameter, bool isSingle)
|
||||
{
|
||||
if (expression.Arguments != null)
|
||||
{
|
||||
int i = 0;
|
||||
foreach (var item in expression.Arguments)
|
||||
{
|
||||
string memberName = expression.Members[i].Name;
|
||||
++i;
|
||||
ResolveNewExpressions(parameter, item, memberName);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class TypeParameterExpressionReolve : BaseResolve
|
||||
{
|
||||
public TypeParameterExpressionReolve(ExpressionParameter parameter) : base(parameter)
|
||||
{
|
||||
var expression = (ParameterExpression)base.Expression;
|
||||
switch (parameter.Context.ResolveType)
|
||||
{
|
||||
case ResolveExpressType.WhereSingle:
|
||||
break;
|
||||
case ResolveExpressType.WhereMultiple:
|
||||
break;
|
||||
case ResolveExpressType.Update:
|
||||
parameter.BaseParameter.CommonTempData = expression.Name;
|
||||
break;
|
||||
case ResolveExpressType.SelectSingle:
|
||||
case ResolveExpressType.SelectMultiple:
|
||||
if (parameter.BaseParameter!=null&¶meter.BaseParameter.CurrentExpression.NodeType == ExpressionType.Lambda)
|
||||
{
|
||||
this.Context.Result.Append(expression.Name + ".*");
|
||||
}
|
||||
else
|
||||
{
|
||||
parameter.BaseParameter.CommonTempData = expression.Name;
|
||||
}
|
||||
break;
|
||||
case ResolveExpressType.FieldSingle:
|
||||
break;
|
||||
case ResolveExpressType.FieldMultiple:
|
||||
break;
|
||||
case ResolveExpressType.Join:
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Text;
|
||||
namespace SqlSugar
|
||||
{
|
||||
public class UnaryExpressionResolve : BaseResolve
|
||||
{
|
||||
public UnaryExpressionResolve(ExpressionParameter parameter) : base(parameter)
|
||||
{
|
||||
var expression = base.Expression as UnaryExpression;
|
||||
var baseParameter = parameter.BaseParameter;
|
||||
switch (this.Context.ResolveType)
|
||||
{
|
||||
case ResolveExpressType.WhereSingle:
|
||||
case ResolveExpressType.WhereMultiple:
|
||||
case ResolveExpressType.FieldSingle:
|
||||
case ResolveExpressType.FieldMultiple:
|
||||
case ResolveExpressType.SelectSingle:
|
||||
case ResolveExpressType.SelectMultiple:
|
||||
case ResolveExpressType.ArraySingle:
|
||||
case ResolveExpressType.ArrayMultiple:
|
||||
case ResolveExpressType.Update:
|
||||
var nodeType = expression.NodeType;
|
||||
base.Expression = expression.Operand;
|
||||
var isMember = expression.Operand is MemberExpression;
|
||||
var isConst = expression.Operand is ConstantExpression;
|
||||
var offsetIsNull = (parameter.OppsiteExpression is ConstantExpression)
|
||||
&&(parameter.OppsiteExpression as ConstantExpression).Value==null
|
||||
&&ExpressionTool.IsComparisonOperator(expression.Operand);
|
||||
if (isMember && offsetIsNull) {
|
||||
Append(parameter, nodeType);
|
||||
}
|
||||
else if (baseParameter.CurrentExpression is NewArrayExpression)
|
||||
{
|
||||
Result(parameter, nodeType);
|
||||
}
|
||||
else if (base.Expression is BinaryExpression || parameter.BaseExpression is BinaryExpression || baseParameter.CommonTempData.ObjToString() == CommonTempDataType.Append.ToString())
|
||||
{
|
||||
Append(parameter, nodeType);
|
||||
}
|
||||
else if (isMember)
|
||||
{
|
||||
MemberLogic(parameter, baseParameter, nodeType);
|
||||
}
|
||||
else if (isConst)
|
||||
{
|
||||
Result(parameter, nodeType);
|
||||
}
|
||||
else
|
||||
{
|
||||
Append(parameter, nodeType);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private void MemberLogic(ExpressionParameter parameter, ExpressionParameter baseParameter, ExpressionType nodeType)
|
||||
{
|
||||
var memberExpression = (base.Expression as MemberExpression);
|
||||
var isLogicOperator = ExpressionTool.IsLogicOperator(baseParameter.OperatorValue) || baseParameter.OperatorValue.IsNullOrEmpty();
|
||||
var isHasValue = isLogicOperator && memberExpression.Member.Name == "HasValue" && memberExpression.Expression != null && memberExpression.NodeType == ExpressionType.MemberAccess;
|
||||
if (isHasValue)
|
||||
{
|
||||
var member = memberExpression.Expression as MemberExpression;
|
||||
parameter.CommonTempData = CommonTempDataType.Result;
|
||||
var isConst = member.Expression != null && member.Expression is ConstantExpression;
|
||||
if (isConst)
|
||||
{
|
||||
var paramterValue = ExpressionTool.DynamicInvoke(member);
|
||||
var paramterName= base.AppendParameter(paramterValue);
|
||||
var result = this.Context.DbMehtods.HasValue(new MethodCallExpressionModel()
|
||||
{
|
||||
Args = new List<MethodCallExpressionArgs>() {
|
||||
new MethodCallExpressionArgs() { IsMember=false, MemberName=paramterName, MemberValue=paramterValue } }
|
||||
});
|
||||
this.Context.Result.Append(result);
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Expression = isConst ? member.Expression : member;
|
||||
this.Start();
|
||||
var methodParamter = isConst ? new MethodCallExpressionArgs() { IsMember = false } : new MethodCallExpressionArgs() { IsMember = true, MemberName = parameter.CommonTempData, MemberValue = null };
|
||||
var result = this.Context.DbMehtods.HasValue(new MethodCallExpressionModel()
|
||||
{
|
||||
Args = new List<MethodCallExpressionArgs>() {
|
||||
methodParamter
|
||||
}
|
||||
});
|
||||
this.Context.Result.Append(result);
|
||||
parameter.CommonTempData = null;
|
||||
}
|
||||
}
|
||||
else if (memberExpression.Type == UtilConstants.BoolType && isLogicOperator)
|
||||
{
|
||||
Append(parameter, nodeType);
|
||||
}
|
||||
else
|
||||
{
|
||||
Result(parameter, nodeType);
|
||||
}
|
||||
}
|
||||
|
||||
private void Result(ExpressionParameter parameter, ExpressionType nodeType)
|
||||
{
|
||||
BaseParameter.ChildExpression = base.Expression;
|
||||
parameter.CommonTempData = CommonTempDataType.Result;
|
||||
if (nodeType == ExpressionType.Not)
|
||||
AppendNot(parameter.CommonTempData);
|
||||
base.Start();
|
||||
parameter.BaseParameter.CommonTempData = parameter.CommonTempData;
|
||||
parameter.BaseParameter.ChildExpression = base.Expression;
|
||||
parameter.CommonTempData = null;
|
||||
}
|
||||
|
||||
private void Append(ExpressionParameter parameter, ExpressionType nodeType)
|
||||
{
|
||||
BaseParameter.ChildExpression = base.Expression;
|
||||
this.IsLeft = parameter.IsLeft;
|
||||
parameter.CommonTempData = CommonTempDataType.Append;
|
||||
if (nodeType == ExpressionType.Not)
|
||||
AppendNot(parameter.CommonTempData);
|
||||
base.Start();
|
||||
parameter.BaseParameter.CommonTempData = parameter.CommonTempData;
|
||||
parameter.BaseParameter.ChildExpression = base.Expression;
|
||||
parameter.CommonTempData = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user