/// <summary>
/// 尝试将 exp 转换成 DbParameterExpression。
/// </summary>
/// <param name="exp"></param>
/// <returns></returns>
public static DbExpression ParseDbExpression(this DbExpression exp)
{
DbExpression stripedExp = DbExpressionHelper.StripInvalidConvert(exp);
DbExpression tempExp = stripedExp;
List <DbConvertExpression> cList = null;
while (tempExp.NodeType == DbExpressionType.Convert)
{
if (cList == null)
{
cList = new List <DbConvertExpression>();
}
DbConvertExpression c = (DbConvertExpression)tempExp;
cList.Add(c);
tempExp = c.Operand;
}
if (tempExp.NodeType == DbExpressionType.Constant || tempExp.NodeType == DbExpressionType.Parameter)
{
return(stripedExp);
}
if (tempExp.NodeType == DbExpressionType.MemberAccess)
{
DbMemberExpression dbMemberExp = (DbMemberExpression)tempExp;
if (ExistDateTime_NowOrDateTime_UtcNow(dbMemberExp))
{
return(stripedExp);
}
DbParameterExpression val;
if (DbExpressionExtensions.TryParseToParameterExpression(dbMemberExp, out val))
{
if (cList != null)
{
if (val.Value == DBNull.Value)//如果是 null，则不需要 Convert 了，在数据库里没意义
{
return(val);
}
DbConvertExpression c = null;
for (int i = cList.Count - 1; i > -1; i--)
{
DbConvertExpression item = cList[i];
c = new DbConvertExpression(item.Type, val);
}
return(c);
}
return(val);
}
}
return(stripedExp);
}
public override DbExpression Visit(DbEqualExpression exp)
{
DbExpression left = exp.Left;
DbExpression right = exp.Right;
left = DbExpressionExtensions.ParseDbExpression(left);
right = DbExpressionExtensions.ParseDbExpression(right);
//明确 left right 其中一边一定为 null
if (DbExpressionExtensions.AffirmExpressionRetValueIsNull(right))
{
left.Accept(this);
this._sqlBuilder.Append(" IS NULL");
return(exp);
}
if (DbExpressionExtensions.AffirmExpressionRetValueIsNull(left))
{
right.Accept(this);
this._sqlBuilder.Append(" IS NULL");
return(exp);
}
left.Accept(this);
this._sqlBuilder.Append(" = ");
right.Accept(this);
return(exp);
}
public static object GetExpressionValue(this DbExpression exp)
{
if (exp.NodeType == DbExpressionType.Constant)
{
return(((DbConstantExpression)exp).Value);
}
if (exp.NodeType == DbExpressionType.MemberAccess)
{
DbMemberExpression m = (DbMemberExpression)exp;
object instance = null;
if (m.Expression != null)
{
instance = DbExpressionExtensions.GetExpressionValue(m.Expression);
/* 非静态成员，需要检查是否为空引用。Nullable<T>.HasValue 的情况比较特俗，暂不考虑 */
TypeInfo declaringTypeInfo = m.Member.DeclaringType.GetTypeInfo();
if (declaringTypeInfo.IsClass || declaringTypeInfo.IsInterface)
{
if (instance == null)
{
throw new NullReferenceException(string.Format("There is an object reference not set to an instance of an object in expression tree.The type of null object is '{0}'.", declaringTypeInfo.FullName));
}
}
}
return(GetMemberAccessExpressionValue(m, instance));
}
throw new NotSupportedException();
}
public override DbExpression Visit(DbMemberExpression exp)
{
MemberInfo member = exp.Member;
if (member.DeclaringType == UtilConstants.TypeOfDateTime)
{
if (member == UtilConstants.PropertyInfo_DateTime_Now)
{
this._sqlBuilder.Append("GETDATE()");
return(exp);
}
if (member == UtilConstants.PropertyInfo_DateTime_UtcNow)
{
this._sqlBuilder.Append("GETUTCDATE()");
return(exp);
}
if (member == UtilConstants.PropertyInfo_DateTime_Today)
{
BuildCastState("GETDATE()", "DATE");
return(exp);
}
if (member == UtilConstants.PropertyInfo_DateTime_Date)
{
BuildCastState(exp.Expression, "DATE");
return(exp);
}
if (IsDbFunction_DATEPART(exp))
{
return(exp);
}
}
DbParameterExpression newExp;
if (DbExpressionExtensions.TryParseToParameterExpression(exp, out newExp))
{
return(newExp.Accept(this));
}
if (member.Name == "Length" && member.DeclaringType == UtilConstants.TypeOfString)
{
this._sqlBuilder.Append("LEN(");
exp.Expression.Accept(this);
this._sqlBuilder.Append(")");
return(exp);
}
else if (member.Name == "Value" && Utils.IsNullable(exp.Expression.Type))
{
exp.Expression.Accept(this);
return(exp);
}
throw new NotSupportedException(string.Format("'{0}.{1}' is not supported.", member.DeclaringType.FullName, member.Name));
}
static void EnsureTrimCharArgumentIsSpaces(DbExpression exp)
{
var m = exp as DbMemberExpression;
if (m == null)
{
throw new NotSupportedException();
}
DbParameterExpression p;
if (!DbExpressionExtensions.TryParseToParameterExpression(m, out p))
{
throw new NotSupportedException();
}
var arg = p.Value;
if (arg == null)
{
throw new NotSupportedException();
}
var chars = arg as char[];
if (chars.Length != 1 || chars[0] != ' ')
{
throw new NotSupportedException();
}
}
static void Method_Contains(DbMethodCallExpression exp, SqlGenerator generator)
{
MethodInfo method = exp.Method;
if (method.DeclaringType == UtilConstants.TypeOfString)
{
Method_String_Contains(exp, generator);
return;
}
List <DbExpression> exps = new List <DbExpression>();
IEnumerable values = null;
DbExpression arg = null;
var declaringType = method.DeclaringType;
if (typeof(IList).IsAssignableFrom(declaringType) || (declaringType.IsGenericType && typeof(ICollection <>).MakeGenericType(declaringType.GetGenericArguments()).IsAssignableFrom(declaringType)))
{
DbMemberExpression memberExp = exp.Object as DbMemberExpression;
if (memberExp == null || !memberExp.CanEvaluate())
{
throw new NotSupportedException(exp.ToString());
}
values = DbExpressionExtensions.GetExpressionValue(memberExp) as IEnumerable; //Enumerable
arg = exp.Arguments.First();
goto constructInState;
}
if (method.IsStatic && declaringType == typeof(Enumerable) && exp.Arguments.Count == 2)
{
DbMemberExpression memberExp = exp.Arguments.First() as DbMemberExpression;
if (memberExp == null || !memberExp.CanEvaluate())
{
throw new NotSupportedException(exp.ToString());
}
values = DbExpressionExtensions.GetExpressionValue(memberExp) as IEnumerable;
arg = exp.Arguments.Skip(1).First();
goto constructInState;
}
throw UtilExceptions.NotSupportedMethod(exp.Method);
constructInState:
foreach (object value in values)
{
if (value == null)
{
exps.Add(DbExpression.Constant(null, arg.Type));
}
else
{
exps.Add(DbExpression.Parameter(value));
}
}
In(generator, exps, arg);
}
/// <summary>
/// 对 memberExpression 进行求值
/// </summary>
/// <param name="exp"></param>
/// <returns>返回 DbParameterExpression</returns>
public static DbParameterExpression ParseToParameterExpression(this DbMemberExpression memberExpression)
{
DbParameterExpression ret = null;
//求值
object val = DbExpressionExtensions.GetExpressionValue(memberExpression);
ret = DbExpression.Parameter(val, memberExpression.Type);
return(ret);
}
public static object GetExpressionValue(this DbExpression exp)
{
if (exp.NodeType == DbExpressionType.Constant)
{
return(((DbConstantExpression)exp).Value);
}
if (exp.NodeType == DbExpressionType.MemberAccess)
{
DbMemberExpression m = (DbMemberExpression)exp;
object instance = null;
if (m.Expression != null)
{
instance = DbExpressionExtensions.GetExpressionValue(m.Expression);
}
return(GetMemberAccessExpressionValue(m, instance));
}
throw new NotSupportedException();
}
