protected override Expression VisitChildren(ExpressionVisitor visitor) {
     Expression b = visitor.Visit(_body);
     if (b == _body) {
         return this;
     }
     return new FinallyFlowControlExpression(b);
 }

 protected override Expression VisitChildren(ExpressionVisitor visitor) {
     Expression v = visitor.Visit(_value);
     if (v == _value) {
         return this;
     }
     return Utils.MakeYield(_target, v, YieldMarker);
 }

 protected override Expression VisitChildren(ExpressionVisitor visitor) {
     Expression v = visitor.Visit(_variable);
     if (v == _variable) {
         return this;
     }
     return Utils.Delete(v);
 }

 protected override Expression VisitChildren(ExpressionVisitor visitor) {
     Expression body = visitor.Visit(_body);
     if (body == _body) {
         return this;
     }
     return new SkipInterpretExpression(body);
 }

 protected override Expression VisitChildren(ExpressionVisitor visitor) {
     var instance = visitor.Visit(_expr);
     if (instance != _expr) {
         return new LightCheckAndThrowExpression(instance);
     }
     return this;
 }

 protected override Expression VisitChildren(ExpressionVisitor visitor) {
     Expression v = visitor.Visit(_value);
     if (v == _value) {
         return this;
     }
     return Utils.Assign(_name, v);
 }

 protected override Expression VisitChildren(ExpressionVisitor visitor) {
     var expr = visitor.Visit(_expr);
     if (expr != _expr) {
         return new LightExceptionConvertingExpression(expr, _supportsLightEx);
     }
     return this;
 }

        /// <summary>
        ///     Reduces the node and then calls the <see cref="ExpressionVisitor.Visit(System.Linq.Expressions.Expression)" /> method passing the
        ///     reduced expression.
        ///     Throws an exception if the node isn't reducible.
        /// </summary>
        /// <param name="visitor"> An instance of <see cref="ExpressionVisitor" />. </param>
        /// <returns> The expression being visited, or an expression which should replace it in the tree. </returns>
        /// <remarks>
        ///     Override this method to provide logic to walk the node's children.
        ///     A typical implementation will call visitor.Visit on each of its
        ///     children, and if any of them change, should return a new copy of
        ///     itself with the modified children.
        /// </remarks>
        protected override Expression VisitChildren(ExpressionVisitor visitor)
        {
            visitor.Visit(_tableExpression);
            visitor.Visit(_predicate);

            return this;
        }

        /// <summary>
        /// 简化节点，然后对简化的表达式调用访问者委托。该方法在节点不可简化时引发异常。
        /// </summary>
        /// <returns>
        /// 要访问的表达式，或应在树中替换此表达式的表达式。
        /// </returns>
        /// <param name="visitor"><see cref="T:System.Func`2"/> 的一个实例。</param>
        protected override Expression VisitChildren(ExpressionVisitor visitor)
        {
            var newArguments = visitor.VisitAndConvert(_arguments, "VisitChildren");

            return newArguments != _arguments
                ? new SqlFunctionExpression(FunctionName, newArguments, Type)
                : this;
        }

		protected override Expression VisitChildren(ExpressionVisitor visitor)
		{
			QueryNode newTarget = (QueryNode)visitor.Visit(Target);
			if (newTarget == Target)
				return this;
			else
				return new MergeByName(newTarget);
		}

        protected override Expression VisitChildren(ExpressionVisitor visitor)
        {
            var arguments = visitor.VisitAndConvert(new ReadOnlyCollection<Expression>(_arguments), "VisitChildren");

            return arguments != Arguments
                ? new SqlFunctionExpression(FunctionName, arguments, Type)
                : this;
        }

        protected override Expression VisitChildren(ExpressionVisitor visitor)
        {
            var newPredicate = visitor.Visit(_predicate);

            return _predicate != newPredicate
                ? new DiscriminatorPredicateExpression(newPredicate, QuerySource)
                : this;
        }

        protected override Expression Accept(ExpressionVisitor visitor)
        {
            var parsedVisitor = visitor as CompilingExpressionVisitor;
            if (parsedVisitor != null)
                return Accept(parsedVisitor);

            return base.Accept(visitor);
        }

        protected override Expression VisitChildren(ExpressionVisitor visitor)
        {
            var newTimestampExpression = visitor.Visit(TimestampExpression);

            return newTimestampExpression != TimestampExpression
                ? new AtTimeZoneExpression(newTimestampExpression, TimeZone)
                : this;
        }

    protected override Expression VisitChildren (ExpressionVisitor visitor)
    {
      var result = visitor.Visit (_expression);
      if (result != _expression)
        return new NonReducibleExtensionExpression (result);

      return this;
    }

		protected override Expression VisitChildren(ExpressionVisitor visitor)
		{
			QueryNode newTarget = (QueryNode)visitor.Visit(Target);
			if (newTarget == Target)
				return this;
			else
				return new Limit(newTarget, Start, Length);
		}

        protected override Expression VisitChildren(ExpressionVisitor visitor) {
            var exception = visitor.Visit(_exception);
            if (exception != _exception) {
                return new LightThrowExpression(exception);
            }

            return this;
        }

        /// <summary>
        ///     Reduces the node and then calls the <see cref="ExpressionVisitor.Visit(System.Linq.Expressions.Expression)" /> method passing the
        ///     reduced expression.
        ///     Throws an exception if the node isn't reducible.
        /// </summary>
        /// <param name="visitor"> An instance of <see cref="ExpressionVisitor" />. </param>
        /// <returns> The expression being visited, or an expression which should replace it in the tree. </returns>
        /// <remarks>
        ///     Override this method to provide logic to walk the node's children.
        ///     A typical implementation will call visitor.Visit on each of its
        ///     children, and if any of them change, should return a new copy of
        ///     itself with the modified children.
        /// </remarks>
        protected override Expression VisitChildren(ExpressionVisitor visitor)
        {
            var newOperand = visitor.Visit(Operand);

            return newOperand != Operand
                ? new ExplicitCastExpression(newOperand, _type)
                : this;
        }

        protected override Expression VisitChildren(ExpressionVisitor visitor) {
            Expression lineNo = visitor.Visit(_lineNumberExpression);
            if (lineNo != _lineNumberExpression) {
                return new LastFaultingLineExpression(lineNo);
            }

            return this;
        }

        protected override Expression VisitChildren(ExpressionVisitor visitor)
        {
            var newExpression = visitor.Visit(_operand);

            return newExpression != _operand
                ? new NotNullableExpression(newExpression)
                : this;
        }