Ejemplo n.º 1
0
        /// <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);
        }
Ejemplo n.º 2
0
        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();
            }
        }
Ejemplo n.º 3
0
        public override DbExpression Visit(DbMemberExpression exp)
        {
            MemberInfo member = exp.Member;

            if (member.DeclaringType == UtilConstants.TypeOfDateTime)
            {
                if (member == UtilConstants.PropertyInfo_DateTime_Now)
                {
                    this._sqlBuilder.Append("DATETIME('NOW','LOCALTIME')");
                    return(exp);
                }

                if (member == UtilConstants.PropertyInfo_DateTime_UtcNow)
                {
                    this._sqlBuilder.Append("DATETIME()");
                    return(exp);
                }

                if (member == UtilConstants.PropertyInfo_DateTime_Today || member == UtilConstants.PropertyInfo_DateTime_Date)
                {
                    this._sqlBuilder.Append("DATE('NOW','LOCALTIME')");
                    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("LENGTH(");
                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));
        }