internal static ArrayLength ArrayLength(UnaryExpression expression)
 {
     return new ArrayLength()
     {
         Operand = Serialize(expression.Operand),
     }.Apply(n => n.Type = TypeRef.Serialize(expression.Type));
 }

 protected override Expression VisitUnary(UnaryExpression node)
 {
     if (node.NodeType == ExpressionType.Not && node.Operand is MemberExpression)
     {
         return base.VisitUnary(node);
     }
     var exp = base.VisitUnary(node);
     if (node.NodeType == ExpressionType.Not)
     {
         string condition = _conditionStack.Pop();
         _conditionStack.Push("(NOT " + condition + ")");
     }
     else if (node.NodeType == ExpressionType.Convert)
     {
         if (node.Operand is ConstantExpression)
         {
             _constStack.Push((node.Operand as ConstantExpression).Value);
         }
     }
     else
     {
         throw new Exception("未支持一元操作符：" + node.NodeType.ToString());
     }
     return exp;
 }

 private static SqlExpression VisitConvert(UnaryExpression expression)
 {
     if (expression.Operand.NodeType == ExpressionType.MemberAccess) {
         return VisitMemberAccess((MemberExpression)expression.Operand);
     }
     throw new NotImplementedException();
 }

            protected override Expression VisitUnary(UnaryExpression node)
            {
                switch (node.NodeType)
                {
                    case ExpressionType.Not:
                        if (node.Operand is SubQueryExpression)
                        {
                            var nested = new WhereClauseVisitor(_parent, _mapping);
                            nested.Visit(node.Operand);

                            var @where = new NotWhereFragment(nested.ToWhereFragment());
                            _register.Peek()(@where);
                        }
                        else
                        {
                            var visitor = new NotVisitor(this, _mapping, _register.Peek());
                            visitor.Visit(node);
                        }

                        return null;
                }


                return base.VisitUnary(node);
            }

 internal static Quote Quote(UnaryExpression expression)
 {
     return new Quote()
     {
         Operand = Serialize(expression.Operand),
     }.Apply(n => n.Type = TypeRef.Serialize(expression.Type));
 }

        protected override Expression VisitUnary(UnaryExpression node) {
            if (node.NodeType == ExpressionType.Convert) {
                return Expression.ConvertChecked(node.Operand, node.Type);
            }

            return base.VisitUnary(node);
        }

        static Node ParseUnaryNot(UnaryExpression e)
        {
            string suffix = e.Operand is BinaryExpression ? ")" : null;
            string prefix = e.Operand is BinaryExpression ? "!(" : "!";

            return new UnaryNode { Prefix = prefix, Operand = Parse(e.Operand), PrefixValue = GetValue(e), Suffix = suffix };
        }

 protected override Expression VisitUnary(UnaryExpression u)
 {
     throw new NotSupportedException(
         string.Format(
             "The unary operator '{0}' is not supported",
             u.NodeType));
 }

 protected override Expression VisitUnary(UnaryExpression node)
 {
     return Expression.MakeUnary(
         node.NodeType,
         Visit(node.Operand),
         node.Type);
 }

		protected override Expression VisitUnary(UnaryExpression unaryExpression)
		{
			if (unaryExpression.NodeType == ExpressionType.Not && unaryExpression.Type.GetUnwrappedNullableType() == typeof(bool))
			{
				var operand = this.Visit(unaryExpression.Operand);

				if (operand is BitBooleanExpression)
				{
					return Expression.MakeUnary(unaryExpression.NodeType, Expression.Equal(operand, Expression.Constant(true, operand.Type)), typeof(bool));
				}
			}
			else if (unaryExpression.NodeType == ExpressionType.Convert
				&& unaryExpression.Type.GetUnwrappedNullableType() == typeof(bool)
				&& unaryExpression.Operand.Type.GetUnwrappedNullableType() != typeof(bool))
			{
				var operand = this.Visit(unaryExpression.Operand);

				if (operand is BitBooleanExpression)
				{
					return Expression.MakeUnary(unaryExpression.NodeType, Expression.Equal(operand, Expression.Constant(true, operand.Type)), typeof(bool));
				}
			}

			return base.VisitUnary(unaryExpression);
		}

        protected override Expression VisitUnary(UnaryExpression node)
        {
            if (node.NodeType != ExpressionType.Convert && node.NodeType != ExpressionType.ConvertChecked)
            {
                return base.VisitUnary(node);
            }

            if (node.Operand.NodeType != ExpressionType.MemberAccess)
            {
                return base.VisitUnary(node);
            }

            if (!ReflectionHelper.IsNullable(node.Type))
            {
                return base.VisitUnary(node);
            }

            MemberExpression memberNode = node.Operand as MemberExpression;

            if (memberNode.Expression == null)
            {
                // Static member access cannot be rewritten
                return base.VisitUnary(node);
            }

            return this.CreateSafeMemberAccessExpression(node.Operand as MemberExpression, node.Type);
        }

        public void AddQueryPart(UnaryExpression leftItem, ConstantExpression rightValue, ExpressionType nodeType)
        {
            if(leftItem.Operand is MethodCallExpression)
            {
                var unaryOperation = (MethodCallExpression)leftItem.Operand;

                if(unaryOperation.Method.Name != "get_Item")
                {
                    throw new InvalidOperationException("Queries based on " + leftItem.Method.Name + " are not yet supported.");
                }

                if(unaryOperation.Arguments[0] is ConstantExpression)
                {
                    var attributeRef = ((ConstantExpression) unaryOperation.Arguments[0]).Value;
                    AddCriteriaToActiveSearchCondition(attributeRef.ToString(), rightValue.Value, GetSearchRelationType(nodeType));
                }
                else
                {
                    throw new InvalidOperationException("Only constant expressions are currently supported.");
                }

            }
            else
            {
                throw new InvalidOperationException("Queries based on " + leftItem.Method.Name + " are not yet supported.");
            }
        }

 protected override Expression VisitUnary(UnaryExpression u)
 {
     if (u.NodeType == ExpressionType.Quote)
     {
         return base.Visit(u.Operand);
     }
     return base.VisitUnary(u);
 }

 internal static Unbox Unbox(UnaryExpression expression)
 {
     return new Unbox()
     {
         Operand = Serialize(expression.Operand),
         Type = TypeRef.Serialize(expression.Type),
     };
 }

        protected override Expression VisitUnary(UnaryExpression u)
        {
            u = (UnaryExpression)base.VisitUnary(u);
            if (u.NodeType != ExpressionType.Not)
                return u;

            return Invert(u.Operand, u);
        }

 internal static IsFalse IsFalse(UnaryExpression expression)
 {
     return new IsFalse()
     {
         Operand = Serialize(expression.Operand),
         Method = expression.Method.Null(m => MethodRef.Serialize(m)),
     }.Apply(n => n.Type = TypeRef.Serialize(expression.Type));
 }

 internal static PreDecrementAssign PreDecrementAssign(UnaryExpression expression)
 {
     return new PreDecrementAssign()
     {
         Operand = Serialize(expression.Operand),
         Method = expression.Method.Null(m => MethodRef.Serialize(m)),
     }.Apply(n => n.Type = TypeRef.Serialize(expression.Type));
 }

 internal static NegateChecked NegateChecked(UnaryExpression expression)
 {
     return new NegateChecked()
     {
         Operand = Serialize(expression.Operand),
         Method = expression.Method.Null(m => MethodRef.Serialize(m)),
     }.Apply(n => n.Type = TypeRef.Serialize(expression.Type));
 }

        //string GetColumnName(LambdaExpression member)
        //{
        //    var mbody = member.Body as MemberExpression;
        //    if (mbody != null) return GetColumnName(mbody);
        //    var ubody = member.Body as UnaryExpression;
        //    if (ubody == null) throw new NotSupportedException("Only members and unary expressions are supported");
        //    return GetColumnName(ubody);
        //}

        private string GetColumnName(UnaryExpression member)
        {
            var mbody = member.Operand as MemberExpression;
            if (mbody != null) return GetColumnName(mbody);
            var ubody = member.Operand as UnaryExpression;
            if (ubody != null) return GetColumnName(ubody);
            throw new NotSupportedException("Only members and unary expressions are supported");
        }

 internal static OnesComplement OnesComplement(UnaryExpression expression)
 {
     return new OnesComplement()
     {
         Operand = Serialize(expression.Operand),
         Method = expression.Method.Null(m => MethodRef.Serialize(m)),
     }.Apply(n => n.Type = TypeRef.Serialize(expression.Type));
 }